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); }