private static async Task <BluetoothDevice> PlatformFromId(string id) { BluetoothLEDevice device = null; if (ulong.TryParse(id, System.Globalization.NumberStyles.HexNumber, null, out var parsedId)) { if (Bluetooth.KnownDevices.ContainsKey(parsedId)) { BluetoothDevice knownDevice = (BluetoothDevice)Bluetooth.KnownDevices[parsedId].Target; if (knownDevice != null) { return(knownDevice); } } device = await BluetoothLEDevice.FromBluetoothAddressAsync(parsedId); } else { device = await BluetoothLEDevice.FromIdAsync(id); } if (device != null) { var success = await device.RequestAccessAsync(); System.Diagnostics.Debug.WriteLine($"RequestAccessAsync {success}"); } return(device); }
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); }
/// <summary> /// Try to connect with the pen. /// </summary> /// <param name="penInformation">PenInformation instance that holds the pen's information</param> /// <returns>True or false if the connection is successful</returns> public async Task <bool> Connect(PenInformation penInformation) { try { if (penInformation.Protocol != Protocols.V2) { throw new NotSupportedException("Not supported protocol version"); } await semaphreSlime.WaitAsync(); Debug.WriteLine(""); bluetoothLEDevice = await BluetoothLEDevice.FromIdAsync(penInformation.Id); var status = await bluetoothLEDevice.RequestAccessAsync(); Debug.WriteLine("RequestAccessAsync result is " + status.ToString()); if (status != Windows.Devices.Enumeration.DeviceAccessStatus.Allowed) { throw new Exception(); } GattDeviceServicesResult result = await bluetoothLEDevice.GetGattServicesAsync(BluetoothCacheMode.Uncached); if (result.Status != GattCommunicationStatus.Success || await Bind(result.Services) == false) { Debug.WriteLine("GetGattServicesAsync status is " + result.Status.ToString()); throw new Exception(); } bluetoothLEDevice.ConnectionStatusChanged += BluetoothLEDevice_ConnectionStatusChanged; return(true); } catch { DisposeBluetoothResource(); return(false); } finally { semaphreSlime.Release(); } }
private bool BluetoothSetup() { BluetoothLEDevice device = this.Waitfor( "connection to Bluetooth device", BluetoothLEDevice.FromBluetoothAddressAsync(System.Convert.ToUInt64("001580912553", 16))); if (device == null) { this.logEol("Device wasn't found"); return(false); } GattDeviceServicesResult deviceServices = this.Waitfor( "device services", device.GetGattServicesAsync()); DeviceAccessStatus deviceAccessStatus = this.Waitfor( "device access", device.RequestAccessAsync()); this.logEol($"Device access status: {deviceAccessStatus}"); System.Guid gyroServiceGuid = System.Guid.Parse("0000ffe0-0000-1000-8000-00805f9b34fb"); GattDeviceService gyroService = deviceServices.Services.Single(x => x.Uuid.Equals(gyroServiceGuid)); var gyroServiceAccessStatus = this.Waitfor( "gro data service access", gyroService.RequestAccessAsync()); this.logEol($"Gyro service access status: {gyroServiceAccessStatus}"); GattCharacteristicsResult characteristics = this.Waitfor( "gyro data service", gyroService.GetCharacteristicsAsync()); this.txRxChannel = characteristics .Characteristics .SingleOrDefault(x => x.UserDescription.Replace(" ", "") == "TX&RX"); if (this.txRxChannel == default(GattCharacteristic)) { this.logEol("Couldn't find TXRX channel...disconnected?"); return(false); } this.txRxChannel.ValueChanged += this.TxRx_ValueChanged; return(true); }
public async Task DiscoverServicesAsync() { m_Device = await BluetoothLEDevice.FromBluetoothAddressAsync(BluetoothAddress); var info = m_Device.DeviceInformation; PrintInfo(info); m_Device.ConnectionStatusChanged += OnConnectionChanged; m_Device.GattServicesChanged += OnGattServicesChanged; var access = await m_Device.RequestAccessAsync(); if (access != Windows.Devices.Enumeration.DeviceAccessStatus.Allowed) { throw new Exception("could not access BLE"); } await Task.Delay(2000); await FillServices(); }
public static async Task Connect(string deviceId) { deviceReference = await BluetoothLEDevice.FromIdAsync(deviceId); await deviceReference.RequestAccessAsync(); GattDeviceServicesResult result = await deviceReference.GetGattServicesAsync(); //Allways check result! if (result.Status == GattCommunicationStatus.Success) { //Put following two lines in try/catch to or check for null!! var characs = await result.Services.Single(s => s.Uuid == Uuids.PoolLabSvc).GetCharacteristicsAsync(); cmdMisoCharacteristic = characs.Characteristics.Single(c => c.Uuid == Uuids.CmdMiso); cmdMosiCharacteristic = characs.Characteristics.Single(c => c.Uuid == Uuids.CmdMosi); misoSigCharacteristic = characs.Characteristics.Single(c => c.Uuid == Uuids.MisoSig); #if DEBUG if (BitConverter.IsLittleEndian) { Debug.WriteLine("LittleEndian"); } else { Debug.WriteLine("BigEndian"); } if (cmdMisoCharacteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Read)) { Debug.WriteLine("CommandMISO characteristic supports reading from it."); } if (cmdMisoCharacteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Write)) { Debug.WriteLine("CommandMISO characteristic supports writing."); } if (cmdMisoCharacteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.ReliableWrites)) { Debug.WriteLine("MISO_Signal characteristic supports reliable writing."); } if (cmdMisoCharacteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.WriteWithoutResponse)) { Debug.WriteLine("MISO_Signal characteristic supports writing without response."); } if (cmdMisoCharacteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Notify)) { Debug.WriteLine("CommandMISO characteristic supports subscribing to notifications."); } if (cmdMosiCharacteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Read)) { Debug.WriteLine("CommandMOSI characteristic supports reading from it."); } if (cmdMosiCharacteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Write)) { Debug.WriteLine("CommandMOSI characteristic supports writing."); } if (cmdMosiCharacteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.ReliableWrites)) { Debug.WriteLine("MISO_Signal characteristic supports reliable writing."); } if (cmdMosiCharacteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.WriteWithoutResponse)) { Debug.WriteLine("MISO_Signal characteristic supports writing without response."); } if (cmdMosiCharacteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Notify)) { Debug.WriteLine("CommandMOSI characteristic supports subscribing to notifications."); } if (misoSigCharacteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Read)) { Debug.WriteLine("MISO_Signal characteristic supports reading from it."); } if (misoSigCharacteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Write)) { Debug.WriteLine("MISO_Signal characteristic supports writing."); } if (misoSigCharacteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.ReliableWrites)) { Debug.WriteLine("MISO_Signal characteristic supports reliable writing."); } if (misoSigCharacteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.WriteWithoutResponse)) { Debug.WriteLine("MISO_Signal characteristic supports writing without response."); } if (misoSigCharacteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Notify)) { Debug.WriteLine("MISO_Signal characteristic supports subscribing to notifications."); } if (misoSigCharacteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Indicate)) { Debug.WriteLine("MISO_Signal characteristic supports indicate."); } #endif IsConnected = true; } else { Debug.WriteLine("No services found"); } }
public async Task <bool> TryToConnect(string deviceId) { if (string.IsNullOrWhiteSpace(deviceId)) { this.logger.Error($"'{nameof(deviceId)}' argument is null or empty"); return(false); } bool success = false; try { GattDeviceService service = null; GattCharacteristic responseCharacteristic = null; BluetoothLEDevice bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(deviceId) .AsTask() .ConfigureAwait(false); if (bluetoothLeDevice == null) { this.logger.Error($"failed to create BLE device with id = '{deviceId}'"); return(false); } this.bluetoothLeDevice = bluetoothLeDevice; bluetoothLeDevice.ConnectionStatusChanged += OnConnectionStatusChanged; DeviceAccessStatus deviceStatus = await bluetoothLeDevice.RequestAccessAsync() .AsTask() .ConfigureAwait(false); if (deviceStatus != DeviceAccessStatus.Allowed) { this.logger.Error($"failed to get access to BLE device with id = '{deviceId}'"); return(false); } // the following method connects to BLE device (and will call OnConnectionStatusChanged) GattDeviceServicesResult result = await bluetoothLeDevice.GetGattServicesAsync(BluetoothCacheMode.Uncached) .AsTask() .ConfigureAwait(false); if (result.Status == GattCommunicationStatus.Success) { service = result.Services.Where(s => s.Uuid == SERVICE_GUID) .FirstOrDefault(); if (service == null) { this.logger.Error($"BLE device with id = '{deviceId}' doesn't have '{SERVICE_GUID}' service"); return(false); } GattOpenStatus status = await service.OpenAsync(GattSharingMode.Exclusive) .AsTask() .ConfigureAwait(false); if (status != GattOpenStatus.Success) { this.logger.Error($"failed to open '{SERVICE_GUID}' service on BLE device with id = '{deviceId}', result = '{status}'"); return(false); } GattCharacteristicsResult characteristicsResult = characteristicsResult = await service.GetCharacteristicsForUuidAsync(RESPONSE_CHARACTERISTICS_GUID) .AsTask() .ConfigureAwait(false); if (characteristicsResult.Status != GattCommunicationStatus.Success) { this.logger.Error($"failed to get '{RESPONSE_CHARACTERISTICS_GUID}' characteristic from '{SERVICE_GUID}' " + $"service on BLE device with id = '{deviceId}', result = '{characteristicsResult.Status}', protocol error = {characteristicsResult.ProtocolError}"); return(false); } responseCharacteristic = characteristicsResult.Characteristics.FirstOrDefault(); if (responseCharacteristic == null) { this.logger.Error($"'{RESPONSE_CHARACTERISTICS_GUID}' characteristic doesn't seem to have any characteristics in '{SERVICE_GUID}' service on BLE device with id = '{deviceId}'"); return(false); } } else { this.logger.Error($"failed to retreive services provided by BLE device with id = '{deviceId}', result = '{result.Status}', protocol error = '{result.ProtocolError}'"); return(false); } this.service = service; this.responseCharacteristic = responseCharacteristic; this.responseCharacteristic.ValueChanged += OnCharacteristicValueChanged; success = true; return(true); } catch (Exception e) { this.logger.Error(e, "unexpected exception while connecting to BLE device"); return(false); } finally { if (!success) { Disconnect(); } } }
private async Task DisplayBluetooth(NameDevice knownDevice, DeviceInformationWrapper di, BluetoothLEDevice ble) { var jsonFormat = Newtonsoft.Json.Formatting.Indented; var jsonSettings = new Newtonsoft.Json.JsonSerializerSettings() { DefaultValueHandling = Newtonsoft.Json.DefaultValueHandling.Ignore, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore, ContractResolver = IgnoreEmptyEnumerableResolver.Instance, }; var wireAllDevices = new NameAllBleDevices(); WireDevice = new NameDevice(); WireDevice.Name = di.di.Name; WireDevice.Details += $"Id:{di.di.Id}\nCanPair:{di.di.Pairing.CanPair} IsPaired:{di.di.Pairing.IsPaired}"; wireAllDevices.AllDevices.Add(WireDevice); WireDevice.ClassModifiers = knownDevice.ClassModifiers; WireDevice.ClassName = knownDevice.ClassName; WireDevice.Description = knownDevice.Description; uiRawData.Text = Newtonsoft.Json.JsonConvert.SerializeObject(WireDevice, jsonFormat); string raw = null; if (ble == null) { // Happens if another program is trying to use the device! raw = $"BLE: ERROR: Another app is using this device.\n"; } else { // TODO: remove this code which is only here while I investigate the WESCALE scale #if NEVER_EVER_DEFINED { // WESCALE: no gatt services var services = ble.GattServices; var count = services.Count; var devacc = ble.DeviceAccessInformation; var devaccstatus = devacc.CurrentStatus; foreach (var service in services) { var chars = service.GetAllCharacteristics(); } try { var guid = Guid.Parse("0000fff0-0000-1000-8000-00805f9b34fb"); var request = await ble.RequestAccessAsync(); var allservice = await ble.GetGattServicesForUuidAsync(guid); var servicefff0 = ble.GetGattService(guid); var charsfff0 = servicefff0.GetAllCharacteristics(); var countfff0 = charsfff0.Count; foreach (var ch in charsfff0) { ; } } catch (Exception ex) { ; } } #endif var result = await ble.GetGattServicesAsync(); if (result.Status != GattCommunicationStatus.Success) { raw += GetStatusString(result.Status, result.ProtocolError); } else { var header = new BleDeviceHeaderControl(); await header.InitAsync(ble); int serviceCount = 0; foreach (var service in result.Services) { await header.AddServiceAsync(ble, service); var shouldDisplay = ServiceShouldBeEdited(service); var defaultService = knownDevice.GetService(service.Uuid.ToString("D")); var wireService = new NameService(service, defaultService, serviceCount++); WireDevice.Services.Add(wireService); try { var cresult = await service.GetCharacteristicsAsync(); if (cresult.Status != GattCommunicationStatus.Success) { raw += GetStatusString(cresult.Status, cresult.ProtocolError); } else { var characteristicCount = 0; foreach (var characteristic in cresult.Characteristics) { //The descriptors don't seem to be actually interesting. it's how we read and write. var descriptorStatus = await characteristic.GetDescriptorsAsync(); if (descriptorStatus.Status == GattCommunicationStatus.Success) { foreach (var descriptor in descriptorStatus.Descriptors) { ; } } var defaultCharacteristic = defaultService?.GetChacteristic(characteristic.Uuid.ToString("D")); var wireCharacteristic = new NameCharacteristic(characteristic, defaultCharacteristic, characteristicCount++); wireService.Characteristics.Add(wireCharacteristic); if (wireCharacteristic.Suppress) { continue; // don't show a UI for a supressed characteristic. } // // Here are each of the editor children items // var edit = new BleCharacteristicControl(knownDevice, service, characteristic); uiEditor.Children.Add(edit); var dc = DeviceCharacteristic.Create(characteristic); //NOTE: does any device have a presentation format? foreach (var format in characteristic.PresentationFormats) { raw += $" Fmt: Description:{format.Description} Namespace:{format.Namespace} Type:{format.FormatType} Unit: {format.Unit} Exp:{format.Exponent}\n"; } try { if (wireCharacteristic.IsRead) { var vresult = await characteristic.ReadValueAsync(); if (vresult.Status != GattCommunicationStatus.Success) { raw += GetStatusString(vresult.Status, vresult.ProtocolError); } else { var dt = BluetoothLEStandardServices.GetDisplayInfo(service, characteristic); var hexResults = dt.AsString(vresult.Value); wireCharacteristic.ExampleData.Add(hexResults); // And add as a converted value var NC = BleNames.Get(knownDevice, service, characteristic); var decode = NC?.Type; if (decode != null && !decode.StartsWith("BYTES|HEX")) { var decoded = ValueParser.Parse(vresult.Value, decode); wireCharacteristic.ExampleData.Add(decoded.UserString); } } } } catch (Exception e) { raw += $" Exception reading value: {e.HResult} {e.Message}\n"; } // Update the UI with the latest discovery // Later: or not. The raw data isn't super useful. //uiRawData.Text = Newtonsoft.Json.JsonConvert.SerializeObject(WireDevice, jsonFormat); } } } catch (Exception e) { raw += $" Exception reading characteristic: {e.HResult} {e.Message}\n"; } } } } JsonAsList = Newtonsoft.Json.JsonConvert.SerializeObject(wireAllDevices, jsonFormat, jsonSettings); JsonAsSingle = Newtonsoft.Json.JsonConvert.SerializeObject(WireDevice, jsonFormat, jsonSettings); uiProgress.IsActive = false; uiRawData.Text += raw; return; }
private async void Bleaw_Received(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args) { if (sender == null) { return; } bool OK = false; if (System.Threading.Interlocked.Increment(ref barrier) == 1) { BLEAdvWatcher.Stop(); Guid guidNotification; ulong blAdress = args.BluetoothAddress;; BluetoothLEDevice blDevice = await Windows.Devices.Bluetooth.BluetoothLEDevice.FromBluetoothAddressAsync(blAdress); if (!(blDevice == null)) { var name = blDevice.Name; System.Diagnostics.Debug.WriteLine("Device Name=:", name); if ((blDevice.DeviceInformation.Kind == Windows.Devices.Enumeration.DeviceInformationKind.AssociationEndpoint) && (NameFilter == ""?true:name.ToLower().Contains(NameFilter.ToLower()))) { System.Diagnostics.Debug.WriteLine("Bluetooth Address: {0}", blAdress); await CC2650SensorTag.PrependTextStatic(string.Format("Bluetooth Address: {0}", blAdress)); byte[] bytes = BitConverter.GetBytes(blAdress); string res = System.Text.Encoding.UTF8.GetString(bytes); string addrStr = bytes[bytes.Length - 3].ToString("X2"); for (int i = bytes.Length - 4; i > -1; i--) { addrStr += ":" + bytes[i].ToString("X2"); } System.Diagnostics.Debug.WriteLine("Bluetooth Address: {0}", addrStr); await CC2650SensorTag.PrependTextStatic(string.Format("Bluetooth Address: {0}", addrStr)); var scanresp = args.AdvertisementType; Windows.Devices.Enumeration.DeviceAccessStatus result; try { result = await blDevice.RequestAccessAsync(); } catch (Exception ex) { result = Windows.Devices.Enumeration.DeviceAccessStatus.DeniedBySystem; } if (result == Windows.Devices.Enumeration.DeviceAccessStatus.Allowed) { name = blDevice.Name; System.Diagnostics.Debug.WriteLine("Endpoint Device Name: {0}", name); await CC2650SensorTag.PrependTextStatic(string.Format("Endpoint Device Name: {0}", name)); var services = await blDevice.GetGattServicesAsync(); var svcs = services.Services; System.Diagnostics.Debug.WriteLine("Endpoint Device Id: {0}", blDevice.DeviceId); await CC2650SensorTag.PrependTextStatic(string.Format("Endpoint Device Id: {0}", blDevice.DeviceId)); System.Diagnostics.Debug.WriteLine("Start"); string nm = blDevice.Name; string did = blDevice.DeviceId; string info = blDevice.DeviceInformation.Name; if (svcs != null) { int num = svcs.Count; if (num != 0) { foreach (var x in svcs) { string sdf = x.Uuid.ToString(); string asdcb = x.DeviceId; System.Diagnostics.Debug.WriteLine("{0} = {1}", sdf, asdcb); } await TagServices.InterogateServices(svcs); OK = true; } else { System.Diagnostics.Debug.WriteLine("No Services."); OK = false; } } else { System.Diagnostics.Debug.WriteLine("ull Services."); OK = false; } } } } } if (!OK) { System.Threading.Interlocked.Decrement(ref barrier); BLEAdvWatcher.Start(); } }
public async Task <Boolean> TryLocateServices(BluetoothLEDevice bluetoothLeDevice) { // Only one init if (GattDeviceServiceTemperature != null || GattDeviceServiceLuminosity != null || GattDeviceServiceBattery != null) { return(true); } // Try get access to device Windows.Devices.Enumeration.DeviceAccessStatus result; try { result = await bluetoothLeDevice.RequestAccessAsync(); } catch (Exception) { result = Windows.Devices.Enumeration.DeviceAccessStatus.DeniedBySystem; } // Access denied if (result != DeviceAccessStatus.Allowed) { return(false); } // Get services of device in loop with timeout of 100 ms GattDeviceServicesResult gattDeviceServicesResult = null; for (int i = 0; i < 5; i++) { // Try get list of services gattDeviceServicesResult = await bluetoothLeDevice.GetGattServicesAsync(BluetoothCacheMode.Uncached); // Any services in list if (gattDeviceServicesResult?.Services.Count > 0) { break; } // Wait 100 ms await Task.Delay(100).ConfigureAwait(false); } // No services available if (gattDeviceServicesResult == null || gattDeviceServicesResult?.Services.Count == 0) { return(false); } // Iterate services foreach (var service in gattDeviceServicesResult.Services) { // 9dc84838-7619-4f09-a1ce-ddcf63225b20 is the luminosity service if (String.Compare(LuminosityGattServiceUuuid, service.Uuid.ToString(), StringComparison.OrdinalIgnoreCase) == 0) { GattDeviceServiceLuminosity = service; } if (String.Compare(BatteryGattServiceUuuid, service.Uuid.ToString(), StringComparison.OrdinalIgnoreCase) == 0) { GattDeviceServiceBattery = service; } if (String.Compare(TemperatureGattServiceUuid, service.Uuid.ToString(), StringComparison.OrdinalIgnoreCase) == 0) { GattDeviceServiceTemperature = service; } } double batteryLevel = await ReadBatteryValue().ConfigureAwait(true); double lux = await ReadLuminosityValue().ConfigureAwait(true); Debug.WriteLine($"SensorBug Lux {lux} lx battery level {batteryLevel} %"); await ReadValues().ConfigureAwait(true); // we can read values => start imer ThreadHelper.RunOnMainThread(() => { Timer?.Start(); }); return(true); }
//Connect to the chosen device private async void ConnectDevice() { if (DeviceInterfacesOutputLst.SelectedItem != null) { string DeviceID = ""; //Device ID foreach (var device in devices.Where(device => device.Name == DeviceInterfacesOutputLst.SelectedItem.ToString())) //selext the chosen device from the listview { DeviceID = device.Id; } BluetoothDevice = await BluetoothLEDevice.FromIdAsync(DeviceID); //request access to the Device DeviceAccessStatus x = await BluetoothDevice.RequestAccessAsync(); //wait for the permission OutputList.Items.Insert(0, "Connection: " + x.ToString() + " - BluetoothLE Device is " + BluetoothDevice.Name); //Create the service and characteristic values to fill with the chosen device information GattDeviceService HRservice = null; GattCharacteristicsResult HRcharacteristics = null; try //read the device characteristics, if the characteristics are not found, an exception get thrown { HRservice = BluetoothDevice.GetGattService(HRserviceGuid); HRcharacteristics = await HRservice.GetCharacteristicsAsync(); } catch { OutputList.Items.Insert(0, "Chosen device does not support HR service, choose another one"); return; } //TFind the characteristics UUID and assign them to the variable foreach (GattCharacteristic caratteristica in HRcharacteristics.Characteristics.Where(caratteristica => caratteristica.Uuid.Equals(HRMeasurement))) { HRreader = caratteristica; //assegno la caratteristica ad HRreader OutputList.Items.Insert(0, "Heart Rate Monitor characteristic found - Handle: " + HRreader.AttributeHandle.ToString()); } //check the server port data try { int serverPortInt; serverPortInt = Int32.Parse(tcpPortText.Text); serverPort = tcpPortText.Text; } catch { OutputList.Items.Insert(0, "Invalid TCP Port, using 13000"); tcpPortText.Text = "13000"; serverPort = tcpPortText.Text; } if (HRreader == null)//if the HR characteristic in not found, show an error { OutputList.Items.Insert(0, "Heart Rate Monitor characteristic not found"); } else //If the characteristic have been found, start the readings { //Requesting notify //NOTE: we are not allowed to read the value on request, we have to ask the device to be notified when the HR value change GattCommunicationStatus status = GattCommunicationStatus.ProtocolError; //setting the status as "protocol error", just in case... OutputList.Items.Insert(0, "Waiting for notify handshake..."); try { status = await HRreader.WriteClientCharacteristicConfigurationDescriptorAsync( GattClientCharacteristicConfigurationDescriptorValue.Notify); } catch { //f**k, i don't know } //We are now ready to receive the informations and send them via TCP if (status == GattCommunicationStatus.Success) { OutputList.Items.Insert(0, "Notify Activated"); OutputList.Items.Insert(0, "Now reading... give me a few seconds"); deviceConnectionState = true; serverPort = tcpPortText.Text; OutputList.Items.Insert(0, "Connecting to port " + serverPort); DispatcherTimerSetup(); read(); } else { if (status == GattCommunicationStatus.ProtocolError) { OutputList.Items.Insert(0, "Notify Failed - Protocol Error"); } if (status == GattCommunicationStatus.Unreachable) { OutputList.Items.Insert(0, "Notify Failed - Unreachable"); } if (status == GattCommunicationStatus.AccessDenied) { OutputList.Items.Insert(0, "Notify Failed - Access Denied"); } OutputList.Items.Insert(0, "Sorry, I'm far from perfect"); } } } else { OutputList.Items.Insert(0, "Select a device from the list"); //nel caso in cui non venga selezionato un dispositivo dalla lista } }