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);