Example #1
0
        /// <summary>
        /// Get known characteristic(s) without service instance
        /// </summary>
        /// <param name="peripheral"></param>
        /// <param name="serviceUuid"></param>
        /// <param name="characteristicUuid"></param>
        /// <param name="throwIfNotFound"></param>
        /// <returns></returns>
        public static IObservable <IGattCharacteristic?> GetKnownCharacteristic(this IPeripheral peripheral, string serviceUuid, string characteristicUuid, bool throwIfNotFound = false) =>
        peripheral
        .GetKnownService(serviceUuid, throwIfNotFound)
        .Select(x =>
        {
            if (x == null)
            {
                return(Observable.Empty <IGattCharacteristic>());
            }

            return(x.GetKnownCharacteristic(characteristicUuid, throwIfNotFound));
        })
        .Switch();
Example #2
0
        public static IObservable <DeviceInfo> ReadDeviceInformation(this IPeripheral peripheral)
        => peripheral
        .GetKnownService(StandardUuids.DeviceInformationServiceUuid, true)
        .SelectMany(x => x.GetCharacteristics())
        .SelectMany(x => x.Select(y => y.Read()))
        .Concat()
        .ToList()
        .Select(data =>
        {
            var dev = new DeviceInfo();
            foreach (var item in data)
            {
                switch (item.Characteristic.Uuid.ToLower())
                {
                case "00002a23-0000-1000-8000-00805f9b34fb":
                    dev.SystemId = Encoding.UTF8.GetString(item.Data);
                    break;

                case "00002a24-0000-1000-8000-00805f9b34fb":
                    dev.ModelNumber = Encoding.UTF8.GetString(item.Data);
                    break;

                case "00002a25-0000-1000-8000-00805f9b34fb":
                    dev.SerialNumber = Encoding.UTF8.GetString(item.Data);
                    break;

                case "00002a26-0000-1000-8000-00805f9b34fb":
                    dev.FirmwareRevision = Encoding.UTF8.GetString(item.Data);
                    break;

                case "00002a27-0000-1000-8000-00805f9b34fb":
                    dev.HardwareRevision = Encoding.UTF8.GetString(item.Data);
                    break;

                case "00002a28-0000-1000-8000-00805f9b34fb":
                    dev.SoftwareRevision = Encoding.UTF8.GetString(item.Data);
                    break;

                case "00002a29-0000-1000-8000-00805f9b34fb":
                    dev.ManufacturerName = Encoding.UTF8.GetString(item.Data);
                    break;
                }
            }
            return(dev);
        });
Example #3
0
        private async Task ReadFromDevice(IPeripheral device)
        {
            StopSearch();
            var ServiceId        = Guid.Parse("0000180A-0000-1000-8000-00805F9B34FB");
            var ManufacturerName = Guid.Parse("00002A29-0000-1000-8000-00805F9B34FB");

            var connectedDevice = await device.ConnectWait();

            var service = await device.GetKnownService(ServiceId);

            var characteristic = await service.GetKnownCharacteristics(new Guid[] { ManufacturerName });

            if (characteristic.CanRead())
            {
                var data = await characteristic.Read();

                var readValue = Encoding.UTF8.GetString(data.Data);
                Debug.WriteLine($"> Read characteristic is: {readValue}");
            }
        }
        public static IObservable <DeviceInfo> ReadDeviceInformation(this IPeripheral peripheral)
        => peripheral
        .GetKnownService(StandardUuids.DeviceInformationServiceUuid, true)
        .SelectMany(x => x.GetCharacteristics())
        .SelectMany(x => x.Select(y => y.Read()))
        .Concat()
        .ToList()
        .Select(data =>
        {
            var dev = new DeviceInfo();
            foreach (var item in data)
            {
                switch (item.Characteristic.Uuid[3])
                {
                case '4':
                    dev.ModelNumber = BitConverter.ToString(item.Data);
                    break;

                case '5':
                    dev.SerialNumber = BitConverter.ToString(item.Data);
                    break;

                case '6':
                    dev.FirmwareRevision = BitConverter.ToString(item.Data);
                    break;

                case '7':
                    dev.HardwareRevision = BitConverter.ToString(item.Data);
                    break;

                case '8':
                    dev.SoftwareRevision = BitConverter.ToString(item.Data);
                    break;

                case '9':
                    dev.ManufacturerName = BitConverter.ToString(item.Data);
                    break;
                }
            }
            return(dev);
        });
 /// <summary>
 /// Discovers all characteristics for a known service
 /// </summary>
 /// <param name="peripheral"></param>
 /// <param name="serviceUuid"></param>
 /// <returns></returns>
 public static IObservable <IGattCharacteristic> GetCharacteristicsForService(this IPeripheral peripheral, Guid serviceUuid) =>
 peripheral
 .GetKnownService(serviceUuid)
 .SelectMany(x => x.DiscoverCharacteristics());
 /// <summary>
 /// Get known characteristic(s) without service instance
 /// </summary>
 /// <param name="peripheral"></param>
 /// <param name="serviceUuid"></param>
 /// <param name="characteristicIds"></param>
 /// <returns></returns>
 public static IObservable <IGattCharacteristic> GetKnownCharacteristics(this IPeripheral peripheral, Guid serviceUuid, params Guid[] characteristicIds) =>
 peripheral
 .GetKnownService(serviceUuid)
 .SelectMany(x => x.GetKnownCharacteristics(characteristicIds));
Example #7
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="peripheral"></param>
 /// <param name="serviceUuid"></param>
 /// <returns></returns>
 public static IObservable <IList <IGattCharacteristic> > GetCharacteristicsByService(this IPeripheral peripheral, string serviceUuid) =>
 peripheral
 .GetKnownService(serviceUuid, true)
 .Select(x => x.GetCharacteristics())
 .Switch();