/// <summary>
/// Returns a GATT characteristic for a sensor's data service.
/// </summary>
/// <param name="sensor">the sensor you want to read</param>
/// <returns>the GATT characteristic</returns>
static async Task <GattCharacteristic> GetCharacteristic(Sensor sensor)
{
//Get a query for devices with this service
string deviceSelector = GattDeviceService.GetDeviceSelectorFromUuid(new Guid(sensor.GetServiceUUID()));
//seek devices using the query
var deviceCollection = await DeviceInformation.FindAllAsync(deviceSelector);
//return info for the first device you find
DeviceInformation device = deviceCollection.FirstOrDefault();
if (device == null)
{
throw new Exception("Device not found.");
}
// using the id get the service
GattDeviceService service = await GattDeviceService.FromIdAsync(device.Id);
//get all characteristics
IReadOnlyList <GattCharacteristic> characteristics = service.GetCharacteristics(new Guid(sensor.GetDataUUID()));
if (characteristics.Count == 0)
{
throw new Exception("characteristic not found.");
}
//Reaturn event handler for first characteristic
return(characteristics[0]);
}
//
// Summary:
// Initializes all the CRTP service and characteristic objects
// Uses the first of each that's found
public async Task <Boolean> InitCrtpService()
{
var bthServices = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(
GattDeviceService.GetDeviceSelectorFromUuid(
crtpServiceGuid), null);
// Use the first instance of this guid
if (bthServices.Count >= 1)
{
crtpService = await GattDeviceService.FromIdAsync(bthServices[0].Id);
if (crtpService != null)
{
var chars = crtpService.GetCharacteristics(crtpCharacteristicGuid);
if (chars.Count >= 1)
{
crtpChar = chars[0];
}
var upChars = crtpService.GetCharacteristics(crtpUpCharacteristicGuid);
if (upChars.Count >= 1)
{
crtpUpChar = upChars[0];
}
var downChars = crtpService.GetCharacteristics(crtpDownCharacteristicGuid);
if (downChars.Count >= 1)
{
crtpDownChar = downChars[0];
}
}
}
return((crtpService != null) && (crtpChar != null) && (crtpUpChar != null) && (crtpDownChar != null));
}
private async void ReFreshDevicesList()
{
System.Diagnostics.Debug.WriteLine("FindAllAsync hearth : " + GattServiceUuids.HeartRate);
System.Diagnostics.Debug.WriteLine("FindAllAsync hearth : " + GattDeviceService.GetDeviceSelectorFromUuid(GattServiceUuids.HeartRate));
String findStuff = "System.DeviceInterface.Bluetooth.ServiceGuid:= \"{0000180D-0000-1000-8000-00805F9B34FB}\" AND System.Devices.InterfaceEnabled:= System.StructuredQueryType.Boolean#True";
var devices = await DeviceInformation.FindAllAsync(findStuff);
// this is the right way, stuff above is for debugging untill things works
// var devices = await DeviceInformation.FindAllAsync(GattDeviceService.GetDeviceSelectorFromUuid(GattServiceUuids.HeartRate));
var items = new List <DeviceViewModel>();
if (devices != null && devices.Count > 0)
{
System.Diagnostics.Debug.WriteLine("FindAllAsync devices.Count : " + devices.Count);
foreach (DeviceInformation device in devices)
{
if (device != null && device.Kind == DeviceInformationKind.DeviceInterface)
{
System.Diagnostics.Debug.WriteLine("Found : " + device.Name + ", id: " + device.Id);
items.Add(new DeviceViewModel(device));
}
}
}
DeviceSelectionListView.ItemsSource = items;
noDevicesLabel.Visibility = items.Count > 0 ? Visibility.Collapsed : Visibility.Visible;
DeviceSelectionListView.Visibility = items.Count > 0 ? Visibility.Visible : Visibility.Collapsed;
}
private async void ReFreshDevicesList()
{
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
var devices = await DeviceInformation.FindAllAsync(GattDeviceService.GetDeviceSelectorFromUuid(GattServiceUuids.HeartRate));
var items = new List <DeviceViewModel>();
if (devices != null && devices.Count > 0)
{
System.Diagnostics.Debug.WriteLine("FindAllAsync devices.Count : " + devices.Count);
foreach (DeviceInformation device in devices)
{
if (device != null)
{
System.Diagnostics.Debug.WriteLine("Found : " + device.Name + ", id: " + device.Id);
items.Add(new DeviceViewModel(device));
}
}
}
DeviceSelectionListView.ItemsSource = items;
noDevicesLabel.Visibility = items.Count > 0 ? Visibility.Collapsed : Visibility.Visible;
DeviceSelectionListView.Visibility = items.Count > 0 ? Visibility.Visible : Visibility.Collapsed;
});
}
private void StartWatchers()
{
// aqsFilter = System.Devices.Aep.ProtocolId:="{bb7bb05e-5972-42b5-94fc-76eaa7084d49}"
// association endpoint (AEP)
string aqsFilter = "System.Devices.Aep.ProtocolId:=\"{bb7bb05e-5972-42b5-94fc-76eaa7084d49}\"";
deviceWatcher = DeviceInformation.CreateWatcher(
aqsFilter,
null, // don't request additional properties for this sample
DeviceInformationKind.AssociationEndpoint);
InitializeBtleWatcher(aqsFilter);
deviceWatcher.Start();
// Start the second watcher for the UP Band Stream Service: GATT_STREAM_SERVICE_UUID
aqsFilter = GattDeviceService.GetDeviceSelectorFromUuid(new Guid(UuidDefs.GATT_STREAM_SERVICE_UUID));
_watcher2 = new BtleWatcher(this, "W2");
_watcher2.InitializeBtleWatcher(aqsFilter);
// Hook a function to the watcher events
_watcher2.WacherEvent += Wacher2EventFired;
//// Start the third watcher for the UP Band Control Service: JAWBONE_CONTROL_SERVICE_UUID
//aqsFilter = GattDeviceService.GetDeviceSelectorFromUuid(new Guid(UuidDefs.JAWBONE_CONTROL_SERVICE_UUID));
//_watcher3 = new BtleWatcher(this, "W3");
//_watcher3.InitializeBtleWatcher(aqsFilter);
//// Start the third watcher for the UP Band Control Service: DEVICE_INFORMATION_SERVICE_UUID
//aqsFilter = GattDeviceService.GetDeviceSelectorFromUuid(new Guid(UuidDefs.DEVICE_INFORMATION_SERVICE_UUID));
//_watcher4 = new BtleWatcher(this, "W4");
//_watcher4.InitializeBtleWatcher(aqsFilter);
//_rootPage.NotifyUser("Starting Watchers Done...", NotifyType.StatusMessage);
//AppBarButtonStop.IsEnabled = true;
}
private async Task <bool> GetHrAndBatteryDevice()
{
StatusInformation = "Start search for devices, HR";
var devices = await DeviceInformation.FindAllAsync(
GattDeviceService.GetDeviceSelectorFromUuid(GattServiceUuids.HeartRate));
if (null == devices || devices.Count <= 0)
{
return(true);
}
foreach (var device in devices.Where(device => device.Name == "Polar H7 498C1817"))
{
_devicePolarHr = device;
StatusInformation2 = "Found hr device";
break;
}
StatusInformation = "Start search for devices, Battery";
devices = await DeviceInformation.FindAllAsync(
GattDeviceService.GetDeviceSelectorFromUuid(GattServiceUuids.Battery));
if (null == devices || devices.Count <= 0)
{
return(true);
}
foreach (var device in devices.Where(device => device.Name == "Polar H7 498C1817"))
{
_devicePolarBattery = device;
StatusInformation2 = "Found battery device";
break;
}
StatusInformation = $"Found HR [{(_devicePolarHr != null)}] Battery [{(_devicePolarBattery != null)}]";
return(_devicePolarHr != null && _devicePolarBattery != null);
}
public void InitiateDefault()
{
var heartrateSelector = GattDeviceService
.GetDeviceSelectorFromUuid(GattServiceUuids.HeartRate);
var devices = DeviceInformation
.FindAllAsync(heartrateSelector)
.AsyncResult();
var device = devices.FirstOrDefault();
if (device == null)
{
throw new ArgumentNullException(
nameof(device),
"Unable to locate heart rate device.");
}
GattDeviceService service;
lock (_disposeSync)
{
if (IsDisposed)
{
throw new ObjectDisposedException(GetType().Name);
}
Cleanup();
service = GattDeviceService.FromIdAsync(device.Id)
.AsyncResult();
_service = service;
}
if (service == null)
{
throw new ArgumentOutOfRangeException(
$"Unable to get service to {device.Name} ({device.Id}). Is the device inuse by another program? The Bluetooth adaptor may need to be turned off and on again.");
}
var heartrate = service
.GetCharacteristics(_heartRateMeasurementCharacteristicUuid)
.FirstOrDefault();
if (heartrate == null)
{
throw new ArgumentOutOfRangeException(
$"Unable to locate heart rate measurement on device {device.Name} ({device.Id}).");
}
var status = heartrate
.WriteClientCharacteristicConfigurationDescriptorAsync(
GattClientCharacteristicConfigurationDescriptorValue.Notify)
.AsyncResult();
heartrate.ValueChanged += HeartRate_ValueChanged;
Debug.WriteLine($"Started {status}");
}
async void Search_Clicked(object sender, EventArgs e)
{
foreach (DeviceInformation di in await DeviceInformation.FindAllAsync(GattDeviceService.GetDeviceSelectorFromUuid(BluetoothUuidHelper.FromShortId(0xfff0))))
{
System.Diagnostics.Debug.WriteLine(di);
}
}
/// <summary>
/// Search paired device
/// </summary>
private async void Init()
{
try
{
//Clear MyoList
pairedMyos = new List <MyoHw>();
connectedMyos = new List <MyoHw>();
//Search paired Myo
devicesCollection = await DeviceInformation.FindAllAsync(
GattDeviceService.GetDeviceSelectorFromUuid(MYO_MAIN_UUID),
new string[] { "System.Devices.ContainerId" });
if (devicesCollection.Count > 0)
{
StartDeviceConnectionWatcher();
foreach (var device in devicesCollection)
{
pairedMyos.Add(new MyoHw(device));
}
}
else
{
throw new Exception("No Myo Found, Please Pair Your Myo First");
}
}
catch (Exception e)
{
throw(new Exception("Search Fail!" + e.Message));
}
}
private async void StartScanAsync()
{
if (false == this.scanning)
{
return;
}
var devices = await DeviceInformation.FindAllAsync(GattDeviceService.GetDeviceSelectorFromUuid(serviceUuid), new string[] { "System.Devices.ContainerId" });
if (devices.Count > 0)
{
var remoteService = new RemoteService(devices[0]);
remoteService.Disconnected += RemoteServiceDisconnected;
remoteService.Connected += RemoteServiceConnected;
remoteService.Connect();
}
else
{
await Task.Delay(100);
StartWatcher();
StartScanAsync();
}
}
/// <summary>
/// Returns a GATT characteristic for a sensor's data service.
/// </summary>
/// <param name="sensor">the sensor you want to read</param>
/// <returns>the GATT characteristic</returns>
public static async Task <GattCharacteristic> GetCharacteristic(Sensor sensor, Attribute attribute)
{
//Get a query for devices with this service
string deviceSelector = GattDeviceService.GetDeviceSelectorFromUuid(new Guid(sensor.GetUUID(Attribute.Service)));
//seek devices using the query
var deviceCollection = await DeviceInformation.FindAllAsync(deviceSelector);
//return info for the first device you find
DeviceInformation device = deviceCollection.FirstOrDefault();
if (device == null)
{
throw new Exception("Device not found.");
}
// use the id to get the service
GattDeviceService service = await GattDeviceService.FromIdAsync(device.Id);
//get matching characteristic
IReadOnlyList <GattCharacteristic> characteristics = service.GetCharacteristics(new Guid(sensor.GetUUID(attribute)));
if (characteristics.Count == 0)
{
throw new Exception("characteristic not found.");
}
//Return first characteristic in the list.
return(characteristics[0]);
}
public void Stop()
{
if (this.DeviceWatcher == null)
{
// Request additional properties
string[] requestedProperties = { "System.Devices.Aep.DeviceAddress", "System.Devices.Aep.IsConnected" };
string serviceDeviceSelector = GattDeviceService.GetDeviceSelectorFromUuid(this.ANCSUuid);
this.DeviceWatcher = DeviceInformation.CreateWatcher(serviceDeviceSelector, requestedProperties);
}
if (this.DeviceWatcher != null)
{
// Unregister the event handlers.
this.DeviceWatcher.Added -= DeviceWatcher_Added;
this.DeviceWatcher.Updated -= DeviceWatcher_Updated;
this.DeviceWatcher.Removed -= DeviceWatcher_Removed;
this.DeviceWatcher.EnumerationCompleted -= DeviceWatcher_EnumerationCompleted;
this.DeviceWatcher.Stopped -= DeviceWatcher_Stopped;
// Stop the watcher.
if (DeviceWatcher.Status == DeviceWatcherStatus.Started)
{
this.DeviceWatcher.Stop();
}
DeviceWatcher = null;
}
// Clear the devices list
Devices.Clear();
}
public async Task <bool> Initialize(string serviceUuid)
{
string selector = GattDeviceService.GetDeviceSelectorFromUuid(new Guid(serviceUuid));
var devices = await DeviceInformation.FindAllAsync(selector, new string[] { "System.Devices.ContainerId" });
var deviceInfo = devices[0];
if (deviceInfo != null)
{
if (this.deviceService != null)
{
Clean();
}
this.deviceService = await GattDeviceService.FromIdAsync(deviceInfo.Id);
if (this.deviceService == null)
{
return(false);
}
return(true);
}
return(false);
}
private async void OHbtnSearch_Click(object sender, RoutedEventArgs e)
{
OHbtnSearch.IsEnabled = false;
var devices = await DeviceInformation.FindAllAsync(
GattDeviceService.GetDeviceSelectorFromUuid(GattServiceUuids.HeartRate),
new string[] { "System.Devices.ContainerId" });
if (devices.Count > 0)
{
foreach (var device in devices)
{
lstDevices.Items.Add(device);
}
lstDevices.Visibility = Visibility.Visible;
}
else
{
var dialog = new MessageDialog("Could not find any Heart Rate devices. Please make sure your device is paired and powered on!");
await dialog.ShowAsync();
}
OHbtnSearch.IsEnabled = true;
}
private async void FindPolarHrDevices()
{
if (_lastBpm != null)
{
var dif = DateTime.Now - _lastBpm.Time;
if (dif.Seconds > 3)
{
SuscribeToReadBpmValues();
}
}
if (_devicePolarHr != null)
{
return;
}
StatusInformation = $"Searching ...";
var devices =
await
DeviceInformation.FindAllAsync(
GattDeviceService.GetDeviceSelectorFromUuid(GattServiceUuids.HeartRate));
if (null == devices || devices.Count <= 0)
{
return;
}
foreach (var device in devices.Where(device => device.Name.Contains("Polar H7")))
{
_devicePolarHr = device;
StatusInformation = $"Polar HR [{_devicePolarHr.Name}], connect to Heart service ...";
Debug.WriteLine(_devicePolarHr.Id);
break;
}
}
/// <summary>
/// Finds connected Bluetooth device with the service GUID.
/// </summary>
/// <exception cref="System.TimeoutException">
/// Could not find connected IrDA bridge within timeout.
/// </exception>
/// <returns></returns>
public async void InitializeTranciever()
{
device = (await DeviceInformation.FindAllAsync(GattDeviceService.GetDeviceSelectorFromUuid(serviceGuid)))[0];
if (device != null)
{
GattCommunicationStatus status;
service = await GattDeviceService.FromIdAsync(device.Id);
commandData = service.GetCharacteristics(new Guid("d40c53c0-4462-4714-99cc-f90772bd7f61"))[0];
respData = service.GetCharacteristics(new Guid("54d8deac-1c1d-4841-947f-ac4406f3034e"))[0];
error = service.GetCharacteristics(new Guid("c29a164e-9406-4d81-800b-29efcb447933"))[0];
respData.ValueChanged += Characteristic_ValueChanged;
error.ValueChanged += Characteristic_ValueChanged;
status = await respData.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify);
status = await error.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify);
if (status == GattCommunicationStatus.Success)
{
DeviceInitialized();
}
else
{
DeviceNotInitialied();
}
}
}
private void StartDeviceWatcher()
{
this.RefreshButton.Enabled = false;
this.RefreshButton.Text = "Stop";
// Additional properties we would like about the device.
string[] requestedProperties = { "System.Devices.Aep.DeviceAddress", "System.Devices.Aep.IsConnected" };
string serviceDeviceSelector = GattDeviceService.GetDeviceSelectorFromUuid(this.ANCSUuid);
this.DeviceWatcher = DeviceInformation.CreateWatcher(serviceDeviceSelector, requestedProperties);
// Register event handlers before starting the watcher.
this.DeviceWatcher.Added += DeviceWatcher_Added;
this.DeviceWatcher.EnumerationCompleted += DeviceWatcher_EnumerationCompleted;
this.DeviceWatcher.Stopped += DeviceWatcher_Stopped;
//deviceWatcher.Added += DeviceWatcher_Added;
//deviceWatcher.Updated += DeviceWatcher_Updated;
//deviceWatcher.Removed += DeviceWatcher_Removed;
//deviceWatcher.EnumerationCompleted += DeviceWatcher_EnumerationCompleted;
//deviceWatcher.Stopped += DeviceWatcher_Stopped;
// Clear the devices list view
this.DevicesListView.BeginUpdate();
this.DevicesListView.Clear();
this.DevicesListView.EndUpdate();
// Start listening
this.DeviceWatcher.Start();
// Enable the button
this.RefreshButton.Enabled = true;
}
private async void StartGattServiceWatcher(DeviceInformation deviceInfoDisp)
{
//Get the Bluetooth address for filtering the watcher
var bleDevice = await BluetoothLEDevice.FromIdAsync(deviceInfoDisp.Id);
var selector = "(" + GattDeviceService.GetDeviceSelectorFromUuid(IoServiceUuid) + ")"
+ " AND (System.DeviceInterface.Bluetooth.DeviceAddress:=\""
+ bleDevice.BluetoothAddress.ToString("X") + "\")";
gattServiceWatcher = DeviceInformation.CreateWatcher(selector);
// Hook up handlers for the watcher events before starting the watcher
gattServiceWatcher.Added += async(watcher, deviceInfo) =>
{
weDoIoService = await GattDeviceService.FromIdAsync(deviceInfo.Id);
outputCommandCharacteristic = weDoIoService.GetCharacteristics(OutputCommandCharacteristicGuid)[0];
};
//gattServiceWatcher.Updated += new TypedEventHandler<DeviceWatcher, DeviceInformationUpdate>(async (watcher, deviceInfoUpdate) => );
//gattServiceWatcher.EnumerationCompleted += new TypedEventHandler<DeviceWatcher, Object>(async (watcher, obj) => );
//gattServiceWatcher.Removed += new TypedEventHandler<DeviceWatcher, DeviceInformationUpdate>(async (watcher, deviceInfoUpdate) => );
//gattServiceWatcher.Stopped += new TypedEventHandler<DeviceWatcher, Object>(async (watcher, obj) => );
gattServiceWatcher.Start();
}
//~HRGATTConnect()
//{
// Dispose(false);
//}
public async void Initialize()
{
try
{
var heartrateServices = await Windows.Devices.Enumeration
.DeviceInformation.FindAllAsync(GattDeviceService
.GetDeviceSelectorFromUuid(
GattServiceUuids.HeartRate),
null);
firstHeartRateMonitorService = await
GattDeviceService.FromIdAsync(heartrateServices[0].Id);
Debug.WriteLine("serviceName: " + heartrateServices[0].Name);
hrMonitorCharacteristics =
firstHeartRateMonitorService.GetCharacteristics(
GattCharacteristicUuids.HeartRateMeasurement)[0];
hrMonitorCharacteristics.ValueChanged += hrMeasurementChanged;
await hrMonitorCharacteristics
.WriteClientCharacteristicConfigurationDescriptorAsync(
GattClientCharacteristicConfigurationDescriptorValue.Notify);
disposed = false;
}
catch (Exception e)
{
}
}
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
foreach (DeviceInformation di in await DeviceInformation.FindAllAsync(GattDeviceService.GetDeviceSelectorFromUuid(GattServiceUuids.Battery)))
{
Devices.Add(di);
}
}
public async Task <bool> UpdateAvailableDevice()
{
DeviceSelectionViewModel.ClearCachedDevices();
try
{
DeviceSelectionViewModel.ClearCachedDevices();
var result = await DeviceInformation.FindAllAsync(GattDeviceService.GetDeviceSelectorFromUuid(GattServiceUuids.HeartRate));
if (result.Count > 0)
{
foreach (var device in result)
{
var ble = await BluetoothLEDevice.FromIdAsync(device.Id) as BluetoothLEDevice;
DeviceSelectionViewModel.AddBLEDevice(ble);
}
}
else
{
if (!await DeviceSelectionViewModel.IsBluetoothSettingOn())
{
ShowErrorMessage();
}
}
return(true);
}
catch (Exception)
{
return(false);
}
}
private static async void PrintService(Guid serviceGuid, int indent)
{
try
{
DebugLine("BT LE SERVICE LOOKUP", indent);
var device = await BluetoothLEDevice.FromIdAsync(serviceGuid.ToString());
Print(device, indent + 1);
}
catch
{
DebugLine("Failure getting device from service id.", indent);
}
try
{
DebugLine("DEVICE INFORMATION GATT SERVICE LOOKUP", indent);
var devices = await DeviceInformation.FindAllAsync(GattDeviceService.GetDeviceSelectorFromUuid(serviceGuid));
DebugLine($"Found Devices: {devices.Count}", indent);
foreach (var device in devices)
{
Print(device, indent + 1);
}
}
catch
{
DebugLine("Failure getting device from service id.", indent);
}
}
private async void RunButton_Click(object sender, RoutedEventArgs e)
{
RunButton.IsEnabled = false;
var devices = await DeviceInformation.FindAllAsync(
GattDeviceService.GetDeviceSelectorFromUuid(GattServiceUuids.HeartRate),
new string[] { "System.Devices.ContainerId" });
DevicesListBox.Items.Clear();
if (devices.Count > 0)
{
foreach (var device in devices)
{
DevicesListBox.Items.Add(device);
}
DevicesListBox.Visibility = Visibility.Visible;
}
else
{
rootPage.NotifyUser("Could not find any Heart Rate devices. Please make sure your device is paired " +
"and powered on!",
NotifyType.StatusMessage);
}
RunButton.IsEnabled = true;
}
private async void RunButton_Click(object sender, RoutedEventArgs e)
{
RunButton.IsEnabled = false;
//var devices = await DeviceInformation.FindAllAsync();
var devices = await DeviceInformation.FindAllAsync(
GattDeviceService.GetDeviceSelectorFromUuid(UARTService.Instance.SERVICE_UUID),
new string[] { "System.Devices.ContainerId" });
DevicesListBox.Items.Clear();
if (devices.Count > 0)
{
foreach (var device in devices)
{
DevicesListBox.Items.Add(device);
}
DevicesListBox.Visibility = Visibility.Visible;
}
else
{
statusTextBlock.Text = "No Devices with UART Service Found!";
}
RunButton.IsEnabled = true;
}
private void StartBLEWatcher()
{
string aqs = "";
for (int i = 0; i < NUM_SENSORS; i++)
{
Guid BLE_GUID;
if (i < 6)
{
BLE_GUID = new Guid(SENSOR_GUID_PREFIX + i + SENSOR_GUID_SUFFFIX);
}
else
{
BLE_GUID = BUTTONS_GUID;
}
aqs += "(" + GattDeviceService.GetDeviceSelectorFromUuid(BLE_GUID) + ")";
if (i < NUM_SENSORS - 1)
{
aqs += " OR ";
}
}
blewatcher = DeviceInformation.CreateWatcher(aqs);
blewatcher.Added += OnBLEAdded;
blewatcher.Updated += OnBLEUpdated;
blewatcher.Removed += OnBLERemoved;
blewatcher.Stopped += OnBLEStopped;
blewatcher.Start();
}
private async void ButtonConnect_Click(object sender, RoutedEventArgs e)
{
// SensorTagを取得
var selector = GattDeviceService.GetDeviceSelectorFromUuid(new Guid(SensorTagUuid.UuidIrtService));
var devices = await DeviceInformation.FindAllAsync(selector);
var deviceInformation = devices.FirstOrDefault();
if (deviceInformation == null)
{
//MessageBox.Show("not found");
return;
}
this.GattDeviceService = await GattDeviceService.FromIdAsync(deviceInformation.Id);
//MessageBox.Show($"found {deviceInformation.Id}");
// センサーの有効化?
var configCharacteristic = this.GattDeviceService.GetCharacteristics(new Guid(SensorTagUuid.UuidIrtConf)).First();
var status = await configCharacteristic.WriteValueAsync(new byte[] { 1 }.AsBuffer());
if (status == GattCommunicationStatus.Unreachable)
{
//MessageBox.Show("Initialize failed");
return;
}
}
private async void StartGattServiceWatcher()
{
//Get the Bluetooth address for filtering the watcher
BluetoothLEDeviceDisplay deviceInfoDisp = resultsListView.SelectedItem as BluetoothLEDeviceDisplay;
BluetoothLEDevice bleDevice = await BluetoothLEDevice.FromIdAsync(deviceInfoDisp.Id);
string selector = "(" + GattDeviceService.GetDeviceSelectorFromUuid(IoServiceUuid) + ")"
+ " AND (System.DeviceInterface.Bluetooth.DeviceAddress:=\""
+ bleDevice.BluetoothAddress.ToString("X") + "\")";
gattServiceWatcher = DeviceInformation.CreateWatcher(selector);
// Hook up handlers for the watcher events before starting the watcher
gattServiceWatcher.Added += new TypedEventHandler <DeviceWatcher, DeviceInformation>(async(watcher, deviceInfo) =>
{
// If the selected device is a WeDo device, enable the controls
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
weDoIoService = await GattDeviceService.FromIdAsync(deviceInfo.Id);
outputCommandCharacteristic = weDoIoService.GetCharacteristics(OutputCommandCharacteristicGuid)[0];
ForwardButton.IsEnabled = true;
StopButton.IsEnabled = true;
BackwardButton.IsEnabled = true;
});
});
gattServiceWatcher.Updated += new TypedEventHandler <DeviceWatcher, DeviceInformationUpdate>(async(watcher, deviceInfoUpdate) =>
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
//Do nothing
});
});
gattServiceWatcher.EnumerationCompleted += new TypedEventHandler <DeviceWatcher, Object>(async(watcher, obj) =>
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
//Do nothing
});
});
gattServiceWatcher.Removed += new TypedEventHandler <DeviceWatcher, DeviceInformationUpdate>(async(watcher, deviceInfoUpdate) =>
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
//Do nothing
});
});
gattServiceWatcher.Stopped += new TypedEventHandler <DeviceWatcher, Object>(async(watcher, obj) =>
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
//Do nothing
});
});
gattServiceWatcher.Start();
}
public async Task <bool> Connect()
{
//Find a device that is advertising the ancs service uuid
var serviceDeviceSelector = GattDeviceService.GetDeviceSelectorFromUuid(_ancsServiceUiid);
var devices = await DeviceInformation.FindAllAsync(serviceDeviceSelector, null);
// sanity check
if (devices.Count == 0)
{
return(false);
}
try
{
this.AncsDevice = devices.First();
//Resolve the service
this.AncsService = await GattDeviceService.FromIdAsync(this.AncsDevice.Id);
this.AncsService.Device.ConnectionStatusChanged += DeviceOnConnectionStatusChanged;
//Get charasteristics of service
this.NotificationSourceCharacteristic = this.AncsService.GetCharacteristics(_notificationSourceCharacteristicUuid).First();
this.ControlPointCharacteristic = this.AncsService.GetCharacteristics(_controlPointCharacteristicUuid).First();
this.DataSourceCharacteristic = this.AncsService.GetCharacteristics(_dataSourceCharacteristicUuid).First();
}
catch (Exception ex)
{
throw ex;
}
return(true);
}
/* Method */
public async void InitializeDevice()
{
/*** Get a list of devices that match desired service UUID ***/
Guid selectedService = new Guid("0000AA10-0000-1000-8000-00805F9B34FB");
var devices = await DeviceInformation.FindAllAsync(GattDeviceService.GetDeviceSelectorFromUuid(selectedService));
/*** Create an instance of the eTDS device ***/
DeviceInformation eTdsDevice = devices[0]; // Only one device should be matching the eTDS-specific service UUID
Console.WriteLine("Device Name: {0}", eTdsDevice.Name); // Display the name of the device
/*** Create an instance of the specified eTDS service ***/
GattDeviceService myService = await GattDeviceService.FromIdAsync(eTdsDevice.Id);
Console.WriteLine("Service UUID: {0}", myService.Uuid.ToString());
/*** Create an instance of the characteristic of the specified service ***/
Guid selectedCharacteristic = new Guid("0000AA11-0000-1000-8000-00805F9B34FB");
const int CHARACTERISTIC_INDEX = 0;
GattCharacteristic myCharacteristic = myService.GetCharacteristics(selectedCharacteristic)[CHARACTERISTIC_INDEX];
myCharacteristic.ProtectionLevel = GattProtectionLevel.Plain; // Set security level to "No encryption"
/*** Create an event handler when the characteristic value changes ***/
myCharacteristic.ValueChanged -= myCharacteristic_ValueChanged;
GattCommunicationStatus disableNotifStatus = await myCharacteristic.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.None);
Console.WriteLine("Disable Notification Status: {0}", disableNotifStatus);
myCharacteristic.ValueChanged += myCharacteristic_ValueChanged;
GattCommunicationStatus enableNotifStatus = await myCharacteristic.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify);
Console.WriteLine("Enable Notification Status: {0}", disableNotifStatus);
}//end method InitializeDevice
public GATTDefaultService(string description, Guid uuid)
{
this.Description = description;
this.UUID = uuid;
this.Filter = GattDeviceService.GetDeviceSelectorFromUuid(uuid);
lookup.Add(this.UUID, this);
}
