Windows UWP Verbindung zu BLE Gerät nach Entdeckung

UPDATE 04/17 - MACHER-UPDATE

Microsoft aktualisiert haben Ihre Bluetooth-APIs. Wir haben jetzt ungepaarten BLE-Gerät-Kommunikation!

Haben Sie sehr wenig Dokumentation bis hin im moment, aber hier ist der wesentlich vereinfachte neue Struktur:

BleWatcher = new BluetoothLEAdvertisementWatcher 
{ 
    ScanningMode = BluetoothLEScanningMode.Active
};
BleWatcher.Start();

BleWatcher.Received += async (w, btAdv) => {
    var device = await BluetoothLEDevice.FromBluetoothAddressAsync(btAdv.BluetoothAddress);
    Debug.WriteLine($"BLEWATCHER Found: {device.name}");

    //SERVICES!!
    var gatt = await device.GetGattServicesAsync();
    Debug.WriteLine($"{device.Name} Services: {gatt.Services.Count}, {gatt.Status}, {gatt.ProtocolError}");

    //CHARACTERISTICS!!
    var characs = await gatt.Services.Single(s => s.Uuid == SAMPLESERVICEUUID).GetCharacteristicsAsync();
    var charac = characs.Single(c => c.Uuid == SAMPLECHARACUUID);
    await charac.WriteValueAsync(SOMEDATA);
};

Jetzt viel besser. Wie ich sagte, es gibt so gut wie keine Dokumentation im moment, ich habe ein sonderbares Problem wo meine ValueChanged-callback-Haltestellen genannt wird, nach 30 Sekunden oder so, obwohl das scheint zu sein, einen gesonderten scoping-Problem.

UPDATE 2 - EINIGE VERRÜCKTHEIT

Nach etwas mehr Herumspielen mit dem neuen Schöpfer-update gibt es ein paar mehr Dinge zu beachten, wenn Gebäude BLE apps.

• Sie nicht mehr benötigen, führen Sie das Bluetooth-Zeug auf dem UI-thread. Es scheint nicht, werden alle Berechtigungen für windows BLE ohne pairing nicht mehr so notwendig für die Ausführung auf UI-thread.
• Finden Sie möglicherweise, dass Ihre Anwendung Stoppt den Empfang von updates aus dem Gerät nach einer Zeit. Dies ist ein scoping-Problem, bei dem Objekte entsorgt werden, sollte nicht. Im obigen code, wenn Sie waren zu hören ValueChanged auf die charac Sie können dieses Problem. Dies ist, weil die GattCharacteristic entsorgt wird, bevor es sein sollte, legen Sie die Eigenschaft als global und nicht sich auf es kopiert werden.
• Trennen scheint ein bisschen kaputt. Das beenden einer app keine verbindungen zu beenden. Als solche stellen Sie sicher, dass Sie die App.xml.cs OnSuspended Rückruf zum beenden von verbindungen. Andernfalls erhalten Sie ein wenig von einer seltsamen Zustand, in dem Windows scheint zu halten (und Lesen!!) die BLE-Verbindung.

Gut es hat seine Macken aber es funktioniert!

ALTE ANTWORT

Nachdem Jason die richtige Antwort über die Geräte müssen gekoppelt werden, um Ihre Dienstleistungen entdeckt werden, ist hier einige Beispiel-code an diese Adresse:

    private void SetupBluetooth()
    {
        Watcher = new BluetoothLEAdvertisementWatcher { ScanningMode = BluetoothLEScanningMode.Active };
        Watcher.Received += DeviceFound;

        DeviceWatcher = DeviceInformation.CreateWatcher();
        DeviceWatcher.Added += DeviceAdded;
        DeviceWatcher.Updated += DeviceUpdated;

        StartScanning();
    }

    private void StartScanning()
    {
        Watcher.Start();
        DeviceWatcher.Start();
    }

    private void StopScanning()
    {
        Watcher.Stop();
        DeviceWatcher.Stop();
    }

    private async void DeviceFound(BluetoothLEAdvertisementWatcher watcher, BluetoothLEAdvertisementReceivedEventArgs btAdv)
    {
        if (_devices.Contains(btAdv.Advertisement.LocalName))
        {
            await Dispatcher.RunAsync(CoreDispatcherPriority.Low, async () =>
            {
                Debug.WriteLine($"---------------------- {btAdv.Advertisement.LocalName} ----------------------");
                Debug.WriteLine($"Advertisement Data: {btAdv.Advertisement.ServiceUuids.Count}");
                var device = await BluetoothLEDevice.FromBluetoothAddressAsync(btAdv.BluetoothAddress);
                var result = await device.DeviceInformation.Pairing.PairAsync(DevicePairingProtectionLevel.None);
                Debug.WriteLine($"Pairing Result: {result.Status}");
                Debug.WriteLine($"Connected Data: {device.GattServices.Count}");
            });
        }
    }

    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 void DeviceUpdated(DeviceWatcher watcher, DeviceInformationUpdate update)
    {
        Debug.WriteLine($"Device updated: {update.Id}");
    }

Die wichtigsten Dinge, die hier zu beachten sind:

• DeviceWatcher braucht beides, Hinzugefügt und Aktualisiert werden Eigenschaften an die Arbeit.
• Müssen Sie fangen die exception FileNotFound die Auftritt, wenn Sie versuchen, zu vernehmen, ein service, der nicht gepaart ist, oder noch nicht bereit.

InformationsquelleAutor der Antwort Gerard Wilkinson

Gerard Wilkinson ' s Antwort ist richtig. Das Leben leichter zu machen, drehte ich Sie in einem erwartbaren Methode mit Reactive Extensions (). Jegliche Kommentare sind willkommen.

Also, wenn Sie das Gerät gefunden mit dem BluetoothLEAdvertisementWatcher und mit ihm gekoppelt ist, können Sie verwenden Sie diese Option, damit GATTServices.

private async Task<GattDeviceService> GetGATTServiceAsync(string deviceName)
{
  //devicewatcher is abused to trigger connection
  var deviceWatcher = DeviceInformation.CreateWatcher(); //trick to enable GATT

  var addedSource = Observable.FromEventPattern(deviceWatcher, nameof(deviceWatcher.Added))
                              .Select(pattern => ((DeviceInformation)pattern.EventArgs));

  var updatedSource = Observable.FromEventPattern(deviceWatcher, nameof(deviceWatcher.Updated))
                                .Select(pattern =>
                                {
                                  var update = ((DeviceInformationUpdate)pattern.EventArgs);
                                  return Observable.FromAsync(() => DeviceInformation.CreateFromIdAsync(update.Id).AsTask());
                                }).Concat();

  var source = addedSource.Merge(updatedSource);
  source.Publish().Connect(); //make sure the event handlers are attached before starting the device watcher

  deviceWatcher.Start();

  var result = await source.Where(di =>  di.Name == deviceName)                                       //find the relevant device
                           .Select(di => Observable.FromAsync(() => GattDeviceService.FromIdAsync(di.Id).AsTask()))       //get all services from the device
                           .Concat()                                                                                      //necessary because of the async method in the previous statement
                           .Where(service => service.Uuid == SERVICE_UUID)                                                //get the service with the right UUID
                           .Retry()                                                                                       //GattDeviceService.FromIdAsync can throw exceptions
                           .FirstAsync();

  deviceWatcher.Stop();

  return result;
}

InformationsquelleAutor der Antwort LanderV