• 用c# 自己封装的Modbus工具类库源码

      前言

            Modbus通讯协议在工控行业的应用是很多的，并且也是上位机开发的基本技能之一。相关的类库也很多也很好用。以前只负责用，对其并没有深入学习和了解。前段时间有点空就在这块挖了挖。想做到知其然还要知其所以然。所以就有了自己封装的Modbus工具类库的想法。一来是练练手，二来是自己封装的用的更顺手。

            Modbus通讯协议我在工作中目前只用到了两种一个是串口通讯ModbusRTU，还有一个是网络通讯ModbusTcp。所以本文只有这两种通讯的实现。

    设计思想

            C#是高级语言有很多好用的东西，如面像对像，设计模式等。但我在工作中还是经常看到面像过程的编程。如有多个串口设备就有多个代码类似的工具类。代码重复非常严重。我认为这种事还是要发点时间总结和代码一下代码，把它封装工具类库。以便后继在其他上的使用。

            本次的封装用了一点面像对像的方法，设计了一个多个Modbus 基类将一些公共方法放在基类中，子类就可以继续使用。不同的子类有不同的功能。可以按需调用。使用简单方便。

    调用示例

            

    1. var _serialPort = new ModbusRTUCoil(portName, baudRate, parity, dataBits, stopBits);
    2. var isOk = false;
    3. var resultModel = _serialPort.ReadDataCoil(1, 1, ModbusFunctionCode.ReadInputCoil, (ushort)type.GetHashCode());
    4. if (resultModel.ResultList != null && resultModel.ResultList.Count > 0)
    5. {
    6.     isOk = resultModel.ResultList.FirstOrDefault();
    7. }

    类库项目结构

            

    代码

            Modbus结果实体

            

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6.  
    7. namespace CJH.ModbusTool
    8. {
    9.     /// 
    10.     /// Modbus结果实体
    11.     /// 
    12.     /// 
    13.     public class ModbusResultModel
    14.     {
    15.         public ModbusResultModel()
    16.         {
    17.             IsSucceed = false;
    18.             Msg = "失败(默认)";
    19.         }
    20.  
    21.         private bool _isSucceed = false;
    22.         /// 
    23.         /// 是否成功
    24.         /// 
    25.         public bool IsSucceed
    26.         {
    27.             get
    28.             {
    29.                 return _isSucceed;
    30.             }
    31.             set
    32.             {
    33.                 _isSucceed = value;
    34.                 if (IsSucceed)
    35.                 {
    36.                     Msg = "成功";
    37.                 }
    38.             }
    39.         }
    40.  
    41.         /// 
    42.         /// 返回消息
    43.         /// 
    44.         public string Msg { get; set; }
    45.  
    46.         /// 
    47.         /// 发送报文
    48.         /// 
    49.         public string SendDataStr { get; set; }
    50.  
    51.         /// 
    52.         /// 原始数据
    53.         /// 
    54.         public byte[] Datas { get; set; }
    55.     }
    56.  
    57.     /// 
    58.     /// Modbus结果实体
    59.     /// 
    60.     /// 
    61.     public class ModbusResultModel<DateType> : ModbusResultModel
    62.     {
    63.         public ModbusResultModel() : base()
    64.         {
    65.             ResultList = new List();
    66.         }
    67.  
    68.         /// 
    69.         /// 解析后的数据
    70.         /// 
    71.         public List ResultList { get; set; }
    72.     }
    73. }

    Modbus 基类

    1. using System;
    2. using System.Collections;
    3. using System.Collections.Generic;
    4. using System.ComponentModel;
    5. using System.Linq;
    6. using System.Text;
    7. using System.Threading.Tasks;
    8.  
    9. namespace CJH.ModbusTool
    10. {
    11.     /// 
    12.     /// Modbus 基类
    13.     /// 
    14.     public abstract class ModbusBase
    15.     {
    16.         /// 
    17.         /// 生成读取报文的 公共方法
    18.         /// 
    19.         /// 从站地址
    20.         /// 寄存器数量
    21.         /// 功能码
    22.         /// 起始寄存器地址
    23.         /// 返回报文(协议格式：站地址+功能码+起始寄存器地址+寄存器数量)
    24.         protected byte[] GenerateReadCommandBytes(byte devAddr, ushort length, ModbusFunctionCode functionCode = ModbusFunctionCode.ReadRegister, ushort startAddr = 0)
    25.         {
    26.             //1.拼接报文:
    27.             var sendCommand = new List<byte>();
    28.  
    29.             //协议格式：站地址+功能码+起始寄存器地址+寄存器数量
    30.             //站地址
    31.             sendCommand.Add(devAddr);
    32.             //功能码
    33.             sendCommand.Add((byte)functionCode.GetHashCode());
    34.             //起始寄存器地址
    35.             sendCommand.Add((byte)(startAddr / 256));
    36.             sendCommand.Add((byte)(startAddr % 256));
    37.             //寄存器数量
    38.             sendCommand.Add((byte)(length / 256));
    39.             sendCommand.Add((byte)(length % 256));
    40.             //CRC
    41.             //byte[] crc = Crc16(sendCommand.ToArray(), sendCommand.Count);
    42.             //sendCommand.AddRange(crc);
    43.  
    44.             return sendCommand.ToArray();
    45.         }
    46.  
    47.         /// 
    48.         /// 生成读取报文的 公共方法
    49.         /// 
    50.         /// 从站地址
    51.         /// 定入数据
    52.         /// 功能码
    53.         /// 写入地址
    54.         /// 返回报文(协议格式：站地址+功能码+起始寄存器地址+寄存器数量)
    55.         protected byte[] GenerateWriteCommandBytes(byte devAddr, ushort data, ModbusFunctionCode functionCode = ModbusFunctionCode.ReadRegister, ushort startAddr = 0)
    56.         {
    57.             //1.拼接报文:
    58.             var sendCommand = new List<byte>();
    59.  
    60.             //协议格式：站地址+功能码+起始寄存器地址+寄存器数量
    61.             //站地址
    62.             sendCommand.Add(devAddr);
    63.             //功能码
    64.             sendCommand.Add((byte)functionCode.GetHashCode());
    65.             //写入地址
    66.             sendCommand.Add((byte)(startAddr / 256));
    67.             sendCommand.Add((byte)(startAddr % 256));
    68.             //写入数据
    69.             var temp_bytes = BitConverter.GetBytes(data);
    70.             if (BitConverter.IsLittleEndian)
    71.             {
    72.                 //temp_bytes.Reverse();
    73.                 Array.Reverse(temp_bytes);
    74.             }
    75.             sendCommand.AddRange(temp_bytes);
    76.             //CRC
    77.             //byte[] crc = Crc16(sendCommand.ToArray(), sendCommand.Count);
    78.             //sendCommand.AddRange(crc);
    79.  
    80.             return sendCommand.ToArray();
    81.         }
    82.  
    83.         /// 
    84.         /// 生成发送命令报文
    85.         /// 
    86.         /// 
    87.         /// 
    88.         protected string generateSendCommandStr(byte[] sendCommand)
    89.         {
    90.             var sendCommandStr = string.Empty;
    91.             foreach (var item in sendCommand)
    92.             {
    93.                 sendCommandStr += Convert.ToString(item, 16) + " ";
    94.             }
    95.             return sendCommandStr;
    96.         }
    97.  
    98.         /// 
    99.         /// 验证CRC
    100.         /// 
    101.         /// 要验证的数据
    102.         /// 
    103.         protected bool CheckCRC(byte[] value)
    104.         {
    105.             var isOk = false;
    106.             if (value != null && value.Length >= 2)
    107.             {
    108.                 int length = value.Length;
    109.                 byte[] buf = new byte[length - 2];
    110.                 Array.Copy(value, 0, buf, 0, buf.Length);
    111.  
    112.                 //自己验证的结果
    113.                 byte[] CRCbuf = Crc16(buf, buf.Length);
    114.                 //把上面验证的结果和串口返回的校验码（最后两个）进行比较
    115.                 if (CRCbuf[0] == value[length - 2] && CRCbuf[1] == value[length - 1])
    116.                 {
    117.                     isOk = true;
    118.                 }
    119.             }
    120.             return isOk;
    121.         }
    122.  
    123.         protected byte[] Crc16(byte[] pucFrame, int usLen)
    124.         {
    125.             int i = 0;
    126.             byte[] res = new byte[2] { 0xFF, 0xFF };
    127.             ushort iIndex;
    128.             while (usLen-- > 0)
    129.             {
    130.                 iIndex = (ushort)(res[0] ^ pucFrame[i++]);
    131.                 res[0] = (byte)(res[1] ^ aucCRCHi[iIndex]);
    132.                 res[1] = aucCRCLo[iIndex];
    133.             }
    134.             return res;
    135.         }
    136.  
    137.         protected readonly byte[] aucCRCHi = {
    138.              0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    139.              0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    140.              0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    141.              0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    142.              0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    143.              0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    144.              0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    145.              0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    146.              0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    147.              0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    148.              0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    149.              0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    150.              0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    151.              0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    152.              0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    153.              0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    154.              0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    155.              0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    156.              0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    157.              0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    158.              0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    159.              0x00, 0xC1, 0x81, 0x40
    160.          };
    161.  
    162.         protected readonly byte[] aucCRCLo = {
    163.              0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7,
    164.              0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E,
    165.              0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, 0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9,
    166.              0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC,
    167.              0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
    168.              0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32,
    169.              0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D,
    170.              0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A, 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38,
    171.              0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF,
    172.              0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
    173.              0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1,
    174.              0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4,
    175.              0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB,
    176.              0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA,
    177.              0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
    178.              0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0,
    179.              0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97,
    180.              0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C, 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E,
    181.              0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89,
    182.              0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
    183.              0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83,
    184.              0x41, 0x81, 0x80, 0x40
    185.          };
    186.  
    187.         /// 
    188.         /// CRC校验
    189.         /// 
    190.         /// 字节数组
    191.         /// 验证长度
    192.         /// 2个字节
    193.         protected byte[] CalculateCRC(byte[] pucFrame, int usLen)
    194.         {
    195.             int i = 0;
    196.             byte[] res = new byte[2] { 0xFF, 0xFF };
    197.             ushort iIndex;
    198.             while (usLen-- > 0)
    199.             {
    200.                 iIndex = (ushort)(res[0] ^ pucFrame[i++]);
    201.                 res[0] = (byte)(res[1] ^ aucCRCHi[iIndex]);
    202.                 res[1] = aucCRCLo[iIndex];
    203.             }
    204.             return res;
    205.         }
    206.     }
    207.  
    208.     /// 
    209.     /// Modbus 功能码
    210.     /// 
    211.     public enum ModbusFunctionCode
    212.     {
    213.         /// 
    214.         /// 读取输出线圈
    215.         /// 
    216.         [Description("读取输出线圈")]
    217.         ReadOutCoil = 1,
    218.  
    219.         /// 
    220.         /// 读取输入线圈
    221.         /// 
    222.         [Description("读取输入线圈")]
    223.         ReadInputCoil = 2,
    224.  
    225.         /// 
    226.         /// 读取保持寄存器
    227.         /// 
    228.         [Description("读取保持寄存器")]
    229.         ReadRegister = 3,
    230.  
    231.         /// 
    232.         /// 读取输入寄存器
    233.         /// 
    234.         [Description("读取输入寄存器")]
    235.         ReadInputRegister = 4,
    236.  
    237.         /// 
    238.         /// (写入)预置单线圈
    239.         /// 
    240.         [Description("(写入)预置单线圈")]
    241.         WriteCoil = 5,
    242.  
    243.         /// 
    244.         /// (写入)预置单个寄存器
    245.         /// 
    246.         [Description("(写入)预置单个寄存器")]
    247.         WriteRegister = 6,
    248.  
    249.         /// 
    250.         /// (写入)预置多寄存器
    251.         /// 
    252.         [Description("(写入)预置多寄存器")]
    253.         WriteRegisterMultiple = 16,
    254.     }
    255. }

    RTU

    串口基类 SerialPortBase

    1. using System;
    2. using System.Collections.Generic;
    3. using System.ComponentModel;
    4. using System.IO.Ports;
    5. using System.Linq;
    6. using System.Text;
    7. using System.Threading.Tasks;
    8.  
    9. namespace CJH.ModbusTool.RTU
    10. {
    11.     //Modbus 规定4个存储区
    12.     // 区号     名称     读写        范围
    13.     // 0区     输出线圈  可读可写    00001-09999
    14.     // 1区     输入线圈  只读        10001-19999
    15.     // 2区     输入寄存器  只读      30001-39999
    16.     // 4区     保存寄存器  可读可写  40001-19999
    17.  
    18.     //功能码
    19.     //01H     读取输出线圈
    20.     //02H     读取输入线圈
    21.     //03H     读取保持寄存器
    22.     //04H     读取输入寄存器
    23.     //05H     （写入）预置单线圈
    24.     //06H     （写入）预置寄存器
    25.     //0FH     （写入）预置多线圈
    26.     //10H     （写入）预置多寄存器
    27.  
    28.     /// 
    29.     /// 串口基类
    30.     /// 
    31.     public abstract class SerialPortBase : ModbusBase
    32.     {
    33.         protected SerialPort SerialPortObj;
    34.  
    35.         /// 
    36.         /// 初始化
    37.         /// 
    38.         /// COM口名称
    39.         /// 波特率
    40.         /// 检验位
    41.         /// 数据位
    42.         /// 停止位
    43.         protected void Init(string portName, int baudRate = 9600, Parity parity = Parity.None, int dataBits = 8, StopBits stopBits = StopBits.One)
    44.         {
    45.             SerialPortObj = new SerialPort(portName, baudRate, parity, dataBits, stopBits);
    46.             if (SerialPortObj.IsOpen)
    47.             {
    48.                 SerialPortObj.Close();
    49.             }
    50.             SerialPortObj.Open();
    51.         }        
    52.  
    53.         /// 
    54.         /// 关闭
    55.         /// 
    56.         public void Close()
    57.         {
    58.             if (SerialPortObj.IsOpen)
    59.             {
    60.                 SerialPortObj.Close();
    61.                 SerialPortObj.Dispose();
    62.                 SerialPortObj = null;
    63.             }
    64.         }
    65.     }
    66.  
    67.     //功能码
    68.     //01H     读取输出线圈
    69.     //02H     读取输入线圈
    70.     //03H     读取保持寄存器
    71.     //04H     读取输入寄存器
    72.     //05H     (写入)预置单线圈
    73.     //06H     (写入)预置寄存器
    74.     //0FH     (写入)预置多线圈
    75.     //10H     (写入)预置多寄存器
    76.  
    77.     
    78. }

    Modbus 串口通讯

    (串口操作的所有功能这个类都能做)

    1. using System;
    2. using System.Collections.Generic;
    3. using System.ComponentModel.Design;
    4. using System.IO.Ports;
    5. using System.Linq;
    6. using System.Text;
    7. using System.Threading.Tasks;
    8.  
    9. namespace CJH.ModbusTool.RTU
    10. {
    11.     /// 
    12.     /// Modbus 串口通讯
    13.     /// 
    14.     public class ModbusRTU : SerialPortBase
    15.     {
    16.         private string _className = "ModbusRTU";
    17.  
    18.         /// 
    19.         /// Modbus 串口通讯
    20.         /// 
    21.         /// COM口名称
    22.         /// 波特率
    23.         /// 检验位
    24.         /// 数据位
    25.         /// 停止位
    26.         public ModbusRTU(string portName, int baudRate = 9600, Parity parity = Parity.None, int dataBits = 8, StopBits stopBits = StopBits.One)
    27.         {
    28.             Init(portName, baudRate, parity, dataBits, stopBits);
    29.             //SerialPortObj.DataReceived += new SerialDataReceivedEventHandler(ComDataReceived);
    30.         }
    31.  
    32.         /// 
    33.         /// 读取线圈数据 ok
    34.         /// 
    35.         /// 从站地址
    36.         /// 寄存器数量
    37.         /// 功能码
    38.         /// 起始寄存器地址
    39.         /// 线圈数据
    40.         public ModbusResultModel ReadData(byte devAddr, ushort length, ModbusFunctionCode functionCode = ModbusFunctionCode.ReadRegister, ushort startAddr = 0)
    41.         {
    42.             return ReadData(devAddr, length, (byte)functionCode, startAddr);
    43.         }
    44.  
    45.         /// 
    46.         /// 读取数据 ok
    47.         /// 
    48.         /// 从站地址
    49.         /// 寄存器数量
    50.         /// 功能码
    51.         /// 起始寄存器地址
    52.         /// 线圈数据
    53.         public ModbusResultModel ReadData(byte devAddr, ushort length, byte functionCode = 2, ushort startAddr = 0)
    54.         {
    55.             var resultModel = new ModbusResultModel();
    56.             //byte[] datas = null;
    57.             if (functionCode >= 1 && functionCode <= 4)
    58.             {
    59.                 try
    60.                 {
    61.                     //1.拼接报文:
    62.                     var sendCommand = new List<byte>();
    63.  
    64.                     //协议格式：站地址+功能码+起始寄存器地址+寄存器数量+CRC
    65.                     //站地址
    66.                     sendCommand.Add(devAddr);
    67.                     //功能码
    68.                     sendCommand.Add(functionCode);
    69.                     //起始寄存器地址
    70.                     sendCommand.Add((byte)(startAddr / 256));
    71.                     sendCommand.Add((byte)(startAddr % 256));
    72.                     //寄存器数量
    73.                     sendCommand.Add((byte)(length / 256));
    74.                     sendCommand.Add((byte)(length % 256));
    75.                     //CRC
    76.                     byte[] crc = Crc16(sendCommand.ToArray(), sendCommand.Count);
    77.                     sendCommand.AddRange(crc);
    78.  
    79.                     resultModel.SendDataStr = generateSendCommandStr(sendCommand.ToArray());
    80.                     //2.发送报文
    81.                     SerialPortObj.Write(sendCommand.ToArray(), 0, sendCommand.Count);
    82.                     //3.接收报文
    83.                     Thread.Sleep(50);//要延时一下，才能读到数据
    84.  
    85.                     //读取响应报文
    86.                     byte[] respBytes = new byte[SerialPortObj.BytesToRead];
    87.                     SerialPortObj.Read(respBytes, 0, respBytes.Length);
    88.                     // respBytes -> 01 01 02 00 00 B9 FC
    89.                     resultModel.Datas = respBytes;
    90.                     // 检查一个校验位
    91.                     //if (CheckCRC(respBytes) && (respBytes.Length == 5 + length * 2) 
    92.                     //    && respBytes[0] == devAdd && respBytes[1] == functionCode && respBytes[1] == length * 2)
    93.                     if (CheckCRC(respBytes) && respBytes[0] == devAddr && respBytes[1] == functionCode)
    94.                     {
    95.                         //datas = respBytes;
    96.                         resultModel.IsSucceed = true;
    97.                     }
    98.                     else
    99.                     {
    100.                         resultModel.Msg = "响应报文校验失败";
    101.                     }
    102.                 }
    103.                 catch (Exception ex)
    104.                 {
    105.                     resultModel.Msg = "异常:" + ex.Message;
    106.                 }
    107.             }
    108.             else
    109.             {
    110.                 //throw new Exception("功能码不正确[1-4]");
    111.                 resultModel.Msg = "功能码不正确[1-4]";
    112.             }
    113.             //SerialPortObj.Close();
    114.             return resultModel;
    115.         }
    116.  
    117.         /// 
    118.         /// 写入单个寄存器 ok
    119.         /// 数据示例: 200
    120.         /// 功能码 6
    121.         /// 
    122.         /// 从站地址
    123.         /// 写入的数据
    124.         /// 写入地址
    125.         /// 是否成功
    126.         public ModbusResultModel WriteDataShort(int devAddr, short value, short startAddr = 0)
    127.         {
    128.             var resultModel = new ModbusResultModel();
    129.             try
    130.             {
    131.                 //bool isOk = false;
    132.                 //1.拼接报文:
    133.                 //var sendCommand = GetSingleDataWriteMessage(devAdd, startAddr, value); //ok
    134.                 var sendCommand = GetSingleDataWriteMessageList(devAddr, startAddr, value); //ok
    135.                                                                                            //var sendCommandStr = string.Join(' ', sendCommand.ToArray());
    136.                 resultModel.SendDataStr = generateSendCommandStr(sendCommand);
    137.  
    138.                 //2.发送报文
    139.                 SerialPortObj.Write(sendCommand.ToArray(), 0, sendCommand.Length);
    140.                 //3.接收报文
    141.                 Thread.Sleep(50);//要延时一下，才能读到数据
    142.  
    143.                 //读取响应报文
    144.                 byte[] respBytes = new byte[SerialPortObj.BytesToRead];
    145.                 SerialPortObj.Read(respBytes, 0, respBytes.Length);
    146.                 // respBytes -> 01 01 02 00 00 B9 FC
    147.                 // 检查一个校验位
    148.                 if (CheckCRC(respBytes) && respBytes[0] == devAddr && respBytes[1] == 0x06)
    149.                 {
    150.                     //isOk = true;
    151.                     resultModel.IsSucceed = true;
    152.                 }
    153.                 else
    154.                 {
    155.                     resultModel.Msg = "响应报文校验失败";
    156.                 }
    157.             }
    158.             catch (Exception ex)
    159.             {
    160.                 resultModel.Msg = "异常:" + ex.Message;
    161.             }
    162.             //SerialPortObj.Close();
    163.             return resultModel;
    164.         }
    165.  
    166.         /// 
    167.         /// 写入单个寄存器 ok
    168.         /// 数据示例: 200
    169.         /// 功能码 6
    170.         /// 
    171.         /// 站地址
    172.         /// 写入的数据集合
    173.         /// 写入地址
    174.         /// 是否成功
    175.         public ModbusResultModel WriteDataShort(int devAddr, List<short> dataList, short startAddr = 0)
    176.         {
    177.             var resultModel = new ModbusResultModel();
    178.             if (dataList != null && dataList.Count > 0)
    179.             {
    180.                 foreach (var item in dataList)
    181.                 {
    182.                     resultModel = WriteDataShort(devAddr, item, startAddr);
    183.                     startAddr++;
    184.                 }
    185.             }
    186.             return resultModel;
    187.         }
    188.  
    189.         /// 
    190.         /// 获取写入单个寄存器的报文
    191.         /// 
    192.         /// 从站地址
    193.         /// 寄存器地址
    194.         /// 写入值
    195.         /// 写入单个寄存器的报文
    196.         private byte[] GetSingleDataWriteMessage(int slaveStation, short startAddr, short value)
    197.         {
    198.             //从站地址
    199.             byte station = (byte)slaveStation;
    200.             //功能码
    201.             byte type = 0x06;//06H     （写入）预置寄存器
    202.             //寄存器地址
    203.             byte[] start = BitConverter.GetBytes(startAddr);
    204.             //值
    205.             byte[] valueBytes = BitConverter.GetBytes(value);
    206.             //根据计算机大小端存储方式进行高低字节转换
    207.             if (BitConverter.IsLittleEndian)
    208.             {
    209.                 Array.Reverse(start);
    210.                 Array.Reverse(valueBytes);
    211.             }
    212.             //拼接报文
    213.             byte[] result = new byte[] { station, type };
    214.             result = result.Concat(start.Concat(valueBytes).ToArray()).ToArray();
    215.  
    216.             //计算校验码并拼接，返回最后的报文结果
    217.             return result.Concat(Crc16(result, result.Length)).ToArray();
    218.         }
    219.  
    220.         /// 
    221.         /// 获取写入单个寄存器的报文
    222.         /// 
    223.         /// 从站地址
    224.         /// 寄存器地址
    225.         /// 写入值
    226.         /// 写入单个寄存器的报文
    227.         private byte[] GetSingleDataWriteMessageList(int slaveStation, short startAddr, short data)
    228.         {
    229.             //1.拼接报文:
    230.             var sendCommand = new List<byte>();
    231.             //从站地址
    232.             byte station = (byte)slaveStation;
    233.             //功能码
    234.             byte type = 0x06;//06H     （写入）预置寄存器            
    235.             //寄存器地址
    236.             byte[] start = BitConverter.GetBytes(startAddr);
    237.             //值
    238.             byte[] valueBytes = BitConverter.GetBytes(data);
    239.             //根据计算机大小端存储方式进行高低字节转换
    240.             if (BitConverter.IsLittleEndian)
    241.             {
    242.                 Array.Reverse(start);
    243.                 Array.Reverse(valueBytes);
    244.             }
    245.             sendCommand.Add((byte)slaveStation);
    246.             sendCommand.Add(type);
    247.             sendCommand.AddRange(start);
    248.             sendCommand.AddRange(valueBytes);
    249.  
    250.             byte[] crc = Crc16(sendCommand.ToArray(), sendCommand.Count);
    251.             sendCommand.AddRange(crc);
    252.             return sendCommand.ToArray();
    253.         }
    254.  
    255.         /// 
    256.         /// 写入多个寄存器 ok
    257.         /// 数据示例: 123.45f, 14.3f
    258.         /// 功能码 10 
    259.         /// 
    260.         /// 从站地址
    261.         /// 写入的数据
    262.         /// 写入地址
    263.         /// 是否成功
    264.         public ModbusResultModel WriteDataFloat(byte devAddr, float data, ushort startAddr = 0)
    265.         {
    266.             return WriteDataFloat(devAddr, new List<float>() { data }, startAddr);
    267.         }
    268.  
    269.         /// 
    270.         /// 写入多个寄存器 ok
    271.         /// 数据示例: 123.45f, 14.3f
    272.         /// 功能码 10 
    273.         /// 
    274.         /// 从站地址
    275.         /// 写入的数据
    276.         /// 写入地址
    277.         /// 是否成功
    278.         public ModbusResultModel WriteDataFloat(byte devAddr, List<float> dataList, ushort startAddr = 0)
    279.         {
    280.             var resultModel = new ModbusResultModel();
    281.             if (dataList != null && dataList.Count > 0)
    282.             {
    283.                 try
    284.                 {
    285.                     byte functionCode = (byte)ModbusFunctionCode.WriteRegisterMultiple.GetHashCode();
    286.                     int length = dataList.Count * 2;
    287.                     //1.拼接报文:
    288.                     var sendCommand = new List<byte>();
    289.  
    290.                     //协议格式：站地址+功能码+起始寄存器地址+寄存器数量+CRC
    291.                     //站地址
    292.                     sendCommand.Add(devAddr);
    293.                     //功能码
    294.                     sendCommand.Add(functionCode);
    295.                     //写入地址
    296.                     sendCommand.Add((byte)(startAddr / 256));
    297.                     sendCommand.Add((byte)(startAddr % 256));
    298.                     //寄存器数量
    299.                     sendCommand.Add((byte)(length / 256));
    300.                     sendCommand.Add((byte)(length % 256));
    301.                     // 获取数值的byte[]
    302.                     List<byte> valueBytes = new List<byte>();
    303.                     foreach (var data in dataList)
    304.                     {
    305.                         List<byte> temp = new List<byte>(BitConverter.GetBytes(data));
    306.                         temp.Reverse();// 调整字节序
    307.                         valueBytes.AddRange(temp);
    308.                     }
    309.                     // 字节数
    310.                     sendCommand.Add((byte)valueBytes.Count);
    311.                     sendCommand.AddRange(valueBytes);
    312.                     //CRC
    313.                     byte[] crc = Crc16(sendCommand.ToArray(), sendCommand.Count);
    314.                     sendCommand.AddRange(crc);
    315.  
    316.                     //000004 - Rx:01 10 00 02 00 04 08 42 F6 E6 66 41 64 CC CD 83 23
    317.                     //000005 - Tx:01 10 00 02 00 04 60 0A
    318.                     //000006 - Rx:01 0A 00 02 00 04 08 42 F6 E6 66 41 64 CC CD 98 F9
    319.                     //000007 - Tx:01 8A 01 86 A0 //报错了
    320.  
    321.                     //2.发送报文
    322.                     SerialPortObj.Write(sendCommand.ToArray(), 0, sendCommand.Count);
    323.                     //3.接收报文
    324.                     Thread.Sleep(50);//要延时一下，才能读到数据
    325.  
    326.                     //读取响应报文
    327.                     byte[] respBytes = new byte[SerialPortObj.BytesToRead];
    328.                     SerialPortObj.Read(respBytes, 0, respBytes.Length);
    329.                     // respBytes -> 01 01 02 00 00 B9 FC
    330.  
    331.                     // 检查一个校验位
    332.                     if (CheckCRC(respBytes) && respBytes[0] == devAddr && respBytes[1] == functionCode)
    333.                     {
    334.                         resultModel.IsSucceed = true;
    335.                     }
    336.                     else
    337.                     {
    338.                         resultModel.Msg = "响应报文校验失败";
    339.                     }
    340.                 }
    341.                 catch (Exception ex)
    342.                 {
    343.                     resultModel.Msg = "异常:" + ex.Message;
    344.                 }
    345.                 //SerialPortObj.Close();
    346.             }
    347.             else
    348.             {
    349.                 resultModel.Msg = "dataLis参数不能为NULL 且 Count 要大于0";
    350.             }
    351.             return resultModel;
    352.         }
    353.  
    354.         /// 
    355.         /// 写单个线圈输出 ok
    356.         /// 
    357.         /// 开关
    358.         /// 从站地址
    359.         /// 写入地址
    360.         /// 
    361.         public ModbusResultModel WriteSingleOutOnOff(bool on, byte devAddr = 1, ushort startAddr = 0)
    362.         {
    363.             var resultModel = new ModbusResultModel();
    364.             try
    365.             {
    366.                 //var isOk = false;
    367.                 //1.拼接报文:
    368.                 var sendCommand = new List<byte>();
    369.                 //协议格式：站地址+功能码+起始寄存器地址+寄存器数量+CRC
    370.                 //站地址
    371.                 sendCommand.Add(devAddr);
    372.                 //功能码
    373.                 byte functionCode = 0x05;
    374.                 sendCommand.Add(functionCode);
    375.                 //写入地址
    376.                 sendCommand.Add((byte)(startAddr / 256));
    377.                 sendCommand.Add((byte)(startAddr % 256));
    378.                 //写入数据
    379.                 sendCommand.Add((byte)(on ? 0xFF : 0x00));//true : 0xFF 开，false : 0x00 关
    380.                 sendCommand.Add(0x00);
    381.                 //CRC
    382.                 byte[] crc = Crc16(sendCommand.ToArray(), sendCommand.Count);
    383.                 sendCommand.AddRange(crc);
    384.                 //2.发送报文
    385.                 SerialPortObj.Write(sendCommand.ToArray(), 0, sendCommand.Count);
    386.                 //isOk = true;
    387.                 resultModel.IsSucceed = true;
    388.             }
    389.             catch (Exception ex)
    390.             {
    391.                 resultModel.Msg = "异常:" + ex.Message;
    392.             }
    393.             return resultModel;
    394.         }
    395.     }
    396. }

    Modbus 串口通讯 读线圈状态

    （这个类是针对线圈的 突出读取数据）

    1. using System;
    2. using System.Collections.Generic;
    3. using System.IO.Ports;
    4. using System.Linq;
    5. using System.Text;
    6. using System.Threading.Tasks;
    7.  
    8. namespace CJH.ModbusTool.RTU
    9. {
    10.     /// 
    11.     /// Modbus 串口通讯 读线圈状态
    12.     /// 
    13.     public class ModbusRTUCoil : ModbusRTU
    14.     {
    15.         //ModbusRTU rtu = new ModbusRTU(portName);
    16.         //var resultModel = rtu.ReadData(1, readLen, ModbusFunctionCode.ReadOutCoil);
    17.  
    18.         /// 
    19.         /// Modbus 串口通讯
    20.         /// 
    21.         /// COM口名称
    22.         /// 波特率
    23.         /// 检验位
    24.         /// 数据位
    25.         /// 停止位
    26.         public ModbusRTUCoil(string portName, int baudRate = 9600, Parity parity = Parity.None, int dataBits = 8, StopBits stopBits = StopBits.One)
    27.             : base(portName, baudRate, parity, dataBits, stopBits)
    28.         {
    29.             //Init(portName, baudRate, parity, dataBits, stopBits);
    30.             //SerialPortObj.DataReceived += new SerialDataReceivedEventHandler(ComDataReceived);
    31.         }
    32.  
    33.         /// 
    34.         /// 读取线圈数据 ok
    35.         /// 
    36.         /// 从站地址
    37.         /// 寄存器数量
    38.         /// 功能码
    39.         /// 起始寄存器地址
    40.         /// 线圈数据
    41.         public ModbusResultModel<bool> ReadDataCoil(byte devAdd, ushort length, ModbusFunctionCode functionCode = ModbusFunctionCode.ReadRegister, ushort startAddr = 0)
    42.         {
    43.             var resultModel = new ModbusResultModel<bool>();
    44.             var model = ReadData(devAdd, length, (byte)functionCode, startAddr);
    45.             if (model != null && model.Datas != null && model.Datas.Length > 5)
    46.             {
    47.                 resultModel.IsSucceed = model.IsSucceed;
    48.                 //报文解析
    49.                 // 检查一个校验位
    50.                 List<byte> respList = new List<byte>(model.Datas);
    51.                 respList.RemoveRange(0, 3);
    52.                 respList.RemoveRange(respList.Count - 2, 2);
    53.                 // 00 00
    54.                 //集合反转
    55.                 respList.Reverse();
    56.                 //转换成2进制
    57.                 var respStrList = respList.Select(r => Convert.ToString(r, 2)).ToList();
    58.                 var values = string.Join("", respStrList).ToList();
    59.                 values.Reverse();
    60.                 //values.ForEach(c => Console.WriteLine(Convert.ToBoolean(int.Parse(c.ToString()))));
    61.                 foreach (var v in values)
    62.                 {
    63.                     resultModel.ResultList.Add(v.ToString() == "1");
    64.                 }
    65.             }
    66.             return resultModel;
    67.         }
    68.     }
    69. }

    TCP

    ModbusTCP 基类

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Net.Sockets;
    5. using System.Runtime.InteropServices;
    6. using System.Security.Cryptography;
    7. using System.Text;
    8. using System.Threading.Tasks;
    9.  
    10. namespace CJH.ModbusTool.TCP
    11. {
    12.     /// 
    13.     /// ModbusTCP 基类
    14.     /// 
    15.     public abstract class ModbusTCPBase : ModbusBase
    16.     {
    17.         private Socket _socket = null;
    18.         ushort _tid = 0;//TransactionId 最大 65535
    19.  
    20.         /// 
    21.         /// 异常码 字典
    22.         /// 
    23.         protected Dictionary<int, string> Errors = new Dictionary<int, string>() {
    24.             { 0x01 , "非法功能码"},
    25.             { 0x02 , "非法数据地址"},
    26.             { 0x03 , "非法数据值"},
    27.             { 0x04 , "从站设备故障"},
    28.             { 0x05 , "确认，从站需要一个耗时操作"},
    29.             { 0x06 , "从站忙"},
    30.             { 0x08 , "存储奇偶性差错"},
    31.             { 0x0A , "不可用网关路径"},
    32.             { 0x0B , "网关目标设备响应失败"},
    33.         };
    34.  
    35.         /// 
    36.         /// Modbus TCP 通讯 初始化
    37.         /// 
    38.         /// 主机地址
    39.         /// 端口
    40.         protected void Init(string host, int port)
    41.         {
    42.             _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    43.             _socket.Connect(host, port);
    44.         }
    45.  
    46.         /// 
    47.         /// 读取报文的 公共方法
    48.         /// 
    49.         /// 从站地址
    50.         /// 寄存器数量
    51.         /// 功能码
    52.         /// 起始寄存器地址
    53.         /// 返回报文(协议格式：TransactionId+协议标识+后续字节数+站地址+功能码+起始寄存器地址+寄存器数量)
    54.         protected byte[] GenerateTcpCommandReadBytes(byte devAddr, ushort length, ModbusFunctionCode functionCode = ModbusFunctionCode.ReadRegister, ushort startAddr = 0)
    55.         {
    56.             var baseCommand = GenerateReadCommandBytes(devAddr, length, functionCode, startAddr);
    57.  
    58.             var sendCommand = new List<byte>();
    59.             //TransactionId
    60.             sendCommand.Add((byte)(_tid / 256));
    61.             sendCommand.Add((byte)(_tid % 256));
    62.             //Modbus 协议标识
    63.             sendCommand.Add(0x00);
    64.             sendCommand.Add(0x00);
    65.             //后续字节数
    66.             sendCommand.Add((byte)(baseCommand.Length / 256));
    67.             sendCommand.Add((byte)(baseCommand.Length % 256));
    68.             _tid++;
    69.             _tid %= 65535;
    70.             sendCommand.AddRange(baseCommand);
    71.             return sendCommand.ToArray();
    72.         }
    73.  
    74.         /// 
    75.         /// 读取报文的 公共方法
    76.         /// 
    77.         /// 从站地址
    78.         /// 输入数据
    79.         /// 功能码
    80.         /// 起始寄存器地址
    81.         /// 返回报文(协议格式：TransactionId+协议标识+后续字节数+站地址+功能码+起始寄存器地址+寄存器数量)
    82.         protected byte[] GenerateTcpCommandWriteBytes(byte devAddr, ushort data, ModbusFunctionCode functionCode = ModbusFunctionCode.WriteRegister, ushort startAddr = 0)
    83.         {
    84.             var baseCommand = GenerateWriteCommandBytes(devAddr, data, functionCode, startAddr);
    85.  
    86.             var sendCommand = new List<byte>();
    87.             //TransactionId
    88.             sendCommand.Add((byte)(_tid / 256));
    89.             sendCommand.Add((byte)(_tid % 256));
    90.             //Modbus 协议标识
    91.             sendCommand.Add(0x00);
    92.             sendCommand.Add(0x00);
    93.             //后续字节数
    94.             sendCommand.Add((byte)(baseCommand.Length / 256));
    95.             sendCommand.Add((byte)(baseCommand.Length % 256));
    96.             _tid++;
    97.             _tid %= 65535;
    98.             sendCommand.AddRange(baseCommand);
    99.             return sendCommand.ToArray();
    100.         }
    101.  
    102.         protected ModbusResultModel SendCommand(byte[] sendCommand)
    103.         {
    104.             var resultModel = new ModbusResultModel();
    105.             try
    106.             {
    107.                 //报文
    108.                 //TransactionId Modbus 协议标识 后续字节数  从站地址  功能码         起始寄存器地址  寄存器数量  CRC
    109.                 //0x00 0x01     0x00   0x00     0x00  0x06  devAddr   functionCode   0x00  0x0A      
    110.  
    111.                 resultModel.SendDataStr = generateSendCommandStr(sendCommand.ToArray());
    112.                 _socket.Send(sendCommand.ToArray());
    113.                 //000002-Rx:00 00 00 00 00 06 01 03 00 01 00 05
    114.                 //000003-Tx:00 00 00 00 00 0D 01 03 0A 00 00 00 00 00 00 00 00 00 00
    115.                 // 00 00 00 00 00 0D 前6位
    116.                 // 01 03 0A (0,1,2)
    117.                 // 0A 数据长度 （0A=10）
    118.  
    119.                 //先取前6位，固定返回
    120.                 var resp_bytes = new byte[6];// 00 00 00 00 00 0D 前6位
    121.                 _socket.Receive(resp_bytes, 0, resp_bytes.Length, SocketFlags.None);
    122.  
    123.                 //取出下标为 ：4和5的数据[00 0D]
    124.                 var len_bytes = resp_bytes.ToList().GetRange(4, 2);
    125.                 //起始寄存器地址 的反向操作
    126.                 //将下标为4和5 两个字节转成10进制数
    127.                 int len = len_bytes[0] * 256 + len_bytes[1];
    128.  
    129.                 //获取数据的长度
    130.                 //01 03 0A 00 00 00 00 00 00 00 00 00 00 [正常]
    131.                 //01 83 02 [异常，83， 异常代码 ：02]
    132.                 resp_bytes = new byte[len];
    133.                 _socket.Receive(resp_bytes, 0, len, SocketFlags.None);
    134.  
    135.                 //检查响应报文是否正常
    136.                 //0x83 1000 0011
    137.                 //01 83 02 [异常，83， 异常代码 ：02]
    138.                 if (resp_bytes[1] > 0x08)//判断是否异常
    139.                 {
    140.                     //resp_bytes[2] = 异常代码 ：02
    141.                     //说明响应是异常报文
    142.                     //返回异常信息，根据resp_bytes字节进行异常关联
    143.                     if (Errors.ContainsKey(resp_bytes[2]))
    144.                     {
    145.                         resultModel.Msg = Errors[resp_bytes[2]];//获取异常码对应的异常说明
    146.                     }
    147.                 }
    148.                 else
    149.                 {
    150.                     //resp_bytes[2] = 0A 数据长度 （0A=10）
    151.                     //正常
    152.                     resultModel.Datas = resp_bytes.ToList().GetRange(3, resp_bytes[2]).ToArray();
    153.                     resultModel.IsSucceed = true;
    154.                 }
    155.             }
    156.             catch (Exception ex)
    157.             {
    158.                 resultModel.Msg = ex.Message;
    159.             }
    160.             return resultModel;
    161.         }
    162.  
    163.         /// 
    164.         /// 解析数据
    165.         /// 
    166.         /// 
    167.         /// 
    168.         /// 
    169.         public List<T> AnalysisDatas<T>(byte[] datas)
    170.         {
    171.             //data_bytes 每两个字节转成一个数字， float 4个字节转成一个数字，double 8个字节转成一个数字
    172.             //2  ushort short int16 uint32 float
    173.             //4  int uint int32 uint32 float
    174.             //8  double
    175.             //16 decimal
    176.             var resultValue = new List();
    177.             try
    178.             {
    179.                 var type_len = Marshal.SizeOf(typeof(T));
    180.                 for (int i = 0; i < datas.Length; i += type_len)
    181.                 {
    182.                     var temp_bytes = datas.ToList().GetRange(i, type_len);
    183.                     if (BitConverter.IsLittleEndian)
    184.                     {
    185.                         temp_bytes.Reverse();
    186.                     }
    187.                     //反射 方法
    188.                     Type bitConverter_type = typeof(BitConverter);
    189.                     var typeMethodList = bitConverter_type.GetMethods().ToList();
    190.                     //找到返回类型和传入的类型一至，且方法的参数是2个的方法
    191.                     var method = typeMethodList.FirstOrDefault(mi => mi.ReturnType == typeof(T)
    192.                                         && mi.GetParameters().Length == 2);
    193.                     if (method == null)
    194.                     {
    195.                         throw new Exception("数据转换类型出错!");
    196.                     }
    197.                     else
    198.                     {
    199.                         //由 bitConverter_type 执行找到的 method方法，注意参数数量，上面找是的两个参数的方法
    200.                         var value = method.Invoke(bitConverter_type, new object[] { temp_bytes.ToArray(), 0 });
    201.                         resultValue.Add((T)value);
    202.                     }
    203.                 }
    204.             }
    205.             catch (Exception ex)
    206.             {
    207.  
    208.             }
    209.             return resultValue;
    210.         }
    211.     }
    212. }

    Modbus TCP 通讯

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6. using System.Net.Sockets;
    7.  
    8. namespace CJH.ModbusTool.TCP
    9. {
    10.     /// 
    11.     /// Modbus TCP 通讯
    12.     /// 
    13.     public class ModbusTCP : ModbusTCPBase
    14.     {
    15.  
    16.         /// 
    17.         /// Modbus TCP 通讯
    18.         /// 
    19.         /// 主机地址
    20.         /// 端口
    21.         public ModbusTCP(string host, int port)
    22.         {
    23.             //_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    24.             //_socket.Connect(host, port);
    25.             Init(host, port);
    26.         }
    27.  
    28.         /// 
    29.         /// 读取保持型寄存器 03
    30.         /// 
    31.         /// 从站地址
    32.         /// 数量
    33.         /// 功能码
    34.         /// 起始地址
    35.         //public ModbusResultModel ReadHoldingRegister(byte devAddr, ushort length, byte functionCode = 3, ushort startAddr = 0)
    36.         //{
    37.         //    var resultModel = new ModbusResultModel();
    38.         //    //报文
    39.         //    //TransactionId Modbus 协议标识 后续字节数  从站地址  功能码         起始寄存器地址  寄存器数量  CRC
    40.         //    //0x00 0x01     0x00   0x00     0x00  0x06  devAddr   functionCode   0x00  0x0A      
    41.         //    try
    42.         //    {
    43.         //        ushort tid = 0;//TransactionId 最大 65535
    44.  
    45.         //        var sendCommand = new List();
    46.         //        //TransactionId
    47.         //        sendCommand.Add((byte)(tid / 256));
    48.         //        sendCommand.Add((byte)(tid % 256));
    49.         //        //Modbus 协议标识
    50.         //        sendCommand.Add(0x00);
    51.         //        sendCommand.Add(0x00);
    52.         //        //后续字节数
    53.         //        sendCommand.Add(0x00);
    54.         //        sendCommand.Add(0x06);
    55.         //        //从站地址
    56.         //        sendCommand.Add(devAddr);
    57.         //        //功能码
    58.         //        sendCommand.Add(functionCode);
    59.         //        //起始寄存器地址
    60.         //        sendCommand.Add((byte)(startAddr / 256));
    61.         //        sendCommand.Add((byte)(startAddr % 256));
    62.         //        //寄存器数量
    63.         //        sendCommand.Add((byte)(length / 256));
    64.         //        sendCommand.Add((byte)(length % 256));
    65.         //        //CRC
    66.         //        //byte[] crc = Crc16(sendCommand.ToArray(), sendCommand.Count);
    67.         //        //sendCommand.AddRange(crc);
    68.         //        tid++;
    69.         //        tid %= 65535;
    70.         //        resultModel.SendDataStr = generateSendCommandStr(sendCommand.ToArray());
    71.         //        _socket.Send(sendCommand.ToArray());
    72.         //        //000002-Rx:00 00 00 00 00 06 01 03 00 01 00 05
    73.         //        //000003-Tx:00 00 00 00 00 0D 01 03 0A 00 00 00 00 00 00 00 00 00 00
    74.         //        // 00 00 00 00 00 0D 前6位
    75.         //        // 01 03 0A (0,1,2)
    76.         //        // 0A 数据长度 （0A=10）
    77.  
    78.         //        //先取前6位，固定返回
    79.         //        var resp_bytes = new byte[6];// 00 00 00 00 00 0D 前6位
    80.         //        _socket.Receive(resp_bytes, 0, resp_bytes.Length, SocketFlags.None);
    81.  
    82.         //        //取出下标为 ：4和5的数据[00 0D]
    83.         //        var len_bytes = resp_bytes.ToList().GetRange(4, 2);
    84.         //        //起始寄存器地址 的反向操作
    85.         //        //将下标为4和5 两个字节转成10进制数
    86.         //        int len = resp_bytes[4] * 256 + resp_bytes[5];
    87.  
    88.         //        //获取数据的长度
    89.         //        //01 03 0A 00 00 00 00 00 00 00 00 00 00 [正常]
    90.         //        //01 83 02 [异常，83， 异常代码 ：02]
    91.         //        resp_bytes = new byte[len];
    92.         //        _socket.Receive(resp_bytes, 0, len, SocketFlags.None);
    93.  
    94.         //        //检查响应报文是否正常
    95.         //        //0x83 1000 0011
    96.         //        //01 83 02 [异常，83， 异常代码 ：02]
    97.         //        if (resp_bytes[1] > 0x08)//判断是否异常
    98.         //        {
    99.         //            //resp_bytes[2] = 异常代码 ：02
    100.         //            //说明响应是异常报文
    101.         //            //返回异常信息，根据resp_bytes字节进行异常关联
    102.         //            if (Errors.ContainsKey(resp_bytes[2]))
    103.         //            {
    104.         //                resultModel.Msg = Errors[resp_bytes[2]];//获取异常码对应的异常说明
    105.         //            }
    106.         //        }
    107.         //        else
    108.         //        {
    109.         //            //resp_bytes[2] = 0A 数据长度 （0A=10）
    110.         //            //正常
    111.         //            resultModel.Datas = resp_bytes.ToList().GetRange(3, resp_bytes[2]).ToArray();
    112.         //            resultModel.IsSucceed = true;
    113.         //        }
    114.         //    }
    115.         //    catch (Exception ex)
    116.         //    {
    117.         //        resultModel.Msg = ex.Message;
    118.         //    }
    119.         //    return resultModel;
    120.         //}
    121.  
    122.         /// 
    123.         /// 读取保持型寄存器 03
    124.         /// 
    125.         /// 从站地址
    126.         /// 数量
    127.         /// 功能码
    128.         /// 起始地址
    129.         /// 返回对象
    130.         public ModbusResultModel<T> ReadHoldingRegister<T>(byte devAddr, ushort length, ModbusFunctionCode functionCode = ModbusFunctionCode.ReadRegister, ushort startAddr = 0)
    131.         {
    132.             var resultModel = new ModbusResultModel();
    133.             try
    134.             {
    135.                 var command = GenerateTcpCommandReadBytes(devAddr, length, functionCode, startAddr);
    136.  
    137.                 resultModel.SendDataStr = generateSendCommandStr(command.ToArray());
    138.                 var receptionModel = SendCommand(command.ToArray());
    139.                 if (receptionModel.IsSucceed
    140.                     && receptionModel.Datas != null && receptionModel.Datas.Length > 0)
    141.                 {
    142.                     resultModel.Datas = receptionModel.Datas;
    143.                     resultModel.ResultList = AnalysisDatas(receptionModel.Datas);
    144.                     resultModel.IsSucceed = true;
    145.                 }
    146.             }
    147.             catch (Exception ex)
    148.             {
    149.                 resultModel.Msg = ex.Message;
    150.             }
    151.             return resultModel;
    152.         }
    153.  
    154.         /// 
    155.         /// 写入保持型寄存器 03
    156.         /// 
    157.         /// 从站地址
    158.         /// 写入数据
    159.         /// 功能码
    160.         /// 起始地址
    161.         /// 返回对象
    162.         public ModbusResultModel WriteHoldingRegister(byte devAddr, ushort data, ModbusFunctionCode functionCode = ModbusFunctionCode.WriteRegister, ushort startAddr = 0)
    163.         {
    164.             var resultModel = new ModbusResultModel();
    165.             try
    166.             {
    167.                 var command = GenerateTcpCommandWriteBytes(devAddr, data, functionCode, startAddr);
    168.  
    169.                 resultModel.SendDataStr = generateSendCommandStr(command.ToArray());
    170.                 var receptionModel = SendCommand(command.ToArray());
    171.                 if (receptionModel.IsSucceed)
    172.                 {
    173.                     resultModel.IsSucceed = true;
    174.                 }
    175.             }
    176.             catch (Exception ex)
    177.             {
    178.                 resultModel.Msg = ex.Message;
    179.             }
    180.             return resultModel;
    181.         }
    182.     }
    183. }

    这就是全部的代码。如有使用的问题可以给我发评论。

  • 相关阅读:
    初学python（一）
    二叉搜索树--详细实现过程
    MySQL——慢查询日志分析
    年薪40w的高级网络工程师面试过程，面试过程不难，但你要真做过才能回答上来
    com.google.code:kaptcha-2.3.jar
    Python模块：hashlib模块教程
    计算机网络 --- 网络编程
    程序员面试金典 - 面试题 17.18. 最短超串
    Nginx学习（2）—— 常用命令
    TypeScript学习记录
  • 原文地址：https://blog.csdn.net/cjh16606260986/article/details/136281351