public void InitiateDefault() { var heartrateSelector = GattDeviceService .GetDeviceSelectorFromUuid(GattServiceUuids.HeartRate); var devices = AsyncResult(DeviceInformation .FindAllAsync(heartrateSelector)); 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 = AsyncResult(GattDeviceService.FromIdAsync(device.Id)); _service = service; } var heartrate = service.GetCharacteristics( GattDeviceService.ConvertShortIdToUuid( _heartRateMeasurementCharacteristicId)) .FirstOrDefault(); if (heartrate == null) { throw new ArgumentOutOfRangeException( $"Unable to locate heart rate measurement on device {device.Name} ({device.Id})."); } var status = AsyncResult( heartrate.WriteClientCharacteristicConfigurationDescriptorAsync( GattClientCharacteristicConfigurationDescriptorValue.Notify)); heartrate.ValueChanged += HeartRate_ValueChanged; Debug.WriteLine($"Started {status}"); }
private static async void DeviceAdded(DeviceWatcher watcher, DeviceInformation device) { try { var service = await GattDeviceService.FromIdAsync(device.Id); WriteLine("Opened Service!!"); } catch { WriteLine("Failed to open service."); } }
public async Task InitAsync() { var devices = await DeviceInformation.FindAllAsync(GattDeviceService.GetDeviceSelectorFromUuid(_servcieUuid), new string[] { "System.Devices.ContainerId" }); var defaultDevice = devices.FirstOrDefault(); if (defaultDevice == null) { throw new Exception("Device not found"); } _service = await GattDeviceService.FromIdAsync(defaultDevice.Id); }
public void InitiateDefault() { filename = "polar" + DateTime.Now.ToString("yyyyMMddhhmmss") + ".csv"; var heartrateSelector = GattDeviceService .GetDeviceSelectorFromUuid(GattServiceUuids.HeartRate); var devices = AsyncResult(DeviceInformation .FindAllAsync(heartrateSelector)); var device = devices.FirstOrDefault(); if (device == null) { throw new ArgumentOutOfRangeException( "Unable to locate heart rate device."); } GattDeviceService service; lock (_disposeSync) { if (_isDisposed) { throw new ObjectDisposedException(GetType().Name); } Cleanup(); service = AsyncResult(GattDeviceService.FromIdAsync(device.Id)); _service = service; } var uuid = BluetoothUuidHelper.FromShortId(_heartRateMeasurementCharacteristicId); var heartrate = AsyncResult(service.GetCharacteristicsForUuidAsync(uuid)).Characteristics.FirstOrDefault(); if (heartrate == null) { throw new ArgumentOutOfRangeException( $"Unable to locate heart rate measurement on device {device.Name} ({device.Id})."); } var status = AsyncResult( heartrate.WriteClientCharacteristicConfigurationDescriptorAsync( GattClientCharacteristicConfigurationDescriptorValue.Notify)); heartrate.ValueChanged += HeartRate_ValueChanged; Debug.WriteLine($"Started {status}"); }
/// <summary> /// Finds the GattDeviceService by sensorServiceUuid. /// IMPORTANT: Has to be called from UI thread the first time the app uses the device to be able to ask the user for permission to use it /// </summary> /// <returns></returns> /// <exception cref="DeviceNotFoundException">Thrown if there isn't a device which matches the sensor service id.</exception> private async Task <GattDeviceService> GetDeviceService() { string selector = GattDeviceService.GetDeviceSelectorFromUuid(new Guid(sensorServiceUuid)); var devices = await DeviceInformation.FindAllAsync(selector); DeviceInformation di = devices.FirstOrDefault(); if (di == null) { throw new DeviceNotFoundException(); } return(await GattDeviceService.FromIdAsync(di.Id)); }
public async Task ConnectToServcie() { var devices = await DeviceInformation.FindAllAsync( GattDeviceService.GetDeviceSelectorFromUuid(BATTERY_SERVICE_ID), new string[] { "System.Devices.ContainerId" }); var defaultDevice = devices.FirstOrDefault(); if (defaultDevice != null) { var service = await GattDeviceService.FromIdAsync(defaultDevice.Id); var Characteristics = service.GetCharacteristics(BATTERY_LEVEL_CHARACTERISTIC_ID); GattCharacteristic characteristic = Characteristics.FirstOrDefault(); if (characteristic != null) { characteristic.ProtectionLevel = GattProtectionLevel.EncryptionRequired; characteristic.ValueChanged += characteristic_ValueChanged; var currentDescriptorValue = await characteristic.ReadClientCharacteristicConfigurationDescriptorAsync(); var CHARACTERISTIC_NOTIFY_TYPE = GattClientCharacteristicConfigurationDescriptorValue.Notify; if (currentDescriptorValue.ClientCharacteristicConfigurationDescriptor != CHARACTERISTIC_NOTIFY_TYPE) { // Set the Client Characteristic Configuration Descriptor to enable the device to indicate // when the Characteristic value changes GattCommunicationStatus status = await characteristic.WriteClientCharacteristicConfigurationDescriptorAsync( CHARACTERISTIC_NOTIFY_TYPE); } //GattReadResult result = await characteristic.ReadValueAsync(); //if (result.Status == GattCommunicationStatus.Success) //{ // var reader = DataReader.FromBuffer(result.Value); // byte[] bytes = new byte[result.Value.Length]; // reader.ReadBytes(bytes); // _deviceManufacturer = System.Text.Encoding.UTF8.GetString(bytes, 0, bytes.Length); //} } } }
public async Task <byte[]> GetValue(Guid gattCharacteristicUuids) { try { var gattDeviceService = await GattDeviceService.FromIdAsync(Device.Id); if (gattDeviceService != null) { var characteristics = gattDeviceService.GetCharacteristics(gattCharacteristicUuids).First(); //If the characteristic supports Notify then tell it to notify us. try { if (characteristics.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Notify)) { characteristics.ValueChanged += characteristics_ValueChanged; await characteristics.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify); } } catch { } //Read if (characteristics.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Read)) { var result = await characteristics.ReadValueAsync(BluetoothCacheMode.Uncached); if (result.Status == GattCommunicationStatus.Success) { byte[] forceData = new byte[result.Value.Length]; DataReader.FromBuffer(result.Value).ReadBytes(forceData); return(forceData); } else { await new MessageDialog(result.Status.ToString()).ShowAsync(); } } } else { await new MessageDialog("Access to the device has been denied =(").ShowAsync(); } } catch (Exception ex) { Debug.WriteLine(ex.Message); } return(null); }
private static async Task <GattDeviceService> Initialize(string serviceUuid) { GattDeviceService deviceService = null; string selector = GattDeviceService.GetDeviceSelectorFromUuid(new Guid(serviceUuid)); var devices = await DeviceInformation.FindAllAsync(selector, new string[] { "System.Devices.ContainerId" }); // devicesTask.Wait(); var deviceInfo = devices[0]; if (deviceInfo != null) { deviceService = await GattDeviceService.FromIdAsync(deviceInfo.Id); } return(deviceService); }
/*----------------- * Methods * ------------------*/ public async void InitializeDevice() { /*** Get a list of devices that match desired service UUID ***/ var devices = await DeviceInformation.FindAllAsync(GattDeviceService.GetDeviceSelectorFromUuid(selectedService)); /*** Create an instance of the eTDS device ***/ eTdsDevice = devices[0]; // Only one device should be matching the eTDS-specific service UUID, hence [0] /*** Create an instance of the specified eTDS service ***/ myService = await GattDeviceService.FromIdAsync(eTdsDevice.Id); /*** Create an instance of the characteristic of the specified service ***/ myCharacteristic = myService.GetCharacteristics(selectedCharacteristic)[0]; myCharacteristic.ProtectionLevel = GattProtectionLevel.Plain; // Set security level to "No encryption" }// end method InitializeDevice
// retornar el servicio principal de la pulsera private async Task getService() { Debug.WriteLine("[miband] accediendo a servicio"); GattDeviceService _service; if (device != null) { _service = await GattDeviceService.FromIdAsync(device.Id); if (_service != null) { this.service = _service; } } }
private async void ButtonAction1_Click(object sender, RoutedEventArgs e) { DevicesInformation = $"Device Id,Name,service.Uuid,service Name,service.AttributeHandle,characteristic.Uuid,Char Name,CharacteristicProperties,Char ProtectionLevel,UserDescription,,,{Environment.NewLine}"; Debug.WriteLine(DevicesInformation); var bts = await DeviceInformation.FindAllAsync(); foreach (var device in bts.Where(di => di.Name == RsServiceDiscovery.DeviceName)) { try { var service = await GattDeviceService.FromIdAsync(device.Id); if (null == service) { continue; } var characteristics = service.GetAllCharacteristics(); if (null == characteristics || characteristics.Count <= 0) { return; } foreach (var characteristic in characteristics) { try { var serviceName = CharacteristicUuidsResolver.GetNameFromUuid(service.Uuid); var charName = CharacteristicUuidsResolver.GetNameFromUuid(characteristic.Uuid); string msg = $"{device.Id}, {device.Name}, {service.Uuid}, {serviceName}, {service.AttributeHandle}, {characteristic.Uuid}, {charName}, {characteristic.CharacteristicProperties}, {characteristic.ProtectionLevel}, {characteristic.UserDescription}{Environment.NewLine}"; Debug.WriteLine(msg); DevicesInformation += msg; } catch { // ignored } } } catch { string msg = $"{device.Id}, {device.Name}, , , , , , , , {Environment.NewLine}"; Debug.WriteLine(msg); DevicesInformation += msg; } } }
static public async void bluetoothle() { //デバイスを検索 string deveiceSelector = GattDeviceService.GetDeviceSelectorFromUuid(GattServiceUuids.HealthThermometer);//uuidから取得 DeviceInformationCollection themometerServices = await DeviceInformation.FindAllAsync(deveiceSelector, null); Console.WriteLine(themometerServices[0].Name); Console.ReadLine(); //デバイの指定 if (themometerServices.Count > 0) { DeviceInformation themometerService = themometerServices.First(); string ServiceNameText = "Using service: " + themometerService.Name; // サービスを作成 GattDeviceService firstThermometerService = await GattDeviceService.FromIdAsync(themometerService.Id); if (firstThermometerService != null) { //Gattの選択 // キャラクタリスティックを取得 GattCharacteristic thermometerCharacteristic = firstThermometerService.GetCharacteristics(GattCharacteristicUuids.TemperatureMeasurement).First(); // 通知イベントを登録 Console.WriteLine("Connect:" + ServiceNameText + "\n"); await thermometerCharacteristic.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Indicate); thermometerCharacteristic.ValueChanged += TemperatureMeasurementChanged; } else { // サービスを見つけられなかった // Capabilityの設定漏れはここへ Console.WriteLine("Notfound:" + ServiceNameText + "\n"); return; } } else { // 発見できなかった // BluetoothがOFFの場合はここへ Console.WriteLine("Notfound : Bluetooth" + "\n"); return; } }
private async Task <GattDeviceService> getDeviceService() { Debug.WriteLine("*getDeviceService: enter=" + sensorServiceUuid); string selector = GattDeviceService.GetDeviceSelectorFromUuid(new Guid(sensorServiceUuid)); var devices = await DeviceInformation.FindAllAsync(selector); DeviceInformation di = devices.FirstOrDefault(); if (di == null) { throw new ArgumentOutOfRangeException(); } return(await GattDeviceService.FromIdAsync(di.Id)); }
/// <summary> /// Finds the GattDeviceService by sensorServiceUuid. /// IMPORTANT: Has to be called from UI thread the first time the app uses the device to be able to ask the user for permission to use it. /// </summary> /// <returns>Returns the gatt device service of the first device that supports it. Returns null if access is denied.</returns> /// <exception cref="DeviceNotFoundException">Thrown if there isn't a device which provides the service Uuid.</exception> public async static Task <GattDeviceService> GetDeviceService(string serviceUuid) { Validator.RequiresNotNullOrEmpty(serviceUuid); string selector = GattDeviceService.GetDeviceSelectorFromUuid(new Guid(serviceUuid)); var devices = await DeviceInformation.FindAllAsync(selector); DeviceInformation di = devices.FirstOrDefault(); if (di == null) { throw new DeviceNotFoundException(); } return(await GattDeviceService.FromIdAsync(di.Id)); }
private async void DeviceAdded(DeviceWatcher watcher, DeviceInformation device) { if (_devices.Contains(device.Name)) { try { var service = await GattDeviceService.FromIdAsync(device.Id); Debug.WriteLine("Opened Service!!"); } catch { Debug.WriteLine("Failed to open service."); } } }
private async void ScaleAdded(DeviceWatcher watcher, DeviceInformation device) { if (device.Name == ScaleName) { try { var service = await GattDeviceService.FromIdAsync(device.Id); var characteristics = service.GetAllCharacteristics(); } catch { Debug.WriteLine("Failed to open service."); } } }
// Get currently selected service using the device id. // This is called everytime before an attempt to get data is made, due to the possiblity of the device disconnecting. internal async Task <GattDeviceService> GetService() { // Attempt to get the servcei using device id. var service = await GattDeviceService.FromIdAsync(this.DeviceID); if (service == null) { // Error accessing the service. throw new UnauthorizedAccessException(); } else { // Have succesfully retrieved the service, return it. return(service); } }
private static async Task <GattReadResult> ReadDeviceIdAsync(string selector) { var devices = await DeviceInformation.FindAllAsync(selector, new string[] { devicesContainerId }); DeviceInformation di = devices.FirstOrDefault(); var containerId = di.Properties[devicesContainerId].ToString(); var selectorWithContainer = String.Format("{0} AND System.Devices.ContainerId:=\"{{{1}}}\"", selector, containerId); var serviceInformations = await DeviceInformation.FindAllAsync(selectorWithContainer); var deviceInformationService = await GattDeviceService.FromIdAsync(serviceInformations.Single().Id); var systemId = deviceInformationService.GetCharacteristics(GattDeviceService.ConvertShortIdToUuid(0x2a23)).First(); // System ID return(await systemId.ReadValueAsync(BluetoothCacheMode.Uncached)); }
private async void ButtonAction2_Click(object sender, RoutedEventArgs e) { var serviceIds = new[] { "00001800-0000-1000-8000-00805F9B34FB", "00001801-0000-1000-8000-00805F9B34FB", "9A66FA00-0800-9191-11E4-012D1540CB8E", "9A66FB00-0800-9191-11E4-012D1540CB8E", "9A66FC00-0800-9191-11E4-012D1540CB8E", "9A66FD21-0800-9191-11E4-012D1540CB8E", "9A66FD51-0800-9191-11E4-012D1540CB8E", "9A66FE00-0800-9191-11E4-012D1540CB8E" }; DevicesInformation = ""; var bts = await DeviceInformation.FindAllAsync(); foreach (var serviceId in serviceIds) { DevicesInformation += $"{serviceId}{Environment.NewLine}"; foreach (var device in bts) { if (!device.Id.ToUpper().Contains(serviceId)) { continue; } DevicesInformation += $" {device.Id}{Environment.NewLine}"; try { var service = await GattDeviceService.FromIdAsync(device.Id); if (null == service) { continue; } var characteristicsFa00 = service.GetAllCharacteristics(); DevicesInformation += $" Allow Chars{Environment.NewLine}"; } catch { DevicesInformation += $" Don't Allow Chars{Environment.NewLine}"; } } } }
// Setup // Saves GATT service object in array private async Task <bool> init() { // Retrieve instances of the GATT services that we will use for (int i = 0; i < NUM_SENSORS; i++) { // Setting Service GUIDs // Built in enumerations are found in the GattServiceUuids class like this: GattServiceUuids.GenericAccess Guid BLE_GUID; if (i < 6) { BLE_GUID = new Guid("F000AA" + i + "0-0451-4000-B000-000000000000"); } else { BLE_GUID = new Guid("0000FFE0-0000-1000-8000-00805F9B34FB"); } // Retrieving and saving GATT services var services = await DeviceInformation.FindAllAsync(GattDeviceService.GetDeviceSelectorFromUuid(BLE_GUID), null); if (services != null && services.Count > 0) { if (services[0].IsEnabled) { GattDeviceService service = await GattDeviceService.FromIdAsync(services[0].Id); if (service.Device.ConnectionStatus == BluetoothConnectionStatus.Connected) { serviceList[i] = service; } else { return(false); } } else { return(false); } } else { return(false); } } return(true); }
async Task <bool> ConnectDaydream(DeviceInformation info) { try { Console.WriteLine(string.Format("Trying to connect {0} {1}", info.Name, info.Id)); service = await AsTask(GattDeviceService.FromIdAsync(info.Id)); if (service == null) { Console.WriteLine("Error: Another program is using the device."); return(false); } var list = service.GetCharacteristics(Constants.DAYDREAM_CHARACTERISTICS_UUID); if (list.Count == 0) { Console.WriteLine("Error: No characteristics. uuid=DAYDREAM_CHARACTERISTICS_UUID."); return(false); } daydreamCharacteristic = list[0]; daydreamCharacteristic.ValueChanged += CallbackDaydream; var status = await AsTask(daydreamCharacteristic.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify)); //Console.WriteLine("Write: {0}", status.ToString()); if (status == GattCommunicationStatus.Success) { Console.WriteLine("Connected."); type = Constants.TYPE_DAYDREAM; bdaddr = BDAddrToString(service.Device.BluetoothAddress); deviceId = service.Device.DeviceId; deviceName = info.Name; return(true); } else { Console.WriteLine("Error: Cannot connect. (Timeout)"); return(false); } } catch (Exception e) { Console.WriteLine("Error: Caught exception. " + e.Message); } return(false); }
private async void startButton_Click(object sender, RoutedEventArgs e) { int count = 0; /*** Get a list of devices that match desired service UUID ***/ Guid selectedService = new Guid("0000AA00-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 displayTextBox.Text = string.Format("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); displayTextBox.Text = string.Format("\r\nService UUID: {0}", myService.Uuid.ToString()); /*** Create an instance of the characteristic of the specified service ***/ Guid selectedCharacteristic = new Guid("0000AA01-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" /*** Reading 1000 data samples ***/ //GattReadResult bleData; //byte[] bleDataArray = new byte[6]; // for (int i = 0; i < 1000; i++) // { // /* Read data from a buffer */ // bleData = await myCharacteristic.ReadValueAsync(BluetoothCacheMode.Uncached); // DataReader.FromBuffer(bleData.Value).ReadBytes(bleDataArray); // /* Display each element of raw data */ // count++; // displayTextBox.Text = string.Format("\r\nValue {0}: {1} {2} {3} {4} {5} {6}", count, bleDataArray[0], bleDataArray[1], bleDataArray[2], bleDataArray[3], bleDataArray[4], bleDataArray[5]); // /* Pause thread execution */ //// await Task.Delay(TimeSpan.FromMilliseconds(100)); // } /*** Create an event handler when the characteristic value changes ***/ myCharacteristic.ValueChanged += myCharacteristic_ValueChanged; await myCharacteristic.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify); }
public async Task <int> Subscribe(String ID) { service = await GattDeviceService.FromIdAsync(ID); characteristics = service.GetCharacteristics(GattCharacteristicUuids.HeartRateMeasurement)[0]; if (!subscribedForNotifications) { // initialize status GattCommunicationStatus status = GattCommunicationStatus.Unreachable; var cccdValue = GattClientCharacteristicConfigurationDescriptorValue.None; if (characteristics.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Indicate)) { cccdValue = GattClientCharacteristicConfigurationDescriptorValue.Indicate; } else if (characteristics.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Notify)) { cccdValue = GattClientCharacteristicConfigurationDescriptorValue.Notify; } try { // BT_Code: Must write the CCCD in order for server to send indications. // We receive them in the ValueChanged event handler. status = await characteristics.WriteClientCharacteristicConfigurationDescriptorAsync(cccdValue); if (status == GattCommunicationStatus.Success) { characteristics.ValueChanged += Characteristic_ValueChanged; subscribedForNotifications = true; Debug.WriteLine("Successfully subscribed for value changes"); return(1); } else { Debug.WriteLine($"Error registering for value changes: {status}"); } } catch (UnauthorizedAccessException ex) { // This usually happens when a device reports that it support indicate, but it actually doesn't. Debug.WriteLine(ex.Message); } } return(0); }
}//end constructor /* Methods */ public async Task InitializationAsync() { /*** Get a list of devices that match desired service UUID ***/ var devices = await DeviceInformation.FindAllAsync(GattDeviceService.GetDeviceSelectorFromUuid(gattService)); /*** Create an instance of the eTDS device ***/ TdsDevice = devices[0]; // Only one device should be matching the eTDS-specific service UUID /*** Create an instance of the specified eTDS service ***/ myService = await GattDeviceService.FromIdAsync(TdsDevice.Id); /*** Create an instance of the characteristic of the specified service ***/ const int CHARACTERISTIC_INDEX = 0; myCharacteristic = myService.GetCharacteristics(gattCharacteristic)[CHARACTERISTIC_INDEX]; myCharacteristic.ProtectionLevel = GattProtectionLevel.Plain; // Set security level to "No encryption" }
private static async Task ReadShockSensor(Guid charId) { var gattDevices = await DeviceInformation.FindAllAsync(GetServiceSelector()); foreach (var gattDevice in gattDevices) { try { var gattServce = await GattDeviceService.FromIdAsync(gattDevice.Id); if (gattServce == null) { Console.WriteLine("Failed to open device: {0}", gattDevice.Id); continue; } var allCharacteristics = gattServce.GetCharacteristics(charId); if (allCharacteristics == null || allCharacteristics.Count == 0) { continue; } var gattCharacteristic = allCharacteristics[0]; Console.WriteLine("Setting chararcteristic config to Indicate...."); var charConfig = await gattCharacteristic.ReadClientCharacteristicConfigurationDescriptorAsync(); if (charConfig.Status == GattCommunicationStatus.Success && charConfig.ClientCharacteristicConfigurationDescriptor != GattClientCharacteristicConfigurationDescriptorValue.Indicate) { await gattCharacteristic.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Indicate); } Console.WriteLine("Reading characteristic value...."); var charValue = await gattCharacteristic.ReadValueAsync(BluetoothCacheMode.Uncached); var strValue = BitConverter.ToString(charValue.Value.ToArray()); Console.WriteLine("Characteristic={0} Handle={2} Value={1}", gattCharacteristic.Uuid, strValue, gattCharacteristic.AttributeHandle); } catch (Exception e) { Console.WriteLine(e.ToString()); } } }
private async Task <Dictionary <string, RsCharacteristic> > GetCharsFromDeviceId(string deviceId, Dictionary <string, RsCharacteristic> dicCharacteristics) { try { var service = await GattDeviceService.FromIdAsync(deviceId); if (null != service) { dicCharacteristics = CompletePropsFromServiceChars(service, deviceId, dicCharacteristics); } } catch { // ignored } return(dicCharacteristics); }
private async void MainPage_Loaded(object sender, RoutedEventArgs e) { var bts = await DeviceInformation.FindAllAsync(); const string deviceId = @"\\?\BTHLEDevice#{9a66fa00-0800-9191-11e4-012d1540cb8e}_e0144d4f3d49#a&1f09a1af&0&0020#{6e3bb679-4372-40c8-9eaa-4509df260cd8}"; var device = bts.First(di => di.Name == DeviceName && di.Id == deviceId); if (null == device) { return; } _service = await GattDeviceService.FromIdAsync(device.Id); if (null == _service) { return; } _characteristics = _service.GetAllCharacteristics(); if (null == _characteristics || _characteristics.Count <= 0) { return; } var characteristic = _characteristics.First(charact => charact.Uuid == RollingSpiderCharacteristicUuids.Parrot_PowerMotors); try { var charName = CharacteristicUuidsResolver.GetNameFromUuid(characteristic.Uuid); Debug.WriteLine(charName); for (int i = 0; i < 255; i++) { Debug.WriteLine(i); byte[] arr = { (byte)02, (byte)40, (byte)20, (byte)0D, 00, 09, 00, 04, 00, 52, 43, 00, 04, (byte)i, 02, 00, 01, 00, }; var writer = new DataWriter(); writer.WriteBytes(arr); await characteristic.WriteValueAsync(writer.DetachBuffer(), GattWriteOption.WriteWithoutResponse); await Task.Delay(TimeSpan.FromSeconds(1)); } } catch { } }
public async Task Connect() { // create service DeviceServices.Add(await GattDeviceService.FromIdAsync(DeviceInformations[0].Id)); DeviceServices.Add(await GattDeviceService.FromIdAsync(DeviceInformations[1].Id)); DeviceServices.Add(await GattDeviceService.FromIdAsync(DeviceInformations[2].Id)); DeviceServices.Add(await GattDeviceService.FromIdAsync(DeviceInformations[3].Id)); DeviceServices.Add(await GattDeviceService.FromIdAsync(DeviceInformations[4].Id)); // register characteristics A00 RegisterCharacteristic(ParrotUuids.Service_A00, ParrotUuids.Characteristic_A01); RegisterCharacteristic(ParrotUuids.Service_A00, ParrotUuids.Characteristic_A02); RegisterCharacteristic(ParrotUuids.Service_A00, ParrotUuids.Characteristic_A0A_Movement); RegisterCharacteristic(ParrotUuids.Service_A00, ParrotUuids.Characteristic_A0B_SimpleCommands); RegisterCharacteristic(ParrotUuids.Service_A00, ParrotUuids.Characteristic_A0C_EmergencyStop); RegisterCharacteristic(ParrotUuids.Service_A00, ParrotUuids.Characteristic_A1E_InitCount1To20); RegisterCharacteristic(ParrotUuids.Service_A00, ParrotUuids.Characteristic_A1F); // register characteristics B00 RegisterCharacteristic(ParrotUuids.Service_B00, ParrotUuids.Characteristic_B01); RegisterCharacteristic(ParrotUuids.Service_B00, ParrotUuids.Characteristic_B0E_DroneState); RegisterCharacteristic(ParrotUuids.Service_B00, ParrotUuids.Characteristic_B1B); RegisterCharacteristic(ParrotUuids.Service_B00, ParrotUuids.Characteristic_B1C); RegisterCharacteristic(ParrotUuids.Service_B00, ParrotUuids.Characteristic_B1F); RegisterCharacteristic(ParrotUuids.Service_B00, ParrotUuids.Characteristic_B0F_Battery); // register characteristics C00 RegisterCharacteristic(ParrotUuids.Service_C00, ParrotUuids.Characteristic_C1); // register characteristics D21 RegisterCharacteristic(ParrotUuids.Service_D21, ParrotUuids.Characteristic_D22); RegisterCharacteristic(ParrotUuids.Service_D21, ParrotUuids.Characteristic_D23); RegisterCharacteristic(ParrotUuids.Service_D21, ParrotUuids.Characteristic_D24); // register characteristics D51 RegisterCharacteristic(ParrotUuids.Service_D51, ParrotUuids.Characteristic_D52); RegisterCharacteristic(ParrotUuids.Service_D51, ParrotUuids.Characteristic_D53); RegisterCharacteristic(ParrotUuids.Service_D51, ParrotUuids.Characteristic_D54); await RegisterEventhandling(ParrotUuids.Service_B00); await RegisterEventhandling(ParrotUuids.Service_D21); await RegisterEventhandling(ParrotUuids.Service_D51); //await InitChannelA1E(); }
private static async Task <GattReadResult> ReadDeviceNameAsync(string selector) { var devices = await DeviceInformation.FindAllAsync(selector, new string[] { devicesContainerId }); DeviceInformation di = devices.FirstOrDefault(); var containerId = di.Properties[devicesContainerId].ToString(); // Access to Generic Attribute Profile service var genericSlector = GattDeviceService.GetDeviceSelectorFromUuid(GattServiceUuids.GenericAccess); var selectorWithContainer = String.Format("{0} AND System.Devices.ContainerId:=\"{{{1}}}\"", genericSlector, containerId); var serviceInformations = await DeviceInformation.FindAllAsync(selectorWithContainer); var gapService = await GattDeviceService.FromIdAsync(serviceInformations.Single().Id); var deviceName = gapService.GetCharacteristics(GattDeviceService.ConvertShortIdToUuid(0x2a00)).First(); return(await deviceName.ReadValueAsync(BluetoothCacheMode.Uncached)); }
async Task <GattDeviceService> GetService(GATTDefaultService service) { var devices = await DeviceInformation.FindAllAsync(service.Filter); foreach (var device in devices) { if (device.Name == DEVICE_NAME) { var deviceService = await GattDeviceService.FromIdAsync(device.Id); if (deviceService.Device.DeviceInformation.Id == this.Device.Id) { return(deviceService); } } } return(null); }