public void CreateWriteMultipleCoilsRequestMaxSize()
{
WriteMultipleCoilsRequest request = new WriteMultipleCoilsRequest(1, 2,
MessageUtility.CreateDefaultCollection<DiscreteCollection, bool>(true,
Modbus.MaximumDiscreteRequestResponseSize));
Assert.Equal(Modbus.MaximumDiscreteRequestResponseSize, request.Data.Count);
}
public async Task RetriesToReadResponse()
{
// Arrange
var target = new Mock <ModbusTransport>(new Mock <IPipeResource>().Object, Mock.Of <ITransactionIdProvider>(), Mock.Of <ILogger <IModbusMaster> >())
{
CallBase = true
};
var request = new WriteMultipleCoilsRequest(1, 1, new bool[] { true });
var response = new WriteMultipleCoilsResponse();
target.SetupWriteRequestAsync(request);
target.SetupReadResponseAsync <WriteMultipleCoilsResponse>(response);
target.SetupRetryReadResponse(request, response, true, false);
// Act
_ = await target.Object.SendAsync <WriteMultipleCoilsResponse>(request);
// Assert
target.Protected().As <IModbusTransportMock>()
.Verify(x => x.WriteRequestAsync(request, It.IsAny <CancellationToken>()), Times.Exactly(1));
target.Protected().As <IModbusTransportMock>()
.Verify(x => x.ReadResponseAsync <WriteMultipleCoilsResponse>(It.IsAny <CancellationToken>()), Times.Exactly(2));
target.Protected().As <IModbusTransportMock>()
.Verify(x => x.RetryReadResponse(request, It.IsAny <IModbusResponse>()), Times.Exactly(2));
target.Protected().As <IModbusTransportMock>()
.Verify(x => x.Validate(request, response), Times.Once());
}
internal static WriteMultipleCoilsResponse WriteMultipleCoils(WriteMultipleCoilsRequest request, ModbusDataCollection<bool> dataSource)
{
DataStore.WriteData(request.Data, dataSource, request.StartAddress);
WriteMultipleCoilsResponse response = new WriteMultipleCoilsResponse(request.SlaveAddress, request.StartAddress, request.NumberOfPoints);
return response;
}
public void CreateWriteMultipleCoilsRequestMaxSize()
{
WriteMultipleCoilsRequest request = new WriteMultipleCoilsRequest(1, 2,
MessageUtility.CreateDefaultCollection <DiscreteCollection, bool>(true, Modbus.MaximumDiscreteRequestResponseSize));
Assert.Equal(Modbus.MaximumDiscreteRequestResponseSize, request.Data.Count);
}
internal static WriteMultipleCoilsResponse WriteMultipleCoils(WriteMultipleCoilsRequest request, DataStore dataStore, ModbusDataCollection <bool> dataSource)
{
DataStore.WriteData(dataStore, request.Data.Take(request.NumberOfPoints), dataSource, request.StartAddress, dataStore.SyncRoot);
WriteMultipleCoilsResponse response = new WriteMultipleCoilsResponse(request.SlaveAddress, request.StartAddress, request.NumberOfPoints);
return(response);
}
public void ToString_WriteMultipleCoilsRequest()
{
DiscreteCollection col = new DiscreteCollection(true, false, true, false, true, true, true, false, false);
WriteMultipleCoilsRequest request = new WriteMultipleCoilsRequest(34, 45, col);
Assert.AreEqual("Write 9 coils starting at address 45.", request.ToString());
}
public void ToString_WriteMultipleCoilsRequest()
{
DiscreteCollection col = new DiscreteCollection(true, false, true, false, true, true, true, false, false);
WriteMultipleCoilsRequest request = new WriteMultipleCoilsRequest(34, 45, col);
Assert.Equal("Write 9 coils starting at address 45.", request.ToString());
}
/// <summary>
/// Force each coil in a sequence of coils to a provided value.
/// </summary>
/// <param name="slaveAddress">Address of the device to write to.</param>
/// <param name="startAddress">Address to begin writing values.</param>
/// <param name="data">Values to write.</param>
public void WriteMultipleCoils(byte slaveAddress, ushort startAddress, bool[] data)
{
ValidateData("data", data, 1968);
WriteMultipleCoilsRequest request = new WriteMultipleCoilsRequest(slaveAddress, startAddress, new DiscreteCollection(data));
Transport.UnicastMessage <WriteMultipleCoilsResponse>(request);
}
public void CreateModbusMessageWriteMultipleCoilsRequestWithInvalidFrameSize()
{
WriteMultipleCoilsRequest request =
ModbusMessageFactory.CreateModbusMessage <WriteMultipleCoilsRequest>(new byte[]
{ 17, Modbus.WriteMultipleCoils, 0, 19, 0, 10, 2 });
Assert.Fail();
}
public void WriteMultipleCoilsRequestToString()
{
// Arrange
var request = new WriteMultipleCoilsRequest(34, 45, new bool[] { true, false, true, false, true, true, true, false, false });
// Act/Assert
Assert.Equal("Write 9 coils starting at address 45 into slave 34", request.ToString());
}
public Task WriteMultipleCoilsAsync(byte slaveAddress, ushort startAddress, bool[] data, CancellationToken token = default)
{
ValidateData(data, 1968);
var request = new WriteMultipleCoilsRequest(slaveAddress, startAddress, data);
return(Transport.SendAsync <WriteMultipleCoilsResponse>(request, token));
}
/// <summary>
/// Asynchronously writes a sequence of coils.
/// </summary>
/// <param name="slaveAddress">Address of the device to write to.</param>
/// <param name="startAddress">Address to begin writing values.</param>
/// <param name="data">Values to write.</param>
/// <returns>A task that represents the asynchronous write operation</returns>
public Task WriteMultipleCoilsAsync(byte slaveAddress, ushort startAddress, bool[] data)
{
ValidateData("data", data, 1968);
var request = new WriteMultipleCoilsRequest(slaveAddress, startAddress, new DiscreteCollection(data));
return(PerformWriteRequestAsync <WriteMultipleCoilsResponse>(request));
}
internal static WriteMultipleCoilsResponse WriteMultipleCoils(WriteMultipleCoilsRequest request,
DataStore dataStore, ModbusDataCollection<bool> dataSource)
{
DataStore.WriteData(dataStore, request.Data.Take(request.NumberOfPoints), dataSource, request.StartAddress,
dataStore.SyncRoot);
var response = new WriteMultipleCoilsResponse(request.SlaveAddress, request.StartAddress, request.NumberOfPoints);
return response;
}
public void WriteMultipCoils_MakeSureWeDoNotWriteRemainder()
{
// 0, false initialized data store
var dataStore = DataStoreFactory.CreateDefaultDataStore();
var request = new WriteMultipleCoilsRequest(1, 0, new DiscreteCollection(Enumerable.Repeat(true, 8).ToArray())) { NumberOfPoints = 2 };
ModbusSlave.WriteMultipleCoils(request, dataStore, dataStore.CoilDiscretes);
Assert.AreEqual(dataStore.CoilDiscretes.Slice(1, 8).ToArray(), new [] { true, true, false, false, false, false, false, false });
}
public void CreateModbusMessageWriteMultipleCoilsRequest()
{
WriteMultipleCoilsRequest request = ModbusMessageFactory.CreateModbusMessage <WriteMultipleCoilsRequest>(new byte[] { 17, Modbus.WriteMultipleCoils, 0, 19, 0, 10, 2, 205, 1 });
WriteMultipleCoilsRequest expectedRequest = new WriteMultipleCoilsRequest(17, 19, new DiscreteCollection(true, false, true, true, false, false, true, true, true, false));
AssertModbusMessagePropertiesAreEqual(expectedRequest, request);
Assert.AreEqual(expectedRequest.StartAddress, request.StartAddress);
Assert.AreEqual(expectedRequest.NumberOfPoints, request.NumberOfPoints);
Assert.AreEqual(expectedRequest.ByteCount, request.ByteCount);
Assert.AreEqual(expectedRequest.Data.NetworkBytes, request.Data.NetworkBytes);
}
public void CreateWriteMultipleCoilsRequest()
{
DiscreteCollection col = new DiscreteCollection(true, false, true, false, true, true, true, false, false);
WriteMultipleCoilsRequest request = new WriteMultipleCoilsRequest(34, 45, col);
Assert.Equal(Modbus.WriteMultipleCoils, request.FunctionCode);
Assert.Equal(34, request.SlaveAddress);
Assert.Equal(45, request.StartAddress);
Assert.Equal(9, request.NumberOfPoints);
Assert.Equal(2, request.ByteCount);
Assert.Equal(col.NetworkBytes, request.Data.NetworkBytes);
}
public byte[] BuildWriteMultipleCoilsCommand(byte slaveAddress, ushort startAddress, bool[] data, out IModbusMessage request)
{
ValidateData("data", data, 1968);
request = new WriteMultipleCoilsRequest(
slaveAddress,
startAddress,
new DiscreteCollection(data));
return(Transport.BuildMessageFrame(request));
}
public void CreateWriteMultipleCoilsRequest()
{
DiscreteCollection col = new DiscreteCollection(true, false, true, false, true, true, true, false, false);
WriteMultipleCoilsRequest request = new WriteMultipleCoilsRequest(34, 45, col);
Assert.AreEqual(Modbus.WriteMultipleCoils, request.FunctionCode);
Assert.AreEqual(34, request.SlaveAddress);
Assert.AreEqual(45, request.StartAddress);
Assert.AreEqual(9, request.NumberOfPoints);
Assert.AreEqual(2, request.ByteCount);
Assert.AreEqual(col.NetworkBytes, request.Data.NetworkBytes);
}
public void WriteMultipCoils_MakeSureWeDoNotWriteRemainder()
{
// 0, false initialized data store
var dataStore = DataStoreFactory.CreateDefaultDataStore();
var request = new WriteMultipleCoilsRequest(1, 0, new DiscreteCollection(Enumerable.Repeat(true, 8).ToArray()))
{
NumberOfPoints = 2
};
ModbusSlave.WriteMultipleCoils(request, dataStore, dataStore.CoilDiscretes);
Assert.AreEqual(dataStore.CoilDiscretes.Slice(1, 8).ToArray(), new [] { true, true, false, false, false, false, false, false });
}
public WriteMultipleCoilsResponse WriteMultipleCoils(ushort startingAddress, bool[] states)
{
var function = new WriteMultipleCoilsRequest(startingAddress, states);
return(CallModbusFunctionSync <WriteMultipleCoilsResponse>(function));
}
public ushort WriteMultipleCoilsAsync(ushort startingAddress, bool[] states)
{
var function = new WriteMultipleCoilsRequest(startingAddress, states);
return(CallModbusFunction(function));
}
public override ModbusFunction WriteMultipleCoils(WriteMultipleCoilsRequest request)
{
var response = new WriteMultipleCoilsResponse(request.StartingAddress, request.Quantity);
return(response);
}
public abstract ModbusFunction WriteMultipleCoils(WriteMultipleCoilsRequest request);
public void CreateModbusMessageWriteMultipleCoilsRequest()
{
WriteMultipleCoilsRequest request =
ModbusMessageFactory.CreateModbusMessage<WriteMultipleCoilsRequest>(new byte[]
{17, Modbus.WriteMultipleCoils, 0, 19, 0, 10, 2, 205, 1});
WriteMultipleCoilsRequest expectedRequest = new WriteMultipleCoilsRequest(17, 19,
new DiscreteCollection(true, false, true, true, false, false, true, true, true, false));
AssertModbusMessagePropertiesAreEqual(expectedRequest, request);
Assert.AreEqual(expectedRequest.StartAddress, request.StartAddress);
Assert.AreEqual(expectedRequest.NumberOfPoints, request.NumberOfPoints);
Assert.AreEqual(expectedRequest.ByteCount, request.ByteCount);
Assert.AreEqual(expectedRequest.Data.NetworkBytes, request.Data.NetworkBytes);
}
static void TestMessage()
{
ModbusMessage fc01Req = new ReadCoilsRequest(0x13, 0x13);
ModbusMessage fc01Res = new ReadCoilsResponse(true, false, true, true, false, false, true, true, true, true, false, true, false, true, true, false, true, false, true, false);
ModbusMessage fc02Req = new ReadDiscreteInputsRequest(0xc4, 0x16);
ModbusMessage fc02Res = new ReadDiscreteInputsResponse(false, false, true, true, false, true, false, true, true, true, false, true, true, false, true, true, true, false, true, false, true, true);
ModbusMessage fc03Req = new ReadHoldingRegistersRequest(0x6b, 0x03);
ModbusMessage fc03Res = new ReadHoldingRegistersResponse(0x022b, 0x0000, 0x0064);
ModbusMessage fc04Req = new ReadInputRegistersRequest(0x08, 0x01);
ModbusMessage fc04Res = new ReadInputRegistersResponse(0x000a);
ModbusMessage fc05Req = new WriteSingleCoilRequest(0xac, true);
ModbusMessage fc05Res = new WriteSingleCoilResponse(0xac, true);
ModbusMessage fc06Req = new WriteSingleRegisterRequest(0x01, 0x0003);
ModbusMessage fc06Res = new WriteSingleRegisterResponse(0x01, 0x0003);
ModbusMessage fc0fReq = new WriteMultipleCoilsRequest(0x13, true, false, true, true, false, false, true, true, true, false);
ModbusMessage fc0fRes = new WriteMultipleCoilsResponse(0x13, 0x0a);
ModbusMessage fc10Req = new WriteMultipleRegistersRequest(0x01, 0x000a, 0x0102);
ModbusMessage fc10Res = new WriteMultipleRegistersResponse(0x01, 0x02);
PrintMessagePDU(fc01Req);
PrintMessagePDU(fc01Res);
PrintMessagePDU(fc02Req);
PrintMessagePDU(fc02Res);
PrintMessagePDU(fc03Req);
PrintMessagePDU(fc03Res);
PrintMessagePDU(fc04Req);
PrintMessagePDU(fc04Res);
PrintMessagePDU(fc05Req);
PrintMessagePDU(fc05Res);
PrintMessagePDU(fc06Req);
PrintMessagePDU(fc06Res);
PrintMessagePDU(fc0fReq);
PrintMessagePDU(fc0fRes);
PrintMessagePDU(fc10Req);
PrintMessagePDU(fc10Res);
Assert(MessagePDU(fc01Req) == "Req.: 01 00 13 00 13", $"{nameof(fc01Req)} Fail");
Assert(MessagePDU(fc01Res) == "Res.: 01 03 cd 6b 05", $"{nameof(fc01Res)} Fail");
Assert(MessagePDU(fc02Req) == "Req.: 02 00 c4 00 16", $"{nameof(fc02Req)} Fail");
Assert(MessagePDU(fc02Res) == "Res.: 02 03 ac db 35", $"{nameof(fc02Res)} Fail");
Assert(MessagePDU(fc03Req) == "Req.: 03 00 6b 00 03", $"{nameof(fc03Req)} Fail");
Assert(MessagePDU(fc03Res) == "Res.: 03 06 02 2b 00 00 00 64", $"{nameof(fc03Res)} Fail");
Assert(MessagePDU(fc04Req) == "Req.: 04 00 08 00 01", $"{nameof(fc04Req)} Fail");
Assert(MessagePDU(fc04Res) == "Res.: 04 02 00 0a", $"{nameof(fc04Res)} Fail");
Assert(MessagePDU(fc05Req) == "Req.: 05 00 ac ff 00", $"{nameof(fc05Req)} Fail");
Assert(MessagePDU(fc05Res) == "Res.: 05 00 ac ff 00", $"{nameof(fc05Res)} Fail");
Assert(MessagePDU(fc06Req) == "Req.: 06 00 01 00 03", $"{nameof(fc06Req)} Fail");
Assert(MessagePDU(fc06Res) == "Res.: 06 00 01 00 03", $"{nameof(fc06Res)} Fail");
Assert(MessagePDU(fc0fReq) == "Req.: 0f 00 13 00 0a 02 cd 01", $"{nameof(fc0fReq)} Fail");
Assert(MessagePDU(fc0fRes) == "Res.: 0f 00 13 00 0a", $"{nameof(fc0fRes)} Fail");
Assert(MessagePDU(fc10Req) == "Req.: 10 00 01 00 02 04 00 0a 01 02", $"{nameof(fc10Req)} Fail");
Assert(MessagePDU(fc10Res) == "Res.: 10 00 01 00 02", $"{nameof(fc10Res)} Fail");
Assert(fc01Req.FunctionCode == (FunctionCode)0x01);
Assert(fc01Res.FunctionCode == (FunctionCode)0x01);
Assert(fc02Req.FunctionCode == (FunctionCode)0x02);
Assert(fc02Res.FunctionCode == (FunctionCode)0x02);
Assert(fc03Req.FunctionCode == (FunctionCode)0x03);
Assert(fc03Res.FunctionCode == (FunctionCode)0x03);
Assert(fc04Req.FunctionCode == (FunctionCode)0x04);
Assert(fc04Res.FunctionCode == (FunctionCode)0x04);
Assert(fc05Req.FunctionCode == (FunctionCode)0x05);
Assert(fc05Res.FunctionCode == (FunctionCode)0x05);
Assert(fc06Req.FunctionCode == (FunctionCode)0x06);
Assert(fc06Res.FunctionCode == (FunctionCode)0x06);
Assert(fc0fReq.FunctionCode == (FunctionCode)0x0f);
Assert(fc0fRes.FunctionCode == (FunctionCode)0x0f);
Assert(fc10Req.FunctionCode == (FunctionCode)0x10);
Assert(fc10Res.FunctionCode == (FunctionCode)0x10);
}
