/// <summary> /// Write a 32 bit value. /// </summary> public static void ReadWrite32BitValue() { using (SerialPort port = new SerialPort("COM1")) { // configure serial port port.BaudRate = 9600; port.DataBits = 8; port.Parity = Parity.None; port.StopBits = StopBits.One; port.Open(); // create modbus master ModbusSerialMaster master = ModbusSerialMaster.CreateRtu(port); byte slaveId = 1; ushort startAddress = 1008; uint largeValue = UInt16.MaxValue + 5; ushort lowOrderValue = BitConverter.ToUInt16(BitConverter.GetBytes(largeValue), 0); ushort highOrderValue = BitConverter.ToUInt16(BitConverter.GetBytes(largeValue), 2); // write large value in two 16 bit chunks master.WriteMultipleRegisters(slaveId, startAddress, new ushort[] { lowOrderValue, highOrderValue }); // read large value in two 16 bit chunks and perform conversion ushort[] registers = master.ReadHoldingRegisters(slaveId, startAddress, 2); uint value = ModbusUtility.GetUInt32(registers[1], registers[0]); } }
public override bool ChecksumsMatch(IModbusMessage message, byte[] messageFrame) { ushort messageCrc = BitConverter.ToUInt16(messageFrame, messageFrame.Length - 2); ushort calculatedCrc = BitConverter.ToUInt16(ModbusUtility.CalculateCrc(message.MessageFrame), 0); return(messageCrc == calculatedCrc); }
public void GetUInt32() { Assert.Equal((uint)0, ModbusUtility.GetUInt32(0, 0)); Assert.Equal((uint)1, ModbusUtility.GetUInt32(0, 1)); Assert.Equal((uint)45, ModbusUtility.GetUInt32(0, 45)); Assert.Equal((uint)65536, ModbusUtility.GetUInt32(1, 0)); }
public void GetDouble() { Assert.Equal(0.0, ModbusUtility.GetDouble(0, 0, 0, 0)); Assert.Equal(1.0, ModbusUtility.GetDouble(16368, 0, 0, 0)); Assert.Equal(Math.PI, ModbusUtility.GetDouble(16393, 8699, 21572, 11544)); Assert.Equal(500.625, ModbusUtility.GetDouble(16511, 18944, 0, 0)); }
public void CalculateLrc2() { //: 02 01 0000 0001 FC ReadCoilsInputsRequest request = new ReadCoilsInputsRequest(Modbus.ReadCoils, 2, 0, 1); Assert.AreEqual(252, ModbusUtility.CalculateLrc(new byte[] { 2, 1, 0, 0, 0, 1 })); }
public void ReadResponseSlaveException() { var mock = new Mock <ModbusRtuTransport>(StreamResource) { CallBase = true }; var 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] }); var 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 GetSingle() { Assert.AreEqual(0F, ModbusUtility.GetSingle(0, 0)); Assert.AreEqual(1F, ModbusUtility.GetSingle(16256, 0)); Assert.AreEqual(9999999F, ModbusUtility.GetSingle(19224, 38527)); Assert.AreEqual(500.625F, ModbusUtility.GetSingle(17402, 20480)); }
public void GetUInt32() { Assert.AreEqual(0, ModbusUtility.GetUInt32(0, 0)); Assert.AreEqual(1, ModbusUtility.GetUInt32(0, 1)); Assert.AreEqual(45, ModbusUtility.GetUInt32(0, 45)); Assert.AreEqual(65536, ModbusUtility.GetUInt32(1, 0)); }
private float ReadFloatRegister(ushort startAddress) { CheckPort(); try { if (!port.IsOpen) { port.Open(); } IModbusSerialMaster master = ModbusSerialMaster.CreateAscii(port); //master.Transport.ReadTimeout = timeout; ushort[] registers = master.ReadHoldingRegisters(slaveId, startAddress, 2); return (ModbusUtility.GetSingle(registers[1], registers[0])); } catch (TimeoutException) { timerGraphUpdate.Stop(); MessageBox.Show("Порт не отвечает"); return(0); } catch (Exception ex) { timerGraphUpdate.Stop(); MessageBox.Show(ex.Message); return(0); } }
public void GetAsciiBytesFromBytes() { byte[] buf = { 2, 5 }; byte[] expectedResult = { 48, 50, 48, 53 }; byte[] result = ModbusUtility.GetAsciiBytes(buf); Assert.AreEqual(expectedResult, result); }
public float[] ReadFloatValues(byte slaveId, ushort register, int count) { if (IsActive) { try { var numInputs = (ushort)(count * 2); var inputs = Connection.ReadInputRegisters(slaveId, register, numInputs); var result = new float[count]; for (var i = 0; i < count; i++) { var index = i * 2; result[i] = ModbusUtility.GetSingle(inputs[index + 1], inputs[index]); } return(result); } catch (Exception ex) { // Connection exception // No response from server // The server maybe close the connection or response timeout if (ex.Source.Equals("System")) { IsActive = false; } // The server return error code. You can get the function code and exception code. //if(ex.Source.Equals("nModbusPC")) { } } } return(null); }
public void GetAsciiBytesFromUshorts() { ushort[] buf = { 300, 400 }; byte[] expectedResult = { 48, 49, 50, 67, 48, 49, 57, 48 }; byte[] result = ModbusUtility.GetAsciiBytes(buf); Assert.AreEqual(expectedResult, result); }
internal override bool ChecksumsMatch(IModbusMessage message, byte[] messageFrame) { var messInt = BitConverter.ToUInt16(messageFrame, messageFrame.Length - 2); var frameInt = BitConverter.ToUInt16(ModbusUtility.CalculateCrc(message.MessageFrame), 0); return(messInt == frameInt); }
/// <summary> /// Sets the crc of the message. /// </summary> /// <param name="message"></param> public static void SetCrc(this byte[] message) { var messageFrame = message.Take(message.Length - 2).ToArray(); var crc = ModbusUtility.CalculateCrc(messageFrame); message[message.Length - 2] = crc[0]; message[message.Length - 1] = crc[1]; }
/// <summary> /// Convert the 16 bit registers to 32 bit registers. /// </summary> internal static IEnumerable <uint> Convert(ushort[] registers) { for (int i = 0; i < registers.Length; i++) { yield return(ModbusUtility.GetUInt32(registers[i + 1], registers[i])); i++; } }
public float[] ReadAnalogs(byte slaveId, ushort address, ushort Count) { float[] retValue = new float[Count]; for (ushort i = 0; i < Count; i++) { ushort[] registers = master.ReadInputRegisters(slaveId, address, 2); retValue[i] = ModbusUtility.GetSingle(registers[1], registers[0]); } return(retValue); }
public byte[] getCRC(byte[] arr) { byte[] crc = ModbusUtility.CalculateCrc(arr); byte[] numArray = new byte[8]; for (int index = 0; index < 8; ++index) { numArray[index] = index >= 6 ? crc[index - 6] : arr[index]; } return(numArray); }
private bool ValidateCrc(byte[] buf) { var datalength = (int)(buf[2]); var databuf = new byte[buf.Length - 2]; Buffer.BlockCopy(buf, 0, databuf, 0, databuf.Length); var crc = ModbusUtility.CalculateCrc(databuf); return(crc[0] == buf[datalength + 3] && crc[1] == buf[datalength + 3 + 1]); }
public void CreateResponse() { ModbusAsciiTransport transport = new ModbusAsciiTransport(MockRepository.GenerateStub <IStreamResource>()); ReadCoilsInputsResponse expectedResponse = new ReadCoilsInputsResponse(Modbus.ReadCoils, 2, 1, new DiscreteCollection(true, false, false, false, false, false, false, true)); byte lrc = ModbusUtility.CalculateLrc(expectedResponse.MessageFrame); ReadCoilsInputsResponse response = transport.CreateResponse <ReadCoilsInputsResponse>(new byte[] { 2, Modbus.ReadCoils, 1, 129, lrc }) as ReadCoilsInputsResponse; Assert.IsNotNull(response); AssertModbusMessagePropertiesAreEqual(expectedResponse, response); }
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); }
internal override byte[] BuildMessageFrame(IModbusMessage message) { List <byte> messageBody = new List <byte>(); messageBody.Add(message.SlaveAddress); messageBody.AddRange(message.ProtocolDataUnit); messageBody.AddRange(ModbusUtility.CalculateCrc(message.MessageFrame)); return(messageBody.ToArray()); }
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 byte[] BuildModbusReadBytes() { List <Byte> readBytes = new List <byte>(); readBytes.Add((byte)DevAddress); readBytes.Add(Convert.ToByte(Code)); readBytes.AddRange(BitConverter.GetBytes(StartRegister)); readBytes.AddRange(BitConverter.GetBytes(RegisterNum)); readBytes.AddRange(ModbusUtility.CalculateCrc(readBytes.ToArray()));//加入校验码 return(readBytes.ToArray()); }
public void CreateResponse_SlaveException() { Mock <ModbusTransport>?mock = new() { CallBase = true }; ModbusTransport? transport = mock.Object; byte[] frame = { 2, 129, 2 }; byte lrc = ModbusUtility.CalculateLrc(frame); IModbusMessage?message = transport.CreateResponse <ReadCoilsInputsResponse>(Enumerable.Concat(frame, new byte[] { lrc }).ToArray()); Assert.IsType <SlaveExceptionResponse>(message); }
public void CreateResponse_SlaveException() { ModbusTransport transport = new ModbusAsciiTransport(MockRepository.GenerateStub <IStreamResource>()); byte[] frame = { 2, 129, 2 }; IModbusMessage message = transport.CreateResponse <ReadCoilsInputsResponse>( Enumerable.Concat(frame, SequenceUtility.ToSequence(ModbusUtility.CalculateLrc(frame))).ToArray()); Assert.IsTrue(message is SlaveExceptionResponse); }
internal override byte[] BuildMessageFrame(IModbusMessage message) { var messageFrame = message.MessageFrame; var crc = ModbusUtility.CalculateCrc(messageFrame); var messageBody = new MemoryStream(messageFrame.Length + crc.Length); messageBody.Write(messageFrame, 0, messageFrame.Length); messageBody.Write(crc, 0, crc.Length); return(messageBody.ToArray()); }
public override byte[] BuildMessageFrame(IModbusMessage message) { byte[] pdu = message.MessageFrame; byte[] crc = ModbusUtility.CalculateCrc(message.MessageFrame); var messageBody = new MemoryStream(pdu.Length + crc.Length); messageBody.Write(pdu, 0, pdu.Length); messageBody.Write(crc, 0, crc.Length); return(messageBody.ToArray()); }
internal override byte[] BuildMessageFrame(IModbusMessage message) { List <byte> frame = new List <byte>(); frame.Add((byte)':'); frame.AddRange(ModbusUtility.GetAsciiBytes(message.SlaveAddress)); frame.AddRange(ModbusUtility.GetAsciiBytes(message.ProtocolDataUnit)); frame.AddRange(ModbusUtility.GetAsciiBytes(ModbusUtility.CalculateLrc(message.MessageFrame))); frame.AddRange(Encoding.ASCII.GetBytes(Environment.NewLine.ToCharArray())); return(frame.ToArray()); }
/// <summary> /// Write a 32 bit value. /// </summary> public async void ReadWriteSerial32BitValue() { using (SerialDevice device = await SerialDevice.FromIdAsync("device_id")) { // configure serial port device.BaudRate = 9600; device.DataBits = 8; device.Parity = SerialParity.Even; device.StopBits = SerialStopBitCount.One; var adapter = new SerialPortAdapter(device); // create modbus master ModbusSerialMaster master = ModbusSerialMaster.CreateRtu(adapter); byte slaveId = 1; ushort startAddress = 1008; uint largeValue = UInt16.MaxValue + 5; ushort lowOrderValue = BitConverter.ToUInt16(BitConverter.GetBytes(largeValue), 0); ushort highOrderValue = BitConverter.ToUInt16(BitConverter.GetBytes(largeValue), 2); // write large value in two 16 bit chunks master.WriteMultipleRegisters(slaveId, startAddress, new ushort[] { lowOrderValue, highOrderValue }); // read large value in two 16 bit chunks and perform conversion ushort[] registers = master.ReadHoldingRegisters(slaveId, startAddress, 2); uint value = ModbusUtility.GetUInt32(registers[1], registers[0]); } }
/// <summary> /// Determines whether the crc stored in the message matches the calculated crc. /// </summary> /// <param name="message"></param> /// <returns></returns> public static bool DoesCrcMatch(this byte[] message) { var messageFrame = message.Take(message.Length - 2).ToArray(); //Calculate the CRC with the given set of bytes var calculatedCrc = BitConverter.ToUInt16(ModbusUtility.CalculateCrc(messageFrame), 0); //Get the crc that is stored in the message var messageCrc = message.GetCRC(); //Determine if they match return(calculatedCrc == messageCrc); }