public override IObservable <IScanResult> Scan(ScanConfig config) { if (this.IsScanning) { throw new ArgumentException("There is already an active scan"); } return(Observable.Create <IScanResult>(ob => { this.IsScanning = true; this.context.Clear(); var sub = this .WhenRadioReady() .Where(rdo => rdo != null) .Select(_ => this.CreateScanner(config)) .Switch() .Subscribe( async args => // CAREFUL { var device = this.context.GetPeripheral(args.BluetoothAddress); if (device == null) { var btDevice = await BluetoothLEDevice.FromBluetoothAddressAsync(args.BluetoothAddress); if (btDevice != null) { device = this.context.AddOrGetPeripheral(btDevice); } } if (device != null) { var adData = new AdvertisementData(args); var scanResult = new ScanResult(device, args.RawSignalStrengthInDBm, adData); ob.OnNext(scanResult); } }, ob.OnError ); var stopSub = this.scanSubject.Subscribe(_ => { this.IsScanning = false; sub?.Dispose(); ob.OnCompleted(); }); return () => { this.IsScanning = false; sub?.Dispose(); stopSub?.Dispose(); }; })); }
static async Task <bool> Pair(AnkiBLE.anki_vehicle vehicle) { BluetoothLEDevice device = await BluetoothLEDevice.FromBluetoothAddressAsync(vehicle.mac_address); DeviceInformationCustomPairing customPairing = device.DeviceInformation.Pairing.Custom; customPairing.PairingRequested += PairingRequestedHandler; DevicePairingResult result = await customPairing.PairAsync(DevicePairingKinds.ConfirmOnly, DevicePairingProtectionLevel.None); customPairing.PairingRequested -= PairingRequestedHandler; return(result.Status == DevicePairingResultStatus.Paired || result.Status == DevicePairingResultStatus.AlreadyPaired); }
private async Task <BluetoothLEDevice> ConnectToDevice(BluetoothLEAdvertisementReceivedEventArgs eventArgs) { BluetoothLEDevice device = await BluetoothLEDevice.FromBluetoothAddressAsync(eventArgs.BluetoothAddress); if (device == null) { Exception e = new Exception("Connecting to bluetooth device failed"); throw e; } return(device); }
/// <summary> /// Handler for devices found when duplicates are allowed /// </summary> /// <param name="watcher">The bluetooth advertisement watcher currently being used</param> /// <param name="btAdv">The advertisement recieved by the watcher</param> private async void DeviceFoundAsyncDuplicate(BluetoothLEAdvertisementWatcher watcher, BluetoothLEAdvertisementReceivedEventArgs btAdv) { BluetoothLEDevice currDevice = await BluetoothLEDevice.FromBluetoothAddressAsync(btAdv.BluetoothAddress); if (currDevice != null) { var device = new Device(this, currDevice, btAdv.RawSignalStrengthInDBm, btAdv.BluetoothAddress.ToString(), ParseAdvertisementData(btAdv.Advertisement)); Trace.Message("DiscoveredPeripheral: {0} Id: {1}", device.Name, device.Id); this.HandleDiscoveredDevice(device); } return; }
public async Task <IGattClient> ConnectToGattServerAsync() { BluetoothLEDevice uwpLeDevice = await BluetoothLEDevice.FromBluetoothAddressAsync(Address); if (uwpLeDevice == null) { return(null); } GattClient gattClient = new GattClient(this, uwpLeDevice); return(gattClient); }
private async void BleWatcher_Received(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args) { if (!string.IsNullOrEmpty(args.Advertisement.LocalName) && args.Advertisement.LocalName == "Flower care") { var device = await BluetoothLEDevice.FromBluetoothAddressAsync(args.BluetoothAddress); if (!bluetoothLEDevices.Any(x => x.DeviceId == device.DeviceId)) { bluetoothLEDevices.Add(device); } } }
/// <summary> /// connects to the BLE device and extracts more information for the /// <see cref="https://docs.microsoft.com/en-us/uwp/api/windows.devices.bluetooth.bluetoothledevice"/> /// </summary> /// <param name="address">the bluetooth device address to connect</param> /// <param name="broadcastTime">the time broadcast message received</param> /// <param name="rssi">the signal strength received</param> /// <returns></returns> private async Task <DnaBluetoothLEDevice> GetBluetoothLEDeviceAsync(ulong address, DateTimeOffset broadcastTime, short rssi) { // get bluetooth device info var device = await BluetoothLEDevice.FromBluetoothAddressAsync(address).AsTask(); // null check if (device == null) { return(null); } // NOTE: this can throw a System.Exception for failure // get GATT Services that are available var gatt = await device.GetGattServicesAsync().AsTask(); // if we have any services.. if (gatt.Status == GattCommunicationStatus.Success) { // loop each GATT Service foreach (var service in gatt.Services) { // this id contains GATT Profile Assigned number var gattProfileID = service.Uuid; //if(service.Uuid.ToString("N").Substring(4,4) == "1808") //{ // System.Diagnostics.Debugger.Break(); //} } } // return the new device information return(new DnaBluetoothLEDevice ( // Device Id deviceId: device.DeviceId, // Bluetooth address address: device.BluetoothAddress, // device name name: device.Name, // broadcast time broadcastTime: broadcastTime, // signal name rssi: rssi, // is connected? connected: device.ConnectionStatus == BluetoothConnectionStatus.Connected, // can pair? canPair: device.DeviceInformation.Pairing.CanPair, // is paired? paired: device.DeviceInformation.Pairing.IsPaired )); }
public override IObservable <IDevice> GetKnownDevice(Guid deviceId) => Observable.FromAsync(async ct => { IDevice device = null; var mac = deviceId.ToMacAddress(); var native = await BluetoothLEDevice.FromBluetoothAddressAsync(mac).AsTask(ct); if (native != null) { device = this.context.AddOrGetDevice(mac, native); } return(device); });
public async override Task <IDevice> ConnectToKnownDeviceAsync(Guid deviceGuid, ConnectParameters connectParameters, CancellationToken cancellationToken) { //convert GUID to string and take last 12 characters as MAC address var guidString = deviceGuid.ToString("N").Substring(20); ulong bluetoothAddr = Convert.ToUInt64(guidString, 16); var nativeDevice = await BluetoothLEDevice.FromBluetoothAddressAsync(bluetoothAddr); var currDevice = new Device(this, nativeDevice, 0, guidString); await ConnectToDeviceAsync(currDevice); return(currDevice); }
public async Task Connect() { if (this.NativeDevice != null && this.NativeDevice.ConnectionStatus == BluetoothConnectionStatus.Connected) { return; } this.connSubject.OnNext(ConnectionStatus.Connecting); this.NativeDevice = await BluetoothLEDevice.FromBluetoothAddressAsync(this.bluetoothAddress); this.NativeDevice.ConnectionStatusChanged += this.OnNativeConnectionStatusChanged; await this.NativeDevice.GetGattServicesAsync(BluetoothCacheMode.Uncached); // HACK: kick the connection on }
private async Task <BluetoothLEDevice> ConnectToDeviceAsync(BrilliantSoleDevice sole) { Console.WriteLine("Attempting to connect to " + sole.name); sole.device = await BluetoothLEDevice.FromBluetoothAddressAsync(sole.address); if (sole.device == null) { Console.WriteLine("Failed to connect to " + sole.name); throw new Exception("Failed to connect."); // TODO - Recover } Console.WriteLine("Successfully connected to " + sole.name); return(sole.device); }
/// <summary> /// Connects to the BLE device and extracts more information from the /// <seealso cref="https://docs.microsoft.com/en-us/uwp/api/windows.devices.bluetooth.bluetoothledevice"/> /// </summary> /// <param name="address">The BT address of the device to connect to</param> /// <param name="broadcastTime">The time the broadcast message was received</param> /// <param name="rssi">The signal strength in dB</param> /// <returns></returns> private async Task <DnaBluetoothLEDevice> GetBluetoothLEDeviceAsync(ulong address, DateTimeOffset broadcastTime, short rssi) { // Get bluetooth device info using var device = await BluetoothLEDevice.FromBluetoothAddressAsync(address).AsTask(); // Null guard if (device == null) { return(null); } // Get GATT services that are available var gatt = await device.GetGattServicesAsync().AsTask(); // If we have any services... if (gatt.Status == GattCommunicationStatus.Success) { // Loop each GATT service foreach (var service in gatt.Services) { // This ID contains the GATT Profile Assigned number we want // TODO: get more info to connect var gattProfileId = service.Uuid; if (service.Uuid.ToString("N").Substring(4, 4) == "1808") { } } } // Return the new device information return(new DnaBluetoothLEDevice ( // Device Id deviceId: device.DeviceId, // Bluetooth Address address: device.BluetoothAddress, // Device Name name: device.Name, // Broadcast Time broadcastTime: broadcastTime, // Signal Strength rssi: rssi, // Is Connected? connected: device.ConnectionStatus == BluetoothConnectionStatus.Connected, // Can Pair? canPair: device.DeviceInformation.Pairing.CanPair, // Is Paired paired: device.DeviceInformation.Pairing.IsPaired )); }
/// <summary> /// Connect to the BLE device and extracts information from the device /// </summary> /// <returns></returns> private async Task <DnaBluetoothLEDevice> GetBluetoothLEDeviceAsync(ulong address, DateTimeOffset brodcastTime, short rssi) { // Get bluetooth device info using var device = await BluetoothLEDevice.FromBluetoothAddressAsync(address).AsTask(); // Null guard if (device == null) { return(null); } // Get GATT services that are available var gatt = await device.GetGattServicesAsync().AsTask(); // If we have any services... if (gatt.Status == GattCommunicationStatus.Success) { // loop each GATT Service foreach (var services in gatt.Services) { // This Id contains the GATT profile assigned number we want! // TODO: get more info and connect var gattProfileId = services.Uuid; } } ; return(new DnaBluetoothLEDevice ( // Device Id deviceid: device.DeviceId, // BlueTooth Address address: device.BluetoothAddress, // Device name name: device.Name, // Time of broadcast broadcastTime: brodcastTime, // Signal strength rssi: rssi, connected: device.ConnectionStatus == BluetoothConnectionStatus.Connected, canpair: device.DeviceInformation.Pairing.CanPair, paired: device.DeviceInformation.Pairing.IsPaired )); }
private async static Task <GattDeviceService> waitConnection(AnkiBLE.anki_vehicle vehicle) { BluetoothLEDevice bluetoothLeDevice = null; GattDeviceService service = null; bluetoothLeDevice = await BluetoothLEDevice.FromBluetoothAddressAsync(vehicle.mac_address); while (bluetoothLeDevice.ConnectionStatus != BluetoothConnectionStatus.Connected) { throw new Exception("Not connected!"); } service = bluetoothLeDevice.GetGattService(Guid.Parse("be15beef-6186-407e-8381-0bd89c4d8df4")); return(service); }
internal BluetoothAdvertisingEvent(BluetoothLEAdvertisementReceivedEventArgs args) { _rssi = args.RawSignalStrengthInDBm; _txPower = args.TransmitPowerLevelInDBm.HasValue ? (sbyte)args.TransmitPowerLevelInDBm.Value : (sbyte)0; /*var sections = args.Advertisement.GetSectionsByType(0xA); * if(sections != null && sections.Count > 0) * { * var array = sections[0].Data.ToArray(); * * _txPower = sections[0].Data.GetByte(0); * }*/ var appearanceSections = args.Advertisement.GetSectionsByType(0x19); if (appearanceSections != null && appearanceSections.Count > 0) { var appearanceArray = appearanceSections[0].Data.ToArray(); _appearance = BitConverter.ToUInt16(appearanceArray, 0); } // https://docs.microsoft.com/en-us/uwp/api/windows.devices.bluetooth.bluetoothledevice.frombluetoothaddressasync?view=winrt-20348 // If there are no other pending request, and the remote device is unreachable, // then the system will wait for seven (7) seconds before it times out. If // there are other pending requests, then each of the requests in the queue can // take seven (7) seconds to process, so the further yours is toward the back // of the queue, the longer you'll wait. IAsyncOperation <BluetoothLEDevice> deviceAsync = BluetoothLEDevice.FromBluetoothAddressAsync(args.BluetoothAddress, args.BluetoothAddressType); // https://github.com/inthehand/32feet/issues/96 // Wait some time for this task to complete otherwise the event will fire // before the 'Device' property as been set. if (deviceAsync.AsTask().Wait(7000)) { Device = deviceAsync.GetResults(); } else { try { // The documents state that it is not possible to cancel 'FromBluetoothAddressAsync' // so mask any exceptions before calling this. deviceAsync.Cancel(); } catch { } } _advertisement = args.Advertisement; }
public override async Task ConnectAsync() { if (ConnectionStatus.DISCONNECTED == ConnectionStatus) { ConnectionStatus = ConnectionStatus.CONNECTING; BluetoothLeDevice = await BluetoothLEDevice.FromBluetoothAddressAsync(BluetoothAddress); BluetoothLeDevice.ConnectionStatusChanged += ConnectionStatusChanged; var gattDeviceServicesResult = await BluetoothLeDevice.GetGattServicesForUuidAsync(SERVICE_UUID); Services = gattDeviceServicesResult.Services; var foundService = gattDeviceServicesResult.Services.Single(s => s.Uuid == SERVICE_UUID); GattCharacteristicsResult gattCharacteristicsResult = await foundService.GetCharacteristicsAsync(); ReadData = gattCharacteristicsResult.Characteristics.Single(x => x.Uuid == CHARACTERISTIC_READ_UUID); Debug.WriteLine("Found Read Char"); WriteData = gattCharacteristicsResult.Characteristics.Single(x => x.Uuid == CHARACTERISTIC_WRITE_UUID); Debug.WriteLine("Found Write Char"); GattCommunicationStatus status = GattCommunicationStatus.Unreachable; int count = 0; do { try { status = await ReadData.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify); Debug.WriteLine("Notify status: " + status); } catch (Exception e) { Debug.WriteLine("Error during notify" + e.Message); } } while (status != GattCommunicationStatus.Success && ++count < 5); if (status == GattCommunicationStatus.Success) { ReadData.ValueChanged += HandleRealTimeData; await WriteValue(); ConnectionStatus = ConnectionStatus.CONNECTED; } else { ConnectionStatus = ConnectionStatus.DISCONNECTED; } } }
private async void Initialize() { Console.WriteLine(tag, "Connecting..."); this.Device = await BluetoothLEDevice.FromBluetoothAddressAsync(this.DeviceAddress); DevicePairingResult result = await this.Device.DeviceInformation.Pairing.PairAsync(); if (result.Status != DevicePairingResultStatus.AlreadyPaired && result.Status != DevicePairingResultStatus.Paired) { Console.WriteLine(tag, "Failed to pair:" + result.Status); this.Device.Dispose(); return; } EnableUpgradeMode(); }
private async void OnAdvertisementReceived(BluetoothLEAdvertisementWatcher watcher, BluetoothLEAdvertisementReceivedEventArgs eventArgs) { Debug.Write("Ad "); string deviceName = eventArgs.Advertisement.LocalName; Debug.WriteLine(deviceName); if (deviceName == "Nano33BLE") { BluetoothLEDevice device = await BluetoothLEDevice.FromBluetoothAddressAsync(eventArgs.BluetoothAddress); watcher.Stop(); SetupConnection(device); } }
// Pairs device with Sensortag public async Task PairSensorTagAsync() { device = await BluetoothLEDevice.FromBluetoothAddressAsync(bleadress); bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(device.DeviceId); var status = await device.DeviceInformation.Pairing.PairAsync(); await GetGATTServicesDataAsync(device); }
internal override async Task RenewCharacteristic() { if (Device != null) { Device = await BluetoothLEDevice.FromBluetoothAddressAsync(Device.BluetoothAddress); Gatt = await Device.GetGattServicesAsync(BluetoothCacheMode.Uncached); AllCharacteristic = await Gatt.Services.Single(s => s.Uuid == Guid.Parse("4E050000-74FB-4481-88B3-9919B1676E93")).GetCharacteristicsAsync(BluetoothCacheMode.Uncached); Characteristic = AllCharacteristic.Characteristics.Single(s => s.Uuid == Guid.Parse("000092d1-0000-1000-8000-00805f9b34fb")); MainBoard.WriteLine("New Hub Found of type " + Enum.GetName(typeof(Hub.Types), Type), Color.Green); } }
public async Task Start() { _device = await BluetoothLEDevice.FromBluetoothAddressAsync(_address); if (_device == null) { GlobalCounters.IncrementFailedCreate(); return; } GlobalDeviceNameTracking.ReportName(_device.Name, _device.BluetoothAddress); _device.ConnectionStatusChanged += ConnectionStatusChanged; GlobalCounters.IncrementDevicesCreated(); }
/// <summary> /// Obtain a new Characteristic /// </summary> /// <param name="device"></param> /// <returns></returns> internal virtual async System.Threading.Tasks.Task RenewCharacteristic() { if (Device != null) { Device = await BluetoothLEDevice.FromBluetoothAddressAsync(Device.BluetoothAddress); Gatt = await Device.GetGattServicesAsync(BluetoothCacheMode.Uncached); AllCharacteristic = await Gatt.Services.Single(s => s.Uuid == Guid.Parse("00001623-1212-efde-1623-785feabcd123")).GetCharacteristicsAsync(BluetoothCacheMode.Uncached); Characteristic = AllCharacteristic.Characteristics.Single(c => c.Uuid == Guid.Parse("00001624-1212-efde-1623-785feabcd123")); MainBoard.WriteLine("New Hub Found of type " + Enum.GetName(typeof(Hub.Types), Type), Color.Green); } }
/// <summary> /// Handle the client's request to connect to a particular peripheral. /// Valid in the discovery state; transitions to connected state on success. /// </summary> /// <param name="parameters"> /// A JSON object containing the UUID of a peripheral found by the most recent discovery request /// </param> private async Task Connect(JObject parameters) { if (_services != null) { //throw JsonRpcException.InvalidRequest("already connected to peripheral"); return; } var peripheralId = parameters["peripheralId"].ToObject <ulong>(); if (!_reportedPeripherals.Contains(peripheralId)) { // the client may only connect to devices that were returned by the current discovery request throw JsonRpcException.InvalidParams($"invalid peripheral ID: {peripheralId}"); } _peripheral = await BluetoothLEDevice.FromBluetoothAddressAsync(peripheralId); var servicesResult = await _peripheral.GetGattServicesAsync(BluetoothCacheMode.Uncached); if (servicesResult.Status != GattCommunicationStatus.Success) { throw JsonRpcException.ApplicationError($"failed to enumerate GATT services: {servicesResult.Status}"); } _peripheral.ConnectionStatusChanged += OnPeripheralStatusChanged; _services = servicesResult.Services; // collect optional services plus all services from all filters // Note: this modifies _optionalServices for convenience since we know it'll go away soon. _allowedServices = _optionalServices ?? new HashSet <Guid>(); _allowedServices = _filters .Where(filter => filter.RequiredServices?.Count > 0) .Aggregate(_allowedServices, (result, filter) => { result.UnionWith(filter.RequiredServices); return(result); }); // clean up resources used by discovery if (_watcher != null) { _watcher.Stop(); _watcher = null; } //_reportedPeripherals.Clear(); _optionalServices = null; }
/// <summary> /// Connects to the BLE device and extracts more information from the /// <see cref="https://docs.microsoft.com/en-us/uwp/api/windows.devices.bluetooth.bluetoothledvice"/> /// </summary> /// <param name="address">The Bluetooth address of the device to connect to</param> /// <param name="broadcastTime">The time the broadcast message was received</param> /// <param name="rssi">The signal strength in dB</param> /// <returns></returns> /// <Capabilities> <DeviceCapability Name = "bluetooth"/></Capabilities> private async Task <RoverBluetoothLEDevice> GetBluetoothLEDeviceAsync(ulong address, DateTimeOffset broadcastTime, short rssi) { // Get bluetooth device info var device = await BluetoothLEDevice.FromBluetoothAddressAsync(address).AsTask(); // Null Guard if (device == null) { return(null); } // NOTE: This can throw a System.Exception for failures // Get GATT services that are available var gatt = await device.GetGattServicesAsync().AsTask(); // If we have any services... if (gatt.Status == GattCommunicationStatus.Success) { // Loop each GATT service foreach (var service in gatt.Services) { // This ID contains the GATT Profile Assigned number needed // TODO: Get more info and connect var gattProfileId = service.Uuid; } } // Return the new device information return(new RoverBluetoothLEDevice ( // Device ID deviceID: device.DeviceId, // Bluetooth Address addressBT: device.BluetoothAddress, // Device name name: device.Name, // Broadcast time broadcastTime: broadcastTime, // Signal strength rssi: rssi, // Is Connected? connected: device.ConnectionStatus == BluetoothConnectionStatus.Connected, // Can Pair? canPair: device.DeviceInformation.Pairing.CanPair, // Is Paired? paired: device.DeviceInformation.Pairing.IsPaired )); }
public override IObservable <IPeripheral?> GetKnownPeripheral(string peripheralUuid) => Observable.FromAsync(async ct => { var mac = Guid.Parse(peripheralUuid).ToBluetoothAddress(); var per = this.context.GetPeripheral(mac); if (per == null) { var native = await BluetoothLEDevice.FromBluetoothAddressAsync(mac).AsTask(ct); if (native != null) { per = this.context.AddOrGetPeripheral(native); } } return(per); });
internal override async Task RenewCharacteristic() { if (Device != null) { Device = await BluetoothLEDevice.FromBluetoothAddressAsync(Device.BluetoothAddress); Gatt = await Device.GetGattServicesAsync(BluetoothCacheMode.Uncached); AllCharacteristic = await Gatt.Services.Single(s => s.Uuid == Guid.Parse("49535343-FE7D-4AE5-8FA9-9FAFD205E455")).GetCharacteristicsAsync(BluetoothCacheMode.Uncached); Characteristic = AllCharacteristic.Characteristics.Single(c => c.Uuid == Guid.Parse("49535343-1E4D-4BD9-BA61-23C647249616")); TxCharacteristic = AllCharacteristic.Characteristics.Single(c => c.Uuid == Guid.Parse("49535343-8841-43F4-A8D4-ECBE34729BB3")); MainBoard.WriteLine("New Hub Found of type " + Enum.GetName(typeof(Hub.Types), Type), Color.Green); } }
private async void AdbWatcher_Received(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args) { if (args.Advertisement.ServiceUuids.Contains(this.targetUuid)) { Debug.WriteLine("detect"); this.adbWatcher.Stop(); this.adbWatcher.Received -= AdbWatcher_Received; this.bleDevice = await BluetoothLEDevice.FromBluetoothAddressAsync(args.BluetoothAddress); // MAC Address -> BLEDevice this.condition.Signal(); await Task.Delay(1000); this.condition.Reset(); } }
private static async void bluetoothFoundAsync(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args) { string deviceName = args.Advertisement.LocalName; string deviceAddress = args.BluetoothAddress.ToString(); if (deviceName.Contains("Foldio")) { var bdevice = await BluetoothLEDevice.FromBluetoothAddressAsync(args.BluetoothAddress); ScannedDevicesList.Add(bdevice); watcher.Stop(); } else { } }
// AdvertisementWatcher Detected device private async void DeviceDiscovered(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args) { bool returnDevice = scanServices.Count == 0; if (!returnDevice) { foreach (Guid uuid in args.Advertisement.ServiceUuids) { returnDevice = scanServices.Contains(uuid.ToString().ToUpper()); if (returnDevice) { break; } } } if (returnDevice) { BluetoothLEDevice device = await BluetoothLEDevice.FromBluetoothAddressAsync(args.BluetoothAddress); if (device != null) { if (!deviceAddresses.Contains(device.BluetoothAddress)) { devices.Add(device); deviceAddresses.Add(device.BluetoothAddress); } string advertisedName = device.Name; List <BluetoothLEAdvertisementDataSection> complete = new List <BluetoothLEAdvertisementDataSection>(args.Advertisement.GetSectionsByType(BluetoothLEAdvertisementDataTypes.CompleteLocalName)); List <BluetoothLEAdvertisementDataSection> smallName = new List <BluetoothLEAdvertisementDataSection>(args.Advertisement.GetSectionsByType(BluetoothLEAdvertisementDataTypes.ShortenedLocalName)); if (complete.Count > 0) { advertisedName = Encoding.UTF8.GetString(complete[0].Data.ToArray()); } else if (smallName.Count > 0) { advertisedName = Encoding.UTF8.GetString(smallName[0].Data.ToArray()); } callback.onDeviceDiscovered((device.BluetoothAddress + "").ToUpper(), advertisedName, args.RawSignalStrengthInDBm); } else { Debug.WriteLine("-------------Error:------------"); Debug.WriteLine("Devie with address " + args.BluetoothAddress + " was a null device!"); Debug.WriteLine("-------------------------------"); } } }
private async Task <bool> ConnectDevice() { if (Device == null) { string bta = BluetoothAddress.ToString("X"); Device = await BluetoothLEDevice.FromBluetoothAddressAsync(BluetoothAddress); if (Device == null) { return(false); } Dbg("connected to device: " + bta); var characteristics = new List <GattCharacteristic>(); var gatt = await Device.GetGattServicesAsync(); var svc_rest = gatt.Services.First(s => s.Uuid == BT.SVC_REST); var svc_advertising = gatt.Services.First(s => s.Uuid == BT.SVC_ADVERTISING); characteristics.AddRange((await svc_rest.GetCharacteristicsAsync()).Characteristics); characteristics.AddRange((await svc_advertising.GetCharacteristicsAsync()).Characteristics); try { // save TX/RX/Manufacturer channels CharTX = characteristics.First(c => c.Uuid == BT.CHAR_TX); CharRX = characteristics.First(c => c.Uuid == BT.CHAR_RX); CharFeedback = characteristics.First(c => c.Uuid == BT.CHAR_FEEDBACK); } catch (Exception) { Dbg("error configuring characteristics: " + bta); Device = null; return(false); } await RefreshData(); #region there is a bug with UWP read notifications, this does not work (yet) //CharRX.ValueChanged += (obj, args) => ProcessRXData(args.CharacteristicValue); // var status = await CharRX.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify); // if (status != GattCommunicationStatus.Success) // { // throw new Exception("Could not connect to receive channel."); // } // Dbg("registered for rx notify: " + bta); #endregion } return(true); }