public void ReadUntilDisconnectAndReadAgainThenClose()
{
byte[] buffer = new byte[8192];
using (SerialPortStream serialSource = new SerialPortStream(SourcePort, 115200, 8, Parity.None, StopBits.One)) {
serialSource.ReadBufferSize = 8192;
serialSource.WriteBufferSize = 8192;
serialSource.Open();
Thread.Sleep(100);
int read = 0;
while (serialSource.Read(buffer, 0, buffer.Length) > 0)
{
Console.WriteLine("In Read Loop");
/* throw away the data */
}
try {
read = serialSource.Read(buffer, 0, buffer.Length);
} catch (System.IO.IOException) {
Console.WriteLine("IOException occurred");
}
Console.WriteLine("Second Read: {0}", read);
serialSource.Close();
}
}
void serailDevice_OnReceive(object sender, SerialDataReceivedEventArgs e)
{
byte[] Data = new byte[serialDevice.BytesToRead];
serialDevice.Read(Data, 0, Data.Length);
telnetServer.SendToNetwork(Data);
}
public byte[] ReadBytes(int bytesCount, TimeSpan timeout, bool discardRemainingBytesAfterSuccessRead)
{
var inBytes = new byte[bytesCount];
int totalReadedBytesCount = 0;
TimeSpan beetweenIterationPause = TimeSpan.FromMilliseconds(25);
var totalIterationsCount = (int)(timeout.TotalMilliseconds / beetweenIterationPause.TotalMilliseconds);
for (int i = 0; i < totalIterationsCount; ++i)
{
_readEplasedTimer.Restart();
var bytesToRead = _port.BytesToRead;
if (bytesToRead != 0)
{
var currentReadedBytesCount = _port.Read(inBytes, totalReadedBytesCount, bytesCount - totalReadedBytesCount);
totalReadedBytesCount += currentReadedBytesCount;
if (totalReadedBytesCount == inBytes.Length)
{
if (discardRemainingBytesAfterSuccessRead)
{
ReadAllBytes();
}
return(inBytes);
}
}
_readEplasedTimer.Stop();
var sleepTime = beetweenIterationPause - _readEplasedTimer.Elapsed;
if (sleepTime.TotalMilliseconds > 0)
{
Thread.Sleep(sleepTime);
}
}
ReadAllBytes();
throw new TimeoutException("ReadFromPort timeout");
}
private void TestEvenParity(SerialPortStream src, SerialPortStream dst)
{
src.Write(new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }, 0, 16);
src.Flush();
int offset = 0;
int counter = 0;
byte[] recv = new byte[256];
while (offset < 16 && counter < 10)
{
offset += dst.Read(recv, offset, recv.Length - offset);
counter++;
Console.WriteLine("Buffer Bytes Received: {0}; Read attempts: {1}", offset, counter);
}
for (int i = 0; i < offset; i++)
{
Console.WriteLine("Offset: {0} = {1:X2}", i, recv[i]);
}
// NOTE: This test case will likely fail on software loopback devices, as they handle bytes and not
// bits as a real UART does
Assert.That(offset, Is.EqualTo(16), "Expected 16 bytes received, but only got {0} bytes", offset);
byte[] expectedrecv = new byte[] { 0x00, 0x81, 0x82, 0x03, 0x84, 0x05, 0x06, 0x87, 0x88, 0x09, 0x0A, 0x8B, 0x0C, 0x8D, 0x8E, 0x0F };
for (int i = 0; i < offset; i++)
{
Assert.That(recv[i], Is.EqualTo(expectedrecv[i]), "Offset {0} got {1}; expected {2}", i, recv[i], expectedrecv[i]);
}
}
public void ReadCharsWithTimeout()
{
using (SerialPortStream dst = new SerialPortStream(DestPort, 115200, 8, Parity.None, StopBits.One))
using (SerialPortStream src = new SerialPortStream(SourcePort, 115200, 8, Parity.None, StopBits.One)) {
src.WriteTimeout = 2 * TimeOut + 500; src.ReadTimeout = 2 * TimeOut + 500;
dst.WriteTimeout = 2 * TimeOut + 500; dst.ReadTimeout = 2 * TimeOut + 500;
src.Open(); Assert.That(src.IsOpen, Is.True);
dst.Open(); Assert.That(dst.IsOpen, Is.True);
new Thread(() => {
Thread.Sleep(TimeOut + 500);
byte[] send = new byte[] { 0x65, 0x66, 0x67 };
src.Write(send, 0, send.Length);
}).Start();
char[] recv = new char[5];
int cread = 0; int counter = 0;
while (cread < 3 && counter < 5)
{
cread += dst.Read(recv, cread, recv.Length - cread);
counter++;
Console.WriteLine("dst.Read. Got cread={0} bytes in {1} loops", cread, counter);
}
for (int i = 0; i < cread; i++)
{
Console.WriteLine("cread[{0}] = {1}", i, recv[i]);
}
Assert.That(cread, Is.EqualTo(3));
Assert.That(recv[0], Is.EqualTo('e'));
Assert.That(recv[1], Is.EqualTo('f'));
Assert.That(recv[2], Is.EqualTo('g'));
}
}
public void ClosedWhenReadBlocked()
{
byte[] buffer = new byte[1024];
using (ManualResetEvent closedEvent = new ManualResetEvent(false))
using (SerialPortStream serialSource = new SerialPortStream(SourcePort, 115200, 8, Parity.None, StopBits.One))
using (SerialPortStream serialDest = new SerialPortStream(DestPort, 115200, 8, Parity.None, StopBits.One)) {
serialSource.Open();
serialDest.Open();
new Thread(
() => {
Thread.Sleep(2000);
Console.WriteLine("Closing serialSource");
// It appears that the MSDN .NET implementation blocks here, never
// to return as we're blocked on another thread.
closedEvent.Set();
serialSource.Close();
Console.WriteLine("Closed serialSource");
}
).Start();
int bytes = serialSource.Read(buffer, 0, buffer.Length);
Console.WriteLine("Read finished, returned {0} bytes", bytes);
if (!closedEvent.WaitOne(0))
{
Assert.Fail("Read returned before being disposed.");
}
Assert.That(bytes, Is.EqualTo(0));
}
}
public byte[] ReadBytes(DeviceAddress address, ushort size)
{
int area = address.Area;
try
{
byte[] header = area == Modbus.fctReadCoil ? CreateReadHeader(address.Start * 16, (ushort)(16 * size), (byte)area) :
CreateReadHeader(address.Start, size, (byte)area);
_serialPort.Write(header, 0, header.Length);
byte[] frameBytes = new byte[size * 2 + 5];
byte[] data = new byte[size * 2];
int numBytesRead = 0;
while (numBytesRead != size)
{
numBytesRead += _serialPort.Read(frameBytes, numBytesRead, size - numBytesRead);
}
if (frameBytes[0] == (byte)_id && Utility.CheckSumCRC(frameBytes))
{
Array.Copy(frameBytes, 3, data, 0, size);
return(data);
}
return(null);
}
catch (Exception e)
{
if (OnClose != null)
{
OnClose(this, new ShutdownRequestEventArgs(e.Message));
}
return(null);
}
}
public int Read(int Bytes2Read)
{
int i = 0;
if (!myserial.IsOpen)
{
throw new ApplicationException("Please initialize and open port before using this method");
}
checked
{
try
{
int num;
for (; i < Bytes2Read; i += num)
{
num = myserial.Read(readbuffer, i, Bytes2Read - i);
}
return(i);
}
catch (Exception ex)
{
ProjectData.SetProjectError(ex);
Exception ex2 = ex;
throw new ApplicationException("Read Error: " + ex2.Message, ex2);
}
}
}
private static bool InitializeSerialPort()
{
Console.WriteLine("Waiting for Everdrive64 USB to be connected");
while (FindDevice.FindFdtiUsbDevices().Where(p => p.nodeDescription == "FT245R USB FIFO").Count() == 0)
{
Thread.Sleep(100);
}
var testPacket = new CommandPacket(CommandPacket.Command.TestConnection);
foreach (var device in FindDevice.FindFdtiUsbDevices().Where(p => p.nodeDescription == "FT245R USB FIFO"))
{
try
{
IoPort = new SerialPortStream(device.nodeComportName);
IoPort.WriteTimeout = 500;
IoPort.ReadTimeout = 500;
IoPort.Open();
testPacket.Send(IoPort);
IoPort.Read(receiveBuffer, 0, 512); //should be 4 if not 512
//ReadResponse(port, 4); //expect RSPk
if (receiveBuffer[3] == (char)'k' && receiveBuffer[4] == (char)'3') //(Unofficial OS EDV3)
{
Console.WriteLine("Connected to EverDrive64 V3 on port: {0}", device.nodeComportName);
switch ((char)receiveBuffer[5])
{
case 'p':
Console.WriteLine("PAL region detected");
break;
case 'n':
Console.WriteLine("NTSC region detected");
break;
case 'm':
Console.WriteLine("MPAL region detected");
break;
default:
Console.WriteLine("Unknown region detected");
break;
}
return(true);
}
if (receiveBuffer[3] == 107) //k
{
Console.WriteLine("Connected to EverDrive64 on port: {0}", device.nodeComportName);
return(true);
}
}
catch (Exception ex)
{
Console.WriteLine("error: {0}", ex.ToString());
}
}
return(false);
}
static async Task Main(string[] args)
{
WriteLine("RS485Master");
WriteLine($"Opening on {args[0]} port");
var port = new SerialPortStream(args[0], 9600, 8, Parity.None, StopBits.One);
port.DataReceived += (s, e) => {
/* var buffer = new byte[port.BytesToRead];
* var read = port.Read(buffer, 0, buffer.Length);
* var id = buffer[0];
* var cmd = buffer[1];
* var cmdlen = buffer[2];
*
* WriteLine($"{read} bytes from {id}: cmd={cmd} len={cmdlen}");
*
* switch (cmd)
* {
* case 0x80 + 0x02:
* var readTemperatureValue = System.BitConverter.ToSingle(buffer, 3);
* WriteLine($"READ TEMPERATURE={readTemperatureValue}");
* break;
* }*/
};
port.Open();
var dato = new char[1];
var send = new char[1];
send[0] = 'a';
try
{
while (true)
{
await Task.Delay(1000);
WriteLine("RECEIVING T0");
port.Write(send, 0, 1);
while (dato[0] != 'o')
{
port.Read(dato, 0, 1);
WriteLine(dato);
WriteLine("HEY PIC");
send[0] = '0';
}
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
port.Close();
}
}
public static byte[] ReadAllBytes(this SerialPortStream port)
{
var bytesToRead = port.BytesToRead;
var result = new byte[bytesToRead];
port.Read(result, 0, bytesToRead);
return(result);
}
public byte[] ReadBytes(int bytesCount, TimeSpan timeout, bool discardRemainingBytesAfterSuccessRead)
{
var inBytes = new byte[bytesCount];
int totalReadedBytesCount = 0;
TimeSpan beetweenIterationPause = TimeSpan.FromMilliseconds(25);
var totalIterationsCount = (int)(timeout.TotalMilliseconds / beetweenIterationPause.TotalMilliseconds);
Log("Iteration period = " + beetweenIterationPause.TotalMilliseconds.ToString("f2") + " ms, max iterations count = " + totalIterationsCount);
for (int i = 0; i < totalIterationsCount; ++i)
{
Log("Iteration number = " + i);
_readEplasedTimer.Restart();
var bytesToRead = _port.BytesToRead;
if (bytesToRead != 0)
{
var currentReadedBytesCount = _port.Read(inBytes, totalReadedBytesCount, bytesCount - totalReadedBytesCount);
Log("Incoming bytes now are = " + inBytes.ToText());
totalReadedBytesCount += currentReadedBytesCount;
Log("Total read bytes count=" + totalReadedBytesCount + ", current read bytes count=" + currentReadedBytesCount);
if (totalReadedBytesCount == inBytes.Length)
{
Log("Result incoming bytes are = " + inBytes.ToText());
if (discardRemainingBytesAfterSuccessRead)
{
Log("Discarding remaining bytes, discarded bytes are: " + ReadAllBytes().ToText());
}
return(inBytes);
}
}
_readEplasedTimer.Stop();
var sleepTime = beetweenIterationPause - _readEplasedTimer.Elapsed;
if (sleepTime.TotalMilliseconds > 0)
{
Thread.Sleep(sleepTime);
}
}
LogError("Timeout, dropping all incoming bytes...");
LogError("Discarded bytes are: " + ReadAllBytes().ToText());
LogError("Rising timeout exception now");
throw new TimeoutException("ReadFromPort timeout");
}
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 void Read_should_return_even_when_read_less_then_buffer()
{
using var port = new SerialPortStream(serial.ConnectionString.Serial.Port, serial.ConnectionString.Serial.BaudRate, 8, Parity.None, StopBits.One);
port.Open();
port.Write(new byte[] { 0x04, 0x00, 0x4c, 0x3a, 0xd2 }, 0, 5);
var b = new byte[100];
var read = port.Read(b, 0, 100);
read.Should().Be(10);
}
public void Read_should_return_even_when_read_less_then_buffer()
{
using (var port = new SerialPortStream(serial.Params, 57600, 8, Parity.None, StopBits.One))
{
port.Open();
port.Write(new byte[] { 0x04, 0x00, 0x4c, 0x3a, 0xd2 }, 0, 5);
var b = new byte[100];
var read = port.Read(b, 0, 100);
read.ShouldBe(10);
}
}
private byte[] ReceiveData(SerialPortStream sp, int size)
{
var buffer = new byte[size];
var dataReceived = 0;
while (dataReceived < size)
{
dataReceived += sp.Read(buffer, dataReceived, size - dataReceived);
}
return(buffer);
}
public void DisconnectOnReadCharsBlockedReadAgain()
{
char[] buffer = new char[1024];
using (SerialPortStream serialSource = new SerialPortStream(SourcePort, 115200, 8, Parity.None, StopBits.One)) {
serialSource.Open();
int bytes = serialSource.Read(buffer, 0, buffer.Length);
Console.WriteLine("{0} bytes read", bytes);
Assert.That(
() => {
bytes = serialSource.Read(buffer, 0, buffer.Length);
Console.WriteLine("{0} bytes read again", bytes);
}, Throws.InstanceOf <System.IO.IOException>());
// Device should still be open.
Assert.That(serialSource.IsOpen, Is.True);
serialSource.Close();
}
}
public static byte[] ReadBytes(this SerialPortStream port, int bytesCount, int timeoutInSeconds)
{
var inBytes = new byte[bytesCount];
int totalReadedBytesCount = 0;
const int iterationsPerSecondCount = 20;
TimeSpan maximumMillsecondsCountToWaitAfterEachIteration =
TimeSpan.FromMilliseconds(1000.0 / iterationsPerSecondCount);
Log.Log("Iteration period = " + maximumMillsecondsCountToWaitAfterEachIteration.TotalMilliseconds.ToString("f2") +
" ms");
//int iterationsLeft = timeoutInSeconds * iterationsPerSecondCount; // check each X ms
for (int i = 0; i < timeoutInSeconds; ++i)
{
for (int j = 0; j < iterationsPerSecondCount; ++j)
{
ReadEplasedTimer.Restart();
var bytesToRead = port.BytesToRead;
if (bytesToRead != 0)
{
var currentReadedBytesCount = port.Read(inBytes, totalReadedBytesCount, bytesCount - totalReadedBytesCount);
Log.Log("Incoming bytes now are = " + inBytes.ToText());
totalReadedBytesCount += currentReadedBytesCount;
Log.Log("Total readed bytes count=" + totalReadedBytesCount);
Log.Log("Current readed bytes count=" + currentReadedBytesCount);
if (totalReadedBytesCount == inBytes.Length)
{
Log.Log("Result incoming bytes are = " + inBytes.ToText());
Log.Log("Discarding remaining bytes...");
Log.Log("Discarded bytes are: " + port.ReadAllBytes().ToText());
return(inBytes);
}
}
ReadEplasedTimer.Stop();
//Log.Log("Iteration operation time = " + ReadEplasedTimer.Elapsed.TotalMilliseconds.ToString("f2") + " ms");
var sleepTime = maximumMillsecondsCountToWaitAfterEachIteration - ReadEplasedTimer.Elapsed;
if (sleepTime.TotalMilliseconds > 0)
{
Thread.Sleep(sleepTime);
}
}
}
Log.Log("Timeout, dropping all bytes...");
Log.Log("Discarded bytes are: " + port.ReadAllBytes().ToText());
Log.Log("Rising timeout exception now");
throw new TimeoutException("ReadFromPort timeout");
}
public byte[] Write(byte[] bytes, int sleep = 200)
{
lock (this)
{
device.Write(bytes, 0, bytes.Length);
Thread.Sleep(sleep);
var len = device.BytesToRead;
var r = new Byte[len];
device.Read(r, 0, len);
return(r);
}
}
private byte[] ReadCurrentReceiveBuffer(int numberOfBytes)
{
var result = new byte[numberOfBytes];
var retrieved = 0;
var retryCount = 0;
while (retrieved < numberOfBytes && retryCount++ < 4)
{
retrieved += serialPort.Read(result, retrieved, numberOfBytes - retrieved);
}
return(result);
}
public void ReadDataEvent()
{
const int blockSize = 8192;
const int testTotalBytes = 344 * 1024; // 344kB of data = 30s (344*1024*10/115200 =~ 30.6s)
int startTick = Environment.TickCount;
using (ManualResetEvent finished = new ManualResetEvent(false))
using (SerialPortStream serialSource = new SerialPortStream(SourcePort, 115200, 8, Parity.None, StopBits.One))
using (SerialPortStream serialDest = new SerialPortStream(DestPort, 115200, 8, Parity.None, StopBits.One)) {
serialSource.ReadBufferSize = blockSize;
serialSource.WriteBufferSize = blockSize;
serialDest.ReadBufferSize = blockSize;
serialDest.WriteBufferSize = blockSize;
byte[] readBuffer = new byte[blockSize];
byte[] writeBuffer = new byte[blockSize];
int totalBytes = 0;
serialDest.DataReceived += (s, e) => {
int bytes = serialDest.Read(readBuffer, 0, readBuffer.Length);
totalBytes += bytes;
Console.WriteLine("===> {0}: EventType: {1}, bytes read = {2}, total read = {3}",
Environment.TickCount - startTick, e.EventType, bytes, totalBytes);
if (totalBytes >= testTotalBytes)
{
finished.Set();
}
};
serialDest.ErrorReceived += (s, e) => {
Console.WriteLine("===> {0}: EventType: {1}", Environment.TickCount - startTick, e.EventType);
};
serialSource.Open();
serialDest.Open();
int writeBytes = 0;
while (writeBytes < testTotalBytes)
{
serialSource.Write(writeBuffer, 0, writeBuffer.Length);
writeBytes += writeBuffer.Length;
Console.WriteLine("===> {0}: Write {1} bytes; Written {2}; Total {3}",
Environment.TickCount - startTick, writeBuffer.Length, writeBytes, testTotalBytes);
}
serialSource.Flush();
// Should only need enough time to wait for the last 8192 bytes to be written.
Assert.That(finished.WaitOne(10000), Is.True);
}
}
private int Recv(byte[] resp, int maxLength)
{
//Read first bytes(s)
_stream.ReadTimeout = 1000;
int totalRead = _stream.Read(resp, 0, maxLength);
if (totalRead == 0)
{
throw new TimeoutException();
}
_stream.ReadTimeout = 5;
while (totalRead < maxLength)
{
//Read remaining bytes
int bytesRead = _stream.Read(resp, totalRead, maxLength - totalRead);
if (bytesRead == 0)
{
break;
}
totalRead += bytesRead;
}
return(totalRead);
}
static async Task Main(string[] args)
{
WriteLine("RS485Master");
WriteLine($"Opening on {args[0]} port");
var port = new SerialPortStream(args[0], 57600, 8, Parity.None, StopBits.One);
port.DataReceived += (s, e) => {
var buffer = new byte[port.BytesToRead];
var read = port.Read(buffer, 0, buffer.Length);
var id = buffer[0];
var cmd = buffer[1];
var cmdlen = buffer[2];
WriteLine($"{read} bytes from {id}: cmd={cmd} len={cmdlen}");
switch (cmd)
{
case 0x80 + 0x02:
var readTemperatureValue = System.BitConverter.ToSingle(buffer, 3);
WriteLine($"READ TEMPERATURE={readTemperatureValue}");
break;
}
};
port.Open();
var requestT0 = new byte[] { 0, 2, 2 };
var requestT1 = new byte[] { 1, 2, 2 };
try
{
while (true)
{
WriteLine("Sending T0");
port.Write(requestT0, 0, requestT0.Length);
await Task.Delay(2000);
WriteLine("Sending T1");
port.Write(requestT1, 0, requestT1.Length);
await Task.Delay(2000);
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
port.Close();
}
}
public void DisconnectOnReadCharsBlocked()
{
char[] buffer = new char[1024];
using (SerialPortStream serialSource = new SerialPortStream(SourcePort, 115200, 8, Parity.None, StopBits.One)) {
serialSource.Open();
int bytes = serialSource.Read(buffer, 0, buffer.Length);
Console.WriteLine("{0} bytes read", bytes);
// Device should still be open.
Assert.That(serialSource.IsOpen, Is.True);
serialSource.Close();
}
}
public void ReadUntilDisconnectThenDispose()
{
byte[] buffer = new byte[8192];
using (SerialPortStream serialSource = new SerialPortStream(SourcePort, 115200, 8, Parity.None, StopBits.One)) {
serialSource.ReadBufferSize = 8192;
serialSource.WriteBufferSize = 8192;
serialSource.Open();
Thread.Sleep(100);
while (serialSource.Read(buffer, 0, buffer.Length) > 0)
{
Console.WriteLine("In Read Loop");
/* throw away the data */
}
}
}
public void Should_get_serial_raw_multiple_times()
{
// Get Reader Serial Number command
byte[] command = { 0x04, 0x00, 0x4c, 0x3a, 0xd2 };
// Response from particular hardware reader
byte[] expectedResponse = { 0x09, 0x00, 0x4c, 0x00, 0x17, 0x43, 0x90, 0x15, 0x49, 0xc0 };
for (var i = 0; i < 10; i++)
{
using var port = new SerialPortStream(serial.ConnectionString.Serial.Port, serial.ConnectionString.Serial.BaudRate, 8, Parity.None, StopBits.One);
port.Open();
port.Write(command, 0, command.Length);
var b = new byte[100];
var read = port.Read(b, 0, 100);
read.Should().Be(expectedResponse.Length);
expectedResponse.Should().Equal(b.Take(expectedResponse.Length));
}
}
protected sealed override IObservable <char> DataReceived()
{
return(Observable.FromEventPattern <SerialDataReceivedEventArgs>(_serialStream, "DataReceived")
.SelectMany(_ =>
{
var dataLength = _serialStream.BytesToRead;
var data = new byte[dataLength];
var nbrDataRead = _serialStream.Read(data, 0, dataLength);
if (nbrDataRead == 0)
{
return new char[0];
}
var chars = Encoding.ASCII.GetChars(data);
return chars;
}));
}
public bool ReadPort(byte[] buf, int len, long timeout)
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
int resLen = 0;
while (resLen < len)
{
resLen += port.Read(buf, resLen, len - resLen);
if (stopWatch.ElapsedMilliseconds > timeout)
{
break;
}
}
return(resLen == len);
}
private byte[] ReadCurrentReceiveBuffer(int numberOfBytes)
{
var result = new byte[numberOfBytes];
var retrieved = 0;
var retryCount = 0;
while (retrieved < numberOfBytes && retryCount++ < 4)
{
retrieved += serialPort.Read(result, retrieved, numberOfBytes - retrieved);
}
if (retrieved < numberOfBytes)
{
logger.Info("Ended up reading short (expected {0} bytes, got only {1})...",
numberOfBytes, retrieved);
}
return(result);
}
void SendLoop()
{
try
{
var buf = new byte[10000];
while (run)
{
var read = port.Read(buf);
socket.Send(buf, 0, read, SocketFlags.None);
Console.WriteLine($"IP << [{read}] << TTY");
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
Dispose();
}
}
public void SerialPortStream_SendReceive()
{
using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One))
using (SerialPortStream dst = new SerialPortStream(c_DestPort, 115200, 8, Parity.None, StopBits.One)) {
src.WriteTimeout = c_Timeout; src.ReadTimeout = c_Timeout;
dst.WriteTimeout = c_Timeout; dst.ReadTimeout = c_Timeout;
src.Open(); Assert.IsTrue(src.IsOpen);
dst.Open(); Assert.IsTrue(dst.IsOpen);
// Send Maximum data in one go
byte[] sendbuf = new byte[src.WriteBufferSize];
#if true
Random r = new Random();
r.NextBytes(sendbuf);
#else
for (int i = 0; i < sendbuf.Length; i++) {
sendbuf[i] = (byte)((i % 77) + 1);
}
#endif
src.Write(sendbuf, 0, sendbuf.Length);
// Receive sent data
int rcv = 0;
int c = 0;
byte[] rcvbuf = new byte[sendbuf.Length + 10];
while (rcv < rcvbuf.Length) {
Trace.WriteLine("Begin Receive: Offset=" + rcv.ToString() + "; Count=" + (rcvbuf.Length - rcv).ToString());
int b = dst.Read(rcvbuf, rcv, rcvbuf.Length - rcv);
if (b == 0) {
if (c == 0) break;
c++;
} else {
c = 0;
}
rcv += b;
}
bool dump = false;
if (rcv != sendbuf.Length) {
Trace.WriteLine("Read length not the same as the amount of data sent (got " + rcv.ToString() + " bytes)");
dump = true;
}
for (int i = 0; i < sendbuf.Length; i++) {
if (sendbuf[i] != rcvbuf[i]) {
Trace.WriteLine("Comparison failure at " + i.ToString());
dump = true;
break;
}
}
if (dump) {
Trace.WriteLine("Send Buffer DUMP");
for (int i = 0; i < sendbuf.Length; i++) {
Trace.WriteLine(sendbuf[i].ToString("X2"));
}
Trace.WriteLine("Receive Buffer DUMP");
for (int i = 0; i < rcv; i++) {
Trace.WriteLine(rcvbuf[i].ToString("X2"));
}
}
src.Close();
dst.Close();
Assert.IsFalse(dump, "Error in transfer");
}
}
