public void CreateResponse()
{
var transport = new ModbusAsciiTransport(StreamResource, new ModbusFactory(), NullModbusLogger.Instance);
var expectedResponse = new ReadCoilsInputsResponse(ModbusFunctionCodes.ReadCoils, 2, 1, new DiscreteCollection(true, false, false, false, false, false, false, true));
byte lrc = ModbusUtility.CalculateLrc(expectedResponse.MessageFrame);
IModbusMessage response = transport.CreateResponse <ReadCoilsInputsResponse>(new byte[] { 2, ModbusFunctionCodes.ReadCoils, 1, 129, lrc });
Assert.IsType <ReadCoilsInputsResponse>(response);
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(expectedResponse, response);
}
public void CreateResponse()
{
ModbusAsciiTransport? transport = new(StreamResource);
ReadCoilsInputsResponse?expectedResponse = new(Modbus.ReadCoils, 2, 1, new DiscreteCollection(true, false, false, false, false, false, false, true));
byte lrc = ModbusUtility.CalculateLrc(expectedResponse.MessageFrame);
IModbusMessage?response = transport.CreateResponse <ReadCoilsInputsResponse>(new byte[] { 2, Modbus.ReadCoils, 1, 129, lrc });
Assert.IsType <ReadCoilsInputsResponse>(response);
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(expectedResponse, response);
}
public void CreateModbusMessageReadWriteMultipleRegistersRequest()
{
ReadWriteMultipleRegistersRequest request =
ModbusMessageFactory.CreateModbusMessage <ReadWriteMultipleRegistersRequest>(new byte[]
{ 0x05, 0x17, 0x00, 0x03, 0x00, 0x06, 0x00, 0x0e, 0x00, 0x03, 0x06, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff });
RegisterCollection writeCollection = new(255, 255, 255);
ReadWriteMultipleRegistersRequest expectedRequest = new(5, 3, 6, 14,
writeCollection);
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(expectedRequest, request);
}
public void ReadDiscretesInputs()
{
ReadCoilsInputsResponse expectedResponse = new ReadCoilsInputsResponse(Modbus.ReadInputs, 1, 2,
new DiscreteCollection(true, false, true, false, true, false, true, false, true));
ReadCoilsInputsResponse response =
ModbusSlave.ReadDiscretes(new ReadCoilsInputsRequest(Modbus.ReadInputs, 1, 1, 9), _testDataStore,
_testDataStore.InputDiscretes);
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(expectedResponse, response);
Assert.Equal(expectedResponse.ByteCount, response.ByteCount);
}
public void CreateModbusMessageReadHoldingRegistersResponse()
{
ReadHoldingInputRegistersResponse response =
ModbusMessageFactory.CreateModbusMessage <ReadHoldingInputRegistersResponse>(new byte[]
{ 11, Modbus.ReadHoldingRegisters, 4, 0, 3, 0, 4 });
ReadHoldingInputRegistersResponse expectedResponse = new(
Modbus.ReadHoldingRegisters, 11, new RegisterCollection(3, 4));
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(expectedResponse, response);
}
public void CreateModbusMessageReadCoilsRequest()
{
ReadCoilsInputsRequest request =
ModbusMessageFactory.CreateModbusMessage <ReadCoilsInputsRequest>(new byte[]
{ 11, Modbus.ReadCoils, 0, 19, 0, 37 });
ReadCoilsInputsRequest expectedRequest = new(Modbus.ReadCoils, 11, 19, 37);
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(request, expectedRequest);
Assert.Equal(expectedRequest.StartAddress, request.StartAddress);
Assert.Equal(expectedRequest.NumberOfPoints, request.NumberOfPoints);
}
public void ReadRegistersInputRegisters()
{
ReadHoldingInputRegistersResponse expectedResponse =
new ReadHoldingInputRegistersResponse(Modbus.ReadInputRegisters, 1,
new RegisterCollection(10, 20, 30, 40, 50, 60));
ReadHoldingInputRegistersResponse response =
ModbusSlave.ReadRegisters(new ReadHoldingInputRegistersRequest(Modbus.ReadInputRegisters, 1, 0, 6),
_testDataStore, _testDataStore.InputRegisters);
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(expectedResponse, response);
Assert.Equal(expectedResponse.ByteCount, response.ByteCount);
}
public void CreateModbusMessageWriteMultipleCoilsResponse()
{
WriteMultipleCoilsResponse response =
ModbusMessageFactory.CreateModbusMessage <WriteMultipleCoilsResponse>(new byte[]
{ 17, Modbus.WriteMultipleCoils, 0, 19, 0, 10 });
WriteMultipleCoilsResponse expectedResponse = new(17, 19, 10);
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(expectedResponse, response);
Assert.Equal(expectedResponse.StartAddress, response.StartAddress);
Assert.Equal(expectedResponse.NumberOfPoints, response.NumberOfPoints);
}
public void CreateModbusMessageWriteSingleCoilRequestResponse()
{
WriteSingleCoilRequestResponse request =
ModbusMessageFactory.CreateModbusMessage <WriteSingleCoilRequestResponse>(new byte[]
{ 17, Modbus.WriteSingleCoil, 0, 172, byte.MaxValue, 0 });
WriteSingleCoilRequestResponse expectedRequest = new(17, 172, true);
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(expectedRequest, request);
Assert.Equal(expectedRequest.StartAddress, request.StartAddress);
Assert.Equal(expectedRequest.Data.NetworkBytes, request.Data.NetworkBytes);
}
public void CreateModbusMessageReadCoilsResponse()
{
ReadCoilsInputsResponse response =
ModbusMessageFactory.CreateModbusMessage <ReadCoilsInputsResponse>(new byte[]
{ 11, Modbus.ReadCoils, 1, 1 });
ReadCoilsInputsResponse expectedResponse = new(Modbus.ReadCoils, 11, 1,
new DiscreteCollection(true, false, false, false));
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(expectedResponse, response);
Assert.Equal(expectedResponse.Data.NetworkBytes, response.Data.NetworkBytes);
}
public void WriteSingleCoil()
{
ushort addressToWrite = 35;
bool valueToWrite = !_testDataStore.CoilDiscretes[addressToWrite + 1];
WriteSingleCoilRequestResponse expectedResponse = new WriteSingleCoilRequestResponse(1, addressToWrite,
valueToWrite);
WriteSingleCoilRequestResponse response =
ModbusSlave.WriteSingleCoil(new WriteSingleCoilRequestResponse(1, addressToWrite, valueToWrite),
_testDataStore, _testDataStore.CoilDiscretes);
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(expectedResponse, response);
Assert.Equal(valueToWrite, _testDataStore.CoilDiscretes[addressToWrite + 1]);
}
public void CreateModbusMessageWriteSingleRegisterRequestResponse()
{
WriteSingleRegisterRequestResponse request =
ModbusMessageFactory.CreateModbusMessage <WriteSingleRegisterRequestResponse>(new byte[]
{ 17, Modbus.WriteSingleRegister, 0, 1, 0, 3 });
WriteSingleRegisterRequestResponse expectedRequest = new(
17, 1, 3);
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(expectedRequest, request);
Assert.Equal(expectedRequest.StartAddress, request.StartAddress);
Assert.Equal(expectedRequest.Data.NetworkBytes, request.Data.NetworkBytes);
}
public void WriteSingleRegister()
{
ushort startAddress = 35;
ushort value = 45;
Assert.NotEqual(value, _testDataStore.HoldingRegisters[startAddress - 1]);
WriteSingleRegisterRequestResponse expectedResponse = new WriteSingleRegisterRequestResponse(1, startAddress,
value);
WriteSingleRegisterRequestResponse response =
ModbusSlave.WriteSingleRegister(new WriteSingleRegisterRequestResponse(1, startAddress, value),
_testDataStore, _testDataStore.HoldingRegisters);
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(expectedResponse, response);
}
public void CreateModbusMessageReadHoldingRegistersRequest()
{
ReadHoldingInputRegistersRequest request =
ModbusMessageFactory.CreateModbusMessage <ReadHoldingInputRegistersRequest>(new byte[]
{ 17, Modbus.ReadHoldingRegisters, 0, 107, 0, 3 });
ReadHoldingInputRegistersRequest expectedRequest = new(
Modbus.ReadHoldingRegisters, 17, 107, 3);
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(expectedRequest, request);
Assert.Equal(expectedRequest.StartAddress, request.StartAddress);
Assert.Equal(expectedRequest.NumberOfPoints, request.NumberOfPoints);
}
public void CreateModbusMessageReturnQueryDataRequestResponse()
{
const byte slaveAddress = 5;
RegisterCollection data = new(50);
byte[] frame = new byte[] { slaveAddress, 8, 0, 0 }.Concat(data.NetworkBytes).ToArray();
DiagnosticsRequestResponse message =
ModbusMessageFactory.CreateModbusMessage <DiagnosticsRequestResponse>(frame);
DiagnosticsRequestResponse expectedMessage =
new(Modbus.DiagnosticsReturnQueryData, slaveAddress, data);
Assert.Equal(expectedMessage.SubFunctionCode, message.SubFunctionCode);
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(expectedMessage, message);
}
public void WriteMultipleCoils()
{
ushort startAddress = 35;
ushort numberOfPoints = 10;
bool val = !_testDataStore.CoilDiscretes[startAddress + 1];
WriteMultipleCoilsResponse expectedResponse = new WriteMultipleCoilsResponse(1, startAddress, numberOfPoints);
WriteMultipleCoilsResponse response =
ModbusSlave.WriteMultipleCoils(
new WriteMultipleCoilsRequest(1, startAddress,
new DiscreteCollection(val, val, val, val, val, val, val, val, val, val)), _testDataStore,
_testDataStore.CoilDiscretes);
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(expectedResponse, response);
Assert.Equal(new bool[] { val, val, val, val, val, val, val, val, val, val },
Enumerable.ToArray <bool>(_testDataStore.CoilDiscretes.Slice(startAddress + 1, numberOfPoints)));
}
public void WriteMultipleRegisters()
{
ushort startAddress = 35;
ushort[] valuesToWrite = new ushort[] { 1, 2, 3, 4, 5 };
Assert.NotEqual(valuesToWrite,
Enumerable.ToArray <ushort>(_testDataStore.HoldingRegisters.Slice(startAddress - 1, valuesToWrite.Length)));
WriteMultipleRegistersResponse expectedResponse = new WriteMultipleRegistersResponse(1, startAddress,
(ushort)valuesToWrite.Length);
WriteMultipleRegistersResponse response =
ModbusSlave.WriteMultipleRegisters(
new WriteMultipleRegistersRequest(1, startAddress, new RegisterCollection(valuesToWrite)),
_testDataStore, _testDataStore.HoldingRegisters);
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(expectedResponse, response);
}
public void CreateModbusMessageWriteMultipleCoilsRequest()
{
WriteMultipleCoilsRequest request =
ModbusMessageFactory.CreateModbusMessage <WriteMultipleCoilsRequest>(new byte[]
{ 17, Modbus.WriteMultipleCoils, 0, 19, 0, 10, 2, 205, 1 });
WriteMultipleCoilsRequest expectedRequest = new(
17, 19, new DiscreteCollection(true, false, true, true, false, false, true, true, true, false));
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(expectedRequest, request);
Assert.Equal(expectedRequest.StartAddress, request.StartAddress);
Assert.Equal(expectedRequest.NumberOfPoints, request.NumberOfPoints);
Assert.Equal(expectedRequest.ByteCount, request.ByteCount);
Assert.Equal(expectedRequest.Data.NetworkBytes, request.Data.NetworkBytes);
}
public void CreateModbusMessageWriteMultipleRegistersRequest()
{
WriteMultipleRegistersRequest request =
ModbusMessageFactory.CreateModbusMessage <WriteMultipleRegistersRequest>(new byte[]
{ 11, Modbus.WriteMultipleRegisters, 0, 5, 0, 1, 2, 255, 255 });
WriteMultipleRegistersRequest expectedRequest = new(
11, 5, new RegisterCollection(ushort.MaxValue));
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(expectedRequest, request);
Assert.Equal(expectedRequest.StartAddress, request.StartAddress);
Assert.Equal(expectedRequest.NumberOfPoints, request.NumberOfPoints);
Assert.Equal(expectedRequest.ByteCount, request.ByteCount);
Assert.Equal(expectedRequest.Data.NetworkBytes, request.Data.NetworkBytes);
}
public void UnicastMessage_PurgeReceiveBuffer()
{
var mock = new Mock <IStreamResource>(MockBehavior.Strict);
IStreamResource serialResource = mock.Object;
var factory = new ModbusFactory();
var transport = new ModbusRtuTransport(serialResource, factory, NullModbusLogger.Instance);
mock.Setup(s => s.DiscardInBuffer());
mock.Setup(s => s.Write(It.IsAny <byte[]>(), 0, 0));
serialResource.DiscardInBuffer();
serialResource.Write(null, 0, 0);
// mangled response
mock.Setup(s => s.Read(It.Is <byte[]>(x => x.Length == 4), 0, 4)).Returns(4);
serialResource.DiscardInBuffer();
serialResource.Write(null, 0, 0);
// normal response
var response = new ReadCoilsInputsResponse(ModbusFunctionCodes.ReadCoils, 2, 1, new DiscreteCollection(true, false, true, false, false, false, false, false));
// write request
mock.Setup(s => s.Write(It.Is <byte[]>(x => x.Length == 8), 0, 8));
// read header
mock.Setup(s => s.Read(It.Is <byte[]>(x => x.Length == 4), 0, 4))
.Returns((byte[] buf, int offset, int count) =>
{
Array.Copy(response.MessageFrame, 0, buf, 0, 4);
return(4);
});
// read remainder
mock.Setup(s => s.Read(It.Is <byte[]>(x => x.Length == 2), 0, 2))
.Returns((byte[] buf, int offset, int count) =>
{
Array.Copy(ModbusUtility.CalculateCrc(response.MessageFrame), 0, buf, 0, 2);
return(2);
});
var request = new ReadCoilsInputsRequest(ModbusFunctionCodes.ReadCoils, 2, 3, 4);
ReadCoilsInputsResponse actualResponse = transport.UnicastMessage <ReadCoilsInputsResponse>(request);
ModbusMessageFixture.AssertModbusMessagePropertiesAreEqual(response, actualResponse);
mock.VerifyAll();
}
