11

src/YSAI.DAQ/YSAI.Modbus/client/ModbusClientData.cs

@@ -57,13 +57,9 @@ namespace YSAI.Modbus.client
         /// </summary>
         public enum ProtocolType
         {
-            [Description("SerialPortParam")]
             Rtu,
-            [Description("SerialPortParam")]
             Ascii,
-            [Description("TcpParam")]
             Tcp,
-            [Description("UdpParam")]
             Udp
         }
 
@@ -126,6 +122,7 @@ namespace YSAI.Modbus.client
             /// </summary>
             [Description("端口")]
             public int Port { get; set; } = 502;
+
             /// <summary>
             /// 连接超时时间
             /// </summary>

src/YSAI.DAQ/YSAI.Modbus/client/ModbusClientOperate.cs

@@ -6,6 +6,7 @@ using NModbus.Extensions.Enron;
 using NModbus.Extensions.Functions;
 using NModbus.Serial;
 using NModbus.Utility;
+using Serilog;
 using System;
 using System.Collections;
 using System.Collections.Concurrent;
@@ -112,7 +113,7 @@ namespace YSAI.Modbus.client
         /// <returns></returns>
         private string? DataConvert(ushort value, DataType dataType)
         {
-            Value = value;
+            Ushort = value;
             switch (dataType)
             {
                 case DataType.MSB:
@@ -126,14 +127,14 @@ namespace YSAI.Modbus.client
                 case DataType.Signed:
                     return Signed.ToString();
                 case DataType.Value:
-                    return Value.ToString();
+                    return Ushort.ToString();
             }
             return null;
         }
-        public ushort Value { get; set; }
-        public byte MSB
+        private ushort Ushort { get; set; }
+        private byte MSB
         {
-            get { return (byte)(Value >> 8); }
+            get { return (byte)(Ushort >> 8); }
             set
             {
                 ushort temp = value;
@@ -142,22 +143,22 @@ namespace YSAI.Modbus.client
 
                 temp += LSB;
 
-                Value = temp;
+                Ushort = temp;
             }
         }
 
-        public byte LSB
+        private byte LSB
         {
-            get { return (byte)Value; }
+            get { return (byte)Ushort; }
             set
             {
-                Value = (ushort)(value + (ushort)(Value & 0xff00));
+                Ushort = (ushort)(value + (ushort)(Ushort & 0xff00));
             }
         }
 
-        public string Hex
+        private string Hex
         {
-            get { return $"0x{Value:x4}"; }
+            get { return $"0x{Ushort:x4}"; }
             set
             {
                 ushort converted;
@@ -169,14 +170,14 @@ namespace YSAI.Modbus.client
 
                 if (ushort.TryParse(value, NumberStyles.AllowHexSpecifier | NumberStyles.HexNumber, null, out converted))
                 {
-                    Value = converted;
+                    Ushort = converted;
                 }
             }
         }
 
-        public string Binary
+        private string Binary
         {
-            get { return Convert.ToString(Value, 2).PadLeft(16, '0').Insert(8, " "); }
+            get { return Convert.ToString(Ushort, 2).PadLeft(16, '0').Insert(8, " "); }
             set
             {
                 try
@@ -184,17 +185,83 @@ namespace YSAI.Modbus.client
                     if (value != null)
                         value = value.Replace(" ", "");
 
-                    Value = Convert.ToUInt16(value, 2);
+                    Ushort = Convert.ToUInt16(value, 2);
                 }
                 catch { }
             }
         }
 
-        public short Signed
+        private short Signed
         {
-            get { return (short)Value; }
-            set { Value = (ushort)value; }
+            get { return (short)Ushort; }
+            set { Ushort = (ushort)value; }
         }
+
+        /// <summary>
+        /// 把两个USHORT转换成float
+        /// </summary>
+        /// <param name="high">高位</param>
+        /// <param name="low">低位</param>
+        /// <returns></returns>
+        public float GetFloat(ushort high, ushort low)
+        {
+           return ModbusUtility.GetSingle(high, low);
+        }
+
+        /// <summary>
+        /// 把四个USHORT转换成float
+        /// </summary>
+        /// <param name="b3">下标3</param>
+        /// <param name="b2">下标2</param>
+        /// <param name="b1">下标1</param>
+        /// <param name="b0">下标0</param>
+        /// <returns></returns>
+        public double GetDouble(ushort b3, ushort b2, ushort b1, ushort b0)
+        {
+            return ModbusUtility.GetDouble(b3, b2, b1, b0);
+        }
+
+        /// <summary>
+        /// 把两个USHORT转换成Uint
+        /// </summary>
+        /// <param name="high">高位</param>
+        /// <param name="low">低位</param>
+        /// <returns></returns>
+        public uint GetUInt32(ushort high, ushort low)
+        {
+            return ModbusUtility.GetUInt32(high, low);
+        }
+
+        /// <summary>
+        /// 将字节数组转换为ASCII字节数组
+        /// </summary>
+        /// <param name="bytes">字节数组</param>
+        /// <returns></returns>
+        public byte[] GetAsciiBytes(params byte[] bytes)
+        {
+            return ModbusUtility.GetAsciiBytes(bytes);
+        }
+
+        /// <summary>
+        ///     将UInt16类型的数组转换为ASCII字节数组
+        /// </summary>
+        /// <param name="ushorts">短数组</param>
+        /// <returns></returns>
+        public byte[] GetAsciiBytes(params ushort[]  ushorts)
+        {
+            return ModbusUtility.GetAsciiBytes(ushorts);
+        }
+
+        /// <summary>
+        /// 将网络顺序字节数组转换为主机顺序UInt16值数组
+        /// </summary>
+        /// <param name="networkBytes">网络顺序字节数组</param>
+        /// <returns></returns>
+        public static ushort[] NetworkBytesToHostUInt16(byte[] networkBytes)
+        {
+            return ModbusUtility.NetworkBytesToHostUInt16(networkBytes);
+        }
+
         #endregion
 
         protected override string LogHead => "[ ModbusClientOperate 操作 ]";

src/YSAI.DAQ/YSAI.Test.Console/Program.cs

@@ -1,5 +1,6 @@
 using Confluent.Kafka;
 using Microsoft.Extensions.Primitives;
+using NModbus.Utility;
 using Org.BouncyCastle.Utilities;
 using S7.Net;
 using System.Collections.Concurrent;
@@ -22,6 +23,7 @@ using YSAI.RelayManage;
 using YSAI.S7.client;
 using YSAI.Unility;
 using ZstdSharp.Unsafe;
+using static YSAI.Modbus.client.ModbusClientData;
 
 //
 //OpcUaClientOperate opcUaClientOperate = OpcUaClientOperate.Instance(new OpcUaClientData.Basics
@@ -203,7 +205,7 @@ ModbusClientOperate modbusClientOperate = ModbusClientOperate.Instance(new Modbu
     ProtocolType = ModbusClientData.ProtocolType.Tcp,
     Ip = "127.0.0.1",
     Port = 502,
-    MRType = ModbusClientData.ModbusReadType.FloatInputRegisters,
+    MRType = ModbusClientData.ModbusReadType.InputRegisters,
     MWType = ModbusClientData.ModbusWriteType.NULL
 });
 
@@ -226,7 +228,13 @@ while (true)
 
 void ModbusClientOperate_OnEvent(object? sender, EventResult e)
 {
-    Console.WriteLine(e.ToJson().JsonFormatting());
+    List<RetValue> retValues = JsonTool.StringToJsonEntity<List<RetValue>>((e.RData as ConcurrentDictionary<string, AddressValue>)["0,2"].Value);
+
+
+    float a = ModbusUtility.GetSingle(int.Parse(retValues[1].Value).ToUshort(), int.Parse(retValues[0].Value).ToUshort());
+
+
+    Console.WriteLine(a);
 }
 
 

src/YSAI.DAQ/YSAI.Unility/ByteTool.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net;
+using System.Resources;
 using System.Text;
 using System.Threading.Tasks;
 
@@ -11,6 +13,210 @@ namespace YSAI.Unility
     /// </summary>
     public class ByteTool
     {
+        private static readonly ushort[] CrcTable =
+       {
+            0X0000, 0XC0C1, 0XC181, 0X0140, 0XC301, 0X03C0, 0X0280, 0XC241,
+            0XC601, 0X06C0, 0X0780, 0XC741, 0X0500, 0XC5C1, 0XC481, 0X0440,
+            0XCC01, 0X0CC0, 0X0D80, 0XCD41, 0X0F00, 0XCFC1, 0XCE81, 0X0E40,
+            0X0A00, 0XCAC1, 0XCB81, 0X0B40, 0XC901, 0X09C0, 0X0880, 0XC841,
+            0XD801, 0X18C0, 0X1980, 0XD941, 0X1B00, 0XDBC1, 0XDA81, 0X1A40,
+            0X1E00, 0XDEC1, 0XDF81, 0X1F40, 0XDD01, 0X1DC0, 0X1C80, 0XDC41,
+            0X1400, 0XD4C1, 0XD581, 0X1540, 0XD701, 0X17C0, 0X1680, 0XD641,
+            0XD201, 0X12C0, 0X1380, 0XD341, 0X1100, 0XD1C1, 0XD081, 0X1040,
+            0XF001, 0X30C0, 0X3180, 0XF141, 0X3300, 0XF3C1, 0XF281, 0X3240,
+            0X3600, 0XF6C1, 0XF781, 0X3740, 0XF501, 0X35C0, 0X3480, 0XF441,
+            0X3C00, 0XFCC1, 0XFD81, 0X3D40, 0XFF01, 0X3FC0, 0X3E80, 0XFE41,
+            0XFA01, 0X3AC0, 0X3B80, 0XFB41, 0X3900, 0XF9C1, 0XF881, 0X3840,
+            0X2800, 0XE8C1, 0XE981, 0X2940, 0XEB01, 0X2BC0, 0X2A80, 0XEA41,
+            0XEE01, 0X2EC0, 0X2F80, 0XEF41, 0X2D00, 0XEDC1, 0XEC81, 0X2C40,
+            0XE401, 0X24C0, 0X2580, 0XE541, 0X2700, 0XE7C1, 0XE681, 0X2640,
+            0X2200, 0XE2C1, 0XE381, 0X2340, 0XE101, 0X21C0, 0X2080, 0XE041,
+            0XA001, 0X60C0, 0X6180, 0XA141, 0X6300, 0XA3C1, 0XA281, 0X6240,
+            0X6600, 0XA6C1, 0XA781, 0X6740, 0XA501, 0X65C0, 0X6480, 0XA441,
+            0X6C00, 0XACC1, 0XAD81, 0X6D40, 0XAF01, 0X6FC0, 0X6E80, 0XAE41,
+            0XAA01, 0X6AC0, 0X6B80, 0XAB41, 0X6900, 0XA9C1, 0XA881, 0X6840,
+            0X7800, 0XB8C1, 0XB981, 0X7940, 0XBB01, 0X7BC0, 0X7A80, 0XBA41,
+            0XBE01, 0X7EC0, 0X7F80, 0XBF41, 0X7D00, 0XBDC1, 0XBC81, 0X7C40,
+            0XB401, 0X74C0, 0X7580, 0XB541, 0X7700, 0XB7C1, 0XB681, 0X7640,
+            0X7200, 0XB2C1, 0XB381, 0X7340, 0XB101, 0X71C0, 0X7080, 0XB041,
+            0X5000, 0X90C1, 0X9181, 0X5140, 0X9301, 0X53C0, 0X5280, 0X9241,
+            0X9601, 0X56C0, 0X5780, 0X9741, 0X5500, 0X95C1, 0X9481, 0X5440,
+            0X9C01, 0X5CC0, 0X5D80, 0X9D41, 0X5F00, 0X9FC1, 0X9E81, 0X5E40,
+            0X5A00, 0X9AC1, 0X9B81, 0X5B40, 0X9901, 0X59C0, 0X5880, 0X9841,
+            0X8801, 0X48C0, 0X4980, 0X8941, 0X4B00, 0X8BC1, 0X8A81, 0X4A40,
+            0X4E00, 0X8EC1, 0X8F81, 0X4F40, 0X8D01, 0X4DC0, 0X4C80, 0X8C41,
+            0X4400, 0X84C1, 0X8581, 0X4540, 0X8701, 0X47C0, 0X4680, 0X8641,
+            0X8201, 0X42C0, 0X4380, 0X8341, 0X4100, 0X81C1, 0X8081, 0X4040
+        };
+
+        /// <summary>
+        ///     Converts four UInt16 values into a IEEE 64 floating point format.
+        /// </summary>
+        /// <param name="b3">Highest-order ushort value.</param>
+        /// <param name="b2">Second-to-highest-order ushort value.</param>
+        /// <param name="b1">Second-to-lowest-order ushort value.</param>
+        /// <param name="b0">Lowest-order ushort value.</param>
+        /// <returns>IEEE 64 floating point value.</returns>
+        public static double GetDouble(ushort b3, ushort b2, ushort b1, ushort b0)
+        {
+            byte[] value = BitConverter.GetBytes(b0)
+                .Concat(BitConverter.GetBytes(b1))
+                .Concat(BitConverter.GetBytes(b2))
+                .Concat(BitConverter.GetBytes(b3))
+                .ToArray();
+
+            return BitConverter.ToDouble(value, 0);
+        }
+
+        /// <summary>
+        ///     Converts two UInt16 values into a IEEE 32 floating point format.
+        /// </summary>
+        /// <param name="highOrderValue">High order ushort value.</param>
+        /// <param name="lowOrderValue">Low order ushort value.</param>
+        /// <returns>IEEE 32 floating point value.</returns>
+        public static float GetSingle(ushort highOrderValue, ushort lowOrderValue)
+        {
+            byte[] value = BitConverter.GetBytes(lowOrderValue)
+                .Concat(BitConverter.GetBytes(highOrderValue))
+                .ToArray();
+
+            return BitConverter.ToSingle(value, 0);
+        }
+
+        /// <summary>
+        ///     Converts two UInt16 values into a UInt32.
+        /// </summary>
+        public static uint GetUInt32(ushort highOrderValue, ushort lowOrderValue)
+        {
+            byte[] value = BitConverter.GetBytes(lowOrderValue)
+                .Concat(BitConverter.GetBytes(highOrderValue))
+                .ToArray();
+
+            return BitConverter.ToUInt32(value, 0);
+        }
+
+        /// <summary>
+        ///     Converts an array of bytes to an ASCII byte array.
+        /// </summary>
+        /// <param name="numbers">The byte array.</param>
+        /// <returns>An array of ASCII byte values.</returns>
+        public static byte[] GetAsciiBytes(params byte[] numbers)
+        {
+            return Encoding.UTF8.GetBytes(numbers.SelectMany(n => n.ToString("X2")).ToArray());
+        }
+
+        /// <summary>
+        ///     Converts an array of UInt16 to an ASCII byte array.
+        /// </summary>
+        /// <param name="numbers">The ushort array.</param>
+        /// <returns>An array of ASCII byte values.</returns>
+        public static byte[] GetAsciiBytes(params ushort[] numbers)
+        {
+            return Encoding.UTF8.GetBytes(numbers.SelectMany(n => n.ToString("X4")).ToArray());
+        }
+
+        /// <summary>
+        ///     Converts a network order byte array to an array of UInt16 values in host order.
+        /// </summary>
+        /// <param name="networkBytes">The network order byte array.</param>
+        /// <returns>The host order ushort array.</returns>
+        public static ushort[] NetworkBytesToHostUInt16(byte[] networkBytes)
+        {
+            if (networkBytes == null)
+            {
+                throw new ArgumentNullException(nameof(networkBytes));
+            }
+
+            if (networkBytes.Length % 2 != 0)
+            {
+                throw new FormatException("Array networkBytes must contain an even number of bytes");
+            }
+
+            ushort[] result = new ushort[networkBytes.Length / 2];
+
+            for (int i = 0; i < result.Length; i++)
+            {
+                result[i] = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(networkBytes, i * 2));
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        ///     Converts a hex string to a byte array.
+        /// </summary>
+        /// <param name="hex">The hex string.</param>
+        /// <returns>Array of bytes.</returns>
+        public static byte[] HexToBytes(string hex)
+        {
+            if (hex == null)
+            {
+                throw new ArgumentNullException(nameof(hex));
+            }
+
+            if (hex.Length % 2 != 0)
+            {
+                throw new FormatException("Hex string must have even number of characters.");
+            }
+
+            byte[] bytes = new byte[hex.Length / 2];
+
+            for (int i = 0; i < bytes.Length; i++)
+            {
+                bytes[i] = Convert.ToByte(hex.Substring(i * 2, 2), 16);
+            }
+
+            return bytes;
+        }
+
+        /// <summary>
+        ///     Calculate Longitudinal Redundancy Check.
+        /// </summary>
+        /// <param name="data">The data used in LRC.</param>
+        /// <returns>LRC value.</returns>
+        public static byte CalculateLrc(byte[] data)
+        {
+            if (data == null)
+            {
+                throw new ArgumentNullException(nameof(data));
+            }
+
+            byte lrc = 0;
+
+            foreach (byte b in data)
+            {
+                lrc += b;
+            }
+
+            lrc = (byte)((lrc ^ 0xFF) + 1);
+
+            return lrc;
+        }
+
+        /// <summary>
+        ///     Calculate Cyclical Redundancy Check.
+        /// </summary>
+        /// <param name="data">The data used in CRC.</param>
+        /// <returns>CRC value.</returns>
+        public static byte[] CalculateCrc(byte[] data)
+        {
+            if (data == null)
+            {
+                throw new ArgumentNullException(nameof(data));
+            }
+
+            ushort crc = ushort.MaxValue;
+
+            foreach (byte b in data)
+            {
+                byte tableIndex = (byte)(crc ^ b);
+                crc >>= 8;
+                crc ^= CrcTable[tableIndex];
+            }
+
+            return BitConverter.GetBytes(crc);
+        }
+
 
         /// <summary>
         /// 字节数据拼接成一个完整的包
@@ -32,6 +238,8 @@ namespace YSAI.Unility
             ms.Close();
             return bytes;
         }
+
+
         public static byte[] calc_modbus_crc(byte[] buffer)
         {
             UInt16 crc = 0xFFFF;
@@ -301,7 +509,7 @@ namespace YSAI.Unility
         /// </summary>
         /// <param name="Data">数据</param>
         /// <returns></returns>
-        public static (byte High, byte Low) ShunnetCRC(byte[] Data)
+        public static (byte High, byte Low) CRC(byte[] Data)
         {
             UInt16 crc = 0;
             for (UInt32 i = 7; i < Data.Length; i++)