public void CrcTest()
{
Assert.AreEqual(
ModbusHelper.CRC16(new byte[] { 0, 0, 1, 1, 2, 3, 4, 5, 0, 0 }, 2, 6),
ModbusHelper.CRC16(new byte[] { 1, 1, 2, 3, 4, 5, 0, 0 }, 0, 6)
);
}
public void DecodeBoolsTest()
{
Assert.AreEqual(bo(), ModbusHelper.DecodeBools(by(0x00), 1, 0));
Assert.AreEqual(bo(true, false, true), ModbusHelper.DecodeBools(by(0x00, 0x05), 1, 3));
Assert.AreEqual(bo(true, false, true, false, false, false, false, false, false, true),
ModbusHelper.DecodeBools(by(0x00, 0x05, 0x02), 1, 10));
}
public static IModbusCommand Parse(byte[] request, int offset)
{
var slave = request[offset + 0];
var code = request[offset + 1];
var address = ModbusHelper.GetUShort(request, offset + 2);
switch (code)
{
case 1:
return(Parse01(slave, code, address, request, offset));
case 2:
return(Parse02(slave, code, address, request, offset));
case 3:
return(Parse03(slave, code, address, request, offset));
case 4:
return(Parse04(slave, code, address, request, offset));
case 5:
return(Parse05(slave, code, address, request, offset));
case 6:
return(Parse06(slave, code, address, request, offset));
case 15:
return(Parse15(slave, code, address, request, offset));
case 16:
return(Parse16(slave, code, address, request, offset));
}
throw Thrower.Make("Unsupported function code {0}", code);
}
/// <summary>
/// 调用读写函数前的校验，此过程包含了解析地址并缓存
/// </summary>
/// <param name="equipmentProps"></param>
/// <returns></returns>
private BllResult <List <string> > Validation(List <EquipmentProp> equipmentProps)
{
if (equipmentProps == null || equipmentProps.Count() == 0)
{
return(BllResultFactory.Error <List <string> >($"未传递属性"));
}
//选取设备类
var ips = equipmentProps.Select(t => t.Equipment).Select(t => t.IP).Distinct().ToList();
//是否存在没有对应的Modbus
var temp = ips.Where(t => !modbusTcpNets.Exists(a => a.IpAddress == t)).ToArray();
if (temp.Length > 0)
{
return(BllResultFactory.Error <List <string> >($"存在IP为{string.Join(",", temp)}没有对应的Modbus实例，请检查Modbus的IP配置"));
}
//缓存中未存在的属性
var tempProps = equipmentProps.Where(t => !_hslModbusDataEntities.Exists(a => a.AddressId == t.Id)).ToList();
//解析属性并加入缓存
foreach (var item in tempProps)
{
var result = ModbusHelper.ParseAddress(item);
if (!result.Success)
{
return(BllResultFactory.Error <List <string> >($"解析地址错误：{result.Msg}"));
}
_hslModbusDataEntities.Add(result.Data);
}
return(BllResultFactory.Sucess(ips));
}
public void EncodeBoolsTest()
{
Assert.AreEqual(by(), ModbusHelper.EncodeBools(bo()));
Assert.AreEqual(by(0x01), ModbusHelper.EncodeBools(bo(true)));
Assert.AreEqual(by(0x03), ModbusHelper.EncodeBools(bo(true, true)));
Assert.AreEqual(by(0x13), ModbusHelper.EncodeBools(bo(true, true, false, false, true)));
Assert.AreEqual(by(0x13, 0x05), ModbusHelper.EncodeBools(bo(true, true, false, false, true, false, false, false, true, false, true)));
}
public void FillRequest(byte[] request, int offset)
{
FillResponse(request, offset, null);
var bytes = ModbusHelper.EncodeBools(values);
request[offset + 6] = (byte)bytes.Length;
ModbusHelper.Copy(bytes, 0, request, offset + 7, bytes.Length);
}
public void FillResponse(byte[] response, int offset, object value)
{
Wrapped.FillResponse(response, offset, value);
var crc = ModbusHelper.CRC16(response, offset, Wrapped.ResponseLength);
response[offset + Wrapped.ResponseLength + 0] = ModbusHelper.Low(crc);
response[offset + Wrapped.ResponseLength + 1] = ModbusHelper.High(crc);
}
public void FillRequest(byte[] request, int offset)
{
Wrapped.FillRequest(request, offset);
var crc = ModbusHelper.CRC16(request, offset, Wrapped.RequestLength);
request[offset + Wrapped.RequestLength + 0] = ModbusHelper.Low(crc);
request[offset + Wrapped.RequestLength + 1] = ModbusHelper.High(crc);
}
private static IModbusCommand Parse05(byte slave, byte code, ushort address, byte[] request, int offset)
{
var value = ModbusHelper.DecodeBool(request[offset + 4]);
var zero = request[offset + 5];
Assert.Equal(zero, 0, "Zero mismatch got {0} expected {1}");
return(new ModbusF05WriteCoil(slave, address, value));
}
public object ParseResponse(byte[] response, int offset)
{
Assert.Equal(ModbusHelper.GetUShort(response, offset + 0), TransactionId,
"TransactionId mismatch got {0} expected {1}");
Assert.Equal(ModbusHelper.GetUShort(response, offset + 2), 0, "Zero mismatch got {0} expected {1}");
Assert.Equal(ModbusHelper.GetUShort(response, offset + 4), Wrapped.ResponseLength,
"Length mismatch got {0} expected {1}");
return(Wrapped.ParseResponse(response, offset + 6));
}
public void FillResponse(byte[] response, int offset, object value)
{
response[offset + 0] = Slave;
response[offset + 1] = 15;
response[offset + 2] = ModbusHelper.High(Address);
response[offset + 3] = ModbusHelper.Low(Address);
response[offset + 4] = ModbusHelper.High(values.Length);
response[offset + 5] = ModbusHelper.Low(values.Length);
}
public IModbusWrapper Parse(byte[] request, int offset)
{
var wrapped = ModbusParser.Parse(request, offset);
var crc = ModbusHelper.CRC16(request, offset, wrapped.RequestLength);
Assert.Equal(crc, ModbusHelper.GetUShortLittleEndian(request, offset + wrapped.RequestLength),
"CRC mismatch {0:X4} expected {1:X4}");
return(new ModbusRTUWrapper(wrapped));
}
public object ParseResponse(byte[] response, int offset)
{
var crc1 = ModbusHelper.CRC16(response, offset, Wrapped.ResponseLength);
//crc is little endian page 13 http://modbus.org/docs/Modbus_over_serial_line_V1_02.pdf
var crc2 = ModbusHelper.GetUShortLittleEndian(response, offset + Wrapped.ResponseLength);
Assert.Equal(crc2, crc1, "CRC mismatch got {0:X4} expected {1:X4}");
return(Wrapped.ParseResponse(response, offset));
}
public object ParseResponse(byte[] response, int offset)
{
Assert.Equal(response[offset + 0], Slave, "Slave mismatch got {0} expected {1}");
Assert.Equal(response[offset + 1], 6, "Function mismatch got {0} expected {1}");
Assert.Equal(ModbusHelper.GetUShort(response, offset + 2), Address,
"Address mismatch got {0} expected {1}");
Assert.Equal(ModbusHelper.GetUShort(response, offset + 4), Value, "Value mismatch got {0} expected {1}");
return(null);
}
public object ParseResponse(byte[] response, int offset)
{
var bytes = ModbusHelper.BytesForBools(Count);
Assert.Equal(response[offset + 0], Slave, "Slave mismatch got {0} expected {1}");
Assert.Equal(response[offset + 1], 2, "Function mismatch got {0} expected {1}");
Assert.Equal(response[offset + 2], bytes, "Bytes mismatch got {0} expected {1}");
return(ModbusHelper.DecodeBools(response, offset + 3, Count));
}
public void FillRequest(byte[] request, int offset)
{
request[offset + 0] = Slave;
request[offset + 1] = 5;
request[offset + 2] = ModbusHelper.High(Address);
request[offset + 3] = ModbusHelper.Low(Address);
request[offset + 4] = ModbusHelper.EncodeBool(Value);
request[offset + 5] = 0;
}
private static IModbusCommand Parse16(byte slave, byte code, ushort address, byte[] request, int offset)
{
var count = ModbusHelper.GetUShort(request, offset + 4);
var values = ModbusHelper.DecodeWords(request, offset + 7, count);
var bytes = request[offset + 6];
Assert.Equal(ModbusHelper.BytesForWords(count), bytes, "Byte count mismatch got {0} expected {1}");
return(new ModbusF16WriteRegisters(slave, address, values));
}
public void FillRequest(byte[] request, int offset)
{
request[offset + 0] = Slave;
request[offset + 1] = 2;
request[offset + 2] = ModbusHelper.High(Address);
request[offset + 3] = ModbusHelper.Low(Address);
request[offset + 4] = ModbusHelper.High(Count);
request[offset + 5] = ModbusHelper.Low(Count);
}
public void FillResponse(byte[] response, int offset, object value)
{
response[offset + 0] = ModbusHelper.High(TransactionId);
response[offset + 1] = ModbusHelper.Low(TransactionId);
response[offset + 2] = 0;
response[offset + 3] = 0;
response[offset + 4] = ModbusHelper.High(Wrapped.ResponseLength);
response[offset + 5] = ModbusHelper.Low(Wrapped.ResponseLength);
Wrapped.FillResponse(response, offset + 6, value);
}
public void FillRequest(byte[] request, int offset)
{
request[offset + 0] = ModbusHelper.High(TransactionId);
request[offset + 1] = ModbusHelper.Low(TransactionId);
request[offset + 2] = 0;
request[offset + 3] = 0;
request[offset + 4] = ModbusHelper.High(Wrapped.RequestLength);
request[offset + 5] = ModbusHelper.Low(Wrapped.RequestLength);
Wrapped.FillRequest(request, offset + 6);
}
public object ParseResponse(byte[] response, int offset)
{
Assert.Equal(response[offset + 0], Slave, "Slave mismatch got {0} expected {1}");
Assert.Equal(response[offset + 1], 5, "Function mismatch got {0} expected {1}");
Assert.Equal(ModbusHelper.GetUShort(response, offset + 2), Address,
"Address mismatch got {0} expected {1}");
Assert.Equal(response[offset + 4], ModbusHelper.EncodeBool(Value), "Value mismatch got {0} expected {1}");
Assert.Equal(response[offset + 5], 0, "Pad mismatch {0} expected:{1}");
return(null);
}
public IModbusWrapper Parse(byte[] request, int offset)
{
var wrapped = ModbusParser.Parse(request, offset + 6);
Assert.Equal(wrapped.RequestLength, ModbusHelper.GetUShort(request, offset + 4),
"RequestLength mismatch got {0} expected {1}");
var transaction = ModbusHelper.GetUShort(request, offset);
return(new ModbusTCPWrapper(wrapped, transaction));
}
public void FillResponse(byte[] response, int offset, object value)
{
var bytes = ModbusHelper.BytesForBools(Count);
response[offset + 0] = Slave;
response[offset + 1] = 2;
response[offset + 2] = bytes;
var data = ModbusHelper.EncodeBools(value as bool[]);
ModbusHelper.Copy(data, 0, response, offset + 3, bytes);
}
private void fmMain_Load(object sender, EventArgs e)
{
string[] p = new string[1];
p[0] = "COM1";
md = new ModbusHelper(p);
md.Open();
th = new TLoopThread(OnThread);
th.Start();
}
public void FillResponse(byte[] response, int offset, object value)
{
var bytes = ModbusHelper.BytesForWords(Count);
response[offset + 0] = Slave;
response[offset + 1] = 3;
response[offset + 2] = bytes;
var data = ModbusHelper.EncodeWords((ushort[])value);
ModbusHelper.Copy(data, 0, response, offset + 3, bytes);
}
public SEDevice()
{
packages = new List <ModbusPackage>();
lockerRequestes = new object();
data = new List <byte>();
requestes = new List <ModbusRequest>();
helper = new ModbusHelper();
dictCreateVariables = new Dictionary <ModbusDataTypes, Func <ModbusVariableParams, IVariable> >();
variables = new Dictionary <string, IVariable>();
InitializationDictCreateVariables();
}
public byte[] GetException(byte code)
{
var exception = new byte[5];
exception[0] = Wrapped.Slave;
exception[1] = (byte)(Wrapped.Code | 0x80);
exception[2] = code;
var crc = ModbusHelper.CRC16(exception, 0, 3);
exception[3] = ModbusHelper.Low(crc);
exception[4] = ModbusHelper.High(crc);
return(exception);
}
public void ModbusTest()
{
Random ran = new Random();
int val = ran.Next(3);
byte[] res = ModbusHelper.SendTrainCyclostyle(number, ModbusHelper.MB_WRITE_MULTIPLE_REGS, 0, 1, new byte[] { (byte)(val >> 8), (byte)(val & 0xFF) });
string str = string.Empty;
for (int i = 0; i < res.Length; i++)
{
str += res[i].ToString("X2") + " ";
}
txt_send.Text = string.Format("Tx:{0}-{1}", number.ToString("D3"), str);
number++;
}
public byte[] GetException(byte code)
{
var exception = new byte[9];
exception[0] = ModbusHelper.High(TransactionId);
exception[1] = ModbusHelper.Low(TransactionId);
exception[2] = 0;
exception[3] = 0;
exception[4] = ModbusHelper.High(3);
exception[5] = ModbusHelper.Low(3);
exception[6 + 0] = Wrapped.Slave;
exception[6 + 1] = (byte)(Wrapped.Code | 0x80);
exception[6 + 2] = code;
return(exception);
}
public void CheckException(byte[] response, int count)
{
if (count < 5)
{
Thrower.Throw("Partial exception packet got {0} expected >= {1}", count, 5);
}
var offset = 0;
var code = response[offset + 1];
if ((code & 0x80) != 0)
{
Assert.Equal(response[offset + 0], Wrapped.Slave, "Slave mismatch got {0} expected {1}");
Assert.Equal(code & 0x7F, Wrapped.Code, "Code mismatch got {0} expected {1}");
var crc1 = ModbusHelper.CRC16(response, offset, 3);
//crc is little endian page 13 http://modbus.org/docs/Modbus_over_serial_line_V1_02.pdf
var crc2 = ModbusHelper.GetUShortLittleEndian(response, offset + 3);
Assert.Equal(crc2, crc1, "CRC mismatch got {0:X4} expected {1:X4}");
throw new ModbusException(response[offset + 2]);
}
}
