User172704 posted@criapix
I have very quickly stripped the file down to its bare-bones and pasted it below. See if you can work out what is happening from this. Maybe the Characteristic_ValueUpdated event handler is what you are looking for. If not, we'll have to figure out a way for me to share the full code securely.
Your device might be the problem. I have tried connecting to cheap BLE devices before and got nowhere. Maybe they have rubbish Bluetooth hardware or maybe they only pay lip-service to implementing a proper interface? If you continue to struggle, I'd get a device like the one I linked to. It wasn't that expensive (maybe £GBP40) and works perfectly.
```
public class BluetoothLE
{
// Event handler for when the Bluetooth LE connection is lost.
private async void BLEAdapter_DeviceConnectionLost( object sender, DeviceErrorEventArgs e )
{
if( e.Device.Id == _thisSessionConnectedDeviceGuid )
{
// Disconnected device has GUID {e.Device.Id}, which matches GUID of connected heart-rate device, so attempt reconnection.
await AttemptReconnectOrDiscoveryAsync( true, CancellationToken.None );
}
}
// Event handler for when a Bluetooth LE device disconnects.
private async void BLEAdapter_DeviceDisconnected( object sender, DeviceEventArgs e )
{
if( e.Device.Id == _thisSessionConnectedDeviceGuid )
{
await AttemptReconnectOrDiscoveryAsync( true, CancellationToken.None );
}
}
// Handle connection timeout.
private void BLEAdapter_ScanTimeoutElapsed( object sender, EventArgs e )
{
}
// Event handler for when a Bluetooth LE device is discovered.
private void BLEAdapter_DeviceDiscovered( object sender, DeviceEventArgs e )
{
_devices.Add( new BluetoothLEDeviceRecord( e.Device ) );
}
// Event handler for when a new value is read from the connected Bluetooth LE device.
private void Characteristic_ValueUpdated( object sender, CharacteristicUpdatedEventArgs e )
{
byte[] valueHexBytes = e.Characteristic.Value;
byte t = valueHexBytes[ 1 ];
valueHexBytes[ 1 ] = valueHexBytes[ 0 ];
valueHexBytes[ 0 ] = t;
UInt16 valueInteger = BitConverter.ToUInt16( valueHexBytes, 0 );
_latestBioSampleValue = (double)valueInteger;
}
// Helper to attempt reconnection of known device or scan if needed.
private async Task<bool> AttemptReconnectOrDiscoveryAsync( bool triggeredbyBLEEvent, CancellationToken cancellationToken )
{
if( await InternalInitialiseOrReinitialiseAsync() )
{
if( Descriptor.TryGetGuid( _BluetoothLEDeviceGUID, out Guid lastBLEDeviceGuid ) )
{
await AttemptReconnectionAsync( lastBLEDeviceGuid );
}
else
{
await ScanForDevices( cancellationToken );
}
await ExamineDiscoveredDevices( cancellationToken );
if( AllOkay )
{
Descriptor.SetOrAddKeyValue( _BluetoothLEDeviceGUID, _connectedBLEDevice.Id.ToString() );
return true;
}
else
{
return false;
}
}
// Attempt reconnection of a known device, bypassing the power-hungry need to do a full scan.
private async Task AttemptReconnectionAsync( Guid deviceGuid )
{
IDevice specificDevice = await ConnectToKnownDeviceAsync( deviceGuid ).ConfigureAwait( false );
if( specificDevice != null )
{
_devices.Add( new BluetoothLEDeviceRecord( specificDevice ) );
}
else
{
IReadOnlyCollection<IDevice> connectedDevices = App.BLE.Adapter.GetSystemConnectedOrPairedDevices();
foreach( IDevice device in connectedDevices )
{
_devices.Add( new BluetoothLEDeviceRecord( device ) );
}
}
}
// Helper to attempt connection to a known device, which saves power wasted on a full scan.
private async Task<IDevice> ConnectToKnownDeviceAsync( Guid deviceGuid )
{
QA.CodeStackDebug();
IDevice device;
try
{
device = await App.BLE.Adapter.ConnectToKnownDeviceAsync( deviceGuid ).TimeoutAfter<IDevice>( TimeSpan.FromSeconds( 30.0 ) );
}
catch( TimeoutException ex )
{
}
return device;
}
// Search the specified device for a heart-rate service.
private async Task SearchForHeartRateService( IDevice connectedDevice, CancellationToken cancellationToken )
{
IReadOnlyList<IService> services = await connectedDevice.GetServicesAsync( cancellationToken );
foreach( IService service in services )
{
IReadOnlyList<ICharacteristic> characteristics = await service.GetCharacteristicsAsync();
foreach( ICharacteristic characteristic in characteristics )
{
if( characteristic.Id == _HeartRateGuid )
{
_connectedBLEDevice = connectedDevice;
_selectedBLEService = service;
_selectedBLECharacteristic = characteristic;
_selectedBLECharacteristic.ValueUpdated += Characteristic_ValueUpdated;
_thisSessionConnectedDeviceGuid = _connectedBLEDevice.Id;
await characteristic.StartUpdatesAsync();
return;
}
}
}
}
// Wraps the scanning for Bluetooth LE devices.
private async Task ScanForDevices( CancellationToken cancellationToken )
{
App.BLE.Adapter.ScanMode = ScanMode.LowLatency;
await App.BLE.Adapter.StartScanningForDevicesAsync( cancellationToken );
}
// Helper to wrap up examining all discovered devices.
private async Task ExamineDiscoveredDevices( CancellationToken cancellationToken )
{
foreach( BluetoothLEDeviceRecord deviceRecord in _devices )
await ExamineDiscoveredDevice( deviceRecord.Device, cancellationToken );
}
// Helper function that determines if a Bluetooth BLE instance has been set.
private bool BLESet => App.BLE != null;
// Helper function that determines if Bluetooth LE is turned on.
private bool BLEOn => BLESet && App.BLE.State == BluetoothState.On;
// Helper to safely determine if a Bluetooth LE device scan is currently underway.
private bool IsScanningForDevices => BLEOn && ( App.BLE.Adapter?.IsScanning ?? false );
// Helper to wrap up ON/OFF state text from the Bluetooth instance on this platform.
private string BLEStateString => ( !BLESet ) ? "BLE instance not set!" : ( App.BLE.IsOn ) ? "BLE State = ON" : "BLE State = OFF";
// Helper to compose the logic conditions necessary to determine is there is a successful connection.
private bool AllOkay => BLEOn && _connectedBLEDevice != null && _selectedBLEService != null && _selectedBLECharacteristic != null;
// Helper that does its best to put the code and Bluetooth back into a known state.
private async Task<bool> InternalInitialiseOrReinitialiseAsync()
{
App.BLE.StateChanged -= BLE_StateChanged;
App.BLE.Adapter.DeviceDiscovered -= BLEAdapter_DeviceDiscovered;
App.BLE.Adapter.ScanTimeoutElapsed -= BLEAdapter_ScanTimeoutElapsed;
App.BLE.Adapter.DeviceDisconnected -= BLEAdapter_DeviceDisconnected;
App.BLE.Adapter.DeviceConnectionLost -= BLEAdapter_DeviceConnectionLost;
_selectedBLECharacteristic.ValueUpdated -= Characteristic_ValueUpdated;
_selectedBLECharacteristic = null;
_connectedBLEDevice = null;
_selectedBLEService = null;
foreach( BluetoothLEDeviceRecord device in _devices )
{
await App.BLE.Adapter.DisconnectDeviceAsync( device.Device );
}
_devices.Clear();
App.BLE.StateChanged += BLE_StateChanged;
App.BLE.Adapter.DeviceDiscovered += BLEAdapter_DeviceDiscovered;
App.BLE.Adapter.ScanTimeoutElapsed += BLEAdapter_ScanTimeoutElapsed;
App.BLE.Adapter.DeviceDisconnected += BLEAdapter_DeviceDisconnected;
App.BLE.Adapter.DeviceConnectionLost += BLEAdapter_DeviceConnectionLost;
return true;
}
// State information for the Bluetooth LE connected device.
private bool _internallyBusy = false;
private IDevice _connectedBLEDevice = null;
private IService _selectedBLEService = null;
private ICharacteristic _selectedBLECharacteristic = null;
private Guid _thisSessionConnectedDeviceGuid = Guid.Empty;
private Collection<BluetoothLEDeviceRecord> _devices = new Collection<BluetoothLEDeviceRecord>();
// Latest bio-sample obtained from the connected device.
private double _latestBioSampleValue = 0.0;
// UUID for heart-rate device (see https://www.bluetooth.com/specifications/bluetooth-core-specification/).
private const int _HeartRateUuid = 0x2a37;
private readonly Guid _HeartRateGuid = _HeartRateUuid.UuidFromPartial();
// How long to attempt reconnection.
private const double _ReconnectionTimeoutSeconds = 30.0;
// These are kept here simply because they may prove to be useful and it can take some digging to find them online.
// Device information 0x180a
// Battery service: 0x180f
// Heart-rate: 0x180d
// Body sensor location: 2a38
// Manufacturer Name String: 2a29
// Model Number String: 2a24
// Hardware Revision String: 2a27
// Firmware Revision String: 2a26
// Software Revision String: 2a28
// BatteryLevelUuid: 0x2a37;
/// <summary>
/// Holds information about a single Bluetooth LE device.
/// </summary>
private struct BluetoothLEDeviceRecord
{
public BluetoothLEDeviceRecord( IDevice device )
{
Device = device;
}
public IDevice Device { get; private set; }
public Guid UniqueId => Device.Id;
public bool IsConnected => Device.State == DeviceState.Connected;
public int Rssi => Device.Rssi;
public string Name => Device.Name;
}
}
}
```
