private void DeviceOnServicesDiscovered(object sender, EventArgs e)
        {
            _moCoBusService = _device.Services
                .FirstOrDefault(svc => svc.ID == BleConstants.ServiceMoCoBus);
            if (_moCoBusService == null)
                return;

            _moCoBusService.CharacteristicsDiscovered += MoCoBusServiceOnCharacteristicsDiscovered;
            _moCoBusService.DiscoverCharacteristics();
        }
Esempio n. 2
0
        public Sensor(ble.IAdapter adapter, ble.IDevice device, ble.IService service)
        {
            BleDevice = device;
            Loading   = true;
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Loading"));
            this.service = service;
            switch (service.Name)
            {
            case "TI SensorTag Barometer":
                ImageId = "Pressure";
                break;

            case "TI SensorTag Humidity":
                ImageId = "Humidity";
                break;

            case "TI SensorTag Infrared Thermometer":
                ImageId = "Thermometer";
                break;
            }
            service.CharacteristicsDiscovered += async(s, e) =>
            {
                foreach (var characteristic in service.Characteristics)
                {
                    if (characteristic.Name.Contains("Data"))
                    {
                        dataChar = await characteristic.ReadAsync();

                        await Task.Delay(1000);
                    }
                    else if (characteristic.Name.Contains("On/Off"))
                    {
                        onOffChar = await characteristic.ReadAsync();

                        onOffChar.Write(new byte[] { 0x01 });
                        await Task.Delay(1000);
                    }
                    else if (characteristic.Name.Contains("Sample Rate"))
                    {
                        sampleChar = await characteristic.ReadAsync();

                        await Task.Delay(1000);
                    }
                }
                if (dataChar.CanUpdate)
                {
                    valueUpdatedHandler = (se, ea) =>
                    {
                        Data = Decode(dataChar);
                        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Data"));
                    };
                    dataChar.ValueUpdated += valueUpdatedHandler;
                    dataChar = await dataChar.ReadAsync();

                    await Task.Delay(2000);

                    dataChar.StartUpdates();
                    Loading = false;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Loading"));
                }
            };
            service.DiscoverCharacteristics();
        }
        void OnDisconnect()
        {
            _moCoBusTxCharacteristic = null;

            if (_moCoBusRxCharacteristic != null)
            {
                try
                {
                    _moCoBusRxCharacteristic.ValueUpdated -= MoCoBusRxCharacteristicOnValueUpdated;
                }
                catch (Exception)
                {
                    // ignore
                }
                _moCoBusRxCharacteristic = null;
            }

            if (_moCoBusService != null)
            {
                try
                {
                    _moCoBusService.CharacteristicsDiscovered -= MoCoBusServiceOnCharacteristicsDiscovered;
                }
                catch (Exception)
                {
                    // ignore
                }
                _moCoBusService = null;
            }

            try
            {
                _device.ServicesDiscovered -= DeviceOnServicesDiscovered;
            }
            catch (Exception)
            {
                // ignore
            }

            ConnectionState = ConnectionState.Disconnected;
        }