private void WriteLighMode(uint lightMode) { Task.Run(async() => { OnewheelBoard onewheel = OnewheelConnectionHelper.INSTANCE.GetOnewheel(); if (onewheel is null) { await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => ShowInfo("Updating light mode failed - not connected!", 5000)); } else { GattWriteResult result = await onewheel.WriteShortAsync(OnewheelCharacteristicsCache.CHARACTERISTIC_LIGHTING_MODE, (short)lightMode); await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { if (result != null && result.Status == GattCommunicationStatus.Success) { ShowInfo("💡 Light mode updated!", 5000); } else { ShowInfo("Failed to update light mode: " + (result == null ? "characteristic not found" : result.Status.ToString()), 5000); } }); } }); }
public async Task <GattWriteResult> DoWriteString(string str) { GattWriteOption writeOption = PreferredWriteOption(); var bytes = Encoding.UTF8.GetBytes(str); const int MAXBYTES = 20; if (bytes.Length > MAXBYTES) { GattWriteResult status = null; for (int i = 0; i < bytes.Length; i += MAXBYTES) { // So many calculations and copying just to get a slice var maxCount = Math.Min(MAXBYTES, bytes.Length - i); var subcommand = new ArraySegment <byte>(bytes, i, maxCount).ToArray().AsBuffer(); status = await Characteristic.WriteValueWithResultAsync(subcommand, writeOption); } return(status); } else { var data = bytes.AsBuffer(); var status = await Characteristic.WriteValueWithResultAsync(data, writeOption); return(status); } }
/// <inheritdoc /> public IGattWriteResultWrapper Create(GattWriteResult result) { Guard.ArgumentNotNull(result, nameof(result)); return(_factory.Invoke(result)); }
protected override async Task StartUpdatesNativeAsync() { this._nativeCharacteristic.ValueChanged += this.OnCharacteristicValueChanged; GattWriteResult result = await this._nativeCharacteristic.WriteClientCharacteristicConfigurationDescriptorWithResultAsync( GattClientCharacteristicConfigurationDescriptorValue.Notify); //output trace message with status of update if (result.Status == GattCommunicationStatus.Success) { Trace.Message("Start Updates Successful"); } else if (result.Status == GattCommunicationStatus.AccessDenied) { Trace.Message("Incorrect permissions to start updates"); } else if (result.Status == GattCommunicationStatus.ProtocolError && result.ProtocolError != null) { Trace.Message("Start updates returned with error: {0}", this.parseError(result.ProtocolError)); } else if (result.Status == GattCommunicationStatus.ProtocolError) { Trace.Message("Start updates returned with unknown error"); } else if (result.Status == GattCommunicationStatus.Unreachable) { Trace.Message("Characteristic properties are unreachable"); } }
public GattWriteResultWrapper([JetBrains.Annotations.NotNull] GattWriteResult result) { Guard.ArgumentNotNull(result, nameof(result)); _result = result; }
public async Task Send(IBuffer buffer) { if (WriteableCharacteristics != null) { GattWriteResult result = await WriteCharacteristic.WriteValueWithResultAsync(buffer); Console.WriteLine(result); } }
/// <summary> /// Write a value into a GATT characteristic /// </summary> /// <param name="characteristic">GATT characteristic</param> /// <param name="value">Value</param> /// <returns>true if the operation succeeded, false otherwise</returns> public async Task <bool> WriteValueAsync(BleGattCharacteristic characteristic, BleValue value) { bool ret = false; GattCharacteristic gatt_characteristic = characteristic.Context as GattCharacteristic; IBuffer buffer = CryptographicBuffer.CreateFromByteArray(value.Value); GattWriteResult result = await gatt_characteristic.WriteValueWithResultAsync(buffer, GattWriteOption.WriteWithResponse); if (result.Status == GattCommunicationStatus.Success) { ret = true; } return(ret); }
public async Task <bool> StopQueryingLineSensor() { GattWriteResult result = await this.responseCharacteristic.WriteClientCharacteristicConfigurationDescriptorWithResultAsync(GattClientCharacteristicConfigurationDescriptorValue.None) .AsTask() .ConfigureAwait(false); if (result.Status != GattCommunicationStatus.Success) { this.logger.Error($"failed to disable notification for '{RESPONSE_CHARACTERISTICS_GUID}' charactersitic for '{SERVICE_GUID}' " + $"service on BLE device with id = '{this.bluetoothLeDevice.DeviceId}', result = '{result.Status}', protocol error = '{result.ProtocolError}'"); return(false); } return(true); }
public async Task <GattCommunicationStatus> WriteCharacteristicValueAsync(GattCharacteristic characteristic, byte[] data, bool withResponse) { var writer = new DataWriter(); writer.WriteBytes(data); if (withResponse) { GattWriteResult result = await characteristic.WriteValueWithResultAsync(writer.DetachBuffer()); return(result.Status); } else { return(await characteristic.WriteValueAsync(writer.DetachBuffer())); } }
protected override async Task <Boolean> WriteNativeAsync(Byte[] data, CharacteristicWriteType writeType) { //print errors if error and write with response if (writeType == CharacteristicWriteType.WithResponse) { GattWriteResult result = await this._nativeCharacteristic.WriteValueWithResultAsync( CryptographicBuffer.CreateFromByteArray(data)); if (result.Status == GattCommunicationStatus.Success) { Trace.Message("Write successful"); return(true); } if (result.Status == GattCommunicationStatus.AccessDenied) { Trace.Message("Incorrect permissions to stop updates"); } else if (result.Status == GattCommunicationStatus.ProtocolError && result.ProtocolError != null) { Trace.Message("Write Characteristic returned with error: {0}", this.parseError(result.ProtocolError)); } else if (result.Status == GattCommunicationStatus.ProtocolError) { Trace.Message("Write Characteristic returned with unknown error"); } else if (result.Status == GattCommunicationStatus.Unreachable) { Trace.Message("Characteristic write is unreachable"); } return(false); } GattCommunicationStatus status = await this._nativeCharacteristic.WriteValueAsync(CryptographicBuffer.CreateFromByteArray(data), GattWriteOption.WriteWithoutResponse); if (status == GattCommunicationStatus.Success) { return(true); } return(false); }
private async Task<int> send_command_async (string command, bool use_send_characteristic = true) { if (ganglion_device == null) { return (int) CustomExitCodes.GANGLION_IS_NOT_OPEN_ERROR; } if (send_characteristic == null) { return (int) CustomExitCodes.SEND_CHARACTERISTIC_NOT_FOUND_ERROR; } var writer = new Windows.Storage.Streams.DataWriter (); writer.WriteString (command); try { GattWriteResult result = null; if (use_send_characteristic) { result = await send_characteristic.WriteValueWithResultAsync (writer.DetachBuffer ()).AsTask ().TimeoutAfter (timeout); } else { result = await disconnect_characteristic.WriteValueWithResultAsync (writer.DetachBuffer ()).AsTask ().TimeoutAfter (timeout); } if (result.Status == GattCommunicationStatus.Success) { return (int) CustomExitCodes.STATUS_OK; } else { return (int) CustomExitCodes.STOP_ERROR; } } catch (TimeoutException e) { return (int) CustomExitCodes.TIMEOUT_ERROR; } catch (Exception e) { return (int) CustomExitCodes.GENERAL_ERROR; } return (int) CustomExitCodes.STATUS_OK; }
//--------------------------------------------------------Constructor:----------------------------------------------------------------\\ #region --Constructors-- #endregion //--------------------------------------------------------Set-, Get- Methods:---------------------------------------------------------\\ #region --Set-, Get- Methods-- #endregion //--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\ #region --Misc Methods (Public)-- public async Task <GattWriteResult> ChangeBoardNameAsync(ChangeBoardNameDialogContext context) { if (context.MODEL.Accepted) { GattWriteResult result = await OnewheelConnectionHelper.INSTANCE.GetOnewheel().WriteStringAsync(OnewheelCharacteristicsCache.CHARACTERISTIC_CUSTOM_NAME, context.MODEL.CustomName); if (result.Status == GattCommunicationStatus.Success) { Logger.Info("Successfully update the custom name to: " + context.MODEL.CustomName); } else { Logger.Error("Failed with " + result.Status + " to update the custom name to: " + context.MODEL.CustomName); } return(result); } return(null); }
private async Task _writeToUart(byte[] value) { GattCharacteristic c = GetCharacteristic(new Guid(BTValues.rxCharacteristic)); if (c == null) { return; } GattWriteResult result = null; try { result = await c.WriteValueWithResultAsync(WindowsRuntimeBufferExtensions.AsBuffer(value)); } catch (Exception e) { } if (result?.Status == GattCommunicationStatus.Success) { callback.onUartDataSent(value); } }
public async Task <GattWriteResult> WriteBytesAsync(Guid uuid, byte[] data) { CHARACTERISTICS.TryGetValue(uuid, out GattCharacteristic c); if (c != null) { IBuffer buffer = CryptographicBuffer.CreateFromByteArray(data); GattWriteResult result = await c.WriteValueWithResultAsync(buffer); if (result.Status == GattCommunicationStatus.Success) { // Convert to little endian: CACHE.AddToDictionary(uuid, data); } return(result); } else { Logger.Warn("Failed to write to write bytes to: " + uuid.ToString() + " - not loaded."); } return(null); }
private async void ReleaseSPIFlash() { try { Console.WriteLine(tag, "ReleaseSPIFlash"); GattDeviceService service = await GetServiceAsync(Constants.SUOTA_SERVICE_UUID); GattCharacteristic characteristic = await GetCharacteristicAsync(Constants.SUOTA_CTRL_UUID, service); byte[] buff = { 1 }; GattWriteResult result = await characteristic.WriteValueWithResultAsync(buff.AsBuffer()); if (result.Status != GattCommunicationStatus.Success) { throw (new Exception("ReleaseSPIFlash. =>" + result.Status)); } } catch (Exception ex) { Console.WriteLine(tag, "Exception while ReleaseSPIFlash. " + ex.Message); } }
/// <summary> /// Register to notifications from a GATT characteristic /// </summary> /// <param name="characteristic">GATT characteristic</param> /// <param name="listener">Method which will be called on each value notification</param> /// <returns>true if the operation succeeded, false otherwise</returns> public async Task <bool> RegisterValueNotificationAsync(BleGattCharacteristic characteristic, Action <BleGattCharacteristic, BleValue> listener) { bool ret = false; GattCharacteristic gatt_characteristic = characteristic.Context as GattCharacteristic; GattClientCharacteristicConfigurationDescriptorValue value; if (gatt_characteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Notify)) { value = GattClientCharacteristicConfigurationDescriptorValue.Notify; } else if (gatt_characteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Indicate)) { value = GattClientCharacteristicConfigurationDescriptorValue.Indicate; } else { value = GattClientCharacteristicConfigurationDescriptorValue.None; } if (value != GattClientCharacteristicConfigurationDescriptorValue.None) { if (!_ble_notification_listeners.ContainsKey(characteristic)) { GattWriteResult result = await gatt_characteristic.WriteClientCharacteristicConfigurationDescriptorWithResultAsync(value); if (result.Status == GattCommunicationStatus.Success) { lock (_ble_notification_listeners) { _ble_notification_listeners.Add(characteristic, listener); } gatt_characteristic.ValueChanged += OnCharacteristicNotification; ret = true; } } } return(ret); }
private async Task <byte[]> readData(Int32 startAddr) { try { GattDeviceService service = await GetServiceAsync(Constants.SUOTA_SERVICE_UUID); GattCharacteristic characteristic = await GetCharacteristicAsync(Constants.SUOTA_CTRL_UUID, service); Int32 endAddr = startAddr + 0x100; byte[] retVar = null; byte[] requestBuff = new byte[] { 3, (byte)(BitConverter.GetBytes(startAddr)[0] & 0xFF), (byte)(BitConverter.GetBytes(startAddr)[1] & 0xFF), (byte)(BitConverter.GetBytes(startAddr)[2] & 0xFF), (byte)(BitConverter.GetBytes(startAddr)[3] & 0xFF), (byte)(BitConverter.GetBytes(endAddr)[0] & 0xFF), (byte)(BitConverter.GetBytes(endAddr)[1] & 0xFF), (byte)(BitConverter.GetBytes(endAddr)[2] & 0xFF), (byte)(BitConverter.GetBytes(endAddr)[3] & 0xFF) }; GattWriteResult result = await characteristic.WriteValueWithResultAsync(requestBuff.AsBuffer()); if (result.Status != GattCommunicationStatus.Success) { throw (new Exception("readData. =>" + result.Status)); } characteristic = await GetCharacteristicAsync(Constants.SUOTA_READ_UUID, service); var ReadResult = await characteristic.ReadValueAsync(); if (ReadResult.Status != GattCommunicationStatus.Success) { throw (new Exception("readDataResult =>" + ReadResult.Status)); } retVar = ReadResult.Value.ToArray(); return(retVar); } catch (Exception ex) { Console.WriteLine(tag, "Exception while readData. " + ex.Message); return(null); } }
private async void Watcher_Received(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args) { if (args.Advertisement.LocalName.Contains("HMSoft")) { BluetoothLEDevice bluetoothLeDevice = await BluetoothLEDevice.FromBluetoothAddressAsync(args.BluetoothAddress); GattDeviceServicesResult result = await bluetoothLeDevice.GetGattServicesAsync(); if (result.Status == GattCommunicationStatus.Success) { var services = result.Services; foreach (var service in services) { if (!foundServices.Contains(service)) { Dispatcher.Invoke(() => { tb.Text += service.Uuid; tb.Text += Environment.NewLine; foundServices.Add(service); }); } if (!service.Uuid.ToString().StartsWith("0000ffe0")) { continue; } GattCharacteristicsResult characteristicsResult = await service.GetCharacteristicsAsync(); if (characteristicsResult.Status == GattCommunicationStatus.Success) { var characteristics = characteristicsResult.Characteristics; foreach (var characteristic in characteristics) { if (!foundCharacters.Contains(characteristic)) { Dispatcher.Invoke(() => { tb.Text += characteristic.Uuid; tb.Text += Environment.NewLine; foundCharacters.Add(characteristic); }); } if (!characteristic.Uuid.ToString().StartsWith("0000ffe1")) { continue; } GattCharacteristicProperties properties = characteristic.CharacteristicProperties; if (properties.HasFlag(GattCharacteristicProperties.Indicate)) { GattWriteResult status = await characteristic.WriteClientCharacteristicConfigurationDescriptorWithResultAsync(GattClientCharacteristicConfigurationDescriptorValue.Indicate); return; } if (properties.HasFlag(GattCharacteristicProperties.Notify)) { GattCommunicationStatus status = await characteristic.WriteClientCharacteristicConfigurationDescriptorAsync( GattClientCharacteristicConfigurationDescriptorValue.Notify); if (status == GattCommunicationStatus.Success) { characteristic.ValueChanged += Characteristic_ValueChanged; } } if (properties.HasFlag(GattCharacteristicProperties.Read)) { GattReadResult gattResult = await characteristic.ReadValueAsync(); if (gattResult.Status == GattCommunicationStatus.Success) { var reader = DataReader.FromBuffer(gattResult.Value); byte[] input = new byte[reader.UnconsumedBufferLength]; reader.ReadBytes(input); Dispatcher.Invoke(() => { tb.Text += "connected: "; tb.Text += Encoding.ASCII.GetString(input); tb.Text += Environment.NewLine; }); } } } } } } } }
public static void ThrowIfError(this GattWriteResult result, [CallerMemberName] string tag = null) => result.Status.ThrowIfError(tag, result.ProtocolError);