private async Task <bool> SynchronizeAsync()
{
try
{
var bytes = CommandConstants.SyncBytes;
await serialPort.WriteAsync(bytes, 0, bytes.Length);
var responseBytes = await ReadCurrentReceiveBufferAsync(4);
var ackBytes = CommandConstants.SyncAckBytes;
return(responseBytes.Length == 4 &&
responseBytes[0] == ackBytes[0] &&
responseBytes[1] == ackBytes[1] &&
responseBytes[2] == ackBytes[2] &&
responseBytes[3] == ackBytes[3]);
}
catch (TimeoutException e)
{
logger.Trace("Timeout while trying to get sync...");
return(false);
}
catch (Exception e)
{
logger.Trace("Exception while trying to get sync ('{0}')", e.Message);
return(false);
}
}
[Timeout(2000)] // We abort the test after timeout. This tests the blocking behavior in ReadAsync and the test will fail if ReadAsync blocks.
public async Task WriteAsync()
{
using (var serialPortStreamWrite = new SerialPortStream("COM1", 9600, 8, Parity.None, StopBits.One))
using (var serialPortStreamRead = new SerialPortStream("COM2", 9600, 8, Parity.None, StopBits.One))
{
serialPortStreamWrite.Open();
serialPortStreamRead.Open();
var buffer = new byte[1024];
var readTask = Task.Run(async() => await serialPortStreamRead.ReadAsync(buffer, 0, buffer.Length));
var bytes = new byte[] { 0x01, 0x02, 0x03 };
await serialPortStreamWrite.WriteAsync(bytes, 0, bytes.Length);
await serialPortStreamWrite.FlushAsync();
// ReadAsync blocks here even if something gets written and flushed to the underlying COM device.
// Fails for netcoreapp3.1, works with net472
await readTask;
Assert.That(buffer[0], Is.EqualTo(0x01));
Assert.That(buffer[1], Is.EqualTo(0x02));
Assert.That(buffer[2], Is.EqualTo(0x03));
}
}
/// <summary>
/// Write data asynchronously on serial port in a thread safe way
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public async Task WriteThreadSafeAsync(byte[] data)
{
//TODO : Change 500 here
if (!await _serialWriteLock.WaitAsync(500, _cancellationToken.Token).ConfigureAwait(false))
{
//TODO : new throw timeout serial writing
}
try
{
await _serialPort.WriteAsync(data, 0, data.Length, _cancellationToken.Token).ConfigureAwait(false);
}
catch (Exception e)
{
_logger.Error(e, "Exception occured in WriteThreadSafeAsync");
OnSerialPortErrorOccured();
Dispose();
}
finally
{
//Release semaphore
_serialWriteLock.Release();
}
}
internal async Task WriteFrame(BaosFrame frame)
{
await _waitSemaphore.WaitAsync();
try
{
_stream.DiscardOutBuffer();
var buffer = frame.ToByteFrame();
Logger.LogHexOut(buffer);
await _stream.WriteAsync(buffer);
if (frame is AckFrame)
{
return;
}
ControlValueIndicator = !ControlValueIndicator;
}
catch (Exception e)
{
Logger.LogError($"Could not write frame {e}", e);
}
finally
{
_waitSemaphore.Release();
}
}
private void _relayerPortB_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
SerialPortStream sp = (SerialPortStream)sender;
var bytes = new byte[sp.BytesToRead];
sp.Read(bytes, 0, bytes.Length);
_relayerPortA.WriteAsync(bytes, 0, bytes.Length);
_snifferPortBA.WriteAsync(bytes, 0, bytes.Length);
SnifferPortBAByteCount += (uint)bytes.Length;
}
public async override Task ConnectAsync()
{
await _semaphoreSlimConnect.WaitAsync();
// already connected
if (Connected)
return;
serialPort.Open();
// make sure we're in a halfway known state...
var dxCommand = new StopDataAcquisitionCommand();
await serialPort.WriteAsync(dxCommand.Command.Select(x => (byte)x).ToArray(), 0, dxCommand.Command.Length);
await Task.Delay(100);
serialPort.DiscardInBuffer();
await WaitForStabilizedMotorSpeedAsync(TimeSpan.FromSeconds(10), throwOnFail: true);
await UpdateDeviceInfoAsync();
_semaphoreSlimConnect.Release();
}
protected override async Task WriteFrame(MBusFrame frame)
{
try
{
_stream.DiscardOutBuffer();
var buffer = frame.ToByteFrame();
Logger.LogHexOut(buffer);
await _stream.WriteAsync(buffer);
}
catch (Exception e)
{
Logger.LogError($"Could not write frame {e}", e);
}
}
private async Task <TResponse> ExecuteSKCommandAsync <TResponse>(AbstractSKCommand <TResponse> command) where TResponse : class
{
//ほかのコマンドとの排他制御
await CommandSemaphore.WaitAsync();
var taskCompletionSource = new TaskCompletionSource <TResponse>();
command.TaskCompletionSource = taskCompletionSource;
OnSerialReceived += command.ReceiveHandler;
try
{
//コマンド書き込み
var commandBytes = command.GetCommandWithArgument();
_logger.LogTrace($">>{command.GetCommandLogString()}");
await serialPort.WriteAsync(commandBytes, 0, commandBytes.Length);
//タイムアウト or コンプリート
if (await Task.WhenAny(taskCompletionSource.Task, Task.Delay(command.Timeout)) == taskCompletionSource.Task)
{
if (command.HasEchoback)
{
_logger.LogTrace($"<<ECHO:{command.EchobackCommand}");
}
return(taskCompletionSource.Task.Result);
}
else
{
if (command.HasEchoback)
{
_logger.LogTrace($"<<ECHO:{command.EchobackCommand}");
}
throw new TimeoutException("Timeout has expired");
}
}
finally
{
OnSerialReceived -= command.ReceiveHandler;
CommandSemaphore.Release();
}
}
static async Task Main(string[] args)
{
Console.WriteLine("Start");
using (var serialPortStreamWrite = new SerialPortStream("COM1", 9600, 8, Parity.None, StopBits.One))
using (var serialPortStreamRead = new SerialPortStream("COM2", 9600, 8, Parity.None, StopBits.One))
{
serialPortStreamWrite.Open();
serialPortStreamRead.Open();
Console.WriteLine("Serial Port Opened");
var buffer = new byte[1024];
var readTask = Task.Run(async() => await serialPortStreamRead.ReadAsync(buffer, 0, buffer.Length));
Console.WriteLine("Wait for write. Enter any key.");
Console.ReadKey();
var bytes = new byte[] { 0x01, 0x02, 0x03 };
Console.WriteLine("Write started");
await serialPortStreamWrite.WriteAsync(bytes, 0, bytes.Length);
await serialPortStreamWrite.FlushAsync();
Console.WriteLine("Write finished");
Console.WriteLine("Awaiting read...");
await readTask;
Console.WriteLine($"Buffer: {buffer[0]}, {buffer[1]}, {buffer[2]}");
Console.WriteLine("Finished.");
}
}
protected override async Task RunAsync(CancellationToken cancellationToken)
{
var options = _options.Value;
_logger.LogInformation("Opening {SerialPort}", options.Port);
using (var port = new SerialPortStream(options.Port, options.Baud))
{
port.Open();
// Clear Status
var cls = Encoding.ASCII.GetBytes("*CLS\n");
await port.WriteAsync(cls, 0, cls.Length);
// §3.5.10
var formatPacked = Encoding.ASCII.GetBytes("FORMat PACKed\n");
await port.WriteAsync(formatPacked, 0, formatPacked.Length);
// §3.5.17
var lterEoi = Encoding.ASCII.GetBytes("SYSTem:COMMunicate:GPIB:LTERminator EOI\n");
await port.WriteAsync(lterEoi, 0, lterEoi.Length);
while (!cancellationToken.IsCancellationRequested)
{
try
{
await _wait.WaitAsync(cancellationToken);
}
catch (OperationCanceledException)
{
}
if (_queue.TryDequeue(out var item))
{
if (item.CancellationToken.IsCancellationRequested)
{
continue;
}
_logger.LogDebug("Sending {Request}", Encoding.ASCII.GetString(item.Request));
await port.WriteAsync(item.Request, 0, item.Request.Length, cancellationToken);
await port.FlushAsync(cancellationToken);
if (item.ExpectResponse)
{
var buffer = ArrayPool <byte> .Shared.Rent(1024);
var offset = 0;
try
{
var length = -1;
while (length == -1 || offset < length)
{
var oldOffset = offset;
var increased = await port.ReadAsync(buffer, offset, buffer.Length - offset, cancellationToken);
offset += increased;
if (offset > 0 && buffer[offset] == '#' && BlockData.TryDecodeLength(buffer.AsSpan().Slice(0, offset), out var decodedLength))
{
length = decodedLength;
}
else
{
var relativeIndex = buffer.AsSpan().Slice(oldOffset, increased).IndexOf((byte)'\n');
if (relativeIndex >= 0)
{
length = oldOffset + relativeIndex + 1;
}
}
}
var response = buffer.AsSpan().Slice(0, length).ToArray();
_logger.LogDebug("Received {ResponseBytes} bytes: {Response}", response.Length, Encoding.ASCII.GetString(response));
item.TaskCompletionSource.SetResult(response);
}
finally
{
ArrayPool <byte> .Shared.Return(buffer);
}
}
else
{
item.TaskCompletionSource.SetResult(null);
}
}
}
port.Close();
}
}
public Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) => _serialPort?.WriteAsync(buffer, offset, count, cancellationToken);
