public void RequestBytesToReadDiagnostics()
{
var transport = new ModbusRtuTransport(StreamResource, Factory, NullModbusLogger.Instance);
byte[] frame = { 0x01, 0x08, 0x00, 0x00, 0xA5, 0x37, 0, 0 };
Assert.Equal(1, transport.RequestBytesToRead(frame));
}
public void Read()
{
MockRepository mocks = new MockRepository();
IStreamResource mockSerialResource = mocks.StrictMock<IStreamResource>();
Expect.Call(mockSerialResource.Read(new byte[5], 0, 5))
.Do(((Func<byte[], int, int, int>) delegate(byte[] buf, int offset, int count)
{
Array.Copy(new byte[] {2, 2, 2}, buf, 3);
return 3;
}));
Expect.Call(mockSerialResource.Read(new byte[] {2, 2, 2, 0, 0}, 3, 2))
.Do(((Func<byte[], int, int, int>) delegate(byte[] buf, int offset, int count)
{
Array.Copy(new byte[] {3, 3}, 0, buf, 3, 2);
return 2;
}));
mocks.ReplayAll();
ModbusRtuTransport transport = new ModbusRtuTransport(mockSerialResource);
Assert.AreEqual(new byte[] {2, 2, 2, 3, 3}, transport.Read(5));
mocks.VerifyAll();
}
public void ReadResponseSlaveException()
{
var factory = new ModbusFactory();
var mock = new Mock <ModbusRtuTransport>(StreamResource, factory, NullModbusLogger.Instance)
{
CallBase = true
};
ModbusRtuTransport transport = mock.Object;
byte[] messageFrame = { 0x01, 0x81, 0x02 };
byte[] crc = ModbusUtility.CalculateCrc(messageFrame);
mock.Setup(t => t.Read(ModbusRtuTransport.ResponseFrameStartLength))
.Returns(Enumerable.Concat(messageFrame, new byte[] { crc[0] }).ToArray());
mock.Setup(t => t.Read(1))
.Returns(new byte[] { crc[1] });
IModbusMessage response = transport.ReadResponse <ReadCoilsInputsResponse>();
Assert.IsType <SlaveExceptionResponse>(response);
var expectedResponse = new SlaveExceptionResponse(0x01, 0x81, 0x02);
Assert.Equal(expectedResponse.MessageFrame, response.MessageFrame);
mock.VerifyAll();
}
public void ResponseBytesToReadDiagnostics()
{
var transport = new ModbusRtuTransport(StreamResource, Factory, NullModbusLogger.Instance);
byte[] frameStart = { 0x01, 0x08, 0x00, 0x00 };
Assert.Equal(4, transport.ResponseBytesToRead(frameStart));
}
public void ReadResponse()
{
MockRepository mocks = new MockRepository();
ModbusRtuTransport transport =
mocks.PartialMock <ModbusRtuTransport>(MockRepository.GenerateStub <IStreamResource>());
Expect.Call(transport.Read(ModbusRtuTransport.ResponseFrameStartLength))
.Return(new byte[] { 1, 1, 1, 0 });
Expect.Call(transport.Read(2))
.Return(new byte[] { 81, 136 });
mocks.ReplayAll();
ReadCoilsInputsResponse response =
transport.ReadResponse <ReadCoilsInputsResponse>() as ReadCoilsInputsResponse;
Assert.IsNotNull(response);
ReadCoilsInputsResponse expectedResponse = new ReadCoilsInputsResponse(Modbus.ReadCoils, 1, 1,
new DiscreteCollection(false));
Assert.AreEqual(response.MessageFrame, expectedResponse.MessageFrame);
mocks.VerifyAll();
}
public void RequestBytesToReadCoils()
{
var transport = new ModbusRtuTransport(StreamResource, Factory, NullModbusLogger.Instance);
byte[] frameStart = { 0x11, 0x01, 0x00, 0x13, 0x00, 0x25 };
Assert.Equal(1, transport.RequestBytesToRead(frameStart));
}
public void ChecksumsMatchFail()
{
var transport = new ModbusRtuTransport(MockRepository.GenerateStub<IStreamResource>());
var message = new ReadCoilsInputsRequest(Modbus.ReadCoils, 17, 19, 38);
byte[] frame = { 17, Modbus.ReadCoils, 0, 19, 0, 37, 14, 132 };
Assert.IsFalse(transport.ChecksumsMatch(message, frame));
}
public void RequestBytesToReadWriteMultipleHoldingRegisters()
{
var transport = new ModbusRtuTransport(StreamResource, Factory, NullModbusLogger.Instance);
byte[] frameStart = { 0x11, 0x10, 0x00, 0x01, 0x00, 0x02, 0x04 };
Assert.Equal(6, transport.RequestBytesToRead(frameStart));
}
public void ResponseBytesToReadInvalidFunctionCode()
{
var transport = new ModbusRtuTransport(StreamResource, Factory, NullModbusLogger.Instance);
byte[] frame = { 0x11, 0x16, 0x00, 0x01, 0x00, 0x02, 0x04 };
Assert.Throws <NotImplementedException>(() => transport.ResponseBytesToRead(frame));
}
public void ChecksumsMatchSucceed()
{
ModbusRtuTransport transport = new ModbusRtuTransport(MockRepository.GenerateStub<IStreamResource>());
ReadCoilsInputsRequest message = new ReadCoilsInputsRequest(Modbus.ReadCoils, 17, 19, 37);
byte[] frame = { 17, Modbus.ReadCoils, 0, 19, 0, 37, 14, 132 };
Assert.IsTrue(transport.ChecksumsMatch(message, frame));
}
public void ResponseBytesToReadWriteCoilsResponse()
{
var transport = new ModbusRtuTransport(StreamResource, Factory, NullModbusLogger.Instance);
byte[] frameStart = { 0x11, 0x0F, 0x00, 0x13, 0x00, 0x0A, 0, 0 };
Assert.Equal(4, transport.ResponseBytesToRead(frameStart));
}
public void ResponseBytesToReadSlaveException()
{
var transport = new ModbusRtuTransport(StreamResource, Factory, NullModbusLogger.Instance);
byte[] frameStart = { 0x01, Modbus.ExceptionOffset + 1, 0x01 };
Assert.Equal(1, transport.ResponseBytesToRead(frameStart));
}
public void ResponseBytesToReadCoils()
{
var transport = new ModbusRtuTransport(StreamResource, Factory, NullModbusLogger.Instance);
byte[] frameStart = { 0x11, 0x01, 0x05, 0xCD, 0x6B, 0xB2, 0x0E, 0x1B };
Assert.Equal(6, transport.ResponseBytesToRead(frameStart));
}
public void Read()
{
var mock = new Mock <IStreamResource>(MockBehavior.Strict);
mock.Setup(s => s.Read(It.Is <byte[]>(x => x.Length == 5), 0, 5))
.Returns((byte[] buf, int offset, int count) =>
{
Array.Copy(new byte[] { 2, 2, 2 }, buf, 3);
return(3);
});
mock.Setup(s => s.Read(It.Is <byte[]>(x => x.Length == 5), 3, 2))
.Returns((byte[] buf, int offset, int count) =>
{
Array.Copy(new byte[] { 3, 3 }, 0, buf, 3, 2);
return(2);
});
var factory = new ModbusFactory();
var transport = new ModbusRtuTransport(mock.Object, factory, NullModbusLogger.Instance);
Assert.Equal(new byte[] { 2, 2, 2, 3, 3 }, transport.Read(5));
mock.VerifyAll();
}
public void Read()
{
MockRepository mocks = new MockRepository();
IStreamResource mockSerialResource = mocks.StrictMock <IStreamResource>();
Expect.Call(mockSerialResource.Read(new byte[5], 0, 5)).Do(((Func <byte[], int, int, int>) delegate(byte[] buf, int offset, int count)
{
Array.Copy(new byte[] { 2, 2, 2 }, buf, 3);
return(3);
}));
Expect.Call(mockSerialResource.Read(new byte[] { 2, 2, 2, 0, 0 }, 3, 2)).Do(((Func <byte[], int, int, int>) delegate(byte[] buf, int offset, int count)
{
Array.Copy(new byte[] { 3, 3 }, 0, buf, 3, 2);
return(2);
}));
mocks.ReplayAll();
ModbusRtuTransport transport = new ModbusRtuTransport(mockSerialResource);
Assert.AreEqual(new byte[] { 2, 2, 2, 3, 3 }, transport.Read(5));
mocks.VerifyAll();
}
public void BuildMessageFrame()
{
byte[] message = { 17, Modbus.ReadCoils, 0, 19, 0, 37, 14, 132 };
var request = new ReadCoilsInputsRequest(Modbus.ReadCoils, 17, 19, 37);
var transport = new ModbusRtuTransport(StreamResource);
Assert.Equal <byte[]>(message, transport.BuildMessageFrame(request));
}
public void RequestBytesToReadWriteCoilsRequest()
{
MockRepository mocks = new MockRepository();
var mockSlave = mocks.PartialMock <ModbusSlave>((byte)1, new EmptyTransport());
byte[] frameStart = { 0x11, 0x0F, 0x00, 0x13, 0x00, 0x0A, 0x02, 0xCD, 0x01 };
Assert.AreEqual(4, ModbusRtuTransport.RequestBytesToRead(frameStart, mockSlave));
}
public void RequestBytesToReadWriteMultipleHoldingRegisters()
{
MockRepository mocks = new MockRepository();
var mockSlave = mocks.PartialMock <ModbusSlave>((byte)1, new EmptyTransport());
byte[] frameStart = { 0x11, 0x10, 0x00, 0x01, 0x00, 0x02, 0x04 };
Assert.AreEqual(6, ModbusRtuTransport.RequestBytesToRead(frameStart, mockSlave));
}
public void BuildMessageFrame()
{
byte[] message = { 17, ModbusFunctionCodes.ReadCoils, 0, 19, 0, 37, 14, 132 };
var request = new ReadCoilsInputsRequest(ModbusFunctionCodes.ReadCoils, 17, 19, 37);
var transport = new ModbusRtuTransport(StreamResource, Factory, NullModbusLogger.Instance);
Assert.Equal(message, transport.BuildMessageFrame(request));
}
public void RequestBytesToReadDiagnostics()
{
MockRepository mocks = new MockRepository();
var mockSlave = mocks.PartialMock <ModbusSlave>((byte)1, new EmptyTransport());
byte[] frame = { 0x01, 0x08, 0x00, 0x00, 0xA5, 0x37, 0, 0 };
Assert.AreEqual(1, ModbusRtuTransport.RequestBytesToRead(frame, mockSlave));
}
public IModbusMaster CreateMaster(Socket client)
{
var adapter = new SocketAdapter(client);
var transport = new ModbusRtuTransport(adapter, this, Logger);
return(new ModbusSerialMaster(transport));
}
public void ChecksumsMatchFail()
{
ModbusRtuTransport transport = new ModbusRtuTransport(MockRepository.GenerateStub <IStreamResource>());
ReadCoilsInputsRequest message = new ReadCoilsInputsRequest(Modbus.ReadCoils, 17, 19, 38);
byte[] frame = { 17, Modbus.ReadCoils, 0, 19, 0, 37, 14, 132 };
Assert.IsFalse(transport.ChecksumsMatch(message, frame));
}
public void ChecksumsMatchFail()
{
var transport = new ModbusRtuTransport(StreamResource);
var message = new ReadCoilsInputsRequest(Modbus.ReadCoils, 17, 19, 38);
byte[] frame = { 17, Modbus.ReadCoils, 0, 19, 0, 37, 14, 132 };
Assert.False((bool)transport.ChecksumsMatch(message, frame));
}
public void RequestBytesToReadInvalidFunctionCode()
{
MockRepository mocks = new MockRepository();
var mockSlave = mocks.PartialMock <ModbusSlave>((byte)1, new EmptyTransport());
byte[] frame = { 0x11, 0xFF, 0x00, 0x01, 0x00, 0x02, 0x04 };
ModbusRtuTransport.RequestBytesToRead(frame, mockSlave);
Assert.Fail();
}
public void ChecksumsMatchFail()
{
var factory = new ModbusFactory();
var transport = new ModbusRtuTransport(StreamResource, factory, NullModbusLogger.Instance);
var message = new ReadCoilsInputsRequest(ModbusFunctionCodes.ReadCoils, 17, 19, 38);
byte[] frame = { 17, ModbusFunctionCodes.ReadCoils, 0, 19, 0, 37, 14, 132 };
Assert.False(transport.ChecksumsMatch(message, frame));
}
public static void Show(Action <IModbusTransport> transportCreated, IModbusTransport transport = null, Grid parent = null)
{
if (transport == null)
{
transport = new ModbusRtuTransport();
}
var control = new ConfigureTransportView(transport);
var dialog = new DialogView(control);
control.ApplyPressed += (newTransport) => {
dialog.Close();
transportCreated(newTransport);
};
dialog.Show(parent);
}
public void ReadRequest()
{
MockRepository mocks = new MockRepository();
ModbusRtuTransport transport = mocks.PartialMock <ModbusRtuTransport>(MockRepository.GenerateStub <IStreamResource>());
Expect.Call(transport.Read(ModbusRtuTransport.RequestFrameStartLength))
.Return(new byte[] { 1, 1, 1, 0, 1, 0, 0 });
Expect.Call(transport.Read(1))
.Return(new byte[] { 5 });
mocks.ReplayAll();
Assert.AreEqual(new byte[] { 1, 1, 1, 0, 1, 0, 0, 5 }, transport.ReadRequest());
mocks.VerifyAll();
}
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();
}
public void UnicastMessage_PurgeReceiveBuffer()
{
MockRepository mocks = new MockRepository();
IStreamResource serialResource = mocks.StrictMock <IStreamResource>();
ModbusSerialTransport transport = new ModbusRtuTransport(serialResource);
serialResource.DiscardInBuffer();
serialResource.Write(null, 0, 0);
LastCall.IgnoreArguments();
// mangled response
Expect.Call(serialResource.Read(new byte[] { 0, 0, 0, 0 }, 0, 4)).Return(4);
serialResource.DiscardInBuffer();
serialResource.Write(null, 0, 0);
LastCall.IgnoreArguments();
// normal response
ReadCoilsInputsResponse response = new ReadCoilsInputsResponse(Modbus.ReadCoils, 2, 1,
new DiscreteCollection(true, false, true, false, false, false, false, false));
// read header
Expect.Call(serialResource.Read(new byte[] { 0, 0, 0, 0 }, 0, 4))
.Do(((Func <byte[], int, int, int>) delegate(byte[] buf, int offset, int count)
{
Array.Copy(response.MessageFrame, 0, buf, 0, 4);
return(4);
}));
// read remainder
Expect.Call(serialResource.Read(new byte[] { 0, 0 }, 0, 2))
.Do(((Func <byte[], int, int, int>) delegate(byte[] buf, int offset, int count)
{
Array.Copy(ModbusUtility.CalculateCrc(response.MessageFrame), 0, buf, 0, 2);
return(2);
}));
mocks.ReplayAll();
ReadCoilsInputsRequest request = new ReadCoilsInputsRequest(Modbus.ReadCoils, 2, 3, 4);
transport.UnicastMessage <ReadCoilsInputsResponse>(request);
mocks.VerifyAll();
}
public void UnicastMessage_PurgeReceiveBuffer()
{
MockRepository mocks = new MockRepository();
IStreamResource serialResource = mocks.StrictMock<IStreamResource>();
ModbusSerialTransport transport = new ModbusRtuTransport(serialResource);
serialResource.DiscardInBuffer();
serialResource.Write(null, 0, 0);
LastCall.IgnoreArguments();
// mangled response
Expect.Call(serialResource.Read(new byte[] {0, 0, 0, 0}, 0, 4)).Return(4);
serialResource.DiscardInBuffer();
serialResource.Write(null, 0, 0);
LastCall.IgnoreArguments();
// normal response
ReadCoilsInputsResponse response = new ReadCoilsInputsResponse(Modbus.ReadCoils, 2, 1,
new DiscreteCollection(true, false, true, false, false, false, false, false));
// read header
Expect.Call(serialResource.Read(new byte[] {0, 0, 0, 0}, 0, 4))
.Do(((Func<byte[], int, int, int>) delegate(byte[] buf, int offset, int count)
{
Array.Copy(response.MessageFrame, 0, buf, 0, 4);
return 4;
}));
// read remainder
Expect.Call(serialResource.Read(new byte[] {0, 0}, 0, 2))
.Do(((Func<byte[], int, int, int>) delegate(byte[] buf, int offset, int count)
{
Array.Copy(ModbusUtility.CalculateCrc(response.MessageFrame), 0, buf, 0, 2);
return 2;
}));
mocks.ReplayAll();
ReadCoilsInputsRequest request = new ReadCoilsInputsRequest(Modbus.ReadCoils, 2, 3, 4);
transport.UnicastMessage<ReadCoilsInputsResponse>(request);
mocks.VerifyAll();
}
public void ReadRequest()
{
var factory = new ModbusFactory();
var mock = new Mock <ModbusRtuTransport>(StreamResource, factory, NullModbusLogger.Instance)
{
CallBase = true
};
ModbusRtuTransport transport = mock.Object;
mock.Setup(t => t.Read(ModbusRtuTransport.RequestFrameStartLength))
.Returns(new byte[] { 1, 1, 1, 0, 1, 0, 0 });
mock.Setup(t => t.Read(1))
.Returns(new byte[] { 5 });
Assert.Equal(new byte[] { 1, 1, 1, 0, 1, 0, 0, 5 }, transport.ReadRequest());
mock.VerifyAll();
}
public void ReadResponseSlaveException()
{
MockRepository mocks = new MockRepository();
ModbusRtuTransport transport = mocks.PartialMock <ModbusRtuTransport>(MockRepository.GenerateStub <IStreamResource>());
byte[] messageFrame = { 0x01, 0x81, 0x02 };
byte[] crc = ModbusUtility.CalculateCrc(messageFrame);
Expect.Call(transport.Read(ModbusRtuTransport.ResponseFrameStartLength))
.Return(messageFrame.Concat(SequenceUtility.ToSequence(crc[0])).ToArray());
Expect.Call(transport.Read(1))
.Return(new byte[] { crc[1] });
mocks.ReplayAll();
Assert.IsTrue(transport.ReadResponse <ReadCoilsInputsResponse>() is SlaveExceptionResponse);
mocks.VerifyAll();
}
public void ReadResponseSlaveExceptionWithErroneousLrc()
{
MockRepository mocks = new MockRepository();
ModbusRtuTransport transport = mocks.PartialMock <ModbusRtuTransport>(MockRepository.GenerateStub <IStreamResource>());
byte[] messageFrame = { 0x01, 0x81, 0x02 };
// invalid crc
byte[] crc = { 0x9, 0x9 };
Expect.Call(transport.Read(ModbusRtuTransport.ResponseFrameStartLength))
.Return(messageFrame.Concat(crc[0].ToSequence()).ToArray());
Expect.Call(transport.Read(1))
.Return(new byte[] { crc[1] });
mocks.ReplayAll();
transport.ReadResponse <ReadCoilsInputsResponse>();
mocks.VerifyAll();
}
public void ReadResponse()
{
var factory = new ModbusFactory();
var mock = new Mock <ModbusRtuTransport>(StreamResource, factory, NullModbusLogger.Instance)
{
CallBase = true
};
ModbusRtuTransport transport = mock.Object;
mock.Setup(t => t.Read(ModbusRtuTransport.ResponseFrameStartLength)).Returns(new byte[] { 1, 1, 1, 0 });
mock.Setup(t => t.Read(2)).Returns(new byte[] { 81, 136 });
IModbusMessage response = transport.ReadResponse <ReadCoilsInputsResponse>();
Assert.IsType <ReadCoilsInputsResponse>(response);
var expectedResponse = new ReadCoilsInputsResponse(ModbusFunctionCodes.ReadCoils, 1, 1, new DiscreteCollection(false));
Assert.Equal(expectedResponse.MessageFrame, response.MessageFrame);
mock.VerifyAll();
}
