示例#1
0
        public async Task PrintAllCharacteristicsAsync()
        {
            Logger.Info("=======================================================");
            Logger.Info("Status: " + BOARD.ConnectionStatus);
            if (BOARD.ConnectionStatus == BluetoothConnectionStatus.Connected)
            {
                GattDeviceServicesResult sResult = await BOARD.GetGattServicesAsync();

                if (sResult.Status == GattCommunicationStatus.Success)
                {
                    foreach (GattDeviceService s in sResult.Services)
                    {
                        Logger.Info("UUID: " + s.Uuid + ", Handle: " + s.AttributeHandle);

                        GattCharacteristicsResult cResult = await s.GetCharacteristicsAsync();

                        if (cResult.Status == GattCommunicationStatus.Success)
                        {
                            foreach (GattCharacteristic c in cResult.Characteristics)
                            {
                                await Utils.PrintAsync(c);
                            }
                        }
                    }
                }
            }
            Logger.Info("=======================================================");
        }
示例#2
0
        private async Task FillServices()
        {
            var result = await m_Device.GetGattServicesAsync(BluetoothCacheMode.Cached);

            Console.WriteLine($"GetGattServicesAsync result status {result.Status} ");
            //if (result.Status == GattCommunicationStatus.Success)
            {
                foreach (var service in result.Services)
                {
                    var res = await service.GetCharacteristicsAsync(BluetoothCacheMode.Cached);

                    //if (res.Status == GattCommunicationStatus.Success)
                    {
                        res.Characteristics.ToList().ForEach(c =>
                        {
                            if (!Characteristics.ContainsKey(c.Uuid))
                            {
                                Characteristics.Add(c.Uuid, c);
                            }
                        });
                        //Characteristics.AddRange(res.Characteristics);
                    }
                }
                Console.WriteLine($"filled  chars - {Characteristics.Count}");
            }
            if (Characteristics.Count < 1)
            {
                Console.WriteLine("could not fill chars - ");
            }
        }
示例#3
0
        public async void ListCurrentDeviceServicesToLog()
        {
            //CheckBluetoothStatus(true);
            BluetoothLEDevice device = await BluetoothLEDevice.FromIdAsync(ChosenDevice.Id);

            if (device == null)
            {
                return;
            }
            DeviceAccessStatus accessStatus = await device.RequestAccessAsync();

            var deviceServicesResult = await device.GetGattServicesAsync();

            // build the string to add in the log
            string services = "[Services list of " + device.Name + "]";
            int    i        = 0;

            foreach (GattDeviceService service in deviceServicesResult.Services)
            {
                services += "\n -- Handle: \t" + service.AttributeHandle.ToString();
                services += "\n --> UUID: \t" + service.Uuid.ToString();
                services += "\n --> Access Info: \t" + service.DeviceAccessInformation.CurrentStatus.ToString();
                i++;
                if (i < deviceServicesResult.Services.Count)
                {
                    services += "\n----------------------------------------------------------------";
                }
            }
            services += "\n\nFor info on Bluetooth Standard codes and identifiers, please visit https://www.bluetooth.com/specifications/assigned-numbers" + "\n";
            // add log
            AddLog(services, AppLog.LogCategory.Debug);
        }
示例#4
0
        async void ConnectDevice(string id)
        {
            BluetoothLEDevice bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(id);

            var srvResultList = await bluetoothLeDevice.GetGattServicesAsync();

            var srvResult = await bluetoothLeDevice.GetGattServicesForUuidAsync(new Guid("0000ffb0-0000-1000-8000-00805f9b34fb"), BluetoothCacheMode.Cached);

            if (srvResult.Status != GattCommunicationStatus.Success || !srvResult.Services.Any())
            {
                Console.WriteLine("Cannot find service for device");
                return;
            }
            Console.WriteLine("connected");
            var service   = srvResult.Services.First();
            var chrResult = await service.GetCharacteristicsAsync();

            if (chrResult.Status != GattCommunicationStatus.Success)
            {
                return;
            }
            var chrs = from x in chrResult.Characteristics
                       select x;
            var gattCharacteristics = chrs as GattCharacteristic[] ?? chrs.ToArray();

            if (!gattCharacteristics.Any())
            {
                return;
            }
            await gattCharacteristics[1].WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify);

            gattCharacteristics[1].ValueChanged += gattCharacteristics_1_ValueChanged;

            sendCommandCharacteristic = gattCharacteristics[1];
        }
        private async void StartDevice()
        {
            //To get your blueToothAddress add: ulong blueToothAddress = device.BluetoothAddress to your old code.
            ulong blueToothAddress = 88396936323791;  //fill in your device address!!

            device = await BluetoothLEDevice.FromBluetoothAddressAsync(blueToothAddress);

            if (device != null)
            {
                string deviceName = device.DeviceInformation.Name;
                Debug.WriteLine(deviceName);
                int  servicesCount = 3;//Fill in the amount of services from your device!!
                int  tryCount      = 0;
                bool connected     = false;
                while (!connected)//This is to make sure all services are found.
                {
                    tryCount++;
                    serviceResult = await device.GetGattServicesAsync();

                    if (serviceResult.Status == GattCommunicationStatus.Success && serviceResult.Services.Count >= servicesCount)
                    {
                        connected = true;
                        Debug.WriteLine("Connected in " + tryCount + " tries");
                    }
                    if (tryCount > 5)//make this larger if faild
                    {
                        Debug.WriteLine("Failed to connect to device ");
                        return;
                    }
                }
            }
        }
示例#6
0
        public async Task DiscoverServicesAsync()
        {
            ResetCharacteristics();

            int retry = 3;

            while (retry >= 0)
            {
                var servicesResult = await device.GetGattServicesAsync(BluetoothCacheMode.Uncached);

                foreach (var service in servicesResult.Services)
                {
                    var charsresult = await service.GetCharacteristicsAsync(BluetoothCacheMode.Uncached);

                    foreach (var characteristic in charsresult.Characteristics)
                    {
                        characteristics.Add(characteristic.Uuid, characteristic);
                    }
                }

                if (characteristics.Count == 0)
                {
                    retry--;
                }
                else
                {
                    retry = -1;
                }
            }

            if (characteristics.Count == 0)
            {
                throw new InvalidOperationException("No GATT characteristics were discovered");
            }
        }
示例#7
0
        /// <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");
            }

            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;

            // cache all characteristics in all services
            foreach (var service in _services)
            {
                var characteristicsResult = await service.GetCharacteristicsAsync(BluetoothCacheMode.Uncached);

                if (characteristicsResult.Status != GattCommunicationStatus.Success)
                {
                    continue;
                }

                foreach (var characteristic in characteristicsResult.Characteristics)
                {
                    _cachedCharacteristics.Add(characteristic.Uuid, characteristic);
                }
            }

            // 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
            _watcher.Stop();
            _watcher = null;
            _reportedPeripherals.Clear();
            _optionalServices = null;
        }
示例#8
0
        public async Task <int> Connect(String ID)
        {
            Debug.WriteLine("Initializing device...");
            try
            {
                // BT_Code: BluetoothLEDevice.FromIdAsync must be called from a UI thread because it may prompt for consent.
                bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(ID);

                if (bluetoothLeDevice == null)
                {
                    var dialog = new MessageDialog("Failed to connect to device.");
                    await dialog.ShowAsync();
                }
                else
                {
                    GattDeviceServicesResult result = await bluetoothLeDevice.GetGattServicesAsync(BluetoothCacheMode.Uncached);

                    if (result.Status == GattCommunicationStatus.Success)
                    {
                        Debug.WriteLine("Connected & Found services");
                        return(1);
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine("Retrieving device properties failed with message: " + ex.Message);
            }
            return(0);
        }
示例#9
0
        private async Task StartCacheAsync()
        {
            // Get all services:
            GattDeviceServicesResult sResult = await DEVICE.GetGattServicesAsync();

            if (sResult.Status == GattCommunicationStatus.Success)
            {
                CHARACTERISTICS.Clear();
                foreach (GattDeviceService s in sResult.Services)
                {
                    // Get all characteristics:
                    GattCharacteristicsResult cResult = await s.GetCharacteristicsAsync();

                    if (cResult.Status == GattCommunicationStatus.Success)
                    {
                        foreach (GattCharacteristic c in cResult.Characteristics)
                        {
                            CHARACTERISTICS.Add(c.Uuid, c);
                            await LoadCharacteristicValueAsync(c);
                        }
                    }
                }
                Logger.Debug("Finished requesting characteristics.");

                await SubscribeToCharacteristicsAsync(CharacteristicsCache.SUBSCRIBE_TO_CHARACTERISTICS);
            }
            else
            {
                Logger.Warn("Failed to request GetGattServicesAsync() - " + sResult.Status.ToString());
            }
        }
示例#10
0
        private async void DeviceWatcher_Added(DeviceWatcher sender, DeviceInformation args)
        {
            device = args;

            BLEdevice = await BluetoothLEDevice.FromIdAsync(device.Id);

            GattDeviceServicesResult result = await BLEdevice.GetGattServicesAsync();

            if (result.Status == GattCommunicationStatus.Success)
            {
                var services = result.Services;
                foreach (var service in services)
                {
                    if (service.Uuid.ToString() == UUID_UART_SERV)
                    {
                        characteristics = await service.GetCharacteristicsAsync();

                        foreach (var characteristic in characteristics.Characteristics)
                        {
                            if (characteristic.Uuid.ToString() == UUID_UART_RX)
                            {
                                character = characteristic;
                            }
                        }
                    }
                }
            }

            Debug.WriteLine("Device Added");
        }
示例#11
0
 private async void ConnDevice_Button_Click(object sender, RoutedEventArgs e)
 {
     await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
     {
         try
         {
             bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(ConnDevice_Id.Text);
             if (bluetoothLeDevice == null)
             {
                 FindDevice_List.Text += String.Format("\r\nwarning1");
             }
         }
         catch (Exception ex) when(ex.HResult == E_DEVICE_NOT_AVAILABLE)
         {
             FindDevice_List.Text += String.Format("\r\nwarning2");
         }
         if (bluetoothLeDevice != null)
         {
             GattDeviceServicesResult result = await bluetoothLeDevice.GetGattServicesAsync(BluetoothCacheMode.Uncached);
             if (result.Status == GattCommunicationStatus.Success)
             {
                 var services = result.Services;
                 foreach (var service in services)
                 {
                     FindDevice_List.Text += String.Format("{0} : {1}\r\n", bluetoothLeDevice.Name, service.Uuid);
                 }
             }
         }
         else
         {
             FindDevice_List.Text += String.Format("\r\nwarning3");
         }
     });
 }
示例#12
0
        private async Task DiscoverServices()
        {
            var gatt = await _myoBle.GetGattServicesAsync();

            if (gatt.Services.Count >= 1)
            {
                foreach (var service in gatt.Services)
                {
                    if (service.Uuid == ControlServiceUUID)
                    {
                        _controlService = service;
                    }
                    else if (service.Uuid == ImuDataServiceUUID)
                    {
                        _imuDataService = service;
                    }
                    else if (service.Uuid == ClassifierServiceUUID)
                    {
                        _classifierService = service;
                    }
                    else if (service.Uuid == RawEmgDataServiceUUID)
                    {
                        _emgDataService = service;
                    }
                }
            }
        }
        public async void StartReceivingData()
        {
            leDevice = await BluetoothLEDevice.FromIdAsync(device.Id);

            var services = await leDevice.GetGattServicesAsync();

            foreach (var service in services.Services)
            {
                switch (service.Uuid.ToString())
                {
                case SensorUUIDs.UUID_ENV_SERV:
                    InitializeTemperatureSensor(service);
                    InitializePressureSensor(service);
                    break;

                case SensorUUIDs.UUID_ACC_SERV:
                    InitializeAccelerationSensor(service);
                    break;
                }
            }

            timer.Interval = new TimeSpan(0, 0, 1);
            timer.Tick    += Timer_Tick;
            timer.Start();
        }
示例#14
0
        private async void Button_Click(object sender, RoutedEventArgs e)
        {
            if (myDevice == null)
            {
                return;
            }
            if (myCharacteristic == null)
            {
                GattDeviceServicesResult result = await myDevice.GetGattServicesAsync();

                foreach (var service in result.Services)
                {
                    if (service.Uuid.ToString() == RSL10_Motion_BLE_SERVICE_UIID)
                    {
                        GattCharacteristicsResult CharResult = await service.GetCharacteristicsAsync(BluetoothCacheMode.Uncached);

                        foreach (var characteristic in CharResult.Characteristics)
                        {
                            if (characteristic.Uuid.ToString() == RSL10_Motion_BLE_CHARACTERISTIC_UIID)
                            {
                                myCharacteristic         = characteristic;
                                dispatcherTimer          = new DispatcherTimer();
                                dispatcherTimer.Tick    += dispatcherTimer_Tick;
                                dispatcherTimer.Interval = new TimeSpan(0, 0, 0, 0, 100);//100 ms
                                dispatcherTimer.Start();
                            }
                        }
                    }
                }
            }
        }
示例#15
0
        public async void Connect()
        {
            bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(this.BluetoothLEid);

            if (bluetoothLeDevice != null)
            {
                GattDeviceServicesResult result = await bluetoothLeDevice.GetGattServicesAsync(BluetoothCacheMode.Uncached);

                if (result.Status == GattCommunicationStatus.Success)
                {
                    var services = result.Services;
                    foreach (var service in services)
                    {
                        if (service.Uuid == HEALTH_THERMOMETER_UUID)
                        {
                            selectedService    = service;
                            tempCharacteristic = await selectedService.GetCharacteristicsForUuidAsync(MagUUID);

                            magCharacteristic  = tempCharacteristic.Characteristics[0];
                            tempCharacteristic = await selectedService.GetCharacteristicsForUuidAsync(WriteUUID);

                            writeCharacteristic = tempCharacteristic.Characteristics[0];
                        }
                    }
                }
                else
                {
                    Debug.WriteLine("Connect Fail");
                }
            }
        }//end method connect
示例#16
0
        public static async Task <string> GuessModelNameAsync(BluetoothLEDevice bluetoothLEDevice)
        {
            GattDeviceServicesResult servicesResult = await bluetoothLEDevice.GetGattServicesAsync();

            if (servicesResult.Status != GattCommunicationStatus.Success)
            {
                return(string.Empty);
            }

            foreach (var service in servicesResult.Services)
            {
                switch (service.Uuid.ToString())
                {
                case "a2220000-f92a-ad93-dc47-9c4df7aa5e9e":
                    return(SupportedSensors.FerrisSensorV1);

                case "6a800001-b5a3-f393-e0a9-e50e24dcca9e":
                    return(SupportedSensors.InfoLinkNRF51SensorTag);

                default:
                    break;
                }
            }

            return("Unknown sensor");
        }
示例#17
0
        public async Task <bool> InitializeService()
        {
            /// Note: BluetoothLEDevice.GattServices property will return an empty list for unpaired devices. For all uses we recommend using the GetGattServicesAsync method.
            // BT_Code: GetGattServicesAsync returns a list of all the supported services of the device (even if it's not paired to the system).
            // If the services supported by the device are expected to change during BT usage, subscribe to the GattServicesChanged event.
            GattDeviceServicesResult result = await BLEDevice.GetGattServicesAsync(BluetoothCacheMode.Uncached);

            if (result.Status != GattCommunicationStatus.Success)
            {
                return(false);
            }
            IReadOnlyList <GattDeviceService> services = result.Services;

            if (!await DeviceInfo.Initialize(result.Services, ValueChanged))
            {
                return(false);
            }
            if (!await Battery.Initialize(result.Services, ValueChanged))
            {
                return(false);
            }
            if (!await Sensors.Initialize(result.Services, ValueChanged))
            {
                return(false);
            }
            if (!await Config.Initialize(result.Services, ValueChanged))
            {
                return(false);
            }
            return(true);
        }
示例#18
0
        public async void Connect()
        {
            DeviceType    dv     = MainPage.TestresultModel.GetDeviceType(3);
            BLEDeviceInfo device = null;

            foreach (var dev in MainPage.TestresultModel.BLEDevices)
            {
                if (dev.DeviceType == DeviceTypesenums.THERMOMETER && dev.IsPaired)
                {
                    device = dev;
                    break;
                }
                else if (dev.DeviceType == DeviceTypesenums.THERMOMETER && !dev.IsPaired)
                {
                    MainPage.mainPage.commChannel.SendMessageToMCC(
                        string.Format(CommunicationCommands.THERMORCONNECTIONSTATUS, "Device is not paried."));
                    MainPage.TestresultModel.NotifyStatusMessage?.Invoke("Device is not paried. ", 1);
                    return;
                }
            }

            GTTServicelist.Clear();
            if (device == null)
            {
                MainPage.mainPage.commChannel.SendMessageToMCC(
                    string.Format(CommunicationCommands.THERMORCONNECTIONSTATUS, "Device not found with id:"));

                MainPage.TestresultModel.NotifyStatusMessage?.Invoke(" Device not found with id: " + MainPage.TestresultModel.ThermoMeterId, 1);
                return;
            }
            bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(device.DeviceInfo.Id);

            if (bluetoothLeDevice == null)
            {
                MainPage.mainPage.commChannel.SendMessageToMCC(
                    string.Format(CommunicationCommands.THERMORCONNECTIONSTATUS, "Device Unreachable."));
                MainPage.TestresultModel.NotifyStatusMessage?.Invoke(" Device Unreachable.", 1);
                return;
            }

            GattDeviceServicesResult result = await bluetoothLeDevice.GetGattServicesAsync(BluetoothCacheMode.Uncached);

            if (result.Status == GattCommunicationStatus.Success)
            {
                var services = result.Services;
                foreach (var svc in services)
                {
                    GTTServicelist.Add(svc.Uuid.ToString().ToLower(), svc);
                }
                SelectService(device);  //MainPage.TestresultModel.ThermoServiceID
            }
            else
            {
                MainPage.mainPage.commChannel.SendMessageToMCC(
                    string.Format(CommunicationCommands.THERMORCONNECTIONSTATUS, "Failed to connect. " + result.Status.ToString()));

                MainPage.TestresultModel.NotifyStatusMessage?.Invoke("Failed to connect. " + result.Status.ToString(), 1);
            }
        }
示例#19
0
 private async void Build()
 {
     await mDevice.GetGattServicesAsync().AsTask().ContinueWith((obj) =>
     {
         Debug.WriteLine("Found Services.");
         ServicesAquired(obj.Result);
     });
 }
        public async Task <BluetoothLEDevice> FromBluetoothAddressAsync(UInt64 address)
        {
            BluetoothLEDevice ble = await BluetoothLEDevice.FromBluetoothAddressAsync(address);

            GattDeviceServicesResult results = await ble.GetGattServicesAsync();

            return(ble);
        }
示例#21
0
        public bool DiscoverServices()
        {
            var t = Task.Run(async() => await bleDevice.GetGattServicesAsync());

            services = WaitTask(t, 10) == t ? t.Result : null;
            stage    = 3;
            return(services != null);
        }
        public async Task <BluetoothLEDevice> BluetoothLEDeviceFromIdAsync(string id)
        {
            BluetoothLEDevice ble = await BluetoothLEDevice.FromIdAsync(id);

            GattDeviceServicesResult results = await ble.GetGattServicesAsync();

            return(ble);
        }
示例#23
0
        // Get all the GATT services from the Sensortag
        public async Task GetGATTServicesDataAsync(BluetoothLEDevice device)
        {
            deviceSerivceResult = await device.GetGattServicesAsync();

            deviceService = deviceSerivceResult.Services[irsensorservice];

            await GetGATTCharacteristicsDataAsync(deviceService);
        }
示例#24
0
        public async Task <IButtplugDevice> CreateDeviceAsync([NotNull] BluetoothLEDevice aDevice)
        {
            // GetGattServicesForUuidAsync is 15063 only
            var services = await aDevice.GetGattServicesAsync(BluetoothCacheMode.Cached);

            List <Guid> uuids = new List <Guid>();

            foreach (var s in services.Services)
            {
                _bpLogger.Trace($"Found service UUID: {s.Uuid} ({aDevice.Name})");
                uuids.Add(s.Uuid);
            }

            var srvs = (from x in services.Services
                        from y in _deviceInfo.Services
                        where x.Uuid == y
                        select x).ToArray();

            if (srvs.Length != 1)
            {
                // Somehow we've gotten multiple services back, something we don't currently support.
                _bpLogger.Error($"Found {srvs.Length} services for {aDevice.Name}, which is more/less than 1. Please fix this in the bluetooth definition.");
                return(null);
            }

            var service = srvs[0];

            var chrResult = await service.GetCharacteristicsAsync();

            if (chrResult.Status != GattCommunicationStatus.Success)
            {
                _bpLogger.Error($"Cannot connect to service {service.Uuid} of {aDevice.Name}.");
                return(null);
            }

            foreach (var s in chrResult.Characteristics)
            {
                _bpLogger.Trace($"Found characteristics UUID: {s.Uuid} ({aDevice.Name})");
            }

            var chrs = chrResult.Characteristics.ToArray();

            // If there aren't any characteristics by this point, something has gone wrong.
            if (!chrs.Any())
            {
                _bpLogger.Error($"Cannot find characteristics for service {service.Uuid} of {aDevice.Name}.");
                return(null);
            }

            var bleInterface = new UWPBluetoothDeviceInterface(_buttplugLogManager, _deviceInfo, aDevice, chrs);

            var device = _deviceInfo.CreateDevice(_buttplugLogManager, bleInterface);

            // If initialization fails, don't actually send the message back. Just return null, we'll
            // have the info in the logs.
            return(await device.InitializeAsync().ConfigureAwait(false) is Ok ? device : null);
        }
示例#25
0
        public async void Connect()
        {
            BLEDeviceInfo device = null;

            foreach (var dev in MainPage.TestresultModel.BLEDevices)
            {
                if (dev.DeviceType == DeviceTypesenums.BPMONITOR && dev.IsPaired)
                {
                    device = dev;
                    break;
                }
                else if (dev.DeviceType == DeviceTypesenums.BPMONITOR && !dev.IsPaired)
                {
                    SendConnectionStatusmessageToMCC("BP Monitor is not Paired.");
                    NotifyStatusMessage?.Invoke("BP Monitor is not Paired.", 3);
                    return;
                }
            }


            GTTServicelist.Clear();
            if (device == null)
            {
                SendConnectionStatusmessageToMCC("BP Monitor is not foud.");
                NotifyStatusMessage?.Invoke("BP Monitor is not foud.", 3);
                return;
            }

            bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(device.DeviceInfo.Id);

            if (bluetoothLeDevice == null)
            {
                SendConnectionStatusmessageToMCC("Device Unreachable.");
                NotifyStatusMessage?.Invoke("Device Unreachable.", 1);
                return;
            }

            // Note: BluetoothLEDevice.GattServices property will return an empty list for unpaired devices. For all uses we recommend using the GetGattServicesAsync method.
            // BT_Code: GetGattServicesAsync returns a list of all the supported services of the device (even if it's not paired to the system).
            // If the services supported by the device are expected to change during BT usage, subscribe to the GattServicesChanged event.
            GattDeviceServicesResult result = await bluetoothLeDevice.GetGattServicesAsync(BluetoothCacheMode.Uncached);

            if (result.Status == GattCommunicationStatus.Success)
            {
                var services = result.Services;
                foreach (var svc in services)
                {
                    GTTServicelist.Add(svc.Uuid.ToString().ToLower(), svc);
                }
                SelectBPMeasureServicesAsync(device);//MainPage.TestresultModel.BPServiceID);
            }
            else
            {
                SendConnectionStatusmessageToMCC("Failed to connect. " + result.Status.ToString());
                NotifyStatusMessage?.Invoke("Failed to connect. " + result.Status.ToString(), 1);
            }
        }
        public async Task <IButtplugDevice> CreateDeviceAsync([NotNull] BluetoothLEDevice aDevice)
        {
            // GetGattServicesForUuidAsync is 15063 only
            var services = await aDevice.GetGattServicesAsync(BluetoothCacheMode.Cached);

            foreach (var s in services.Services)
            {
                _bpLogger.Debug("Found service UUID: " + s.Uuid + " (" + aDevice.Name + ")");
            }

            var srvResult = await aDevice.GetGattServicesForUuidAsync(_deviceInfo.Services[0], BluetoothCacheMode.Cached);

            if (srvResult.Status != GattCommunicationStatus.Success || !srvResult.Services.Any())
            {
                _bpLogger.Debug("Cannot find service for device (" + aDevice.Name + ")");
                return(null);
            }

            var service = srvResult.Services.First();

            var chrResult = await service.GetCharacteristicsAsync();

            if (chrResult.Status != GattCommunicationStatus.Success)
            {
                return(null);
            }

            foreach (var s in chrResult.Characteristics)
            {
                _bpLogger.Trace("Found characteristics UUID: " + s.Uuid + " (" + aDevice.Name + ")");
            }

            var chrs = from x in chrResult.Characteristics
                       where _deviceInfo.Characteristics.Contains(x.Uuid)
                       select x;

            var gattCharacteristics = chrs as GattCharacteristic[] ?? chrs.ToArray();

            if (!gattCharacteristics.Any())
            {
                return(null);
            }

            // TODO This assumes we're always planning on having the UUIDs sorted in the Info classes, which is probably not true.
            var bleInterface = new UWPBluetoothDeviceInterface(_buttplugLogManager,
                                                               aDevice, gattCharacteristics.OrderBy((aChr) => aChr.Uuid).ToArray());

            var device = _deviceInfo.CreateDevice(_buttplugLogManager, bleInterface);

            if (await device.Initialize() is Ok)
            {
                return(device);
            }

            // If initialization fails, don't actually send the message back. Just return null, we'll have the info in the logs.
            return(null);
        }
        public async void UpdateAllData()
        {
            leDevice = await BluetoothLEDevice.FromIdAsync(device.Id);

            string selector = "(System.DeviceInterface.Bluetooth.DeviceAddress:=\"" + leDevice.BluetoothAddress.ToString("X") + "\")";

            var services = await leDevice.GetGattServicesAsync();

            foreach (var service in services.Services)
            {
                switch (service.Uuid.ToString())
                {
                case SensorUUIDs.UUID_UART_SERV:
                {
                    var characteristics = await service.GetCharacteristicsAsync();

                    foreach (var character in characteristics.Characteristics)
                    {
                        switch (character.Uuid.ToString())
                        {
                        case SensorUUIDs.UUID_UART_RX:
                        {
                            var writer = new DataWriter();
                            // DATA:SET command not yet working
                            //string message = "DATA:SET #22046524f4d205741544348\n";
                            //writer.WriteString(message);
                            //await character.WriteValueAsync(writer.DetachBuffer());

                            // Reading and displaying heartrate from BioSensor
                            RateSensor bs = new RateSensor();
                            bs.RateSensorInit();
                            // await Task.Delay(1000);
                            bs.RateMonitorON();
                            hrmHeartRate = bs.GetHeartRate();
                            Debug.WriteLine($"Current heartrate: {hrmHeartRate}");
                            // hrmHeartRate = bs.I2C_ReadRegData(HrmSensor, AS7000_REG_HRM_HEARTRATE);
                            //await Task.Delay(1);



                            //writing TRIGGER to the AdafruitBT
                            writer.WriteString("TRIGGER\n");
                            //writing current HeartRate to the Adafruit bluetooth
                            //writer.WriteString(hrmHeartRate);
                            await character.WriteValueAsync(writer.DetachBuffer());
                        }
                        break;
                        }
                    }
                }
                break;
                }
            }
        }
示例#28
0
        /// <summary>
        /// Connect to the device, check if there's the DFU Service and start the firmware update
        /// </summary>
        /// <param name="device">The device discovered</param>
        /// <returns></returns>
        public async void connectToDeviceAsync2(DeviceInformation device)
        {
            try
            {
                var deviceAddress = "N/A";
                if (device.Id.Contains("-"))
                {
                    deviceAddress = device.Id.Split('-')[1];
                }

                Console.WriteLine("Connecting to:" + deviceAddress + "...");

                BluetoothLEDevice bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(device.Id);

                Console.WriteLine("Name:" + bluetoothLeDevice);

                //Perform the connection to the device
                var result = await bluetoothLeDevice.GetGattServicesAsync();

                if (result.Status == GattCommunicationStatus.Success)
                {
                    Console.WriteLine("Device " + deviceAddress + " connected. Updating firmware...");
                    //Scan the available services
                    var services = result.Services;
                    foreach (var service_ in services)
                    {
                        Console.WriteLine("Service " + service_.Uuid);
                        //If DFUService found...
                        if (service_.Uuid == new Guid(UARTService.UARTService_UUID))
                        { //NRF52 DFU Service
                            Console.WriteLine("UART Service found");

                            var stCharacteristic = service_.GetCharacteristics(new Guid(UARTService.UARTCharacteristics_UUID_TX))[0];
                            await stCharacteristic.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify);

                            stCharacteristic.ValueChanged += Characteristic_ValueChangedTest;

                            this.startReaderAsync(this.txCharacteristic);
                            this.startReaderAsync(this.rxCharacteristic);

                            break;
                        }
                    }
                }
                else
                {
                    Console.WriteLine("Status error: " + result.Status.ToString() + " need to restarte the device");
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("ERROR: Accessing2 your device failed." + Environment.NewLine + e.Message + "\n" + e.StackTrace);
            }
        }
        private async Task <bool> GetAllPrimaryServices(BluetoothCacheMode cacheMode)
        {
            var    succeeded = false;
            string debugMsg  = String.Format("GetAllPrimaryServices: ");

            Debug.WriteLine(debugMsg + "Entering");

            // Get all the services for this device
            var result = await BluetoothLEDevice.GetGattServicesAsync(cacheMode);

            if (result.Status == GattCommunicationStatus.Success)
            {
                System.Diagnostics.Debug.WriteLine(debugMsg + "GetGattServiceAsync SUCCESS");

                lock (Services)
                {
                    foreach (var serv in result.Services)
                    {
                        if (!GattServiceUuidHelper.IsReserved(serv.Uuid))
                        {
                            var temp = new ObservableGattDeviceService(serv);
                            // This isn't awaited so that the user can disconnect while the services are still being enumerated
                            temp.Initialize();
                            Services.Add(temp);
                        }
                        else
                        {
                            serv.Dispose();
                        }
                    }
                    ServiceCount = Services.Count();
                }

                succeeded = true;
            }
            else if (result.Status == GattCommunicationStatus.ProtocolError)
            {
                ErrorText = debugMsg + "GetGattServiceAsync Error: Protocol Error - " + result.ProtocolError.Value;
                System.Diagnostics.Debug.WriteLine(ErrorText);
                string msg           = "Connection protocol error: " + result.ProtocolError.Value.ToString();
                var    messageDialog = new MessageDialog(msg, "Connection failures");
                await messageDialog.ShowAsync();
            }
            else if (result.Status == GattCommunicationStatus.Unreachable)
            {
                ErrorText = debugMsg + "GetGattServiceAsync Error: Unreachable";
                System.Diagnostics.Debug.WriteLine(ErrorText);
                string msg           = "Device unreachable";
                var    messageDialog = new MessageDialog(msg, "Connection failures");
                await messageDialog.ShowAsync();
            }

            return(succeeded);
        }
示例#30
0
        private async Task <bool> ConnectImpl()
        {
            if (!ClearBluetoothLEDeviceAsync())
            {
                Console.WriteLine("Error: Unable to reset state, try again.");
                //Debug.Assert(false, "Error: Unable to reset state, try again.");
                return(false);
            }

            try
            {
                var device = KnownDevices[0];
                // BT_Code: BluetoothLEDevice.FromIdAsync must be called from a UI thread because it may prompt for consent.
                bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(device.Id);

                if (bluetoothLeDevice == null)
                {
                    Console.WriteLine("Failed to connect to device.");
                    return(false);
                }
            }
            catch (Exception ex) when(ex.HResult == E_DEVICE_NOT_AVAILABLE)
            {
                Console.WriteLine("Bluetooth radio is not on.");
            }

            if (bluetoothLeDevice != null)
            {
                // Note: BluetoothLEDevice.GattServices property will return an empty list for unpaired devices. For all uses we recommend using the GetGattServicesAsync method.
                // BT_Code: GetGattServicesAsync returns a list of all the supported services of the device (even if it's not paired to the system).
                // If the services supported by the device are expected to change during BT usage, subscribe to the GattServicesChanged event.
                GattDeviceServicesResult result = await bluetoothLeDevice.GetGattServicesAsync(BluetoothCacheMode.Uncached);

                if (result.Status == GattCommunicationStatus.Success)
                {
                    var services = result.Services;
                    Console.WriteLine(String.Format("Found {0} services", services.Count));
                    foreach (var service in services)
                    {
                        ServiceCollection.Add(new BluetoothLEAttributeDisplay(service));
                    }

                    return(true);
                }
                else
                {
                    Console.WriteLine("Device unreachable");
                    //Debug.Assert(false, "Device unreachable");
                    return(false);
                }
            }

            return(false);
        }