public void CreateModbusMessageReadCoilsResponseWithInvalidDataSize()
{
byte[] frame = { 11, Modbus.ReadCoils, 4, 1, 2, 3 };
Assert.Throws <FormatException>(() => ModbusMessageFactory.CreateModbusMessage <ReadCoilsInputsResponse>(frame));
}
public void CreateModbusMessageSlaveExceptionResponseWithInvalidFunctionCode()
{
SlaveExceptionResponse response =
ModbusMessageFactory.CreateModbusMessage <SlaveExceptionResponse>(new byte[] { 11, 128, 2 });
}
public void CreateModbusMessageWriteFileRecordRequestThrowsOnNotEnoughBytes()
{
Assert.Throws <FormatException>(() => ModbusMessageFactory.CreateModbusMessage <WriteFileRecordRequest>(new byte[]
{ 17, ModbusFunctionCodes.WriteFileRecord, 0, 19, 0, 10 }));
}
public void CreateModbusRequestWithInvalidMessageFrame()
{
ModbusMessageFactory.CreateModbusRequest(new byte[] { 0, 1 });
Assert.Fail();
}
public void CreateModbusMessageReadHoldingRegistersRequestWithInvalidFrameSize()
{
ReadHoldingInputRegistersRequest request = ModbusMessageFactory.CreateModbusMessage <ReadHoldingInputRegistersRequest>(new byte[] { 11, Modbus.ReadHoldingRegisters, 0, 0, 5 });
}
public void CreateModbusMessageWriteSingleRegisterRequestResponseWithInvalidFrameSize()
{
WriteSingleRegisterRequestResponse request = ModbusMessageFactory.CreateModbusMessage <WriteSingleRegisterRequestResponse>(new byte[] { 11, Modbus.WriteSingleRegister, 0, 1, 0 });
Assert.Fail();
}
public void CreateModbusMessageWriteMultipleCoilsResponseWithInvalidFrameSize()
{
WriteMultipleCoilsResponse request = ModbusMessageFactory.CreateModbusMessage <WriteMultipleCoilsResponse>(new byte[] { 17, Modbus.WriteMultipleCoils, 0, 19, 0 });
Assert.Fail();
}
public void CreateModbusMessageWriteMultipleRegistersRequestWithInvalidFrameSize()
{
Assert.Throws <FormatException>(() =>
ModbusMessageFactory.CreateModbusMessage <WriteMultipleRegistersRequest>(new byte[]
{ 11, Modbus.WriteMultipleRegisters, 0, 5, 0, 1, 2 }));
}
public void CreateModbusMessageReadCoilsRequestWithInvalidFrameSize()
{
byte[] frame = { 11, Modbus.ReadCoils, 4, 1, 2 };
Assert.Throws <FormatException>(() => ModbusMessageFactory.CreateModbusMessage <ReadCoilsInputsRequest>(frame));
}
public void CreateModbusMessageWriteSingleCoilRequestResponseWithInvalidFrameSize()
{
Assert.Throws <FormatException>(() =>
ModbusMessageFactory.CreateModbusMessage <WriteSingleCoilRequestResponse>(new byte[]
{ 11, Modbus.WriteSingleCoil, 0, 105, byte.MaxValue }));
}
public void CreateModbusMessageWriteSingleRegisterRequestResponseWithInvalidFrameSize()
{
Assert.Throws <FormatException>(() =>
ModbusMessageFactory.CreateModbusMessage <WriteSingleRegisterRequestResponse>(new byte[]
{ 11, Modbus.WriteSingleRegister, 0, 1, 0 }));
}
public void CreateModbusMessageSlaveExceptionResponseWithInvalidFrameSize()
{
Assert.Throws <FormatException>(() => ModbusMessageFactory.CreateModbusMessage <SlaveExceptionResponse>(new byte[] { 11, 128 }));
}
public void CreateModbusMessageReadHoldingRegistersRequestWithInvalidFrameSize()
{
Assert.Throws <FormatException>(() =>
ModbusMessageFactory.CreateModbusMessage <ReadHoldingInputRegistersRequest>(new byte[]
{ 11, ModbusFunctionCodes.ReadHoldingRegisters, 0, 0, 5 }));
}
public void CreateModbusMessageWriteMultipleCoilsRequestWithInvalidFrameSize()
{
Assert.Throws <FormatException>(() =>
ModbusMessageFactory.CreateModbusMessage <WriteMultipleCoilsRequest>(new byte[]
{ 17, ModbusFunctionCodes.WriteMultipleCoils, 0, 19, 0, 10, 2 }));
}
public void CreateModbusMessageReadHoldingRegistersResponseWithInvalidFrameSize()
{
Assert.Throws <FormatException>(() => ModbusMessageFactory.CreateModbusMessage <ReadHoldingInputRegistersResponse>(new byte[]
{ 11, Modbus.ReadHoldingRegisters }));
}
public void CreateModbusMessageWriteMultipleCoilsResponseWithInvalidFrameSize()
{
Assert.Throws <FormatException>(() =>
ModbusMessageFactory.CreateModbusMessage <WriteMultipleCoilsResponse>(new byte[]
{ 17, Modbus.WriteMultipleCoils, 0, 19, 0 }));
}
public void CreateModbusMessageWriteSingleCoilRequestResponseWithInvalidFrameSize()
{
WriteSingleCoilRequestResponse request = ModbusMessageFactory.CreateModbusMessage <WriteSingleCoilRequestResponse>(new byte[] { 11, Modbus.WriteSingleCoil, 0, 105, byte.MaxValue });
Assert.Fail();
}
public void CreateModbusMessageReadWriteMultipleRegistersRequestWithInvalidFrameSize()
{
byte[] frame = { 17, Modbus.ReadWriteMultipleRegisters, 1, 2, 3 };
Assert.Throws <FormatException>(() =>
ModbusMessageFactory.CreateModbusMessage <ReadWriteMultipleRegistersRequest>(frame));
}
public void CreateModbusMessageWriteMultipleRegistersRequestWithInvalidFrameSize()
{
WriteMultipleRegistersRequest request = ModbusMessageFactory.CreateModbusMessage <WriteMultipleRegistersRequest>(new byte[] { 11, Modbus.WriteMultipleRegisters, 0, 5, 0, 1, 2 });
Assert.Fail();
}
public void CreateModbusMessageReturnQueryDataRequestResponseTooSmall()
{
byte[] frame = new byte[] { 5, 8, 0, 0, 5 };
Assert.Throws <FormatException>(() =>
ModbusMessageFactory.CreateModbusMessage <DiagnosticsRequestResponse>(frame));
}
public void CreateModbusMessageReturnQueryDataRequestResponseTooSmall()
{
byte[] frame = new byte[] { 5, 8, 0, 0, 5 };
DiagnosticsRequestResponse message = ModbusMessageFactory.CreateModbusMessage <DiagnosticsRequestResponse>(frame);
}
public void CreateModbusRequestWithInvalidMessageFrame()
{
Assert.Throws <FormatException>(() => ModbusMessageFactory.CreateModbusRequest(new byte[] { 0, 1 }));
}
public void CreateModbusRequestWithInvalidFunctionCode()
{
ModbusMessageFactory.CreateModbusRequest(new byte[] { 1, 99, 0, 0, 0, 1, 23 });
Assert.Fail();
}
public void CreateModbusRequestWithInvalidFunctionCode()
{
Assert.Throws <ArgumentException>(() => ModbusMessageFactory.CreateModbusRequest(new byte[] { 1, 99, 0, 0, 0, 1, 23 }));
}
public void CreateModbusMessageReadHoldingRegistersResponseWithInvalidFrameSize()
{
ModbusMessageFactory.CreateModbusMessage <ReadHoldingInputRegistersResponse>(new byte[]
{ 11, Modbus.ReadHoldingRegisters });
}
public void CreateModbusMessageReadCoilsResponseWithNoByteCount()
{
byte[] frame = { 11, Modbus.ReadCoils };
Assert.Throws <FormatException>(() => ModbusMessageFactory.CreateModbusMessage <ReadCoilsInputsResponse>(frame));
}
public void CreateModbusMessageSlaveExceptionResponseWithInvalidFrameSize()
{
ModbusMessageFactory.CreateModbusMessage <SlaveExceptionResponse>(new byte[] { 11, 128 });
Assert.Fail();
}
/// <summary>
/// Start slave listening for requests.
/// </summary>
public override void Listen()
{
// This external Variable can stop this process
stop = false;
while (!stop)
{
try
{
try
{
// read request and build message
byte[] frame = SerialTransport.ReadRequest();
IModbusMessage request = ModbusMessageFactory.CreateModbusRequest(frame);
// here for debugging purposes writes what port is being read
if (Debug == true)
{
using (StreamWriter outHandle = new StreamWriter("Output.txt", true))
{
if (request.FunctionCode == Modbus.ReadHoldingRegisters)
{
outHandle.WriteLine("{0} Reading Port {1} functioncode {2} startadress {3} points {4}", DateTime.Now.ToString(), request.SlaveAddress, request.FunctionCode,
((ReadHoldingInputRegistersRequest)request).StartAddress, ((ReadHoldingInputRegistersRequest)request).NumberOfPoints);
}
else if (request.FunctionCode == Modbus.ReadInputRegisters)
{
outHandle.WriteLine("{0} Reading Port {1} functioncode {2} startadress {3} points {4}", DateTime.Now.ToString(), request.SlaveAddress, request.FunctionCode,
((ReadHoldingInputRegistersRequest)request).StartAddress, ((ReadHoldingInputRegistersRequest)request).NumberOfPoints);
}
else if (request.FunctionCode == Modbus.WriteMultipleRegisters)
{
outHandle.WriteLine("{0} Write Port {1} functioncode {2} startadress {3} points {4}", DateTime.Now.ToString(), request.SlaveAddress, request.FunctionCode,
((WriteMultipleRegistersRequest)request).StartAddress, ((WriteMultipleRegistersRequest)request).NumberOfPoints);
var items = ((WriteMultipleRegistersRequest)request).Data;
foreach (var item in items)
{
outHandle.WriteLine(item);
}
}
else if (request.FunctionCode == Modbus.WriteMultipleRegisters)
{
outHandle.WriteLine("{0} Write Port {1} functioncode {2} startadress {3} data {4}", DateTime.Now.ToString(), request.SlaveAddress, request.FunctionCode,
((WriteSingleRegisterRequestResponse)request).StartAddress, ((WriteSingleRegisterRequestResponse)request).Data);
}
//response = ReadRegisters((ReadHoldingInputRegistersRequest) request, DataStore, DataStore.HoldingRegisters);
//break;
//case Modbus.ReadInputRegisters:
//outHandle.WriteLine("{0} Reading Port {1}", DateTime.Now.ToString(), request.SlaveAddress, request.FunctionCode );
}
}
if (SerialTransport.CheckFrame && !SerialTransport.ChecksumsMatch(request, frame))
{
string errorMessage = String.Format(CultureInfo.InvariantCulture, "Checksums failed to match {0} != {1}", request.MessageFrame.Join(", "), frame.Join(", "));
_logger.Error(errorMessage);
throw new IOException(errorMessage);
}
// only service requests addressed to this particular slave
if (m_internalMap != null)
{
if (!doesIdExist(request.SlaveAddress))
{
_logger.DebugFormat("NModbus Slave {0} ignoring request intended for NModbus Slave {1}", UnitId, request.SlaveAddress);
continue;
}
}
else
{
if (request.SlaveAddress != UnitId)
{
_logger.DebugFormat("NModbus Slave {0} ignoring request intended for NModbus Slave {1}", UnitId, request.SlaveAddress);
continue;
}
}
// perform action
if (m_internalMap != null)
{
DataStore = m_internalMap[request.SlaveAddress];
}
IModbusMessage response = ApplyRequest(request);
// write response
SerialTransport.Write(response);
}
catch (NotImplementedException ni)
{
SerialTransport.DiscardInBuffer();
Console.WriteLine(ni.Message);
Console.WriteLine("Just ignoring for time being");
}
catch (IOException ioe)
{
_logger.ErrorFormat("IO Exception encountered while listening for requests - {0}", ioe.Message);
SerialTransport.DiscardInBuffer();
}
catch (TimeoutException te)
{
_logger.ErrorFormat("Timeout Exception encountered while listening for requests - {0}", te.Message);
SerialTransport.DiscardInBuffer();
}
// TODO better exception handling here, missing FormatException, NotImplemented...
}
catch (InvalidOperationException)
{
// throw;
// when the underlying transport is disposed
Console.WriteLine("Invalid Operation Exception not stopping");
}
catch (Exception e)
{
Console.WriteLine("Invalid Operation Exception not stopping: " + e.Message);
}
}
}
