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