private async Task splitProcess(string str512, ICharacteristic _characteristic)
{
int chunkSize = 512;
int stringLength = str512.Length;
byte[] senddata = Encoding.UTF8.GetBytes("start");
var bytes = await _characteristic.WriteAsync(senddata);
//receiveStr("start");
for (int i = 0; i < stringLength; i += chunkSize)
{
if (i + chunkSize > stringLength)
{
chunkSize = stringLength - i;
}
senddata = Encoding.UTF8.GetBytes(str512.Substring(i, chunkSize));
bytes = await _characteristic.WriteAsync(senddata);
//receiveStr(str.512.Substring(i, chunkSize));
}
senddata = Encoding.UTF8.GetBytes("end");
bytes = await _characteristic.WriteAsync(senddata);
//receiveStr("end");
}
private async void blePing()
{
if (IsBleConnected)
{
byte[] ping = new byte[] { 0x31, 0x32, 0x33 };
await dataWriteCharacteristic.WriteAsync(ping);
}
}
async private Task SendCmdAndWait(byte [] command)
{
await charCtrl.WriteAsync(command);
image = null;
imageProcessed = null;
canvasView.InvalidateSurface();
canvasViewProcessed.InvalidateSurface();
await NotifyWaitMsg();
}
public async Task Subscribe()
{
try
{
Debug.WriteLine($"***SUBSCRIBING {Data.Name}...");
if (Data.Id != null)
{
if (_device == null)
{
var cancellationTokenSource = new CancellationTokenSource(5000);
_device = await SensorKit.Instance.Adapter.ConnectToKnownDeviceAsync(Data.Id, default(ConnectParameters), cancellationTokenSource.Token);
}
if (_device != null && (uart == null || _uartTX == null || _uartRX == null))
{
_connectedTime = DateTime.Now;
uart = await _device.GetServiceAsync(NORDIC_UART_SERVICE);
if (uart != null)
{
_uartRX = await uart.GetCharacteristicAsync(NORDIC_UART_RX);
_uartTX = await uart.GetCharacteristicAsync(NORDIC_UART_TX);
_uartRX.ValueUpdated += (s, e) =>
{
var received = Encoding.UTF8.GetString(e.Characteristic.Value, 0, e.Characteristic.Value.Length);
ParsePacket(received);
};
IsConnected = true;
await _uartRX.StartUpdatesAsync();
}
}
if (_uartTX != null)
{
await _uartTX.WriteAsync(Encoding.UTF8.GetBytes(SYNC_COMMAND_HISTORY));
}
InvokeHelper.Invoke(() =>
{
Data.NotifyPropertyChanged("IsSubscribed");
});
}
}catch (Exception x)
{
Debug.WriteLine(x);
}
}
private async Task <bool> SendBleMessage(string message)
{
bool result = false;
if (_bleDevice != null && (!String.IsNullOrWhiteSpace(message)))
{
_txCharacteristic = _txCharacteristic
?? await FindBleCharacteristic(BleUartServiceId, BleTxCharacteristicId, _bleDevice);
if (_txCharacteristic == null)
{
throw new InvalidOperationException("Unable to retrieve the characteristic needed to send commands to the BLE device.");
}
else if (!_txCharacteristic.CanWrite)
{
throw new InvalidOperationException("The characteristic needed to send commands to the BLE device does not support this operation.");
}
byte[] bytesToSend = Encoding.ASCII.GetBytes(message);
result = await _txCharacteristic.WriteAsync(bytesToSend);
_previousValue = 0;
}
return(result);
}
/// <summary>
/// Handles the remote date time validation.
/// </summary>
/// <remarks>
/// We validate the DA-12 station time and if it's before 2009 we know
/// it's not valid, so we set a new time.
/// We take a Unix timestamp as UTC and formats it into a station command to
/// update the time.
/// </remarks>
/// <param name="txCharacteristic">Bluetooth service characteristic</param>
/// <param name="remoteUnixDateTime">The remote Unix date time.</param>
public async Task <bool> HandleRemoteDateTimeValidation(ICharacteristic txCharacteristic, int remoteUnixDateTime)
{
// Validate our station Unix time converted to windows time is less
// than 2009. If it is we know the station time needs to be set.
if (remoteUnixDateTime.UnixTimeStampToDateTime().Year < CoreConstants.StationSettingLowestDateTimeYear)
{
// Get Unix timestamp "now" as UTC
Int32 unixTimestampUtc = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
// Format DA-12 station Unix timestamp
// T - is to set the station time,
// 0 - is the data type
// 00 - device index / unused
// Next set of digits is Unix time UTC (converted to HEX)
string remoteUnitTimestamp = "{T000" + unixTimestampUtc.ToString("X") + "}";
// Send set Unix UTC time command to remote
await txCharacteristic.WriteAsync(remoteUnitTimestamp.StrToByteArray()).ConfigureAwait(true);
// Wait a couple seconds for remote to process
await Task.Delay(3000).ConfigureAwait(true);
// Let caller know we set station time
return(true);
}
// We didn't set station time
return(false);
}
async Task SetColor()
{
byte[] rgb = new byte[] { (byte)SliderRed.Value, (byte)SliderGreen.Value, (byte)SliderBlue.Value };
await charRGB.WriteAsync(rgb);
ColorIndicator.Color = new Color(rgb[0] / 255.0, rgb[1] / 255.0, rgb[2] / 255.0);
}
private async Task GetMovementService()
{
try
{
IService service = await device.GetServiceAsync(Guid.Parse("f000aa80-0451-4000-b000-000000000000"));
ICharacteristic dataCharacteristic = await service.GetCharacteristicAsync(Guid.Parse("f000aa81-0451-4000-b000-000000000000"));
ICharacteristic configCharacteristic = await service.GetCharacteristicAsync(Guid.Parse("f000aa82-0451-4000-b000-000000000000"));
await configCharacteristic.WriteAsync(new byte[] { 0x7F, 0x00 });
_gyro = new Gyroscope();
_acc = new Accelerometer();
_mag = new Magnetometer();
Plates = new List <Plate>();
database = new StrongPlateDataService();
dataCharacteristic.ValueUpdated += (o, args) =>
{
byte[] bytes = args.Characteristic.Value;
SetGyro(bytes);
SetAcc(bytes);
SetMag(bytes);
addPlate();
};
await dataCharacteristic.StartUpdatesAsync();
}
catch (Exception ex)
{
Debug.WriteLine("Error GetMovementService: " + ex);
}
}
Guid myCharacteristicUuid = Guid.Parse("fe68847f-59ec-4429-9701-74423a4a7ad4"); // UUID of a known characteristic (Dimming Value)
private async void OnSliderChanged(object sender, ValueChangedEventArgs args)
{
if (Service == null)
{
try { Service = await device.GetServiceAsync(myServiceUuid); }
catch { return; }
}
if (Characteristic == null)
{
try { Characteristic = await Service.GetCharacteristicAsync(myCharacteristicUuid); }
catch { return; }
}
double value = args.NewValue;
//string valor = String.Format("{0:F0}", value);
int iValue = (int)Math.Round(value);
//int iValue = Convert.ToByte(value);
sLabel.Text = iValue.ToString();
byte[] sliderValue = BitConverter.GetBytes(iValue);
if (Characteristic.CanWrite)
{
try
{
var res = await Characteristic.WriteAsync(sliderValue);
}
catch (Exception ex)
{
//await DisplayAlert("Alert", ex.Message ,"Ok");
}
}
//sLabel.Text = BitConverter.ToString(valorb);
//var characteristic = await GetCharacteristicById(parameters, Guid.Parse("00002A87-0000-1000-8000-00805f9b34fb"));
//byte[] array = Encoding.UTF8.GetBytes(UserDataMock.Email);
//characteristic.WriteAsync(array);
}
private async void BtnWOn_Clicked(object sender, EventArgs e)
{
//Guid myServiceUuid = new Guid("166e3275-1b3a-465c-b0e1-3cbc24c5acbe"); // UUID of a known service (Dimming Service)
try
{
Service = await device.GetServiceAsync(myServiceUuid);
}
catch (Exception ex)
{
return;
}
//Guid myCharacteristicUuid = Guid.Parse("fe68847f-59ec-4429-9701-74423a4a7ad4"); // UUID of a known characteristic (Dimming Value)
try
{
Characteristic = await Service.GetCharacteristicAsync(myCharacteristicUuid);
}
catch
{
return;
}
if (Characteristic.CanWrite)
{
var result = await Characteristic.WriteAsync(new byte[] { 255 });
if (!result)
{
Debug.WriteLine("CAN'T WRITE TO CHARACTERISTIC");
}
else
{
Debug.WriteLine("CHARACTERISTIC WRITTEN");
}
}
}
public async Task SendAsync(string message)
{
if (_characteristic != null)
{
await _characteristic.WriteAsync(GetBytes(message));
}
}
private async Task SendDataAsync(string value)
{
await _characteristic?.WriteAsync(Encoding.ASCII.GetBytes(value));
_selectedCommand = value;
UpdateControlColors();
}
private async Task <bool> SendFrame(byte[] frame)
{
if (!_isConnected)
{
return(await Task.FromResult(false));
}
else
{
if (_analyzerChar != null)
{
_responseFrame = null;
byte[] frameToSend = new byte[8 + frame.Length];
// Imposto l'header
Encoding.ASCII.GetBytes(_frameMarker).CopyTo(frameToSend, 0);
// Imposto il frame da inviare
frame.CopyTo(frameToSend, 4);
// Calcolo e imposto il crc
UInt32 crc = Crc32_STM.CalculateFromBuffer(frameToSend, frameToSend.Length - 4);
ArrConverter.SetBufferFromUInt32(crc, frameToSend, frameToSend.Length - 4);
await _analyzerChar.WriteAsync(frameToSend);
}
else
{
return(await Task.FromResult(false));
}
}
return(await Task.FromResult(true));
}
async private void BtnTalk_Released(object sender, EventArgs e)
{
await charCtrl.WriteAsync(new byte[1] {
CMD_MIC_CLOSE
});
Player.Stop();
if (SamplingRatePicker.SelectedIndex != 0)
{
return;
}
ISpeechRecognition engine;
switch (EnginePicker.SelectedIndex)
{
case 1:
engine = new TecentAiRecognizer();
break;
case 2:
engine = new GoogleRecognizer("cmn-Hans-CN");
break;
case 3:
engine = new GoogleRecognizer("en-US");
break;
default:
engine = new NullRecognizer();
break;
}
STTResult.Text = "Recognizing ...";
var samples = AllSamples.ToArray();
try
{
STTResult.Text = await engine.Recognize(samples);
}
catch (Exception ex)
{
STTResult.Text = "error: " + ex.Message;
}
}
private async Task SendDataAsync(string componentCode, string value)
{
//Prefix
string data = "#$";
data += componentCode + value + "%";
await _characteristic?.WriteAsync(Encoding.ASCII.GetBytes(data));
}
async Task <bool> Upload(byte[] page, int BLOCK_SIZE, Action <int> onProgress)
{
var cmd = new byte[] { ETAG_CMD_IMG_START_WRITE };
if (!await charCtrl.WriteAsync(cmd))
{
return(false);
}
if (!await CheckStatus())
{
return(false);
}
int current = 0;
int cnt = 0;
while (current < page.Length)
{
onProgress(current);
int size = Math.Min(BLOCK_SIZE, page.Length - current);
var block = new byte[size];
Array.Copy(page, current, block, 0, size);
if (!await charData.WriteAsync(block))
{
return(false);
}
current += size;
cnt++;
if ((cnt % 4) == 0)
{
if (!await WaitData(current))
{
return(false);
}
}
}
// wait for BLE stack
if (!await WaitData(current))
{
return(false);
}
cmd = new byte[] { ETAG_CMD_IMG_COMPLETE, 0, 0, 0, 0 };
UInt32 sum = (UInt32)page.Sum((x) => x);
Utils.WriteLittle(sum, cmd, 1);
if (!await charCtrl.WriteAsync(cmd))
{
return(false);
}
await Task.Delay(10);
return(await CheckStatus());
}
public async Task <bool> WriteValueAsync(byte[] data)
{
if (data is null)
{
throw new ArgumentNullException(nameof(data));
}
return(await _characteristic.WriteAsync(data));
}
/// <summary>
/// Writes the given data in the bluetooth connection interface.
/// </summary>
/// <param name="data">The data to be written in the connection interface.</param>
/// <param name="offset">The start offset in the data to write.</param>
/// <param name="length">The number of bytes to write.</param>
/// <exception cref="XBeeException">If there is any XBee error.</exception>
/// <seealso cref="WriteData(byte[])"/>
public void WriteData(byte[] data, int offset, int length)
{
lock (txLock)
{
Debug.WriteLine("----- WriteData " + HexUtils.ByteArrayToHexString(data));
bool dataWritten = false;
// Create a task to write in the TX characteristic.
Task task = Task.Run(async() =>
{
try
{
byte[] buffer = new byte[length];
Array.Copy(data, offset, buffer, 0, length);
byte[] dataToWrite = encrypt ? encryptor.TransformFinalBlock(buffer, 0, buffer.Length) : buffer;
// Split the data in chunks with a max length of the current MTU.
foreach (byte[] chunk in GetChunks(dataToWrite))
{
// Write the chunk in the TX characteristic.
dataWritten = await txCharacteristic.WriteAsync(chunk);
}
}
finally
{
lock (writeLock)
{
Monitor.Pulse(writeLock);
}
}
});
if (!task.IsCompleted)
{
// Wait until the task finishes.
lock (writeLock)
{
Monitor.Wait(writeLock, WRITE_TIMEOUT);
}
}
// If the data could not be written, decrement the counter and throw an exception.
if (!dataWritten)
{
encryptor.DecrementCounter();
throw new XBeeException(ERROR_WRITE);
}
// If the task finished with excepction, throw it.
if (task.Exception != null)
{
throw task.Exception.InnerException;
}
}
}
async private Task SetFreq(double freq)
{
uint f = (uint)Math.Round(freq);
byte[] cmd = new byte[2] {
(byte)(f & 0xff), (byte)(f >> 8)
};
await charKey.WriteAsync(cmd);
}
public async Task <bool> Send(byte[] msg)
{
if (IsConnected() && characteristic.CanWrite)
{
return(await characteristic.WriteAsync(msg));
}
else
{
return(false);
}
}
async private void Run(CancellationToken token)
{
var buf = new byte[MtuSize];
var now = DateTime.Now;
long total = 0;
long dev_total = 0;
long my_total = 0;
var error = false;
int cnt = 0;
while (!error && !token.IsCancellationRequested)
{
try
{
if (my_total - dev_total < 2000)
{
if (await charInput.WriteAsync(buf))
{
cnt++;
total += MtuSize;
my_total += MtuSize;
}
}
else
{
await Task.Delay(200);
}
}
catch (Exception) { error = true; }
if (cnt >= 5)
{
// verify data has been written into device
dev_total = await GetTotalBytes() - StartByteNumber;
if (my_total - dev_total < 10)
{
cnt = 0;
}
}
var temp = DateTime.Now;
double span = (temp - now).TotalMilliseconds;
if (span > 1000.0)
{
SaveSpeed(CurM2STpt, TptM2SSeries, total * 8.0 / span);
now = temp;
total = 0;
}
}
Testing = false;
Device.BeginInvokeOnMainThread(() => CurM2STpt.Text = "Stopped");
}
private async void SendCommandButton_Clicked(object sender, EventArgs e)
{
try
{
if (sendCharacteristic != null)
{
var bytes = await sendCharacteristic.WriteAsync(Encoding.ASCII.GetBytes($"{CommandTxt.Text}\r\n"));
}
}
catch
{
Output.Text += "Error sending comand to UART." + Environment.NewLine;
}
}
/// <summary>
/// Sends the request message to the slave device
/// </summary>
/// <returns>The message.</returns>
/// <param name="message">Message.</param>
public async Task <TransmissionState> SendMessage(byte[] message)
{
bool succed = false;
try
{
succed = await writeCharac.WriteAsync(message);
}
catch (System.Exception ex)
{
System.Diagnostics.Debug.WriteLine("Failed to WriteAsync Message: " + ex.Message.ToString());
succed = await writeCharac.WriteAsync(message);
}
if (succed == true)
{
return(TransmissionState.OK);
}
else
{
return(TransmissionState.ErrorSendMessage);
}
}
async void Reset_Clicked(object sender, System.EventArgs e)
{
if (_characteristicSnd != null && _characteristicSnd.CanWrite)
{
byte[] cmd = { (byte)'R', (byte)'S', (byte)'T' };
await _characteristicSnd.WriteAsync(cmd);
}
else
{
rotationSliderX.Value = 0;
rotationSliderY.Value = 0;
rotationSliderZ.Value = 0;
}
}
public bool Send(byte[] pInput)
{
try
{
mCharacteristic.WriteAsync(pInput);
return(true);
}
catch (Exception e)
{
Debug.WriteLine("Failed to Send.");
Debug.WriteLine(e);
}
return(false);
}
public async Task <bool> WriteCharacteristics(ICharacteristic ch, byte[] data)
{
if (ch == null)
{
return(false);
}
try
{
return(await ch.WriteAsync(data));
}
catch
{
return(false);
}
}
async void TryWrite(string command)
{
if (mainCharacteristic == null || writing == true)
{
return;
}
writing = true;
try
{
await mainCharacteristic.WriteAsync(Encoding.ASCII.GetBytes(command));
}
catch { }
writing = false;
}
public void WriteValueAsyncInCharacteristic(byte[] bytesArray, ICharacteristic characteristic)
{
Device.BeginInvokeOnMainThread(async() =>
{
try
{
bool result = await characteristic.WriteAsync(bytesArray);
System.Diagnostics.Debug.WriteLine("Write ok ! " + result);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Error WriteValueAsyncInCharacteristic " + ex.Message);
}
});
}
async private void BtnSend_Clicked(object sender, EventArgs e)
{
if (Input.Text?.Length < 1)
{
return;
}
byte[] bytes = Encoding.UTF8.GetBytes(Input.Text);
var buf = new byte[bytes.Length + 1];
Array.Copy(bytes, buf, bytes.Length);
buf[bytes.Length] = 0;
await charInput.WriteAsync(buf);
DataLog.Text = DataLog.Text + "\n> " + Input.Text + "\n";
Input.Text = "";
}
private async Task Finish()
{
//UUID_EEPROM_CONTROL < -0x09, 0x01(ustawienie trybu bufora cyklicznego)
//UUID_EEPROM_CONTROL < -0x01, 0x01
var data = new byte[2];
data[0] = 0x09;
data[1] = 0x01;
await _eepromControlCharacteristic.WriteAsync(data);
data[0] = 0x01;
data[1] = 0x01;
await _eepromControlCharacteristic.WriteAsync(data);
}