[网络协议]C#使用Modbus协议读写汇川PLC的M区寄存器（基本接口封装）

C#使用Modbus-TCP协议读取汇川PLC，Modbus读写是按照MW地址来处理的

【寄存器单位是字WORD，占用两个字节，类似于C#中的ushort（UInt16）】，实际测试发现字符串是按照字节颠倒的

本文封装函数为基础数据类型读写，字节流读写、长字符串读写。

主要封装函数有：

public int WriteValue<T>(int startAddress, T value, out string msg) where T : struct

public int WriteValue(int startAddress, byte[] buffer, out string msg)

public int WriteString(int startAddress, int length, string barcode, out string msg)

public int WriteLongString(int startAddress, string longString, out string msg)

public int ReadValue<T>(int startAddress, out T value, out string msg) where T : struct

public int ReadValue(int startAddress, int length, out byte[] values, out string msg)

public int ReadLongString(int startAddress, int length, out string longString, out string msg)

源程序如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace InovancePlcDemo
{
    /// <summary>
    /// 汇川PLC读写地址表
    /// 斯内科 20210907
    /// </summary>
    public class InovanceTcp
    {
        /// <summary>
        /// 是否已连接
        /// </summary>
        public bool IsConnected;
        /// <summary>
        /// 字节存放类型，汇川PLC默认为CDAB
        /// </summary>
        public StoreByteCategory StoreByteCategory { get; set; }
        /// <summary>
        /// 是否字符串颠倒，相邻两个字符交换位置【比如：ABCD存放是BADC】
        /// </summary>
        public bool IsStringReverse = true;
        string ip;
        int port;
        /// <summary>
        /// TCP客户端对象
        /// </summary>
        TcpClient msender;
        /// <summary>
        /// TCP连接成功后生成的发送和接收Session会话对象
        /// </summary>
        Socket msock;
        /// <summary>
        /// 记录Modbus的发送和接收数据包事件
        /// 第一个参数是发送的数据包，第二个参数是响应的数据包，第三个参数的获取到响应数据包所花费的时间（ms）
        /// </summary>
        public event Action<byte[], byte[], double> RecordDataEvent;

        /// <summary>
        /// 汇川PLC的Modbus协议Tcp连接的构造函数（PLC的IP地址、PLC端口号、本机节点）
        /// </summary>
        /// <param name="ip">IP地址</param>
        /// <param name="port">端口号，默认502</param>
        /// <returns>实例化一个Modbus协议Tcp连接</returns>
        public InovanceTcp(string ip, int port, StoreByteCategory storeByteCategory = StoreByteCategory.CDAB, bool isStringReverse = true)
        {
            this.ip = ip;
            this.port = port;
            this.StoreByteCategory = storeByteCategory;
            this.IsStringReverse = isStringReverse;
            IsConnected = false;
        }

        /// <summary>
        /// 断开连接
        /// </summary>
        public void DisConnect()
        {
            msender?.Close();
            msock?.Close();
            msock?.Dispose();
            IsConnected = false;
        }

        /// <summary>
        /// 连接PLC
        /// </summary>
        public void Connect()
        {
            if (!IsConnected)
            {
                msender = new TcpClient(ip, port);
                msock = msender.Client;
                msock.ReceiveTimeout = 3000;
                IsConnected = true;
            }
        }

        /// <summary>
        /// 写基本数据类型到PLC，如bool,short,int,uint,float等
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="startAddress">起始寄存器地址，以字（WORD）为单位，形如MW32000</param>
        /// <param name="value"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public int WriteValue<T>(int startAddress, T value, out string msg) where T : struct
        {
            byte[] datas = new byte[0];
            if (typeof(T) == typeof(bool))
            {
                datas = BitConverter.GetBytes(Convert.ToBoolean(value));
            }
            else if (typeof(T) == typeof(sbyte))
            {
                datas = new byte[1] { (byte)Convert.ToSByte(value) };
            }
            else if (typeof(T) == typeof(byte))
            {
                datas = new byte[1] { Convert.ToByte(value) };
            }
            else if (typeof(T) == typeof(short))
            {
                datas = BitConverter.GetBytes(Convert.ToInt16(value));
            }
            else if (typeof(T) == typeof(ushort))
            {
                datas = BitConverter.GetBytes(Convert.ToUInt16(value));
            }
            else if (typeof(T) == typeof(int))
            {
                datas = BitConverter.GetBytes(Convert.ToInt32(value));
            }
            else if (typeof(T) == typeof(uint))
            {
                datas = BitConverter.GetBytes(Convert.ToUInt32(value));
            }
            else if (typeof(T) == typeof(long))
            {
                datas = BitConverter.GetBytes(Convert.ToInt64(value));
            }
            else if (typeof(T) == typeof(ulong))
            {
                datas = BitConverter.GetBytes(Convert.ToUInt64(value));
            }
            else if (typeof(T) == typeof(float))
            {
                datas = BitConverter.GetBytes(Convert.ToSingle(value));
            }
            else if (typeof(T) == typeof(double))
            {
                datas = BitConverter.GetBytes(Convert.ToDouble(value));
            }
            else
            {
                //暂不考虑 char(就是ushort，两个字节)，decimal（十六个字节） 等类型
                msg = $"写Modbus数据暂不支持其他类型：{value.GetType()}";
                return -1;
            }
            byte[] rcvBuffer = new byte[0];
            return SendByte(startAddress, false, 0, ref rcvBuffer, out msg, datas);
        }

        /// <summary>
        /// 写入连续的字节数组
        /// </summary>
        /// <param name="startAddress">起始寄存器地址，以字（WORD）为单位，形如MW32000</param>
        /// <param name="buffer"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public int WriteValue(int startAddress, byte[] buffer, out string msg)
        {
            byte[] rcvBuffer = new byte[0];
            return SendByte(startAddress, false, 0, ref rcvBuffer, out msg, buffer);
        }
        /// <summary>
        /// 写指定长度的字符串(比如条码)到汇川PLC，最大240个字符
        /// 将字符串填充满length个，不足时用 空字符'\0'填充，相当于清空所有字符后重新填充
        /// </summary>
        /// <param name="startAddress"></param>
        /// <param name="length">字符串的最大长度【范围1~240】,超过240个字符将直接返回错误</param>
        /// <param name="barcode">实际字符串，长度可能小于最大长度length</param>
        /// <returns></returns>
        public int WriteString(int startAddress, int length, string barcode, out string msg)
        {
            if (barcode == null)
            {
                barcode = string.Empty;
            }
            //将字符串填充满length个，不足时用 空字符'\0'填充，相当于清空所有字符后填充
            //防止出现 上一次写 【ABCD】，本次写 【12】， 读取字符串 结果是【12CD】 的问题
            barcode = barcode.PadRight(length, '\0');
            return WriteValue(startAddress, Encoding.ASCII.GetBytes(barcode), out msg);
        }

        /// <summary>
        /// 写长字符串
        /// 一个寄存器地址可以存放两个字节【两个字符】，设定每次最多写入200个字符，
        /// 分多次写入，每一次写入的起始寄存器地址偏移100
        /// </summary>
        /// <param name="startAddress">起始地址</param>
        /// <param name="longString">长字符串</param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public int WriteLongString(int startAddress, string longString, out string msg)
        {
            msg = string.Empty;
            if (longString == null)
            {
                longString = string.Empty;
            }
            int cycleCount = 200;//每20个字符就进行分段
            int maxLength = longString.Length;
            int pageSize = (maxLength + cycleCount - 1) / cycleCount;
            int errorCode = -1;
            for (int i = 0; i < pageSize; i++)
            {
                int writeLength = cycleCount;
                if (i == pageSize - 1)
                {
                    //最后一次
                    writeLength = maxLength - i * cycleCount;
                }
                //分段字符串，每次最多200个
                string segment = longString.Substring(i * cycleCount, writeLength);
                //寄存器地址是字，所以需要 字节个数 除以2
                errorCode = WriteString(startAddress + (i * cycleCount / 2), writeLength, segment, out msg);
                if (errorCode != 0)
                {
                    return errorCode;
                }
            }
            return errorCode;
        }

        /// <summary>
        /// 读取基本数据类型
        /// </summary>
        /// <typeparam name="T">基本的数据类型，如short，int，double等</typeparam>
        /// <param name="startAddress"></param>
        /// <param name="value"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public int ReadValue<T>(int startAddress, out T value, out string msg) where T : struct
        {
            value = default(T);
            int length = 0;//读取的连续字节个数
            if (typeof(T) == typeof(bool) || typeof(T) == typeof(sbyte) || typeof(T) == typeof(byte))
            {
                length = 1;
            }
            else if (typeof(T) == typeof(short) || typeof(T) == typeof(ushort))
            {
                length = 2;
            }
            else if (typeof(T) == typeof(int) || typeof(T) == typeof(uint) || typeof(T) == typeof(float))
            {
                length = 4;
            }
            else if (typeof(T) == typeof(long) || typeof(T) == typeof(ulong) || typeof(T) == typeof(double))
            {
                length = 8;
            }
            else
            {
                //暂不考虑 char(就是ushort，两个字节)，decimal（十六个字节） 等类型
                msg = $"读Modbus数据暂不支持其他类型：{value.GetType()}";
                return -1;
            }
            byte[] rcvBuffer = new byte[0];
            int errorCode = SendByte(startAddress, true, length, ref rcvBuffer, out msg);
            if (errorCode != 0)
            {
                return errorCode;
            }
            if (typeof(T) == typeof(bool))
            {
                value = (T)(object)Convert.ToBoolean(rcvBuffer[0]);
            }
            else if (typeof(T) == typeof(sbyte))
            {
                value = (T)(object)(sbyte)rcvBuffer[0];
            }
            else if (typeof(T) == typeof(byte))
            {
                value = (T)(object)rcvBuffer[0];
            }
            else if (typeof(T) == typeof(short))
            {
                value = (T)(object)BitConverter.ToInt16(rcvBuffer, 0);
            }
            else if (typeof(T) == typeof(ushort))
            {
                value = (T)(object)BitConverter.ToUInt16(rcvBuffer, 0);
            }
            else if (typeof(T) == typeof(int))
            {
                value = (T)(object)BitConverter.ToInt32(rcvBuffer, 0);
            }
            else if (typeof(T) == typeof(uint))
            {
                value = (T)(object)BitConverter.ToUInt32(rcvBuffer, 0);
            }
            else if (typeof(T) == typeof(long))
            {
                value = (T)(object)BitConverter.ToInt64(rcvBuffer, 0);
            }
            else if (typeof(T) == typeof(ulong))
            {
                value = (T)(object)BitConverter.ToUInt64(rcvBuffer, 0);
            }
            else if (typeof(T) == typeof(float))
            {
                value = (T)(object)BitConverter.ToSingle(rcvBuffer, 0);
            }
            else if (typeof(T) == typeof(double))
            {
                value = (T)(object)BitConverter.ToDouble(rcvBuffer, 0);
            }
            return 0;
        }

        /// <summary>
        /// 从起始地址开始，读取一段字节流
        /// </summary>
        /// <param name="startAddress">起始寄存器地址</param>
        /// <param name="length">读取的字节个数,最多250个字节，最多125个寄存器</param>
        /// <param name="values">返回的字节流数据</param>
        /// <returns>true：读取成功 false：读取失败</returns>
        public int ReadValue(int startAddress, int length, out byte[] values, out string msg)
        {
            values = new byte[length];
            return SendByte(startAddress, true, length, ref values, out msg);
        }

        /// <summary>
        /// 读取（长）字符串，设定每次最多读取200个字符，
        /// 分多次读取，每一次读取的起始寄存器地址偏移100
        /// </summary>
        /// <param name="startAddress"></param>
        /// <param name="length"></param>
        /// <param name="longString"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public int ReadLongString(int startAddress, int length, out string longString, out string msg)
        {
            msg = string.Empty;
            longString = string.Empty;
            int cycleCount = 200;
            int pageSize = (length + cycleCount - 1) / cycleCount;
            int errorCode = -1;
            for (int i = 0; i < pageSize; i++)
            {
                int readLength = cycleCount;
                if (i == pageSize - 1)
                {
                    //最后一次
                    readLength = length - i * cycleCount;
                }
                byte[] values;
                errorCode = ReadValue(startAddress + (i * cycleCount / 2), readLength, out values, out msg);
                if (errorCode != 0)
                {
                    return errorCode;
                }
                longString += Encoding.ASCII.GetString(values);
            }
            return errorCode;
        }

        /// <summary>
        /// 用于排他锁,确保在多线程调用该接口时，不会同时调用。确保在处理当前命令时，其他命令请等待
        /// </summary>
        static int lockedValue = 0;

        #region 关键的Modbus报文处理
        /// <summary>
        /// 报文处理：发送命令并等待响应结果
        /// 确保不能同时读写同一个地址，需要加一个锁对象
        /// </summary>
        /// <param name="startAddress">要读写的汇川PLC的内存寄存器地址，只考虑M区的MW起始寄存器地址，如果是MB请除以2后传入；如果是MD请乘以2后传入</param>
        /// <param name="isRead">读(true)还是写(false)</param>
        /// <param name="length">读取的字节个数,最多250个字节，最多125个寄存器。如果是写入，该参数无意义，直接按datas.Length处理</param>
        /// <param name="rev">返回的字节流数据,直接是用户所需的字节流数据。写寄存器时，此参数无意义</param>
        /// <param name="msg">异常信息描述</param>
        /// <param name="datas">要写入的字节流数据，读取时【isRead=true】忽略该参数</param>
        /// <returns>返回错误号，0为处理成功</returns>
        private int SendByte(int startAddress, bool isRead, int length, ref byte[] rev, out string msg, byte[] datas = null)
        {
            msg = string.Empty;
            if (!IsConnected)
            {
                msg = $"【未建立连接】尚未连接汇川PLC成功【{ip}:{port}】,请检查配置和网络，当前起始地址【{startAddress}】";
                return 1000;
            }
            if (startAddress < 0 || startAddress > 65535)
            {
                msg = $"【参数非法】汇川PLC的Modbus协议的起始地址必须在0~65535之间,当前起始地址【{startAddress}】";
                return 1001;
            }
            //读保持寄存器0x03读取的寄存器数量的范围为 1~125。因一个寄存器【一个Word】存放两个字节，因此 字节数组的长度范围 为 1~250
            if (isRead && (length < 1 || length > 250))
            {
                msg = $"【参数非法】读取的字节数组的长度范围为1~250，当前起始地址【{startAddress}】，读取长度【{length}】";
                return 1002;
            }
            if (!isRead && (datas == null || datas.Length < 1 || datas.Length > 240))
            {
                msg = $"【参数非法】写入的字节数组的不能为空，也不能写入超过120个寄存器【240个字节】，当前起始地址【{startAddress}】";
                return 1003;
            }
            //添加锁
            while (Interlocked.Exchange(ref lockedValue, 1) != 0)
            {
                //此循环用于等待当前捕获current的线程执行结束
                //Thread.Sleep(50);
            }
            byte[] addrArray = BitConverter.GetBytes((ushort)startAddress);
            byte[] SendByte = new byte[12];
            //读取的寄存器个数： 如果length为偶数 则为 length/2 如果length为奇数，则为(length+1)/2。因整数相除，结果不考虑余数，所以如下通用：
            byte registerCount = (byte)((length + 1) / 2);
            if (isRead)
            {
                /*
                 * 发送的请求【读多个保持寄存器 0x03】Modbus字节流说明：
            * byte[0] byte[1] 随便指定，PLC返回的前两个字节完全一致
            * byte[2]=0 byte[3]=0 固定为0 代表Modbus标识
            * byte[4] byte[5] 排在byte[5]后面所有字节的个数，也就是总长度6
            * byte[6] 站号(从站标识)，随便指定，00--FF都可以,PLC返回的保持一致
            * byte[7] 功能码，读保持寄存器 0x03：
            * byte[8] byte[9] 起始地址，如起始地址为整数20 则为 0x00 0x14，再如起始地址为整数1000，则为 0x03 0xE8
            * byte[10] byte[11] 寄存器个数【Word】，读取的数据长度【以字Word为单位】，读取Int32或Float就是两个字，读取byte或short就是一个字 范围【1~125 即 0x0001~0x007D】
                */
                SendByte = new byte[12] { 0x02, 0x01, 0x00, 0x00, 0x00, 0x06, 0x01, 0x03, addrArray[1], addrArray[0], 0x00, registerCount };
            }
            else
            {
                //生成写入寄存器命令
                SendByte = GenerateWriteCommand(addrArray, datas);
            }
            System.Diagnostics.Stopwatch stopwatch = System.Diagnostics.Stopwatch.StartNew();
            try
            {
                msock.Send(SendByte, SocketFlags.None);
            }
            catch (SocketException ex)
            {
                IsConnected = false;
                msg = $"【网络异常】发送命令失败，当前起始地址【{startAddress}】,套接字错误【{ex.SocketErrorCode}】,【{ex.Message}】";
                //释放锁
                Interlocked.Exchange(ref lockedValue, 0);//将current重置为0
                return 1004;
            }
            catch (Exception ex)
            {
                IsConnected = false;
                msg = $"【处理异常】发送命令失败，当前起始地址【{startAddress}】【{ex.Message}】";
                //释放锁
                Interlocked.Exchange(ref lockedValue, 0);//将current重置为0
                return 1005;
            }

            byte[] buffer = new byte[2048];
            int rcvCount = 0;//收到的字节数
            try
            {
                rcvCount = msock.Receive(buffer);
                RecordDataEvent?.Invoke(SendByte, new ArraySegment<byte>(buffer, 0, rcvCount).ToArray(), stopwatch.Elapsed.TotalMilliseconds);
            }
            catch (SocketException ex)
            {
                IsConnected = false;
                msg = $"【网络异常】接收数据失败，当前起始地址【{startAddress}】,套接字错误【{ex.SocketErrorCode}】,【{ex.Message}】";
                //释放锁
                Interlocked.Exchange(ref lockedValue, 0);//将current重置为0
                return 1006;
            }
            catch (Exception ex)
            {
                IsConnected = false;
                msg = $"【处理异常】接收数据失败，当前起始地址【{startAddress}】【{ex.Message}】";
                //释放锁
                Interlocked.Exchange(ref lockedValue, 0);//将current重置为0
                return 1007;
            }
            if (rcvCount < 9 || buffer[0] != SendByte[0] || buffer[1] != SendByte[1] || buffer[2] != SendByte[2] || buffer[3] != SendByte[3] || buffer[7] != SendByte[7])
            {
                msg = $"【数据非法】接收数据非法或者处理失败，当前起始地址【{startAddress}】接收的数据【{string.Join(",", new ArraySegment<byte>(buffer, 0, rcvCount))}】";
                Interlocked.Exchange(ref lockedValue, 0);//将current重置为0
                return 1008;
            }
            if (isRead)
            {
                /*
                 * * 接收的内容解析：【读多个保持寄存器 0x03】【Modbus响应】
            * byte[0] byte[1] 与发送的一致
            * byte[2]=0 byte[3]=0 固定为0 代表Modbus标识
            * byte[4] byte[5] 排在byte[5]后面所有字节的个数
            * byte[6] 站号，与发送的一致
            * byte[7] 功能码，与发送的一致
            * byte[8] 表示byte[8]后面跟随的字节数【发送的寄存器个数 * 2】
            * byte[9] byte[10] byte[11] byte[12] byte[...] 真实数据的字节流，字节流的总个数就是byte[8]
                */
                int receiveLength = buffer[8];
                if (receiveLength != registerCount * 2)
                {
                    //接收到的实际数据字节个数:buffer[8]
                    msg = $"【数据非法】解析接收数据非法，读取后接收的实际数据长度【{receiveLength}】不是读取寄存器数量【{registerCount}】的2倍.当前起始地址【{startAddress}】接收的数据【{string.Join(",", new ArraySegment<byte>(buffer, 0, rcvCount))}】";
                    Interlocked.Exchange(ref lockedValue, 0);//将current重置为0
                    return 1009;
                }
                rev = new byte[receiveLength];
                //相邻两个数据交换 【索引0和索引1交换，索引2与索引3交换，...】
                for (int i = 0; i < receiveLength; i++)
                {
                    if (i % 2 == 0)
                    {
                        rev[i] = buffer[9 + i + 1];
                    }
                    else
                    {
                        rev[i] = buffer[9 + i - 1];
                    }
                }
            }
            else
            {
                if (buffer[7] == 0x10 && rcvCount > 11 && buffer[11] != SendByte[11])
                {
                    //如果是写多个寄存器 并且 写入的寄存器数量不匹配
                    msg = $"【数据非法】解析接收数据非法，写多个寄存器时，返回的写入寄存器数量【{buffer[11]}】与请求的寄存器数量【{SendByte[11]}】不一致，地址【{startAddress}】接收的数据【{string.Join(",", new ArraySegment<byte>(buffer, 0, rcvCount))}】";
                    Interlocked.Exchange(ref lockedValue, 0);//将current重置为0
                    return 1010;
                }
            }            
            //释放锁
            Interlocked.Exchange(ref lockedValue, 0);//将current重置为0
            return 0;            
        }
        #endregion

        /// <summary>
        /// 生成写入寄存器命令
        /// </summary>
        /// <param name="addrArray">起始地址字节数组，其实就是ushort地址转化后的两个字节</param>
        /// <param name="datas">要写入的字节数组</param>
        /// <returns></returns>
        private byte[] GenerateWriteCommand(byte[] addrArray, byte[] datas)
        {
            byte[] SendByte = new byte[12];
            //如果是写PLC寄存器地址
            byte registerCount = (byte)((datas.Length + 1) / 2);
            //实际写入的字节个数：注意buffer数组的长度为奇数时 需要将最后一个寄存器的高位设置为0
            byte writeByteCount = (byte)(registerCount * 2);
            if (registerCount == 1)
            {
                //如果只写入一个寄存器，可以使用0x06命令【写单个保持寄存器】，用于sbyte,byte,short,ushort                    
                SendByte = new byte[12] { 0x02, 0x01, 0x00, 0x00, 0x00, 0x06, 0x01, 0x06, addrArray[1], addrArray[0], 0x00, 0x00 };
                if (datas.Length == 1)
                {
                    SendByte[11] = datas[0];
                }
                else //写入的字节数组长度为2
                {
                    SendByte[10] = datas[1];
                    SendByte[11] = datas[0];
                }
                return SendByte;
            }
            //如果2个或多个寄存器，使用命令0x10【写多个保持寄存器】，用于int,uint,float,long,ulong,double等
            //实际写入的字节个数：注意buffer数组的长度为奇数时 需要将最后一个寄存器的高位设置为0
            /*
             * 发送的请求【写多个保持寄存器 0x10】Modbus字节流说明：【写Int32，UInt32，Float需要两个寄存器 写Int64，UInt64，Double需要四个寄存器】
             * byte[0] byte[1] 随便指定，PLC返回的前两个字节完全一致
             * byte[2]=0 byte[3]=0 固定为0 代表Modbus标识 随便指定也可以
             * byte[4] byte[5] 排在byte[5]后面所有字节的个数
             * byte[6] 站号，随便指定，00--FF都可以,PLC返回的保持一致
             * byte[7] 功能码，0x10：写多个保持寄存器
             * byte[8] byte[9] 起始地址，如起始地址为整数20 则为 0x00 0x14，再如起始地址为整数1000，则为 0x03 0xE8
             * byte[10] byte[11] 寄存器数量【设置长度】，范围1~120【0x78】，因此byte[10]=0, byte[11]为寄存器数量
             * byte[12] 字节个数 也就是【寄存器数量*2】，范围【2~240】
             * byte[13] byte[14] byte[15] byte[16] byte[...]  具体的数据内容 对应 数据一高位 数据一低位 数据二高位 数据二低位
            */
            SendByte = new byte[13 + writeByteCount];
            SendByte[0] = 0x02;
            SendByte[1] = 0x01;
            SendByte[5] = (byte)(7 + writeByteCount);
            SendByte[6] = 0x01;
            SendByte[7] = 0x10;//写多个寄存器标记：0x10
            SendByte[8] = addrArray[1];
            SendByte[9] = addrArray[0];
            SendByte[11] = registerCount;
            SendByte[12] = writeByteCount;
            //交换相邻两个字节 【索引0和索引1交换，索引2与索引3交换，...需考虑datas.Length是奇数时的特殊处理】
            for (int i = 0; i < writeByteCount; i++)
            {
                if (i % 2 == 0)
                {
                    if (i + 1 == datas.Length)
                    {
                        //如果是写入奇数个字节，需要将最后一个寄存器的高位设置为0
                        SendByte[13 + i] = 0;
                    }
                    else
                    {
                        SendByte[13 + i] = datas[i + 1];
                    }
                }
                else
                {
                    SendByte[13 + i] = datas[i - 1];
                }
            }
            return SendByte;
        }
    }

    /// <summary>
    /// 字节存储类型，C#中字节存放顺序是DCBA【低字节在前】
    /// 汇川PLC默认存储是CDAB
    /// </summary>
    public enum StoreByteCategory
    {
        /// <summary>
        /// 顺序，高字节在前,低字节在后
        /// </summary>
        ABCD = 0,
        /// <summary>
        /// 字正序，字节颠倒
        /// </summary>
        BADC = 1,
        /// <summary>
        /// 字颠倒，字节正序
        /// </summary>
        CDAB = 2,
        /// <summary>
        /// 逆序，低字节在前,高字节在后
        /// </summary>
        DCBA = 3
    }
}