NET工控，上位机,Modbus485网口/串口通讯（鸣志步进电机,鸣志伺服电机,松下伺服电机,华庆军继电器模块）

using Modbus.Device; using Sunny.UI; using System; using System.IO.Ports; using System.Linq; using System.Net; using System.Net.Sockets; using System.Threading;  namespace SunnyUI_NuclearForm {     /// <summary>     /// Modbus通用帮助类     /// </summary>     public class ModbusHelper : IDisposable     {          IModbusMaster master;          //串口通信         SerialPort serialPort;          //网口-TCP         TcpClient tcpClient;          //网口-套接字(备用)         Socket socket;           //private static readonly object threadObj = new object();//线程安全锁          //ManualResetEvent manualEvent = new ManualResetEvent(true);//true运行，false不运行           #region  connection          /// <summary>         /// 串口连接         /// </summary>         /// <returns></returns>         public bool ConnectForSerialPort(string com, int baudRate)         {             bool result = false;              if (!string.IsNullOrWhiteSpace(com) && baudRate > 0)             {                 serialPort = new SerialPort();                  serialPort.PortName = com;                 serialPort.BaudRate = baudRate;                  //下面三个参数看情况要不要开放                 serialPort.DataBits = 8;                 serialPort.StopBits = StopBits.One;                 serialPort.Parity = Parity.None;                  try                 {                     if (!serialPort.IsOpen)                     {                         serialPort.Open();                     }                       master = ModbusSerialMaster.CreateRtu(serialPort);                     master.Transport.ReadTimeout = 3 * 1000;//读 超时时间                     master.Transport.WriteTimeout = 3 * 1000;//写 超时时间                     master.Transport.Retries = 20;//重试次数                     master.Transport.WaitToRetryMilliseconds = 3 * 1000;//重试间隔                      result = true;                 }                 catch (Exception e)                 {                     //打开失败                     LogHelper.Error($"串口无法连接！COM：{com}，波特率：{baudRate}。以下为详细信息：rn{e.Message}");                     result = false;                 }             }             return result;         }          /// <summary>         /// 网口TCP连接         /// </summary>         /// <param name="ip"></param>         /// <returns></returns>         public bool ConnectForTCP(string ip, int port)         {             bool result = false;             if (!string.IsNullOrWhiteSpace(ip) && port > 0)             {                 try                 {                     tcpClient = new TcpClient(ip, port);                     if (tcpClient.Connected)                     {                         master = ModbusIpMaster.CreateIp(tcpClient);                          master.Transport.ReadTimeout = 3 * 1000;//读 超时时间                         master.Transport.WriteTimeout = 3 * 1000;//写 超时时间                         master.Transport.Retries = 20;//重试次数                         master.Transport.WaitToRetryMilliseconds = 3 * 1000;//重试间隔                          result = true;                     }                     else                     {                         LogHelper.Error($"网口无法连接！IP：{ip}，端口：{port}。rn");                         result = false;                     }                 }                 catch (Exception e)                 {                     LogHelper.Error($"网口无法连接！IP：{ip}，端口：{port}。以下为详细信息：rn{e.Message}");                     return false;                 }              }             return result;          }          /// <summary>         ///  Socket连接(备用)         /// </summary>         /// <param name="ip"></param>         /// <param name="port"></param>         /// <returns></returns>         public bool ConnectForSocket(string ip, int port)         {             bool result = false;             if (!string.IsNullOrWhiteSpace(ip) && port > 0)             {                 //部分硬件,用TCP发指令没响应,但是用Socket可以,不知道是没支持好TCP还是没支持好Modbus                 //所以在此留下备用通信方法                   socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);                  try                 {                     socket.Connect(IPAddress.Parse(ip), port);                     result = true;                  }                 catch (Exception e)                 {                     //连接失败                     LogHelper.Error($"Socket(备用)无法连接！IP：{ip}，端口：{port}。以下为详细信息：rn{e.Message}");                     result = false;                 }              }             return result;         }          #endregion          #region send          /// <summary>         /// 向串口发送数据 Modbus报文(字节)         /// </summary>         public void SendSerialByte(byte[] arr)         {             //this.manualEvent.WaitOne();//等待             //lock (threadObj)             //{             //this.manualEvent.Reset();//红灯              if (serialPort != null && serialPort.IsOpen && arr != null && arr.Count() > 0)             {                 serialPort.DiscardInBuffer();                 serialPort.DiscardOutBuffer();                  Thread.Sleep(50);                  serialPort.Write(arr, 0, arr.Length);                  Thread.Sleep(50);//写入读取命令后延时读取 或者跟下一条命令之间产生间隔                  try                 {                     // 接收来自读取命令的数据 广播命令执行完毕不响应                     //byte[] receiveData = new byte[1024];                     //int bytesRead = serialPort.Read(receiveData, 0, receiveData.Length);                      if (serialPort.BytesToRead > 0)                     {                         var result = serialPort.ReadExisting();                     }                  }                 catch (Exception e)                 {                  }              }              //this.manualEvent.Set();//绿灯             //}         }          /// <summary>         /// 向串口发送数据 Modbus报文(字符串)         /// </summary>         public string SendSerialString(string str)         {             string result = string.Empty;              //this.manualEvent.WaitOne();//等待              //lock (threadObj)             //{             //this.manualEvent.Reset();//红灯             if (serialPort != null && serialPort.IsOpen && !string.IsNullOrWhiteSpace(str))             {                  serialPort.DiscardInBuffer();                 serialPort.DiscardOutBuffer();                  Thread.Sleep(50);                  serialPort.Write(str);                  Thread.Sleep(50);//写入读取命令后延时读取 或者跟下一条命令之间产生间隔                  try                 {                     // 接收来自读取命令的数据 广播命令执行完毕不响应                     if (serialPort.BytesToRead > 0)                     {                         result = serialPort.ReadExisting();                     }                 }                 catch (Exception e)                 {                  }              }             //this.manualEvent.Set();//绿灯             //}             return result;         }          /// <summary>         /// 向网口发送数据 Modbus报文         /// </summary>         /// <param name="arr"></param>         public void SendTCPByte(byte[] arr)         {             if (arr != null && arr.Count() > 0 && tcpClient.Connected)             {                 // 获取网络流                 NetworkStream stream = tcpClient.GetStream();                  //tcpClient.Client.Send(arr);                 stream.Write(arr, 0, arr.Length);                 //Thread.Sleep(50);//写入读取命令后延时读取 或者跟下一条命令之间产生间隔                  try                 {                     // 接收来自读取命令的数据 广播命令执行完毕不响应                     byte[] receiveData = new byte[1024];                     int bytesRead = stream.Read(receiveData, 0, receiveData.Length);                 }                 catch (Exception)                 {                      throw;                 }              }           }          /// <summary>         /// 向网口发送数据 Modbus报文(Socket备用)         /// </summary>         /// <param name="arr"></param>         public void SendSocketByte(byte[] arr)         {             if (arr != null && arr.Count() > 0 && socket.Connected)             {                 socket.Send(arr);                 //Thread.Sleep(50);//写入读取命令后延时读取 或者跟下一条命令之间产生间隔                  try                 {                     // 接收来自读取命令的数据 广播命令执行完毕不响应                     byte[] buffer = new byte[1024];                     int byteRead = socket.Receive(buffer);                 }                 catch (Exception)                 {                      throw;                 }               }         }          #endregion          #region read           /// <summary>         /// 读取单个线圈 Modbus 01功能码         /// </summary>         /// <param name="slaveAddress">从站号</param>         /// <param name="StartAddress">开始读取的寄存器地址</param>         /// <param name="numberOfPoints">读取数据个数</param>         /// <returns></returns>         public bool[] ReadCoils_01(byte slaveAddress, ushort startAddress, ushort numberOfPoints)         {             return master.ReadCoils(slaveAddress, startAddress, numberOfPoints);         }          /// <summary>         /// 读取离散/输入线圈  Modbus 02功能码         /// </summary>         /// <param name="slaveAddress">从站号</param>         /// <param name="StartAddress">开始读取的寄存器地址</param>         /// <param name="numberOfPoints">读取数据个数</param>         /// <returns></returns>         public bool[] ReadInputs_02(byte slaveAddress, ushort startAddress, ushort numberOfPoints)         {             return master.ReadInputs(slaveAddress, startAddress, numberOfPoints);         }          /// <summary>         /// 读取保持型寄存器  Modbus 03功能码         /// </summary>         /// <param name="slaveAddress">从站号</param>         /// <param name="StartAddress">开始读取的寄存器地址</param>         /// <param name="numberOfPoints">读取数据个数</param>         /// <returns></returns>         public ushort[] ReadHoldingRegisters_03(byte slaveAddress, ushort StartAddress, ushort numberOfPoints)         {              try             {                 ushort[] Uvalue = master.ReadHoldingRegisters(slaveAddress, StartAddress, numberOfPoints);                  //ushort 转short                 //short[] value = new short[Uvalue.Length];                 //for (int i = 0; i < Uvalue.Length; i++)                 //{                 //    if (Uvalue[i] > short.MaxValue)                 //    {                 //        value[i] = (short)(Uvalue[i] - 65536);                 //    }                 //    else                 //    {                 //        value[i] = (short)Uvalue[i];                 //    }                 //}                  return Uvalue;             }             catch (Exception e)             {                 return null;             }          }          /// <summary>         /// 读取输入寄存器 Modbus 04功能码         /// </summary>         /// <param name="slaveAddress">从站号</param>         /// <param name="StartAddress">开始读取的寄存器地址</param>         /// <param name="numberOfPoints">读取数据个数</param>         /// <returns></returns>         public ushort[] ReadInputRegisters_04(byte slaveAddress, ushort startAddress, ushort numberOfPoints)         {              try             {                 ushort[] Uvalue = master.ReadInputRegisters(slaveAddress, startAddress, numberOfPoints);                  //ushort 转short                  //short[] value = new short[Uvalue.Length];                 //for (int i = 0; i < Uvalue.Length; i++)                 //{                 //    if (Uvalue[i] > short.MaxValue)                 //    {                 //        value[i] = (short)(Uvalue[i] - 65536);                 //    }                 //    else                 //    {                 //        value[i] = (short)Uvalue[i];                 //    }                   //}                  return Uvalue;             }             catch (Exception e)             {                 return null;             }          }           #endregion          #region write          /// <summary>         /// 写单个线圈 Modbus 05功能码         /// </summary>         /// <param name="slaveAddress"></param>         /// <param name="coilAddress"></param>         /// <param name="value"></param>         public void WriteSingleCoil_05(byte slaveAddress, ushort coilAddress, bool value)         {              master.WriteSingleCoil(slaveAddress, coilAddress, value);          }          /// <summary>         /// 写单个保持寄存器 Modbus 06功能码         /// </summary>         /// <param name="slaveAddress"></param>         /// <param name="registerAddress"></param>         /// <param name="value"></param>         public void WriteSingleRegister_06(byte slaveAddress, ushort registerAddress, ushort value)         {              try             {                 //short 转 ushort                  //ushort Uvalue;                 //if (value < 0)                 //{                 //    Uvalue = (ushort)(ushort.MaxValue + value + 1);                 //}                 //else                 //{                 //    Uvalue = (ushort)value;                 //}                 master.WriteSingleRegister(slaveAddress, registerAddress, value);             }             catch (Exception e)             {                 return;             }           }            /// <summary>         /// 写多个寄存器  Modbus 10功能码          /// </summary>         /// <param name="slaveAddress"></param>         /// <param name="startAddress"></param>         /// <param name="data"></param>         public void WriteMultipleRegisters_10(byte slaveAddress, ushort startAddress, ushort[] data)         {             try             {                 master.WriteMultipleRegisters(slaveAddress, startAddress, data);                 //master.WriteMultipleRegistersAsync(slaveAddress, startAddress, data);             }             catch (Exception e)             {              }             }          #endregion          #region  鸣志伺服-多线程不安全模式          // 设置加减速,减速度,速度 数值1-10k/分钟         public void SetAccelerationSpeedDeceleration(byte slaveAddr, ushort acceleration, ushort deceleration, ushort speed)         {             ushort parametersAddress = 344;              ushort[] parameters = new ushort[6];             parameters[0] = 0;             parameters[1] = acceleration;             parameters[2] = 0;             parameters[3] = deceleration;             parameters[4] = 0;             parameters[5] = speed;              WriteMultipleRegisters_10(slaveAddr, parametersAddress, parameters);         }          /// <summary>         /// 读取伺服电机加速度减速度速度         /// </summary>         /// <param name="slaveAddr"></param>         /// <returns></returns>         public ushort[] ReadAccelerationSpeedDeceleration(byte slaveAddr)         {             ushort[] result = new ushort[3];             ushort[] speedArr = ReadHoldingRegisters_03(slaveAddr, 344, 6);             if (speedArr != null && speedArr.Length >= 6)             {                 //AC  加速度  344+1                 //DC  减速度  346+1                 //VE  速度  348+1                 result[0] = speedArr[1];                 result[1] = speedArr[3];                 result[2] = speedArr[5];             }             return result;         }          // 设置距离 数值1-100/圈         public void Distance(byte slaveAddr, long distance)         {              ushort parametersAddress = 350;             ushort[] parameters = new ushort[1];             parameters[0] = (ushort)distance;              WriteMultipleRegisters_10(slaveAddr, parametersAddress, parameters);          }          // 设置距离 脉冲数         public void DistanceForPulse(byte slaveAddr, int pulse)         {             string convert = pulse.ToString("X").PadLeft(8, '0'); //转十六进制然后八位补零              var sendByte = new byte[] {                   slaveAddr,                   0X10, 0x01, 0x5E, 0x00, 0x02 ,0x04 ,                   Convert.ToByte(convert.Substring(0, 2), 16),                   Convert.ToByte(convert.Substring(2, 2), 16),             Convert.ToByte(convert.Substring(4, 2), 16),             Convert.ToByte(convert.Substring(6, 2), 16)};              var crc = CRC16.CRC16Calc(sendByte);             var newSend = sendByte.Concat(crc).ToArray();              SendSerialByte(newSend);           }           //Modbus 寄存器表中寄存器40125被定义为操作码寄存器，向40125寄存器写入相应的操作码，即执行相应操作码的动作         //FL 0x66          //SK 0xE1         //SO 0x8B          /// <summary>         /// 电机旋转运行到指定距离 (执行相对移动命令,移动距离和方向来自最后一个DI命令 按给定长度进至距离)         /// </summary>         /// <param name="slaveAddr"></param>         public void Opcode_FL(byte slaveAddr)         {             ushort operationCodeAddress = 124;             byte opCode = 0x66;              WriteSingleRegister_06(slaveAddr, operationCodeAddress, opCode);         }          /// <summary>         /// 强制停止         /// </summary>         /// <param name="slaveAddr"></param>         public void Opcode_SK(byte slaveAddr)         {             ushort operationCodeAddress = 124;             byte opCode = 0xE1;             WriteSingleRegister_06(slaveAddr, operationCodeAddress, opCode);         }          ///// <summary>         ///// 强制停止-带缓冲         ///// </summary>         ///// <param name="slaveAddr"></param>         //public  void Opcode_SKD(byte slaveAddr)         //{         //    ushort operationCodeAddress = 124;         //    byte opCode = 0xE2;         //    master.WriteSingleRegister(slaveAddr, operationCodeAddress, opCode);         //}          /// <summary>         /// 报警清除         /// </summary>         /// <param name="slaveAddr"></param>         public void Opcode_AX(byte slaveAddr)         {             ushort operationCodeAddress = 124;             byte opCode = 0xBA;             WriteSingleRegister_06(slaveAddr, operationCodeAddress, opCode);         }           //1 0x31 数字量输入/输出端口1         //2 0x32 数字量输入/输出端口2         //3 0x33 数字量输入/输出端口3         //4 0x34 数字量输入/输出端口4         //5 0x35 数字量输入/输出端口5         //6 0x36 数字量输入/输出端口6         //7 0x37 数字量输出端口7         //8 0x38 数字量输出端口8         //9 0x39 数字量输出端口9         //L 0x4C 低电平(光耦导通)         //H 0x48 高电平(光耦断开)          /// <summary>         /// Y口输出  L 0x4C H 0x48         /// </summary>         /// <param name="slaveAddr"></param>         public void Opcode_SO(byte slaveAddr, byte ioPoint, byte condition)         {             ushort operationCodeAddress = 124;             byte operationCode = 0x8B;              ushort[] operationCodeParameters = new ushort[3];             operationCodeParameters[0] = operationCode;             operationCodeParameters[1] = ioPoint;             operationCodeParameters[2] = condition;              WriteMultipleRegisters_10(slaveAddr, operationCodeAddress, operationCodeParameters);           }          /// <summary>         /// X口输入 ,0触碰1断开         /// </summary>         /// <param name="slaveAddr"></param>         public string Opcode_IS(byte slaveAddr)         {             string result = string.Empty;             try             {                 ushort inputPortAddress = 5;                 ushort numberRegisters = 1;                  ushort[] data = ReadHoldingRegisters_03(slaveAddr, inputPortAddress, numberRegisters);                 if (data != null && data.Count() > 0)                 {                     result = Convert.ToString(data[0], 2).PadLeft(12, '0');//转2进制,然后12位补零;                 }             }             catch (Exception)             {                  throw;             }             return result;         }          /// <summary>         /// 伺服使能         /// </summary>         /// <param name="slaveAddr"></param>         /// <returns></returns>         public void Opcoded_ME(byte slaveAddr)         {             ushort operationCodeAddress = 124;             byte opCode = 0x9F;             WriteSingleRegister_06(slaveAddr, operationCodeAddress, opCode);         }          /// <summary>         /// 伺服使能关闭         /// </summary>         /// <param name="slaveAddr"></param>         /// <returns></returns>         public void Opcoded_MD(byte slaveAddr)         {             ushort operationCodeAddress = 124;             byte opCode = 0x9E;             WriteSingleRegister_06(slaveAddr, operationCodeAddress, opCode);         }          //以下单独设置参数，在不知道其他参数，不改动其他参数的时候使用（备用）          // 设置加速度         public void Acceleration(byte slaveAddr, ushort acceleration)         {             ushort parametersAddress = 344;              ushort[] parameters = new ushort[2];             parameters[0] = 0;             parameters[1] = acceleration;               WriteMultipleRegisters_10(slaveAddr, parametersAddress, parameters);         }          // 设置减速度         public void Deceleration(byte slaveAddr, ushort deceleration)         {             ushort parametersAddress = 346;              ushort[] parameters = new ushort[2];             parameters[0] = 0;             parameters[1] = deceleration;               WriteMultipleRegisters_10(slaveAddr, parametersAddress, parameters);         }          // 设置速度         public void Speed(byte slaveAddr, ushort speed)         {             ushort parametersAddress = 348;              ushort[] parameters = new ushort[2];             parameters[0] = 0;             parameters[1] = speed;               WriteMultipleRegisters_10(slaveAddr, parametersAddress, parameters);         }          #endregion          #region 鸣志步进-多线程不安全模式           //鸣志步进写入,读取命令延时在 ModbusHelper.SendSerialString 统一设置          //步进电机10以及以上从站地址以符号表示           //AC25 - 将加 设置为25转/秒/秒          344         //DE25 - 将减 设置为25转/秒/秒          346         //VE1.5 - 将速度设置为1.5转/秒          348         //FL20000 - 执行20000步的按长度给进移动到距离 350          /// <summary>         ///  步进电机设置加速，减速，速度 支持整数和小数 数值1-10转/秒         /// </summary>         public void Stepping_SetAccelerationSpeedDeceleration(object slaveAddr, string acceleration, string deceleration, string speed)         {             string strAC = $"{slaveAddr}AC{acceleration}r";             SendSerialString(strAC);             //加速度               string strDE = $"{slaveAddr}DE{deceleration}r";             SendSerialString(strDE);             //减速度               string strVE = $"{slaveAddr}VE{speed}r";             SendSerialString(strVE);             //速度         }          /// <summary>         /// 步进电机读取当前电机的加速度减速度速度         /// </summary>         /// <param name="slaveAddr"></param>         /// <returns></returns>         public int[] Stepping_Read_AC_DE_VE(object slaveAddr)         {             int[] result = new int[3];               //加速度             string strAC = $"{slaveAddr}ACr";             var speed = SendSerialString(strAC);             speed = speed.Replace($"{slaveAddr}AC=", string.Empty);             speed = speed.Replace("r", string.Empty);             if (!string.IsNullOrWhiteSpace(speed))             {                 result[0] = Convert.ToInt32(speed);             }              //减速度             string strDE = $"{slaveAddr}DEr";             speed = SendSerialString(strDE);             speed = speed.Replace($"{slaveAddr}DE=", string.Empty);             speed = speed.Replace("r", string.Empty);             if (!string.IsNullOrWhiteSpace(speed))             {                 result[1] = Convert.ToInt32(speed);             }              //速度             string strVE = $"{slaveAddr}VEr";             speed = SendSerialString(strVE);             speed = speed.Replace($"{slaveAddr}VE=", string.Empty);             speed = speed.Replace("r", string.Empty);             if (!string.IsNullOrWhiteSpace(speed))             {                 result[2] = Convert.ToInt32(speed);             }              return result;         }           /// <summary>         ///  设置步进电机移动距离 (支持正负数)   数值1w脉冲/圈         /// </summary>         /// <param name="slaveAddr"></param>         /// <param name="speed"></param>         public void Stepping_Distance(object slaveAddr, long distance)         {             string strDI = $"{slaveAddr}DI{distance}r";             SendSerialString(strDI);             //移动距离         }          /// <summary>         ///  电机旋转运行到指定距离 (执行相对移动命令,移动距离和方向来自最后一个DI命令 按给定长度进至距离) 数值同DI         /// </summary>         public void Stepping_FL(object slaveAddr, string numberStr)         {             string str = $"{slaveAddr}FL{numberStr}r";             SendSerialString(str);         }           /// <summary>         ///  设置步进电机强制停止         /// </summary>         public void Stepping_SK(object slaveAddr)         {             string str = $"{slaveAddr}SKr";             SendSerialString(str);         }          /// <summary>         ///  设置步进电机报警复位(部分电机是限位开关，不是限位传感器)         /// </summary>         public void Stepping_AR(object slaveAddr)         {             string str = $"{slaveAddr}ARr";             SendSerialString(str);         }          /// <summary>         ///  设置步进电机Y口开关,L开,H关         /// </summary>         public void Stepping_SO(object slaveAddr, int number, string _switch)         {             string str = $"{slaveAddr}SO{number}{_switch}r";             SendSerialString(str);         }          /// <summary>         ///  读取步进电机X口开关,0触碰1断开         /// </summary>         public string Stepping_IS(object slaveAddr)         {             string str = $"{slaveAddr}ISr";             str = SendSerialString(str);             return str;          }          /// <summary>         ///  设置步进电机运转时同时输出 1 支持 0 不支持         /// </summary>         public void Stepping_MT(object slaveAddr, int number)         {             //2024年 鸣志研发确认鸣志伺服暂不支持MT多任务并行             string str = $"{slaveAddr}MT{number}r";             SendSerialString(str);         }             #endregion          #region close  关闭串口、网口、Socket连接          /// <summary>         ///  关闭串口,Modbus485连接         /// </summary>         public void CloseSerialPort()         {             serialPort.Close();             master.Dispose();         }          /// <summary>         ///  关闭网口,Modbus485连接         /// </summary>         public void CloseTCP()         {             tcpClient.Close();             master.Dispose();         }          /// <summary>         /// 关闭socket,Modbus485连接         /// </summary>         public void CloseSocket()         {             socket.Close();             socket.Disconnect(true);              //master.Dispose();         }          /// <summary>         /// 垃圾回收,串口,网口,socket,Modbus485 全部关闭         /// 单个设备调试用using,多线程流程用手动连接并关闭         /// </summary>         public void Dispose()         {             try             {                 //串口部分                 if (serialPort != null)                 {                     serialPort.Close();                 }                  //网口部分                 if (tcpClient != null)                 {                     tcpClient.Close();                 }                  //socket 备用部分                 if (socket != null)                 {                     socket.Close();                 }                  //modbus-485                 if (master != null)                 {                     master.Dispose();                 }              }             catch (Exception e)             {                 LogHelper.Error($"垃圾回收处理异常:" + e.Message);             }          }          #endregion      }      /// <summary>     ///  16位CRC校验     /// </summary>     public static class CRC16     {         /// <summary>         /// 输出CRC校验码         /// </summary>         /// <param name="data">输入字节数组</param>         /// <returns>字节0是高8位，字节1是低8位</returns>         public static byte[] CRC16Calc(byte[] data)         {             //crc计算赋初始值             int crc = 0xffff;             for (int i = 0; i < data.Length; i++)             {                 crc = crc ^ data[i];                 for (int j = 0; j < 8; j++)                 {                     int temp;                     temp = crc & 1;                     crc = crc >> 1;                     crc = crc & 0x7fff;                     if (temp == 1)                     {                         crc = crc ^ 0xa001;                     }                     crc = crc & 0xffff;                 }             }             //CRC寄存器的高低位进行互换             byte[] crc16 = new byte[2];             //CRC寄存器的高8位变成低8位，             crc16[1] = (byte)((crc >> 8) & 0xff);             //CRC寄存器的低8位变成高8位             crc16[0] = (byte)(crc & 0xff);              return crc16;         }       }  }

using System; using System.Linq; using System.Threading;  namespace SunnyUI_NuclearForm {     /// <summary>     /// 线程安全版 鸣志步进/伺服,松下伺服,华庆军继电器模块通用帮助类     /// </summary>     public class ThreadModbusHelper     {          private static readonly object threadLock = new object();//线程安全锁          /// <summary>         ///  松下         /// </summary>         /// <param name="com"></param>         /// <param name="baudRate"></param>         /// <param name="arr"></param>         /// <returns></returns>         public void PannasonicSendByte(string com, int baudRate, byte[] arr)         {             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      modbus.SendSerialByte(arr);                  }             }         }          /// <summary>         /// 华庆军         /// </summary>         /// <param name="com"></param>         /// <param name="baudRate"></param>         /// <param name="arr"></param>         /// <returns></returns>         public void HuaqingjunSendByte(string com, int baudRate, byte[] arr)         {             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      modbus.SendSerialByte(arr);                  }             }         }           /// <summary>         /// 称重模块获取数值/去皮归零         /// </summary>         public string GetWeight(string com, int baudRate, byte slaveAddr)         {             string result = string.Empty;              lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      //去皮                     //slaveAddr = 18;                     ushort operationCodeAddress = 240; //去皮地址                     modbus.WriteSingleCoil_05(slaveAddr, operationCodeAddress, true);                      Thread.Sleep(100);//去皮再称重延迟                      ushort[] weightArr = modbus.ReadHoldingRegisters_03(slaveAddr, 1, 3);                     if (weightArr != null && weightArr.Length > 0)                     {                         ushort weight = weightArr[2];                         var weight1 = weight.ToString().Substring(0, weight.ToString().Length - 1);//正整数部分                         var weight2 = weight.ToString().Substring(weight.ToString().Length - 1, 1);//小数部分                          result = $"{weight1}.{weight2}";                     }                   }             }              return result;          }           #region Stepping_Moons          /// <summary>         /// 步进电机设置加速，减速，速度 支持整数和小数 数值1-10转/秒         /// </summary>         /// <param name="com"></param>         /// <param name="baudRate"></param>         /// <param name="arr"></param>         /// <returns></returns>         public void Stepping_SetAccelerationSpeedDeceleration(string com, int baudRate, object slaveAddr, string acceleration, string deceleration, string speed)         {             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      string strAC = $"{slaveAddr}AC{acceleration}r";                     modbus.SendSerialString(strAC);                     //加速度                       string strDE = $"{slaveAddr}DE{deceleration}r";                     modbus.SendSerialString(strDE);                     //减速度                       string strVE = $"{slaveAddr}VE{speed}r";                     modbus.SendSerialString(strVE);                     //速度                  }             }         }           /// <summary>         /// 设置步进电机移动距离 (支持正负数)   数值1w脉冲/圈         /// </summary>         /// <param name="com"></param>         /// <param name="baudRate"></param>         /// <param name="arr"></param>         /// <returns></returns>         public void Stepping_Distance(string com, int baudRate, object slaveAddr, long distance)         {             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      string strDI = $"{slaveAddr}DI{distance}r";                     modbus.SendSerialString(strDI);                     //移动距离                  }             }         }           /// <summary>         /// 电机旋转运行到指定距离 (执行相对移动命令,移动距离和方向来自最后一个DI命令 按给定长度进至距离) 数值同DI         /// </summary>         /// <param name="com"></param>         /// <param name="baudRate"></param>         /// <param name="arr"></param>         /// <returns></returns>         public void Stepping_FL(string com, int baudRate, object slaveAddr, string numberStr)         {             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      string str = $"{slaveAddr}FL{numberStr}r";                     modbus.SendSerialString(str);                  }             }         }          /// <summary>         /// 设置步进电机强制停止         /// </summary>         /// <param name="com"></param>         /// <param name="baudRate"></param>         /// <param name="arr"></param>         /// <returns></returns>         public void Stepping_SK(string com, int baudRate, object slaveAddr)         {             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      string str = $"{slaveAddr}SKr";                     modbus.SendSerialString(str);                  }             }         }          /// <summary>         ///  设置步进电机报警复位(部分电机是限位开关，不是限位传感器)         /// </summary>         /// <param name="com"></param>         /// <param name="baudRate"></param>         /// <param name="arr"></param>         /// <returns></returns>         public void Stepping_AR(string com, int baudRate, object slaveAddr)         {             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      string str = $"{slaveAddr}ARr";                     modbus.SendSerialString(str);                  }             }         }          /// <summary>         ///  设置步进电机Y口开关,L开,H关         /// </summary>         /// <param name="com"></param>         /// <param name="baudRate"></param>         /// <param name="arr"></param>         /// <returns></returns>         public void Stepping_SO(string com, int baudRate, object slaveAddr, int number, string _switch)         {             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      string str = $"{slaveAddr}SO{number}{_switch}r";                     modbus.SendSerialString(str);                  }             }         }          /// <summary>         ///  读取步进电机X口开关,0触碰1断开         /// </summary>         /// <param name="com"></param>         /// <param name="baudRate"></param>         /// <param name="arr"></param>         /// <returns></returns>         public string Stepping_IS(string com, int baudRate, object slaveAddr)         {             string str = string.Empty;             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      str = $"{slaveAddr}ISr";                     str = modbus.SendSerialString(str);                  }             }             return str;         }          /// <summary>         ///  设置步进电机运转时同时输出 1 支持 0 不支持         /// </summary>         public void Stepping_MT(string com, int baudRate, object slaveAddr, int number)         {             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      modbus.Stepping_MT(slaveAddr, number);                  }             }         }            #endregion          #region Servo_Moons          /// <summary>         /// 伺服电机设置加速，减速，速度 支持整数 数值1-10k/分钟         /// </summary>         /// <param name="com"></param>         /// <param name="baudRate"></param>         /// <param name="arr"></param>         /// <returns></returns>         public void Servo_SetAccelerationSpeedDeceleration(string com, int baudRate, byte slaveAddr, ushort acceleration, ushort deceleration, ushort speed)         {             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      ushort parametersAddress = 344;                      ushort[] parameters = new ushort[6];                     parameters[0] = 0;                     parameters[1] = acceleration;                     parameters[2] = 0;                     parameters[3] = deceleration;                     parameters[4] = 0;                     parameters[5] = speed;                      modbus.WriteMultipleRegisters_10(slaveAddr, parametersAddress, parameters);                  }             }         }          /// <summary>         /// 设置距离 数值1-100/圈         /// </summary>         /// <param name="com"></param>         /// <param name="baudRate"></param>         /// <param name="arr"></param>         /// <returns></returns>         public void Servo_Distance(string com, int baudRate, byte slaveAddr, long distance)         {             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      ushort parametersAddress = 350;                      ushort[] parameters = new ushort[1];                     parameters[0] = (ushort)distance;                      modbus.WriteMultipleRegisters_10(slaveAddr, parametersAddress, parameters);                  }             }         }          /// <summary>         /// 电机旋转运行到指定距离 (执行相对移动命令,移动距离和方向来自最后一个DI命令 按给定长度进至距离)         /// </summary>         /// <param name="com"></param>         /// <param name="baudRate"></param>         /// <param name="arr"></param>         /// <returns></returns>         public void Servo_FL(string com, int baudRate, byte slaveAddr)         {             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      ushort operationCodeAddress = 124;                     byte opCode = 0x66;                      modbus.WriteSingleRegister_06(slaveAddr, operationCodeAddress, opCode);                  }             }         }          /// <summary>         /// 强制停止         /// </summary>         /// <param name="com"></param>         /// <param name="baudRate"></param>         /// <param name="arr"></param>         /// <returns></returns>         public void Servo_SK(string com, int baudRate, byte slaveAddr)         {             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      ushort operationCodeAddress = 124;                     byte opCode = 0xE1;                     modbus.WriteSingleRegister_06(slaveAddr, operationCodeAddress, opCode);                  }             }         }          /// <summary>         /// 报警清除         /// </summary>         /// <param name="com"></param>         /// <param name="baudRate"></param>         /// <param name="arr"></param>         /// <returns></returns>         public void Servo_AX(string com, int baudRate, byte slaveAddr)         {             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      ushort operationCodeAddress = 124;                     byte opCode = 0xBA;                     modbus.WriteSingleRegister_06(slaveAddr, operationCodeAddress, opCode);                  }             }         }           /// <summary>         /// Y口输出  L 0x4C H 0x48         /// </summary>         /// <param name="com"></param>         /// <param name="baudRate"></param>         /// <param name="arr"></param>         /// <returns></returns>         public void Servo_SO(string com, int baudRate, byte slaveAddr, byte ioPoint, byte condition)         {             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      ushort operationCodeAddress = 124;                     byte operationCode = 0x8B;                      ushort[] operationCodeParameters = new ushort[3];                     operationCodeParameters[0] = operationCode;                     operationCodeParameters[1] = ioPoint;                     operationCodeParameters[2] = condition;                      modbus.WriteMultipleRegisters_10(slaveAddr, operationCodeAddress, operationCodeParameters);                  }             }         }           /// <summary>         /// X口输入         /// </summary>         /// <param name="com"></param>         /// <param name="baudRate"></param>         /// <param name="arr"></param>         /// <returns></returns>         public string Servo_IS(string com, int baudRate, byte slaveAddr)         {             string result = string.Empty;             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      try                     {                         ushort inputPortAddress = 5;                         ushort numberRegisters = 1;                          ushort[] data = modbus.ReadHoldingRegisters_03(slaveAddr, inputPortAddress, numberRegisters);                         if (data != null && data.Count() > 0)                         {                             result = Convert.ToString(data[0], 2).PadLeft(12, '0');//转2进制,然后12位补零;                         }                     }                     catch (Exception)                     {                      }                   }             }             return result;         }          /// <summary>         /// 伺服使能关闭         /// </summary>         /// <param name="com"></param>         /// <param name="baudRate"></param>         /// <param name="arr"></param>         /// <returns></returns>         public void Servo_MD(string com, int baudRate, byte slaveAddr)         {             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      modbus.Opcoded_MD(slaveAddr);                  }             }         }          /// <summary>         /// 伺服使能         /// </summary>         /// <param name="com"></param>         /// <param name="baudRate"></param>         /// <param name="slaveAddr"></param>         public void Servo_ME(string com, int baudRate, byte slaveAddr)         {             lock (threadLock)             {                 using (ModbusHelper modbus = new ModbusHelper())                 {                     modbus.ConnectForSerialPort(com, baudRate);                      modbus.Opcoded_ME(slaveAddr);                  }             }         }                         #endregion      } }

Modbus-RTU的功能码是用于指示Modbus协议进行何种数据操作的标识符。以下是常用的Modbus-RTU功能码及其含义： 01：读取线圈状态，用于读取开关量输入（DO）。 02：读取离散输入状态，用于读取开关量输入（DI）。 03：读取保持寄存器，用于读取模拟量输入（AI）。 04：读取输入寄存器，用于读取模拟量输入（AI）。 05：写单个线圈，用于控制开关量输出（DO）。 06：写单个保持寄存器，用于控制模拟量输出（AO）。 15：写多个线圈，用于控制多个开关量输出（DO）。 16：写多个保持寄存器，用于控制多个模拟量输出（AO）。 需要注意的是，不同设备支持的功能码可能不同，因此在使用Modbus-RTU通信时需要根据实际情况选择合适的功能码。

读取 00A0h 伺服准备状态 (S-RDY) ReadOnly 0：准备 OFF 1：准备 ON 01 01 00 A0 00 01 FD E8 01 01 01 01 90 48 

读取电压 01 03 60 2C 00 02 1B C2  01 03 04 05 28 00 05 BA F4  00050528H = 329000 (D

01 05 00 61 FF 00 DD E4   ，报警清除 0000h:输入 OFF、FF00h：输入 ON 01 05 00 61 00 00 9C 14

加速度减速度速度 01 06 46 00 01f4 设置v0=500

0E 10 01 5E 00 02 04 00 1E 84 80  //200w 0E  10 015E 0002 04 FFE1 7B80 //-200w

ModbusHelper modbusHelper = new ModbusHelper();  modbusHelper.ConnectForTCP("IP", "端口")  // 发送数据到硬件 //00 00 00 00 00 06 01 05 00 00 ff 00 开 byte[] arr = new byte[12]; arr[0] = 0x00; arr[1] = 0x00; arr[2] = 0x00; arr[3] = 0x00; arr[4] = 0x00; arr[5] = 0x06; arr[6] = 0x01; arr[7] = 0x05; arr[8] = 0x00; arr[9] = 0x00; arr[10] = 0xff; arr[11] = 0x00; modbusHelper.SendTCPByte(arr);

modbusHelper.CloseTCP();

  using (ModbusHelper com5_modbusHelper = new ModbusHelper())   {       com5_modbusHelper.ConnectForSerialPort("COM5", 9600);       byte slaveAddr = 2;    //开盖抓手X       com5_modbusHelper.Stepping_AR(slaveAddr);//报警清除       //你操作厂家硬件的指令代码集   }

步进电机设置加速，减速，速度 支持整数和小数 数值1-10转/秒 步进电机读取当前电机的加速度减速度速度 设置步进电机移动距离 (支持正负数)   数值1w脉冲/圈 电机旋转运行到指定距离 (执行相对移动命令,移动距离和方向来自最后一个DI命令 按给定长度进至距离) 数值同DI 设置步进电机强制停止 设置步进电机报警复位 设置步进电机Y口开关,L开,H关 读取步进电机X口开关,0触碰1断开 设置步进电机运转时同时输出

  using (ModbusHelper com6_modbusHelper = new ModbusHelper())   {       com6_modbusHelper.ConnectForSerialPort("COM6", 9600);        //从站地址       byte slaveAddr = 1;

    com6_modbusHelper.Stepping_SetAccelerationSpeedDeceleration(slaveAddr, "8", "8", "6");//设置加速度减速度速度
    int[] arr=com6_modbusHelper.Stepping_Read_AC_DE_VE(slaveAddr);//读取指定电机的加速度减速度速度

//比如一个电机走一段路，从0米处运转到时速100码的过程是加速度，然后按照速度120码均速前进到终点，再终点前按照减速度逐渐停止到0码是减速度。
      com6_modbusHelper.Stepping_Distance(slaveAddr, 10000);//1w是脉冲数，一般绝大部分电机都是1w脉冲一圈, -1w就是反转1圈
      com6_modbusHelper.Stepping_FL(slaveAddr, "同DI脉冲数");//一般设置了DI后在执行FL，电机才会运行
      com6_modbusHelper.Stepping_SK(slaveAddr);//强制停止电机当前的运转
      com6_modbusHelper.Stepping_AR(slaveAddr);//报警清除,一般电机运行到限位处或者负载过大，驱动器会拒绝继续执行操作命令，需要先清除报警
      com6_modbusHelper.Stepping_SO(slaveAddr, 1, "L"); //电机的Y_口开启
      com6_modbusHelper.Stepping_SO(slaveAddr, 1, "H"); //电机的Y_口关闭
      com6_modbusHelper.Stepping_IS(slaveAddr)//根据这个从站地址读取这个电机的全部输出口,0开1关
      com6_modbusHelper.Stepping_MT(slaveAddr, number);//设置步进电机运转时同时输出 1 支持 0 不支持，鸣志步进电机支持此指令，伺服电机不支持
   }

设置加减速,减速度,速度 读取伺服电机加速度减速度速度 设置距离 数值1-100/圈 设置距离 脉冲数 电机旋转运行到指定距离 (执行相对移动命令,移动距离和方向来自最后一个DI命令 按给定长度进至距离) 强制停止 报警清除 Y口输出  L 0x4C H 0x48 X口输入 ,0触碰1断开 伺服使能 伺服使能关闭

     private static ThreadModbusHelper modbus_com5 = new ThreadModbusHelper();//在这里控制伺服全部使用多线程安全帮助类

      modbus_com5.Servo_SetAccelerationSpeedDeceleration("com5", 9600, slaveAddr, 3000, 3000, 5000);//设置加速度减速度速度，这里的加减速度要/6,速度要/240,才是真正的RPM(每分钟X转)

    ushort[] arr=modbus_com5.ReadAccelerationSpeedDeceleration("com5", 9600, slaveAddr);//读取加速度减速度速度，这个方法在多线程不安全版本里，没有集成进多线程安全版本

      modbus_com5.Servo_Distance("com5", 9600, slaveAddr, 15);//通过圈数控制电机运转，支持正负数

      modbus_com5.DistanceForPulse(slaveAddr, pulse);//通过脉冲控制电机运转，支持正负数
      modbus_com5.Servo_FL("com5", 9600, slaveAddr);//让电机运转执行DI命令

      modbus_com5.Servo_SK("com6", 9600, slaveAddr);//电机强制停止

      modbus_com5.Servo_AX("com5", 9600, slaveAddr);//报警清除

      modbus_com5.Servo_SO("com5", 9600, slaveAddr, 0x34, 0x4C);//Y口输出,这里展示的是Y4口，开启。0x34可以替换为 0x31-0x38 对应y1-y8地址，0x4c是开启，0x48是关闭

      modbus_com5.Servo_IS("com5", 9600, slaveAddr)//读取X口，0触碰1断开,如果8个输入口都是触碰状态,可能返回的是0,需要强制补零

      modbus_com5.Servo_MD("COM6", 9600, slaveAddr);//伺服使能关闭
      modbus_com5.Servo_ME("COM6", 9600, slaveAddr);//伺服使能开启，在使用伺服电机需要先伺服使能才能使用其功能

// 0A05000AFF00AD43 Y11打开 modbus_com8.HuaqingjunSendByte("com8", 9600, new byte[] { 0x0A, 0X05, 0X00, 0X0A, 0XFF, 0X00, 0XAD, 0X43 });

//十进制 var modbusData = modbusHelper.ReadHoldingRegisters_03(0x01, 0x04, 1);  //十进制转二进制并八位补零 var binary = modbusData != null && modbusData.Length > 0 ? Convert.ToString(modbusData[0], 2).PadLeft(8, '0') : "00000000";  //二进制转数组 var inArray = StringToArray(binary);  //IN1-IN8数据绑定         //0断开1闭合

00 05 00 60 FF 00 8D F5  ，00 为广播全部从站伺服开启 00 05 00 60 00 00 CC 05  ，00 为广播全部从站伺服关闭  01 05 00 60 FF 00 8C 24 , 指定从站，伺服使能开启  0060线圈写入FF00 ON 01 05 00 60 00 00 CD D4  , 指定从站，伺服使能关闭  0060线圈写入0000 off   01 06 44 14 00 00 DD 3E  ，指定运行block编号，4414寄存器地址写入0000，指定运行block_0号动作 这里解释下block 是什么，松下伺服电机需要先编辑好block动作，然后调用block，电机才会运转。block里包括常用的正转反转加速减速速度，回原点，紧急刹车等功能  01 05 01 20 FF 00 8C 0C  ，0120线圈对应地址，STB开关, FF00开启 01 05 01 20 00 00 CD FC ，0120线圈对应地址，STB开关, 0000关闭  05线圈   01 05 00 61 FF 00 DD E4   ，报警清除 0000h:输入 OFF、FF00h：输入 ON 01 05 00 61 00 00 9C 14  06 寄存器 01 06 46 3a 00 00   原点有效化 01 06 46 3a 00 01   原点无效化 01 06 10 20 61 73   保存到 EEPROM  加速度减速度速度 01 06 46 00 01f4 设置v0=500 01 06 46 10 00 64 设置a0=100 01 06 46 20 00 64 设置d0=100  读取 00A0h 伺服准备状态 (S-RDY) ReadOnly 0：准备 OFF 1：准备 ON 01 01 00 A0 00 01 FD E8 01 01 01 01 90 48   读取电压 01 03 60 2C 00 02 1B C2  01 03 04 05 28 00 05 BA F4  00050528H = 329000 (D

 using (ModbusHelper bottle_modbusHelper = new ModbusHelper())  {      bottle_modbusHelper.ConnectForSerialPort("COM6", 9600);       //16 10       //10 06 44 14 00 08  指定运行block编号      byteArr = new byte[] { 0x10, 0x06, 0x44, 0x14, 0x00, 0x08 };      crc = CRC16.CRC16Calc(byteArr);      newArr = byteArr.Concat(crc).ToArray();      bottle_modbusHelper.SendSerialByte(newArr);       Thread.Sleep(50);//松下命令间隔       //10 05 01 20 FF 00   ，STB开      byteArr = new byte[] { 0x10, 0x05, 0x01, 0x20, 0xFF, 0x00 };      crc = CRC16.CRC16Calc(byteArr);      newArr = byteArr.Concat(crc).ToArray();      bottle_modbusHelper.SendSerialByte(newArr);  }