public async Task WriteCharacteristicAsync(Tuple <Guid, Guid> gattChar, GattCharWriteType writeType, byte[] value)
{
var serviceResult = await device.GetGattServicesForUuidAsync(gattChar.Item1);
var charResult = await serviceResult.Services.FirstOrDefault().GetCharacteristicsForUuidAsync(gattChar.Item2);
var status = await charResult.Characteristics.FirstOrDefault().WriteValueAsync(value.AsBuffer(),
writeType == GattCharWriteType.WRITE_WITHOUT_RESPONSE ? GattWriteOption.WriteWithoutResponse : GattWriteOption.WriteWithResponse);
if (status != GattCommunicationStatus.Success)
{
throw new InvalidOperationException("Failed to write value to GATT characteristic: " + gattChar.Item2.ToString());
}
}
public async Task WriteCharacteristicAsync(Tuple <Guid, Guid> gattChar, GattCharWriteType writeType, byte[] value)
{
var ch = await GetGattCharacteristicAsync(gattChar);
if (writeType == GattCharWriteType.WRITE_WITH_RESPONSE)
{
CharacteristicResult resp = await ch.Write(value);
//if (resp.S)
// Note - whaddayou do with a failed write?
}
else
{
ch.WriteWithoutResponse(value);
}
}
public async Task WriteCharacteristicAsync(Tuple <Guid, Guid> gattChar, GattCharWriteType writeType, byte[] value)
{
if (characteristics.TryGetValue(gattChar.Item2, out var characteristic))
{
var result = await characteristic.WriteValueAsync(value.AsBuffer(),
writeType == GattCharWriteType.WRITE_WITHOUT_RESPONSE?GattWriteOption.WriteWithoutResponse : GattWriteOption.WriteWithResponse);
if (result != GattCommunicationStatus.Success)
{
throw new InvalidOperationException("Failed to write value to GATT characteristic: " + gattChar.Item2.ToString());
}
}
else
{
throw new InvalidOperationException(string.Format("GATT characteristic '{0}' does not exist", gattChar.Item2));
}
}
public async Task WriteCharacteristicAsync(Tuple <Guid, Guid> gattChar, GattCharWriteType writeType, byte[] value)
{
if (this.m_Device == null)
{
return;
}
//if (this.Characteristics.Count == 0)
//{
// await FillServices();
//}
//GattDeviceServicesResult result = await m_Device.GetGattServicesForUuidAsync(gattChar.Item1);
//if (result.Services.Count > 0)
{
//var service = result.Services[0];
//var chars = await service.GetCharacteristicsForUuidAsync(gattChar.Item2);
//if (chars.Characteristics.Count > 0)
{
var characteristic = await GetChar(gattChar.Item2);
if (characteristic != null)
{
var properties = characteristic.CharacteristicProperties;
if (properties.HasFlag(GattCharacteristicProperties.Write))
{
var writer = new DataWriter();
writer.WriteBytes(value);
var opt = writeType == GattCharWriteType.WRITE_WITH_RESPONSE ? GattWriteOption.WriteWithResponse : GattWriteOption.WriteWithoutResponse;
await characteristic.WriteValueAsync(writer.DetachBuffer(), opt);
Console.WriteLine($"writen to {characteristic}");
return;
}
else
{
Console.WriteLine($"Could not write to {characteristic}");
}
}
}
}
//Console.WriteLine("could not write to characteristic",char)
throw new IOException("could not write to characteristic");
}
public async Task WriteCharacteristicAsync(Tuple <Guid, Guid> gattChar, GattCharWriteType writeType, byte[] bytes)
{
var value = WarbleGatt.FindCharacteristic(gattChar.Item2.ToString());
if (value == null)
{
throw new InvalidOperationException(string.Format("Characteristic '{0}' does not exist", gattChar.Item2));
}
else
{
if (writeType == GattCharWriteType.WRITE_WITHOUT_RESPONSE)
{
await value.WriteWithoutResponseAsync(bytes);
}
else
{
await value.WriteAsync(bytes);
}
}
}
public async Task WriteCharacteristicAsync(Tuple <Guid, Guid> gattChar, GattCharWriteType writeType, byte[] value)
{
if (value[1] == 0x80)
{
connectCommands.Add(value);
if (initResponse.moduleResponses.TryGetValue(value[0], out var response))
{
if (delayModuleDiscovery)
{
await Task.Delay(RESPONSE_DELAY);
}
charChangedHandler(response);
}
}
else
{
if (value[0] == 0xb && value[1] == 0x84)
{
connectCommands.Add(value);
await Task.Delay(RESPONSE_DELAY);
charChangedHandler(new byte[] { 0x0b, 0x84, 0x15, 0x04, 0x00, 0x00, 0x05 });
}
else
{
commands.Add(value);
writeTypes.Add(writeType);
byte[] response = null;
if (customResponses.ContainsKey(value))
{
response = customResponses[value];
}
else if (loggerId < maxLoggers && value[0] == 0xb && value[1] == 0x2)
{
response = new byte[] { value[0], 0x2, loggerId };
loggerId++;
}
else if (dataProcessorId < maxProcessors && value[0] == 0x9 && value[1] == 0x2)
{
response = new byte[] { value[0], 0x2, dataProcessorId };
dataProcessorId++;
}
else if (eventId < maxEvents && value[0] == 0xa && value[1] == 0x3)
{
response = new byte[] { value[0], 0x2, eventId };
eventId++;
}
else if (timerId < maxTimers && value[0] == 0xc && value[1] == 0x2)
{
response = new byte[] { value[0], 0x2, timerId };
timerId++;
}
else if (value[0] == 0xf && value[1] == 0x2)
{
response = new byte[] { value[0], 0x2, macroId };
macroId++;
}
else if (value[0] == 0xb && value[1] == 0x85)
{
sendMockResponse(new byte[] { 0x0b, 0x85, 0x9e, 0x01, 0x00, 0x00 });
}
else if (value[0] == 0xfe && (value[1] == 0x1 || value[1] == 0x6 || value[1] == 0x2))
{
await Task.Delay(1000);
nDisconnects++;
OnDisconnect();
}
if (response != null)
{
await Task.Delay(RESPONSE_DELAY);
charChangedHandler(response);
}
}
}
}
public Task WriteCharacteristicAsync(Tuple <Guid, Guid> gattChar, GattCharWriteType writeType, byte[] value)
{
if (value[1] == 0x80)
{
connectCommands.Add(value);
if (initResponse.moduleResponses.TryGetValue(value[0], out var response))
{
if (delayModuleDiscovery)
{
pendingResponses.Enqueue(response);
}
else
{
charChangedHandler(response);
}
}
}
else
{
if (value[0] == 0xb && value[1] == 0x84)
{
connectCommands.Add(value);
pendingResponses.Enqueue(new byte[] { 0x0b, 0x84, 0x15, 0x04, 0x00, 0x00, 0x05 });
}
else
{
commands.Add(value);
writeTypes.Add(writeType);
if (customResponses.ContainsKey(value))
{
pendingResponses.Enqueue(customResponses[value]);
}
else if (loggerId < maxLoggers && value[0] == 0xb && value[1] == 0x2)
{
byte[] response = { value[0], 0x2, loggerId };
loggerId++;
pendingResponses.Enqueue(response);
}
else if (dataProcessorId < maxProcessors && value[0] == 0x9 && value[1] == 0x2)
{
byte[] response = { value[0], 0x2, dataProcessorId };
dataProcessorId++;
pendingResponses.Enqueue(response);
}
else if (eventId < maxEvents && value[0] == 0xa && value[1] == 0x3)
{
byte[] response = { value[0], 0x2, eventId };
eventId++;
pendingResponses.Enqueue(response);
}
else if (timerId < maxTimers && value[0] == 0xc && value[1] == 0x2)
{
byte[] response = { value[0], 0x2, timerId };
timerId++;
pendingResponses.Enqueue(response);
}
else if (value[0] == 0xf && value[1] == 0x2)
{
byte[] response = { value[0], 0x2, macroId };
macroId++;
pendingResponses.Enqueue(response);
}
else if (value[0] == 0xb && value[1] == 0x85)
{
sendMockResponse(new byte[] { 0x0b, 0x85, 0x9e, 0x01, 0x00, 0x00 });
}
}
}
return(Task.FromResult(true));
}
