public void CreateModbusMessageReadWriteMultipleRegistersRequestWithInvalidFrameSize()
{
byte[] frame = { 17, Modbus.ReadWriteMultipleRegisters, 1, 2, 3 };
ReadWriteMultipleRegistersRequest request = ModbusMessageFactory.CreateModbusMessage <ReadWriteMultipleRegistersRequest>(frame);
Assert.Fail();
}
private ushort[] PerformReadRegisters(ReadWriteMultipleRegistersRequest request)
{
ReadHoldingInputRegistersResponse response =
Transport.UnicastMessage <ReadHoldingInputRegistersResponse>(request);
return(response.Data.Take(request.ReadRequest.NumberOfPoints).ToArray());
}
public void ToString_ReadWriteMultipleRegistersRequest()
{
RegisterCollection writeCollection = new RegisterCollection(255, 255, 255);
ReadWriteMultipleRegistersRequest request = new ReadWriteMultipleRegistersRequest(5, 3, 6, 14, writeCollection);
Assert.AreEqual("Write 3 holding registers starting at address 14, and read 6 registers starting at address 3.", request.ToString());
}
/// <summary>
/// Performs a combination of one read operation and one write operation in a single Modbus transaction.
/// The write operation is performed before the read.
/// </summary>
/// <param name="slaveAddress">Address of device to read values from.</param>
/// <param name="startReadAddress">Address to begin reading (Holding registers are addressed starting at 0).</param>
/// <param name="numberOfPointsToRead">Number of registers to read.</param>
/// <param name="startWriteAddress">Address to begin writing (Holding registers are addressed starting at 0).</param>
/// <param name="writeData">Register values to write.</param>
public ushort[] ReadWriteMultipleRegisters(byte slaveAddress, ushort startReadAddress, ushort numberOfPointsToRead, ushort startWriteAddress, ushort[] writeData)
{
ReadWriteMultipleRegistersRequest request = new ReadWriteMultipleRegistersRequest(slaveAddress, startReadAddress, numberOfPointsToRead, startWriteAddress, new RegisterCollection(writeData));
ReadHoldingInputRegistersResponse response = Transport.UnicastMessage <ReadHoldingInputRegistersResponse>(request);
return(CollectionUtility.ToArray(response.Data));
}
internal IModbusMessage ApplyRequest(IModbusMessage request)
{
Log.Info(request.ToString());
ModbusSlaveRequestReceived.Raise(this, new ModbusSlaveRequestEventArgs(request));
IModbusMessage response;
switch (request.FunctionCode)
{
case Modbus.ReadCoils:
response = ReadDiscretes((ReadCoilsInputsRequest)request, DataStore, DataStore.CoilDiscretes);
break;
case Modbus.ReadInputs:
response = ReadDiscretes((ReadCoilsInputsRequest)request, DataStore, DataStore.InputDiscretes);
break;
case Modbus.ReadHoldingRegisters:
response = ReadRegisters((ReadHoldingInputRegistersRequest)request, DataStore, DataStore.HoldingRegisters);
break;
case Modbus.ReadInputRegisters:
response = ReadRegisters((ReadHoldingInputRegistersRequest)request, DataStore, DataStore.InputRegisters);
break;
case Modbus.Diagnostics:
response = request;
break;
case Modbus.WriteSingleCoil:
response = WriteSingleCoil((WriteSingleCoilRequestResponse)request, DataStore, DataStore.CoilDiscretes);
break;
case Modbus.WriteSingleRegister:
response = WriteSingleRegister((WriteSingleRegisterRequestResponse)request, DataStore, DataStore.HoldingRegisters);
break;
case Modbus.WriteMultipleCoils:
response = WriteMultipleCoils((WriteMultipleCoilsRequest)request, DataStore, DataStore.CoilDiscretes);
break;
case Modbus.WriteMultipleRegisters:
response = WriteMultipleRegisters((WriteMultipleRegistersRequest)request, DataStore, DataStore.HoldingRegisters);
break;
case Modbus.ReadWriteMultipleRegisters:
ReadWriteMultipleRegistersRequest readWriteRequest = (ReadWriteMultipleRegistersRequest)request;
response = ReadRegisters(readWriteRequest.ReadRequest, DataStore, DataStore.HoldingRegisters);
WriteMultipleRegisters(readWriteRequest.WriteRequest, DataStore, DataStore.HoldingRegisters);
break;
default:
string errorMessage = String.Format(CultureInfo.InvariantCulture, "Unsupported function code {0}", request.FunctionCode);
Log.Error(errorMessage);
throw new ArgumentException(errorMessage, "request");
}
return(response);
}
public void ProtocolDataUnit()
{
RegisterCollection writeCollection = new RegisterCollection(255, 255, 255);
ReadWriteMultipleRegistersRequest request = new ReadWriteMultipleRegistersRequest(5, 3, 6, 14, writeCollection);
byte[] pdu = { 0x17, 0x00, 0x03, 0x00, 0x06, 0x00, 0x0e, 0x00, 0x03, 0x06, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff };
Assert.AreEqual(pdu, request.ProtocolDataUnit);
}
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 RegisterCollection(255, 255, 255);
ReadWriteMultipleRegistersRequest expectedRequest = new ReadWriteMultipleRegistersRequest(5, 3, 6, 14, writeCollection);
AssertModbusMessagePropertiesAreEqual(expectedRequest, request);
}
/// <summary>
/// Performs a combination of one read operation and one write operation in a single Modbus transaction.
/// The write operation is performed before the read.
/// </summary>
/// <param name="slaveAddress">Address of device to read values from.</param>
/// <param name="startReadAddress">Address to begin reading (Holding registers are addressed starting at 0).</param>
/// <param name="numberOfPointsToRead">Number of registers to read.</param>
/// <param name="startWriteAddress">Address to begin writing (Holding registers are addressed starting at 0).</param>
/// <param name="writeData">Register values to write.</param>
public ushort[] ReadWriteMultipleRegisters(byte slaveAddress, ushort startReadAddress, ushort numberOfPointsToRead, ushort startWriteAddress, ushort[] writeData)
{
ValidateNumberOfPoints("numberOfPointsToRead", numberOfPointsToRead, 125);
ValidateData("writeData", writeData, 121);
ReadWriteMultipleRegistersRequest request = new ReadWriteMultipleRegistersRequest(slaveAddress, startReadAddress, numberOfPointsToRead, startWriteAddress, new RegisterCollection(writeData));
ReadHoldingInputRegistersResponse response = Transport.UnicastMessage <ReadHoldingInputRegistersResponse>(request);
return(response.Data.ToArray());
}
/// <summary>
/// Asynchronously performs a combination of one read operation and one write operation in a single Modbus transaction.
/// The write operation is performed before the read.
/// </summary>
/// <param name="slaveAddress">Address of device to read values from.</param>
/// <param name="startReadAddress">Address to begin reading (Holding registers are addressed starting at 0).</param>
/// <param name="numberOfPointsToRead">Number of registers to read.</param>
/// <param name="startWriteAddress">Address to begin writing (Holding registers are addressed starting at 0).</param>
/// <param name="writeData">Register values to write.</param>
/// <returns>A task that represents the asynchronous operation</returns>
public Task <short[]> ReadWriteMultipleRegistersAsync(byte slaveAddress, ushort startReadAddress,
ushort numberOfPointsToRead, ushort startWriteAddress, short[] writeData)
{
ValidateNumberOfPoints("numberOfPointsToRead", numberOfPointsToRead, 125);
ValidateData("writeData", writeData, 121);
var request = new ReadWriteMultipleRegistersRequest(
slaveAddress,
startReadAddress,
numberOfPointsToRead,
startWriteAddress,
new RegisterCollection(writeData));
return(PerformReadRegistersAsync(request));
}
public void ReadWriteMultipleRegistersRequest()
{
RegisterCollection writeCollection = new RegisterCollection(255, 255, 255);
ReadWriteMultipleRegistersRequest request = new ReadWriteMultipleRegistersRequest(5, 3, 6, 14, writeCollection);
Assert.AreEqual(Modbus.ReadWriteMultipleRegisters, request.FunctionCode);
Assert.AreEqual(5, request.SlaveAddress);
// test read
Assert.IsNotNull(request.ReadRequest);
Assert.AreEqual(request.SlaveAddress, request.ReadRequest.SlaveAddress);
Assert.AreEqual(3, request.ReadRequest.StartAddress);
Assert.AreEqual(6, request.ReadRequest.NumberOfPoints);
// test write
Assert.IsNotNull(request.WriteRequest);
Assert.AreEqual(request.SlaveAddress, request.WriteRequest.SlaveAddress);
Assert.AreEqual(14, request.WriteRequest.StartAddress);
Assert.AreEqual(writeCollection.NetworkBytes, request.WriteRequest.Data.NetworkBytes);
}
private Task <ushort[]> PerformReadRegistersAsync(ReadWriteMultipleRegistersRequest request)
{
return(Task.Factory.StartNew(() => PerformReadRegisters(request)));
}
internal IModbusMessage ApplyRequest(IModbusMessage request)
{
IModbusMessage response;
try
{
Debug.WriteLine(request.ToString());
var eventArgs = new ModbusSlaveRequestEventArgs(request);
ModbusSlaveRequestReceived?.Invoke(this, eventArgs);
switch (request.FunctionCode)
{
case Modbus.ReadCoils:
response = ReadDiscretes(
(ReadCoilsInputsRequest)request,
DataStore,
DataStore.CoilDiscretes);
break;
case Modbus.ReadInputs:
response = ReadDiscretes(
(ReadCoilsInputsRequest)request,
DataStore,
DataStore.InputDiscretes);
break;
case Modbus.ReadHoldingRegisters:
response = ReadRegisters(
(ReadHoldingInputRegistersRequest)request,
DataStore,
DataStore.HoldingRegisters);
break;
case Modbus.ReadInputRegisters:
response = ReadRegisters(
(ReadHoldingInputRegistersRequest)request,
DataStore,
DataStore.InputRegisters);
break;
case Modbus.Diagnostics:
response = request;
break;
case Modbus.WriteSingleCoil:
response = WriteSingleCoil(
(WriteSingleCoilRequestResponse)request,
DataStore,
DataStore.CoilDiscretes);
WriteComplete?.Invoke(this, eventArgs);
break;
case Modbus.WriteSingleRegister:
response = WriteSingleRegister(
(WriteSingleRegisterRequestResponse)request,
DataStore,
DataStore.HoldingRegisters);
WriteComplete?.Invoke(this, eventArgs);
break;
case Modbus.WriteMultipleCoils:
response = WriteMultipleCoils(
(WriteMultipleCoilsRequest)request,
DataStore,
DataStore.CoilDiscretes);
WriteComplete?.Invoke(this, eventArgs);
break;
case Modbus.WriteMultipleRegisters:
response = WriteMultipleRegisters(
(WriteMultipleRegistersRequest)request,
DataStore,
DataStore.HoldingRegisters);
WriteComplete?.Invoke(this, eventArgs);
break;
case Modbus.ReadWriteMultipleRegisters:
ReadWriteMultipleRegistersRequest readWriteRequest = (ReadWriteMultipleRegistersRequest)request;
WriteMultipleRegisters(
readWriteRequest.WriteRequest,
DataStore,
DataStore.HoldingRegisters);
WriteComplete?.Invoke(this, eventArgs);
response = ReadRegisters(
readWriteRequest.ReadRequest,
DataStore,
DataStore.HoldingRegisters);
break;
default:
string msg = $"Unsupported function code {request.FunctionCode}.";
Debug.WriteLine(msg);
throw new InvalidModbusRequestException(Modbus.IllegalFunction);
}
}
catch (InvalidModbusRequestException ex)
{
// Catches the exception for an illegal function or a custom exception from the ModbusSlaveRequestReceived event.
response = new SlaveExceptionResponse(
request.SlaveAddress,
(byte)(Modbus.ExceptionOffset + request.FunctionCode),
ex.ExceptionCode);
}
return(response);
}
