Alter ValueHelper

2023-06-27 17:38:47 +08:00
parent d9678ee31c
commit 34a49e22da
16 changed files with 466 additions and 150 deletions
--- a/Modbus.Net/Modbus.Net.Modbus/ModbusProtocolLinkerBytesExtend.cs
+++ b/Modbus.Net/Modbus.Net.Modbus/ModbusProtocolLinkerBytesExtend.cs
@@ -67,9 +67,9 @@ namespace Modbus.Net.Modbus
                var transaction = (ushort)(_sendCount % 65536 + 1);
                var tag = (ushort)0;
                var leng = (ushort)content.Length;
-                Array.Copy(BigEndianValueHelper.Instance.GetBytes(transaction), 0, newFormat, 0, 2);
-                Array.Copy(BigEndianValueHelper.Instance.GetBytes(tag), 0, newFormat, 2, 2);
-                Array.Copy(BigEndianValueHelper.Instance.GetBytes(leng), 0, newFormat, 4, 2);
+                Array.Copy(BigEndianLsbValueHelper.Instance.GetBytes(transaction), 0, newFormat, 0, 2);
+                Array.Copy(BigEndianLsbValueHelper.Instance.GetBytes(tag), 0, newFormat, 2, 2);
+                Array.Copy(BigEndianLsbValueHelper.Instance.GetBytes(leng), 0, newFormat, 4, 2);
                Array.Copy(content, 0, newFormat, 6, content.Length);
                _sendCount++;
            }
--- a/Modbus.Net/Modbus.Net.Opc/OpcConnector.cs
+++ b/Modbus.Net/Modbus.Net.Opc/OpcConnector.cs
@@ -96,11 +96,24 @@ namespace Modbus.Net.Opc
                    if (tag != null)
                    {
                        var result = await Client.ReadAsync<object>(tag);
-                        logger.LogInformation($"Opc Machine {ConnectionToken} Read Opc tag {tag} for value {result.Value}");
+                        object resultTrans;
+                        if (result.Value.ToString() == "False")
+                        {
+                            resultTrans = (byte)0;
+                        }
+                        else if (result.Value.ToString() == "True")
+                        {
+                            resultTrans = (byte)1;
+                        }
+                        else
+                        {
+                            resultTrans = result.Value;
+                        }
+                        logger.LogInformation($"Opc Machine {ConnectionToken} Read Opc tag {tag} for value {result.Value} {result.Value.GetType().FullName}");
                        return new OpcParamOut
                        {
                            Success = true,
-                            Value = BigEndianValueHelper.Instance.GetBytes(result.Value, result.Value.GetType())
+                            Value = BigEndianLsbValueHelper.Instance.GetBytes(resultTrans, resultTrans.GetType())
                        };
                    }
                    return new OpcParamOut
--- a/Modbus.Net/Modbus.Net.Opc/OpcProtocol.cs
+++ b/Modbus.Net/Modbus.Net.Opc/OpcProtocol.cs
@@ -171,7 +171,7 @@
        /// <returns>结构化的输出数据</returns>
        public override IOutputStruct Unformat(OpcParamOut messageBytes, ref int pos)
        {
-            var ansByte = BigEndianValueHelper.Instance.GetByte(messageBytes.Value, ref pos);
+            var ansByte = BigEndianLsbValueHelper.Instance.GetByte(messageBytes.Value, ref pos);
            var ans = ansByte != 0;
            return new WriteRequestOpcOutputStruct(ans);
        }
--- a/Modbus.Net/Modbus.Net.Siemens/SiemensProtocol.cs
+++ b/Modbus.Net/Modbus.Net.Siemens/SiemensProtocol.cs
@@ -162,9 +162,9 @@ namespace Modbus.Net.Siemens
        public override IOutputStruct Unformat(byte[] messageBytes, ref int pos)
        {
            pos = 1;
-            var masterAddress = BigEndianValueHelper.Instance.GetByte(messageBytes, ref pos);
-            var slaveAddress = BigEndianValueHelper.Instance.GetByte(messageBytes, ref pos);
-            var confirmMessage = BigEndianValueHelper.Instance.GetByte(messageBytes, ref pos);
+            var masterAddress = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos);
+            var slaveAddress = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos);
+            var confirmMessage = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos);
            return new ComCreateReferenceSiemensOutputStruct(slaveAddress, masterAddress, confirmMessage);
        }
    }
@@ -236,19 +236,19 @@ namespace Modbus.Net.Siemens
                case 0xc0:
                    {
                        pos += 2;
-                        tdpuSize = BigEndianValueHelper.Instance.GetByte(messageBytes, ref pos);
+                        tdpuSize = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos);
                        break;
                    }
                case 0xc1:
                    {
                        pos += 2;
-                        srcTsap = BigEndianValueHelper.Instance.GetUShort(messageBytes, ref pos);
+                        srcTsap = BigEndianLsbValueHelper.Instance.GetUShort(messageBytes, ref pos);
                        break;
                    }
                case 0xc2:
                    {
                        pos += 2;
-                        dstTsap = BigEndianValueHelper.Instance.GetUShort(messageBytes, ref pos);
+                        dstTsap = BigEndianLsbValueHelper.Instance.GetUShort(messageBytes, ref pos);
                        break;
                    }
            }
@@ -334,7 +334,7 @@ namespace Modbus.Net.Siemens
        /// <returns>输出数据</returns>
        public override IOutputStruct Unformat(byte[] messageBytes, ref int pos)
        {
-            var confirmByte = BigEndianValueHelper.Instance.GetByte(messageBytes, ref pos);
+            var confirmByte = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos);
            return new ComConfirmMessageSiemensOutputStruct(confirmByte);
        }
    }
@@ -399,11 +399,11 @@ namespace Modbus.Net.Siemens
        public override IOutputStruct Unformat(byte[] messageBytes, ref int pos)
        {
            pos = 4;
-            var pduRef = BigEndianValueHelper.Instance.GetUShort(messageBytes, ref pos);
+            var pduRef = BigEndianLsbValueHelper.Instance.GetUShort(messageBytes, ref pos);
            pos = 14;
-            var maxCalling = BigEndianValueHelper.Instance.GetUShort(messageBytes, ref pos);
-            var maxCalled = BigEndianValueHelper.Instance.GetUShort(messageBytes, ref pos);
-            var maxPdu = BigEndianValueHelper.Instance.GetUShort(messageBytes, ref pos);
+            var maxCalling = BigEndianLsbValueHelper.Instance.GetUShort(messageBytes, ref pos);
+            var maxCalled = BigEndianLsbValueHelper.Instance.GetUShort(messageBytes, ref pos);
+            var maxPdu = BigEndianLsbValueHelper.Instance.GetUShort(messageBytes, ref pos);
            return new EstablishAssociationSiemensOutputStruct(pduRef, maxCalling, maxCalled, maxPdu);
        }
    }
@@ -563,7 +563,7 @@ namespace Modbus.Net.Siemens
            var dbBlock = r_message.DbBlock;
            var area = r_message.Area;
            var offsetBit = r_message.Offset * 8;
-            var offsetBitBytes = BigEndianValueHelper.Instance.GetBytes(offsetBit);
+            var offsetBitBytes = BigEndianLsbValueHelper.Instance.GetBytes(offsetBit);
            return Format(new byte[4], slaveAddress, masterAddress, (byte)0x6c, protoId, rosctr, redId, pduRef, parLg,
                datLg, serviceId, numberOfVariables
                , variableSpec, vAddrLg, syntaxId, type, numberOfElements, dbBlock, area,
@@ -579,11 +579,11 @@ namespace Modbus.Net.Siemens
        public override IOutputStruct Unformat(byte[] messageBytes, ref int pos)
        {
            pos = 4;
-            var pduRef = BigEndianValueHelper.Instance.GetUShort(messageBytes, ref pos);
+            var pduRef = BigEndianLsbValueHelper.Instance.GetUShort(messageBytes, ref pos);
            pos = 14;
-            var accessResult = BigEndianValueHelper.Instance.GetByte(messageBytes, ref pos);
-            var dataType = BigEndianValueHelper.Instance.GetByte(messageBytes, ref pos);
-            var length = BigEndianValueHelper.Instance.GetUShort(messageBytes, ref pos);
+            var accessResult = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos);
+            var dataType = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos);
+            var length = BigEndianLsbValueHelper.Instance.GetUShort(messageBytes, ref pos);
            var byteLength = length / 8;
            var values = new byte[byteLength];
            Array.Copy(messageBytes, pos, values, 0, byteLength);
@@ -700,7 +700,7 @@ namespace Modbus.Net.Siemens
        public override byte[] Format(IInputStruct message)
        {
            var r_message = (WriteRequestSiemensInputStruct)message;
-            var valueBytes = BigEndianValueHelper.Instance.ObjectArrayToByteArray(r_message.WriteValue);
+            var valueBytes = BigEndianLsbValueHelper.Instance.ObjectArrayToByteArray(r_message.WriteValue);
            var slaveAddress = r_message.SlaveAddress;
            var masterAddress = r_message.MasterAddress;
            const byte protoId = 0x32;
@@ -719,7 +719,7 @@ namespace Modbus.Net.Siemens
            var dbBlock = r_message.DbBlock;
            var area = r_message.Area;
            var offsetBit = r_message.Offset * 8;
-            var offsetBitBytes = BigEndianValueHelper.Instance.GetBytes(offsetBit);
+            var offsetBitBytes = BigEndianLsbValueHelper.Instance.GetBytes(offsetBit);
            const byte reserved = 0x00;
            const byte type = (byte)SiemensDataType.OtherAccess;
            var numberOfWriteBits = (ushort)(valueBytes.Length * 8);
@@ -739,16 +739,16 @@ namespace Modbus.Net.Siemens
        {
            if (messageBytes.Length == 1)
            {
-                var accessResult = BigEndianValueHelper.Instance.GetByte(messageBytes, ref pos);
+                var accessResult = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos);
                return new WriteRequestSiemensOutputStruct(0,
                    accessResult == 0xe5 ? SiemensAccessResult.NoError : SiemensAccessResult.InvalidAddress);
            }
            else
            {
                pos = 4;
-                var pduRef = BigEndianValueHelper.Instance.GetUShort(messageBytes, ref pos);
+                var pduRef = BigEndianLsbValueHelper.Instance.GetUShort(messageBytes, ref pos);
                pos = 14;
-                var accessResult = BigEndianValueHelper.Instance.GetByte(messageBytes, ref pos);
+                var accessResult = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos);
                return new WriteRequestSiemensOutputStruct(pduRef, (SiemensAccessResult)accessResult);
            }
        }
--- a/Modbus.Net/Modbus.Net.Siemens/SiemensProtocolLinkerBytesExtend.cs
+++ b/Modbus.Net/Modbus.Net.Siemens/SiemensProtocolLinkerBytesExtend.cs
@@ -15,7 +15,7 @@ namespace Modbus.Net.Siemens
        public byte[] BytesExtend(byte[] content)
        {
            Array.Copy(new byte[] { 0x03, 0x00, 0x00, 0x00, 0x02, 0xf0, 0x80 }, 0, content, 0, 7);
-            Array.Copy(BigEndianValueHelper.Instance.GetBytes((ushort)content.Length), 0, content, 2, 2);
+            Array.Copy(BigEndianLsbValueHelper.Instance.GetBytes((ushort)content.Length), 0, content, 2, 2);
            return content;
        }

--- a/Modbus.Net/Modbus.Net.Siemens/SiemensStructDefinition.cs
+++ b/Modbus.Net/Modbus.Net.Siemens/SiemensStructDefinition.cs
@@ -7,9 +7,9 @@
            get
            {
                var pos = 15;
-                return BigEndianValueHelper.Instance.GetBit(BigEndianValueHelper.Instance.GetBytes(TodValue), ref pos);
+                return BigEndianLsbValueHelper.Instance.GetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), ref pos);
            }
-            set { TodValue = BigEndianValueHelper.Instance.SetBit(BigEndianValueHelper.Instance.GetBytes(TodValue), 15, value); } 
+            set { TodValue = BigEndianLsbValueHelper.Instance.SetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), 15, value); } 
        }

        public byte K0_4
@@ -17,13 +17,13 @@
            get
            {
                var pos = 0;
-                var byteValue = BigEndianValueHelper.Instance.GetByte(BigEndianValueHelper.Instance.GetBytes(TodValue), ref pos);
+                var byteValue = BigEndianLsbValueHelper.Instance.GetByte(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), ref pos);
                return (byte)(byteValue%64/4);
            }
            set
            {
                var pos = 0;
-                var byteValue = BigEndianValueHelper.Instance.GetByte(BigEndianValueHelper.Instance.GetBytes(TodValue), ref pos);
+                var byteValue = BigEndianLsbValueHelper.Instance.GetByte(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), ref pos);
                byteValue = (byte)(byteValue - (byteValue%128/4) + value);
                TodValue = (ushort)(TodValue%128 + byteValue*128);
            }
@@ -34,9 +34,9 @@
            get
            {
                var pos = 5;
-                return BigEndianValueHelper.Instance.GetBit(BigEndianValueHelper.Instance.GetBytes(TodValue), ref pos);
+                return BigEndianLsbValueHelper.Instance.GetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), ref pos);
            }
-            set { TodValue = BigEndianValueHelper.Instance.SetBit(BigEndianValueHelper.Instance.GetBytes(TodValue), 5, value); }
+            set { TodValue = BigEndianLsbValueHelper.Instance.SetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), 5, value); }
        }

        public byte UA
@@ -44,15 +44,15 @@
            get
            {
                var pos = 3;
-                var low = BigEndianValueHelper.Instance.GetBit(BigEndianValueHelper.Instance.GetBytes(TodValue), ref pos) ? 1 : 0;
-                var high = BigEndianValueHelper.Instance.GetBit(BigEndianValueHelper.Instance.GetBytes(TodValue), ref pos) ? 1 : 0;
+                var low = BigEndianLsbValueHelper.Instance.GetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), ref pos) ? 1 : 0;
+                var high = BigEndianLsbValueHelper.Instance.GetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), ref pos) ? 1 : 0;
                high *= 2;
                return (byte) (high + low);
            }
            set
            {
-                TodValue = BigEndianValueHelper.Instance.SetBit(BigEndianValueHelper.Instance.GetBytes(TodValue), 3, value % 2 >= 1);
-                TodValue = BigEndianValueHelper.Instance.SetBit(BigEndianValueHelper.Instance.GetBytes(TodValue), 4, value / 2 >= 1);
+                TodValue = BigEndianLsbValueHelper.Instance.SetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), 3, value % 2 >= 1);
+                TodValue = BigEndianLsbValueHelper.Instance.SetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), 4, value / 2 >= 1);
            }
        }
        public bool UZS
@@ -60,9 +60,9 @@
            get
            {
                var pos = 2;
-                return BigEndianValueHelper.Instance.GetBit(BigEndianValueHelper.Instance.GetBytes(TodValue), ref pos);
+                return BigEndianLsbValueHelper.Instance.GetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), ref pos);
            }
-            set { TodValue = BigEndianValueHelper.Instance.SetBit(BigEndianValueHelper.Instance.GetBytes(TodValue), 2, value); }
+            set { TodValue = BigEndianLsbValueHelper.Instance.SetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), 2, value); }
        }

        public bool ESY
@@ -70,9 +70,9 @@
            get
            {
                var pos = 1;
-                return BigEndianValueHelper.Instance.GetBit(BigEndianValueHelper.Instance.GetBytes(TodValue), ref pos);
+                return BigEndianLsbValueHelper.Instance.GetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), ref pos);
            }
-            set { TodValue = BigEndianValueHelper.Instance.SetBit(BigEndianValueHelper.Instance.GetBytes(TodValue), 1, value); }
+            set { TodValue = BigEndianLsbValueHelper.Instance.SetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), 1, value); }
        }

        public bool SYA
@@ -80,9 +80,9 @@
            get
            {
                var pos = 0;
-                return BigEndianValueHelper.Instance.GetBit(BigEndianValueHelper.Instance.GetBytes(TodValue), ref pos);
+                return BigEndianLsbValueHelper.Instance.GetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), ref pos);
            }
-            set { TodValue = BigEndianValueHelper.Instance.SetBit(BigEndianValueHelper.Instance.GetBytes(TodValue), 0, value); }
+            set { TodValue = BigEndianLsbValueHelper.Instance.SetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), 0, value); }
        }

        public ushort TodValue { get; set; }
--- a/Modbus.Net/Modbus.Net/Helper/AssemblyHelper.cs
+++ b/Modbus.Net/Modbus.Net/Helper/AssemblyHelper.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Modbus.Net
+{
+    /// <summary>
+    ///     程序集辅助类
+    /// </summary>
+    public static class AssemblyHelper
+    {
+        /// <summary>
+        ///     获取与Modbus.Net相关的所有程序集
+        /// </summary>
+        /// <returns></returns>
+        public static List<Assembly> GetAllLibraryAssemblies()
+        {
+            List<Assembly> allAssemblies = new List<Assembly>();
+            string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+
+            allAssemblies.Add(Assembly.Load("Modbus.Net"));
+
+            foreach (string dll in Directory.GetFiles(path, "Modbus.Net.*.dll"))
+                allAssemblies.Add(Assembly.LoadFile(dll));
+
+            return allAssemblies;
+        }
+    }
+}
--- a/Modbus.Net/Modbus.Net/Helper/CRC16.cs
+++ b/Modbus.Net/Modbus.Net/Helper/CRC16.cs
--- a/Modbus.Net/Modbus.Net/Helper/ValueHelper.cs
+++ b/Modbus.Net/Modbus.Net/Helper/ValueHelper.cs
@@ -8,16 +8,17 @@ using System.Text;
 namespace Modbus.Net
 {
    /// <summary>
-    ///     值与字节数组之间转换的辅助类（小端格式），这是一个Singleton类
+    ///     值与字节数组之间转换的辅助类
    /// </summary>
-    public class ValueHelper
+    public abstract class ValueHelper
    {
-        private static readonly ILogger<ValueHelper> logger = LogProvider.CreateLogger<ValueHelper>();
-
        /// <summary>
        ///     兼容数据类型对应的字节长度
        /// </summary>
-        public Dictionary<string, double> ByteLength = new Dictionary<string, double>
+        /// <summary>
+        ///     兼容数据类型对应的字节长度
+        /// </summary>
+        public static Dictionary<string, double> ByteLength => new Dictionary<string, double>
        {
            {"System.Boolean", 0.125},
            {"System.Byte", 1},
@@ -31,10 +32,301 @@ namespace Modbus.Net
            {"System.Double", 8}
        };

+        /// <summary>
+        ///     将一个byte数字转换为一个byte元素的数组。
+        /// </summary>
+        /// <param name="value">byte数字</param>
+        /// <returns>byte数组</returns>
+        public abstract byte[] GetBytes(byte value);
+
+        /// <summary>
+        ///     将short数字转换为byte数组
+        /// </summary>
+        /// <param name="value">待转换的值</param>
+        /// <returns>转换后的byte数组</returns>
+        public abstract byte[] GetBytes(short value);
+
+        /// <summary>
+        ///     将int数字转换为byte数组
+        /// </summary>
+        /// <param name="value">待转换的值</param>
+        /// <returns>转换后的byte数组</returns>
+        public abstract byte[] GetBytes(int value);
+
+        /// <summary>
+        ///     将long数字转换为byte数组
+        /// </summary>
+        /// <param name="value">待转换的值</param>
+        /// <returns>转换后的byte数组</returns>
+        public abstract byte[] GetBytes(long value);
+
+        /// <summary>
+        ///     将ushort数字转换为byte数组
+        /// </summary>
+        /// <param name="value">待转换的值</param>
+        /// <returns>转换后的byte数组</returns>
+        public abstract byte[] GetBytes(ushort value);
+
+        /// <summary>
+        ///     将uint数字转换为byte数组
+        /// </summary>
+        /// <param name="value">待转换的值</param>
+        /// <returns>转换后的byte数组</returns>
+        public abstract byte[] GetBytes(uint value);
+
+        /// <summary>
+        ///     将ulong数字转换为byte数组
+        /// </summary>
+        /// <param name="value">待转换的值</param>
+        /// <returns>转换后的byte数组</returns>
+        public abstract byte[] GetBytes(ulong value);
+
+        /// <summary>
+        ///     将float数字转换为byte数组
+        /// </summary>
+        /// <param name="value">待转换的值</param>
+        /// <returns>转换后的byte数组</returns>
+        public abstract byte[] GetBytes(float value);
+
+        /// <summary>
+        ///     将double数字转换为byte数组
+        /// </summary>
+        /// <param name="value">待转换的值</param>
+        /// <returns>转换后的byte数组</returns>
+        public abstract byte[] GetBytes(double value);
+
+        /// <summary>
+        ///     将object数字转换为byte数组
+        /// </summary>
+        /// <param name="value">待转换的值</param>
+        /// <param name="type">待转换的值的类型</param>
+        /// <returns>转换后的byte数组</returns>
+        public abstract byte[] GetBytes(object value, Type type);
+
+        /// <summary>
+        ///     将byte数组中相应的位置转换为对应类型的数字
+        /// </summary>
+        /// <param name="data">待转换的字节数组</param>
+        /// <param name="pos">转换数字的位置</param>
+        /// <param name="subPos">转换数字的比特位置（仅Type为bool的时候有效）</param>
+        /// <param name="t">转换的类型</param>
+        /// <returns>转换出的数字</returns>
+        public abstract object GetValue(byte[] data, ref int pos, ref int subPos, Type t);
+
+        /// <summary>
+        ///     将byte数组中相应的位置转换为byte数字
+        /// </summary>
+        /// <param name="data">待转换的数组</param>
+        /// <param name="pos">转换数字的位置</param>
+        /// <returns>转换出的数字</returns>
+        public abstract byte GetByte(byte[] data, ref int pos);
+
+        /// <summary>
+        ///     将byte数组中相应的位置转换为short数字
+        /// </summary>
+        /// <param name="data">待转换的数组</param>
+        /// <param name="pos">转换数字的位置</param>
+        /// <returns>转换出的数字</returns>
+        public abstract short GetShort(byte[] data, ref int pos);
+
+        /// <summary>
+        ///     将byte数组中相应的位置转换为int数字
+        /// </summary>
+        /// <param name="data">待转换的数组</param>
+        /// <param name="pos">转换数字的位置</param>
+        /// <returns>转换出的数字</returns>
+        public abstract int GetInt(byte[] data, ref int pos);
+
+        /// <summary>
+        ///     将byte数组中相应的位置转换为long数字
+        /// </summary>
+        /// <param name="data">待转换的数组</param>
+        /// <param name="pos">转换数字的位置</param>
+        /// <returns>转换出的数字</returns>
+        public abstract long GetLong(byte[] data, ref int pos);
+
+        /// <summary>
+        ///     将byte数组中相应的位置转换为ushort数字
+        /// </summary>
+        /// <param name="data">待转换的数组</param>
+        /// <param name="pos">转换数字的位置</param>
+        /// <returns>转换出的数字</returns>
+        public abstract ushort GetUShort(byte[] data, ref int pos);
+
+        /// <summary>
+        ///     将byte数组中相应的位置转换为uint数字
+        /// </summary>
+        /// <param name="data">待转换的数组</param>
+        /// <param name="pos">转换数字的位置</param>
+        /// <returns>转换出的数字</returns>
+        public abstract uint GetUInt(byte[] data, ref int pos);
+
+        /// <summary>
+        ///     将byte数组中相应的位置转换为ulong数字
+        /// </summary>
+        /// <param name="data">待转换的数组</param>
+        /// <param name="pos">转换数字的位置</param>
+        /// <returns>转换出的数字</returns>
+        public abstract ulong GetULong(byte[] data, ref int pos);
+
+        /// <summary>
+        ///     将byte数组中相应的位置转换为float数字
+        /// </summary>
+        /// <param name="data">待转换的数组</param>
+        /// <param name="pos">转换数字的位置</param>
+        /// <returns>转换出的数字</returns>
+        public abstract float GetFloat(byte[] data, ref int pos);
+
+        /// <summary>
+        ///     将byte数组中相应的位置转换为double数字
+        /// </summary>
+        /// <param name="data">待转换的数组</param>
+        /// <param name="pos">转换数字的位置</param>
+        /// <returns>转换出的数字</returns>
+        public abstract double GetDouble(byte[] data, ref int pos);
+
+        /// <summary>
+        ///     将byte数组中相应的位置转换为字符串
+        /// </summary>
+        /// <param name="data">待转换的数组</param>
+        /// <param name="count">转换的个数</param>
+        /// <param name="pos">转换数字的位置</param>
+        /// <param name="encoding">编码方法</param>
+        /// <returns>转换出的字符串</returns>
+        public abstract string GetString(byte[] data, int count, ref int pos, Encoding encoding);
+
+        /// <summary>
+        ///     将byte数组中相应的位置转换为8个bit数字
+        /// </summary>
+        /// <param name="data">待转换的数组</param>
+        /// <param name="pos">转换数字的位置</param>
+        /// <returns>转换出的位数组</returns>
+        public abstract bool[] GetBits(byte[] data, ref int pos);
+
+        /// <summary>
+        ///     获取一个byte中相对应的bit数组展开中第n个位置中的bit元素。
+        /// </summary>
+        /// <param name="number">byte数字</param>
+        /// <param name="pos">bit数组中的对应位置</param>
+        /// <param name="subPos">小数位</param>
+        /// <returns>对应位置的bit元素</returns>
+        public abstract bool GetBit(byte number, ref int pos, ref int subPos);
+
+        /// <summary>
+        ///     获取一个字节数组中某个Bit位的数据
+        /// </summary>
+        /// <param name="number">byte数字</param>
+        /// <param name="pos">bit数组中的对应位置</param>
+        /// <param name="subPos">小数位</param>
+        /// <returns>对应位置的bit元素</returns>
+        public abstract bool GetBit(byte[] number, ref int pos, ref int subPos);
+
+        /// <summary>
+        ///     反转一个字节的8个Bit位
+        /// </summary>
+        /// <param name="originalByte">原始bit数组</param>
+        /// <returns>反转的bit数组</returns>
+        public abstract byte ReverseByte(byte originalByte);
+
+        /// <summary>
+        ///     将待转换的对象数组转换为需要发送的byte数组
+        /// </summary>
+        /// <param name="contents">object数组</param>
+        /// <returns>byte数组</returns>
+        public abstract byte[] ObjectArrayToByteArray(object[] contents);
+
+        /// <summary>
+        ///     将byte数组转换为用户指定类型的数组，通过object数组的方式返回，用户需要再把object转换为自己需要的类型，或调用ObjectArrayToDestinationArray返回单一类型的目标数组。
+        /// </summary>
+        /// <param name="contents">byte数组</param>
+        /// <param name="translateTypeAndCount">单一的类型和需要转换的个数的键值对</param>
+        /// <returns>object数组</returns>
+        public abstract object[] ByteArrayToObjectArray(byte[] contents, KeyValuePair<Type, int> translateTypeAndCount);
+
+        /// <summary>
+        ///     将一个byte数组转换成用户指定类型的数组，使用模板参数确定需要转换的类型
+        /// </summary>
+        /// <typeparam name="T">目标数组类型</typeparam>
+        /// <param name="contents">待转换的数组</param>
+        /// <param name="getCount">转换的个数</param>
+        /// <returns>以T为类型的数组</returns>
+        public abstract T[] ByteArrayToDestinationArray<T>(byte[] contents, int getCount);
+
+        /// <summary>
+        ///     将byte数组转换为用户指定类型的数组，通过object数组的方式返回，用户需要再把object转换为自己需要的类型，或调用ObjectArrayToDestinationArray返回单一类型的目标数组。
+        /// </summary>
+        /// <param name="contents">byte数组</param>
+        /// <param name="translateTypeAndCount">
+        ///     一连串类型和需要转换的个数的键值对，该方法会依次转换每一个需要转的目标数据类型。比如：typeof(int),5; typeof(short),3
+        ///     会转换出8个元素（当然前提是byte数组足够长的时候），5个int和3个short，然后全部变为object类型返回。
+        /// </param>
+        /// <returns>object数组</returns>
+        public abstract object[] ByteArrayToObjectArray(byte[] contents, IEnumerable<KeyValuePair<Type, int>> translateTypeAndCount);
+
+        /// <summary>
+        ///     将object数组转换为目标类型的单一数组
+        /// </summary>
+        /// <typeparam name="T">需要转换的目标类型</typeparam>
+        /// <param name="contents">object数组</param>
+        /// <returns>目标数组</returns>
+        public abstract T[] ObjectArrayToDestinationArray<T>(object[] contents);
+
+        /// <summary>
+        ///     在一个数组中写一个值
+        /// </summary>
+        /// <param name="contents">待写入的字节数组</param>
+        /// <param name="setPos">设置的位置</param>
+        /// <param name="subPos">设置的比特位位置（仅setValue为bit的时候有效）</param>
+        /// <param name="setValue">写入的值</param>
+        /// <returns>写入是否成功</returns>
+        public abstract bool SetValue(byte[] contents, int setPos, int subPos, object setValue);
+
+        /// <summary>
+        ///     将short值设置到byte数组中
+        /// </summary>
+        /// <param name="contents">待设置的byte数组</param>
+        /// <param name="pos">设置的位置</param>
+        /// <param name="setValue">要设置的值</param>
+        /// <returns>设置是否成功</returns>
+        public abstract bool SetValue(byte[] contents, int pos, object setValue);
+
+        /// <summary>
+        ///     设置一组数据中的一个bit
+        /// </summary>
+        /// <param name="contents">待设置的字节数组</param>
+        /// <param name="pos">位置</param>
+        /// <param name="subPos">bit位置</param>
+        /// <param name="setValue">bit数</param>
+        /// <returns>设置是否成功</returns>
+        public abstract bool SetBit(byte[] contents, int pos, int subPos, bool setValue);
+
+        /// <summary>
+        ///     根据端格式获取ValueHelper实例
+        /// </summary>
+        /// <param name="endian">端格式</param>
+        /// <returns>对应的ValueHelper实例</returns>
+        public static ValueHelper GetInstance(Endian endian)
+        {
+            foreach (var assembly in AssemblyHelper.GetAllLibraryAssemblies())
+            {
+                var valueHelper = assembly.GetType("Modbus.Net."+endian.ToString() + "ValueHelper")?.GetProperty("Instance")?.GetValue(null, null) as ValueHelper;
+                if (valueHelper != null) return valueHelper;
+            }
+            return null;
+        }
+    }
+
+    /// <summary>
+    ///     值与字节数组之间转换的辅助类（小端格式），这是一个Singleton类
+    /// </summary>
+    public class LittleEndianLsbValueHelper : ValueHelper
+    {
+        private static readonly ILogger<LittleEndianLsbValueHelper> logger = LogProvider.CreateLogger<LittleEndianLsbValueHelper>();
+
        /// <summary>
        ///     构造器
        /// </summary>
-        protected ValueHelper()
+        protected LittleEndianLsbValueHelper()
        {
        }

@@ -53,7 +345,7 @@ namespace Modbus.Net
        /// </summary>
        /// <param name="value">byte数字</param>
        /// <returns>byte数组</returns>
-        public byte[] GetBytes(byte value)
+        public override byte[] GetBytes(byte value)
        {
            return new[] { value };
        }
@@ -63,7 +355,7 @@ namespace Modbus.Net
        /// </summary>
        /// <param name="value">待转换的值</param>
        /// <returns>转换后的byte数组</returns>
-        public virtual byte[] GetBytes(short value)
+        public override byte[] GetBytes(short value)
        {
            return BitConverter.GetBytes(value);
        }
@@ -73,7 +365,7 @@ namespace Modbus.Net
        /// </summary>
        /// <param name="value">待转换的值</param>
        /// <returns>转换后的byte数组</returns>
-        public virtual byte[] GetBytes(int value)
+        public override byte[] GetBytes(int value)
        {
            return BitConverter.GetBytes(value);
        }
@@ -83,7 +375,7 @@ namespace Modbus.Net
        /// </summary>
        /// <param name="value">待转换的值</param>
        /// <returns>转换后的byte数组</returns>
-        public virtual byte[] GetBytes(long value)
+        public override byte[] GetBytes(long value)
        {
            return BitConverter.GetBytes(value);
        }
@@ -93,7 +385,7 @@ namespace Modbus.Net
        /// </summary>
        /// <param name="value">待转换的值</param>
        /// <returns>转换后的byte数组</returns>
-        public virtual byte[] GetBytes(ushort value)
+        public override byte[] GetBytes(ushort value)
        {
            return BitConverter.GetBytes(value);
        }
@@ -103,7 +395,7 @@ namespace Modbus.Net
        /// </summary>
        /// <param name="value">待转换的值</param>
        /// <returns>转换后的byte数组</returns>
-        public virtual byte[] GetBytes(uint value)
+        public override byte[] GetBytes(uint value)
        {
            return BitConverter.GetBytes(value);
        }
@@ -113,7 +405,7 @@ namespace Modbus.Net
        /// </summary>
        /// <param name="value">待转换的值</param>
        /// <returns>转换后的byte数组</returns>
-        public virtual byte[] GetBytes(ulong value)
+        public override byte[] GetBytes(ulong value)
        {
            return BitConverter.GetBytes(value);
        }
@@ -123,7 +415,7 @@ namespace Modbus.Net
        /// </summary>
        /// <param name="value">待转换的值</param>
        /// <returns>转换后的byte数组</returns>
-        public virtual byte[] GetBytes(float value)
+        public override byte[] GetBytes(float value)
        {
            return BitConverter.GetBytes(value);
        }
@@ -133,7 +425,7 @@ namespace Modbus.Net
        /// </summary>
        /// <param name="value">待转换的值</param>
        /// <returns>转换后的byte数组</returns>
-        public virtual byte[] GetBytes(double value)
+        public override byte[] GetBytes(double value)
        {
            return BitConverter.GetBytes(value);
        }
@@ -144,7 +436,7 @@ namespace Modbus.Net
        /// <param name="value">待转换的值</param>
        /// <param name="type">待转换的值的类型</param>
        /// <returns>转换后的byte数组</returns>
-        public virtual byte[] GetBytes(object value, Type type)
+        public override byte[] GetBytes(object value, Type type)
        {
            switch (type.FullName)
            {
@@ -193,6 +485,11 @@ namespace Modbus.Net
                        var bytes = _Instance.GetBytes((byte)value);
                        return bytes;
                    }
+                case "System.Boolean":
+                    {
+                        var bytes = _Instance.GetBytes((bool)value ? (byte)1 : (byte)0);
+                        return bytes;
+                    }
                default:
                    {
                        throw new NotImplementedException("没有实现除整数以外的其它转换方式");
@@ -208,7 +505,7 @@ namespace Modbus.Net
        /// <param name="subPos">转换数字的比特位置（仅Type为bool的时候有效）</param>
        /// <param name="t">转换的类型</param>
        /// <returns>转换出的数字</returns>
-        public virtual object GetValue(byte[] data, ref int pos, ref int subPos, Type t)
+        public override object GetValue(byte[] data, ref int pos, ref int subPos, Type t)
        {
            switch (t.FullName)
            {
@@ -275,7 +572,7 @@ namespace Modbus.Net
        /// <param name="data">待转换的数组</param>
        /// <param name="pos">转换数字的位置</param>
        /// <returns>转换出的数字</returns>
-        public virtual byte GetByte(byte[] data, ref int pos)
+        public override byte GetByte(byte[] data, ref int pos)
        {
            var t = data[pos];
            pos += 1;
@@ -288,7 +585,7 @@ namespace Modbus.Net
        /// <param name="data">待转换的数组</param>
        /// <param name="pos">转换数字的位置</param>
        /// <returns>转换出的数字</returns>
-        public virtual short GetShort(byte[] data, ref int pos)
+        public override short GetShort(byte[] data, ref int pos)
        {
            var t = BitConverter.ToInt16(data, pos);
            pos += 2;
@@ -301,7 +598,7 @@ namespace Modbus.Net
        /// <param name="data">待转换的数组</param>
        /// <param name="pos">转换数字的位置</param>
        /// <returns>转换出的数字</returns>
-        public virtual int GetInt(byte[] data, ref int pos)
+        public override int GetInt(byte[] data, ref int pos)
        {
            var t = BitConverter.ToInt32(data, pos);
            pos += 4;
@@ -314,7 +611,7 @@ namespace Modbus.Net
        /// <param name="data">待转换的数组</param>
        /// <param name="pos">转换数字的位置</param>
        /// <returns>转换出的数字</returns>
-        public virtual long GetLong(byte[] data, ref int pos)
+        public override long GetLong(byte[] data, ref int pos)
        {
            var t = BitConverter.ToInt64(data, pos);
            pos += 8;
@@ -327,7 +624,7 @@ namespace Modbus.Net
        /// <param name="data">待转换的数组</param>
        /// <param name="pos">转换数字的位置</param>
        /// <returns>转换出的数字</returns>
-        public virtual ushort GetUShort(byte[] data, ref int pos)
+        public override ushort GetUShort(byte[] data, ref int pos)
        {
            var t = BitConverter.ToUInt16(data, pos);
            pos += 2;
@@ -340,7 +637,7 @@ namespace Modbus.Net
        /// <param name="data">待转换的数组</param>
        /// <param name="pos">转换数字的位置</param>
        /// <returns>转换出的数字</returns>
-        public virtual uint GetUInt(byte[] data, ref int pos)
+        public override uint GetUInt(byte[] data, ref int pos)
        {
            var t = BitConverter.ToUInt32(data, pos);
            pos += 4;
@@ -353,7 +650,7 @@ namespace Modbus.Net
        /// <param name="data">待转换的数组</param>
        /// <param name="pos">转换数字的位置</param>
        /// <returns>转换出的数字</returns>
-        public virtual ulong GetULong(byte[] data, ref int pos)
+        public override ulong GetULong(byte[] data, ref int pos)
        {
            var t = BitConverter.ToUInt64(data, pos);
            pos += 8;
@@ -366,7 +663,7 @@ namespace Modbus.Net
        /// <param name="data">待转换的数组</param>
        /// <param name="pos">转换数字的位置</param>
        /// <returns>转换出的数字</returns>
-        public virtual float GetFloat(byte[] data, ref int pos)
+        public override float GetFloat(byte[] data, ref int pos)
        {
            var t = BitConverter.ToSingle(data, pos);
            pos += 4;
@@ -379,7 +676,7 @@ namespace Modbus.Net
        /// <param name="data">待转换的数组</param>
        /// <param name="pos">转换数字的位置</param>
        /// <returns>转换出的数字</returns>
-        public virtual double GetDouble(byte[] data, ref int pos)
+        public override double GetDouble(byte[] data, ref int pos)
        {
            var t = BitConverter.ToDouble(data, pos);
            pos += 8;
@@ -394,7 +691,7 @@ namespace Modbus.Net
        /// <param name="pos">转换数字的位置</param>
        /// <param name="encoding">编码方法</param>
        /// <returns>转换出的字符串</returns>
-        public virtual string GetString(byte[] data, int count, ref int pos, Encoding encoding)
+        public override string GetString(byte[] data, int count, ref int pos, Encoding encoding)
        {
            var t = encoding.GetString(data, pos, count);
            pos += count;
@@ -407,7 +704,7 @@ namespace Modbus.Net
        /// <param name="data">待转换的数组</param>
        /// <param name="pos">转换数字的位置</param>
        /// <returns>转换出的位数组</returns>
-        public virtual bool[] GetBits(byte[] data, ref int pos)
+        public override bool[] GetBits(byte[] data, ref int pos)
        {
            var t = new bool[8];
            var temp = data[pos];
@@ -427,7 +724,7 @@ namespace Modbus.Net
        /// <param name="pos">bit数组中的对应位置</param>
        /// <param name="subPos">小数位</param>
        /// <returns>对应位置的bit元素</returns>
-        public bool GetBit(byte number, ref int pos, ref int subPos)
+        public override bool GetBit(byte number, ref int pos, ref int subPos)
        {
            if (subPos < 0 && subPos >= 8) throw new IndexOutOfRangeException();
            var ans = number % 2;
@@ -454,7 +751,7 @@ namespace Modbus.Net
        /// <param name="pos">bit数组中的对应位置</param>
        /// <param name="subPos">小数位</param>
        /// <returns>对应位置的bit元素</returns>
-        public virtual bool GetBit(byte[] number, ref int pos, ref int subPos)
+        public override bool GetBit(byte[] number, ref int pos, ref int subPos)
        {
            return GetBit(number[pos], ref pos, ref subPos);
        }
@@ -464,7 +761,7 @@ namespace Modbus.Net
        /// </summary>
        /// <param name="originalByte">原始bit数组</param>
        /// <returns>反转的bit数组</returns>
-        public virtual byte ReverseByte(byte originalByte)
+        public override byte ReverseByte(byte originalByte)
        {
            byte result = 0;
            for (var i = 0; i < 8; i++)
@@ -481,7 +778,7 @@ namespace Modbus.Net
        /// </summary>
        /// <param name="contents">object数组</param>
        /// <returns>byte数组</returns>
-        public virtual byte[] ObjectArrayToByteArray(object[] contents)
+        public override byte[] ObjectArrayToByteArray(object[] contents)
        {
            var b = false;
            //先查找传入的结构中有没有数组，有的话将其打开
@@ -604,7 +901,7 @@ namespace Modbus.Net
        /// <param name="contents">byte数组</param>
        /// <param name="translateTypeAndCount">单一的类型和需要转换的个数的键值对</param>
        /// <returns>object数组</returns>
-        public virtual object[] ByteArrayToObjectArray(byte[] contents, KeyValuePair<Type, int> translateTypeAndCount)
+        public override object[] ByteArrayToObjectArray(byte[] contents, KeyValuePair<Type, int> translateTypeAndCount)
        {
            return ByteArrayToObjectArray(contents, new List<KeyValuePair<Type, int>> { translateTypeAndCount });
        }
@@ -616,7 +913,7 @@ namespace Modbus.Net
        /// <param name="contents">待转换的数组</param>
        /// <param name="getCount">转换的个数</param>
        /// <returns>以T为类型的数组</returns>
-        public virtual T[] ByteArrayToDestinationArray<T>(byte[] contents, int getCount)
+        public override T[] ByteArrayToDestinationArray<T>(byte[] contents, int getCount)
        {
            var objectArray = _Instance.ByteArrayToObjectArray(contents,
                new KeyValuePair<Type, int>(typeof(T), getCount));
@@ -632,7 +929,7 @@ namespace Modbus.Net
        ///     会转换出8个元素（当然前提是byte数组足够长的时候），5个int和3个short，然后全部变为object类型返回。
        /// </param>
        /// <returns>object数组</returns>
-        public virtual object[] ByteArrayToObjectArray(byte[] contents,
+        public override object[] ByteArrayToObjectArray(byte[] contents,
            IEnumerable<KeyValuePair<Type, int>> translateTypeAndCount)
        {
            var translation = new List<object>();
@@ -729,7 +1026,7 @@ namespace Modbus.Net
        /// <typeparam name="T">需要转换的目标类型</typeparam>
        /// <param name="contents">object数组</param>
        /// <returns>目标数组</returns>
-        public T[] ObjectArrayToDestinationArray<T>(object[] contents)
+        public override T[] ObjectArrayToDestinationArray<T>(object[] contents)
        {
            var array = new T[contents.Length];
            Array.Copy(contents, array, contents.Length);
@@ -744,7 +1041,7 @@ namespace Modbus.Net
        /// <param name="subPos">设置的比特位位置（仅setValue为bit的时候有效）</param>
        /// <param name="setValue">写入的值</param>
        /// <returns>写入是否成功</returns>
-        public bool SetValue(byte[] contents, int setPos, int subPos, object setValue)
+        public override bool SetValue(byte[] contents, int setPos, int subPos, object setValue)
        {
            var type = setValue.GetType();

@@ -814,7 +1111,7 @@ namespace Modbus.Net
        /// <param name="pos">设置的位置</param>
        /// <param name="setValue">要设置的值</param>
        /// <returns>设置是否成功</returns>
-        public virtual bool SetValue(byte[] contents, int pos, object setValue)
+        public override bool SetValue(byte[] contents, int pos, object setValue)
        {
            try
            {
@@ -864,7 +1161,7 @@ namespace Modbus.Net
        /// <param name="subPos">bit位置</param>
        /// <param name="setValue">bit数</param>
        /// <returns>设置是否成功</returns>
-        public virtual bool SetBit(byte[] contents, int pos, int subPos, bool setValue)
+        public override bool SetBit(byte[] contents, int pos, int subPos, bool setValue)
        {
            try
            {
@@ -890,35 +1187,7 @@ namespace Modbus.Net
        /// <summary>
        ///     ValueHelper单例的实例
        /// </summary>
-        public static ValueHelper Instance => _instance ?? (_instance = new ValueHelper());
-
-        /// <summary>
-        ///     根据端格式获取ValueHelper实例
-        /// </summary>
-        /// <param name="endian">端格式</param>
-        /// <returns>对应的ValueHelper实例</returns>
-        public static ValueHelper GetInstance(Endian endian)
-        {
-            switch (endian)
-            {
-                case Endian.LittleEndianLsb:
-                    {
-                        return Instance;
-                    }
-                case Endian.BigEndianLsb:
-                    {
-                        return BigEndianValueHelper.Instance;
-                    }
-                case Endian.BigEndianMsb:
-                    {
-                        return BigEndianMsbValueHelper.Instance;
-                    }
-                default:
-                    {
-                        return Instance;
-                    }
-            }
-        }
+        public static ValueHelper Instance => _instance ?? (_instance = new LittleEndianLsbValueHelper());

        #endregion
    }
@@ -926,14 +1195,14 @@ namespace Modbus.Net
    /// <summary>
    ///     值与字节数组之间转换的辅助类（大端格式），这是一个Singleton类
    /// </summary>
-    public class BigEndianValueHelper : ValueHelper
+    public class BigEndianLsbValueHelper : LittleEndianLsbValueHelper
    {
-        private static BigEndianValueHelper _bigEndianInstance;
+        private static BigEndianLsbValueHelper _bigEndianInstance;

        /// <summary>
        ///     构造器
        /// </summary>
-        protected BigEndianValueHelper()
+        protected BigEndianLsbValueHelper()
        {
        }

@@ -950,8 +1219,8 @@ namespace Modbus.Net
        /// <summary>
        ///     覆盖的获取实例的方法
        /// </summary>
-        public new static BigEndianValueHelper Instance
-            => _bigEndianInstance ?? (_bigEndianInstance = new BigEndianValueHelper());
+        public new static BigEndianLsbValueHelper Instance
+            => _bigEndianInstance ?? (_bigEndianInstance = new BigEndianLsbValueHelper());

        /// <summary>
        ///     将short数字转换为byte数组
@@ -1169,9 +1438,9 @@ namespace Modbus.Net
    /// <summary>
    ///     值与字节数组之间转换的辅助类（大端-大端位格式），这是一个Singleton类
    /// </summary>
-    public class BigEndianMsbValueHelper : BigEndianValueHelper
+    public class BigEndianMsbValueHelper : BigEndianLsbValueHelper
    {
-        private static BigEndianValueHelper _bigEndianInstance;
+        private static BigEndianMsbValueHelper _bigEndianInstance;

        /// <summary>
        ///     构造函数
@@ -1198,7 +1467,7 @@ namespace Modbus.Net
        /// <summary>
        ///     覆盖的实例获取方法
        /// </summary>
-        public new static BigEndianValueHelper Instance
+        public new static BigEndianMsbValueHelper Instance
            => _bigEndianInstance ?? (_bigEndianInstance = new BigEndianMsbValueHelper());

        /// <summary>
--- a/Modbus.Net/Modbus.Net/Machine/AddressCombiner.cs
+++ b/Modbus.Net/Modbus.Net/Machine/AddressCombiner.cs
@@ -124,7 +124,7 @@ namespace Modbus.Net
                                        AddressHelper.MapProtocolGetCountToAbstractByteCount(
                                            preNum - (int)Math.Floor(initNum),
                                            AddressTranslator.GetAreaByteLength(address.Area),
-                                            BigEndianValueHelper.Instance.ByteLength[preType.FullName])),
+                                            ValueHelper.ByteLength[preType.FullName])),
                                DataType = typeof(byte),
                                OriginalAddresses = originalAddresses.ToList()
                            });
@@ -153,7 +153,7 @@ namespace Modbus.Net
                        Math.Ceiling(
                            AddressHelper.MapProtocolGetCountToAbstractByteCount(
                                preNum - (int)Math.Floor(initNum), AddressTranslator.GetAreaByteLength(area),
-                                BigEndianValueHelper.Instance.ByteLength[preType.FullName])),
+                                ValueHelper.ByteLength[preType.FullName])),
                    DataType = typeof(byte),
                    OriginalAddresses = originalAddresses.ToList()
                });
@@ -173,9 +173,9 @@ namespace Modbus.Net
            foreach (var communicationUnit in ans)
            {
                var oldByteCount = communicationUnit.GetCount *
-                                   BigEndianValueHelper.Instance.ByteLength[communicationUnit.DataType.FullName];
+                                   ValueHelper.ByteLength[communicationUnit.DataType.FullName];
                var oldOriginalAddresses = communicationUnit.OriginalAddresses.ToList();
-                while (oldByteCount * BigEndianValueHelper.Instance.ByteLength[communicationUnit.DataType.FullName] >
+                while (oldByteCount * ValueHelper.ByteLength[communicationUnit.DataType.FullName] >
                       MaxLength)
                {
                    var newOriginalAddresses = new List<AddressUnit<TKey>>();
@@ -184,9 +184,9 @@ namespace Modbus.Net
                    do
                    {
                        var currentAddressUnit = oldOriginalAddresses.First();
-                        newByteCount += BigEndianValueHelper.Instance.ByteLength[currentAddressUnit.DataType.FullName];
+                        newByteCount += ValueHelper.ByteLength[currentAddressUnit.DataType.FullName];
                        if (newByteCount > MaxLength) break;
-                        oldByteCount -= BigEndianValueHelper.Instance.ByteLength[currentAddressUnit.DataType.FullName];
+                        oldByteCount -= ValueHelper.ByteLength[currentAddressUnit.DataType.FullName];
                        newOriginalAddresses.Add(currentAddressUnit);
                        oldOriginalAddresses.RemoveAt(0);
                    } while (newByteCount < MaxLength);
@@ -199,7 +199,7 @@ namespace Modbus.Net
                        GetCount =
                            (int)
                            Math.Ceiling(newByteCount /
-                                         BigEndianValueHelper.Instance.ByteLength[communicationUnit.DataType.FullName]),
+                                         ValueHelper.ByteLength[communicationUnit.DataType.FullName]),
                        OriginalAddresses = newOriginalAddresses
                    };

@@ -214,7 +214,7 @@ namespace Modbus.Net
                communicationUnit.GetCount =
                    (int)
                    Math.Ceiling(oldByteCount /
-                                 BigEndianValueHelper.Instance.ByteLength[communicationUnit.DataType.FullName]);
+                                 ValueHelper.ByteLength[communicationUnit.DataType.FullName]);
                communicationUnit.OriginalAddresses = oldOriginalAddresses;
                newAns.Add(communicationUnit);
            }
@@ -309,7 +309,7 @@ namespace Modbus.Net
                                             continusAddress.Address, preCommunicationUnit.Address,
                                             AddressTranslator.GetAreaByteLength(continusAddress.Area)) -
                                         preCommunicationUnit.GetCount *
-                                         BigEndianValueHelper.Instance.ByteLength[
+                                         ValueHelper.ByteLength[
                                             preCommunicationUnit.DataType.FullName])
                    };
                    addressesGaps.Add(gap);
@@ -327,8 +327,8 @@ namespace Modbus.Net
                nowAddress = continusAddresses[index];
                index--;
                var preAddress = continusAddresses[index];
-                if (nowAddress.GetCount * BigEndianValueHelper.Instance.ByteLength[nowAddress.DataType.FullName] +
-                    preAddress.GetCount * BigEndianValueHelper.Instance.ByteLength[preAddress.DataType.FullName] +
+                if (nowAddress.GetCount * ValueHelper.ByteLength[nowAddress.DataType.FullName] +
+                    preAddress.GetCount * ValueHelper.ByteLength[preAddress.DataType.FullName] +
                    orderedGap.GapNumber > MaxLength) continue;
                jumpNumberInner -= orderedGap.GapNumber;
                if (jumpNumberInner < 0) break;
@@ -341,10 +341,10 @@ namespace Modbus.Net
                    Address = preAddress.Address,
                    GetCount =
                        (int)
-                        (preAddress.GetCount * BigEndianValueHelper.Instance.ByteLength[preAddress.DataType.FullName]) +
+                        (preAddress.GetCount * ValueHelper.ByteLength[preAddress.DataType.FullName]) +
                        orderedGap.GapNumber +
                        (int)
-                        (nowAddress.GetCount * BigEndianValueHelper.Instance.ByteLength[nowAddress.DataType.FullName]),
+                        (nowAddress.GetCount * ValueHelper.ByteLength[nowAddress.DataType.FullName]),
                    DataType = typeof(byte),
                    OriginalAddresses = preAddress.OriginalAddresses.ToList().Union(nowAddress.OriginalAddresses)
                };
@@ -385,7 +385,7 @@ namespace Modbus.Net
        public override IEnumerable<CommunicationUnit<TKey>> Combine(IEnumerable<AddressUnit<TKey>> addresses)
        {
            var addressUnits = addresses as IList<AddressUnit<TKey>> ?? addresses.ToList();
-            var count = addressUnits.Sum(address => BigEndianValueHelper.Instance.ByteLength[address.DataType.FullName]);
+            var count = addressUnits.Sum(address => ValueHelper.ByteLength[address.DataType.FullName]);
            return
                new AddressCombinerNumericJump<TKey>((int)(count * Percentage / 100.0), MaxLength, AddressTranslator)
                    .Combine(
--- a/Modbus.Net/Modbus.Net/Machine/AddressHelper.cs
+++ b/Modbus.Net/Modbus.Net/Machine/AddressHelper.cs
@@ -80,7 +80,7 @@ namespace Modbus.Net
            double byteLength)
        {
            return protocolAddress +
-                   BigEndianValueHelper.Instance.ByteLength[nextPositionBetweenType.FullName] / byteLength;
+                   ValueHelper.ByteLength[nextPositionBetweenType.FullName] / byteLength;
        }

        /// <summary>
@@ -92,7 +92,7 @@ namespace Modbus.Net
        public static double GetAbstractCoordinateNextPosition(double abstractAddress, Type nextPositionBetweenType)
        {
            return abstractAddress +
-                   BigEndianValueHelper.Instance.ByteLength[nextPositionBetweenType.FullName];
+                   ValueHelper.ByteLength[nextPositionBetweenType.FullName];
        }
    }
 }
--- a/Modbus.Net/Modbus.Net/Machine/BaseMachine.cs
+++ b/Modbus.Net/Modbus.Net/Machine/BaseMachine.cs
@@ -192,7 +192,7 @@ namespace Modbus.Net
                                    communicateAddress.SubAddress),
                                (int)
                                Math.Ceiling(communicateAddress.GetCount *
-                                             BigEndianValueHelper.Instance.ByteLength[
+                                             ValueHelper.ByteLength[
                                                 communicateAddress.DataType.FullName]));


@@ -210,7 +210,7 @@ namespace Modbus.Net
                    else if (datas.Datas.Length != 0 && datas.Datas.Length <
                        (int)
                        Math.Ceiling(communicateAddress.GetCount *
-                                     BigEndianValueHelper.Instance.ByteLength[
+                                     ValueHelper.ByteLength[
                                         communicateAddress.DataType.FullName]))
                    {
                        return new ReturnStruct<Dictionary<string, ReturnUnit<double>>>()
@@ -437,7 +437,7 @@ namespace Modbus.Net
                            AddressFormater.FormatAddress(communicateAddress.Area, communicateAddress.Address, 0),
                            (int)
                            Math.Ceiling(communicateAddress.GetCount *
-                                         BigEndianValueHelper.Instance.ByteLength[
+                                         ValueHelper.ByteLength[
                                             communicateAddress.DataType.FullName]));

                    var valueHelper = ValueHelper.GetInstance(BaseUtility.Endian);
@@ -458,7 +458,7 @@ namespace Modbus.Net
                    else if (datas.Datas.Length <
                    (int)
                    Math.Ceiling(communicateAddress.GetCount *
-                                 BigEndianValueHelper.Instance.ByteLength[
+                                 ValueHelper.ByteLength[
                                     communicateAddress.DataType.FullName]))
                        return new ReturnStruct<bool>()
                        {
--- a/Modbus.Net/Modbus.Net/README.md
+++ b/Modbus.Net/Modbus.Net/README.md
@@ -288,7 +288,8 @@ But after ":", property should match constructor except protocol, which refer to

 The main target of Modbus.Net is building a high extensable hardware communication protocol, so we allow everyone to extend the protocol.

-To extend Modbus.Net, first of all ValueHelper.cs in Modbus.Net is a really powerful tool that you can use to modify values in byte array.There are two ValueHelpers: ValueHelper(Little Endian) and BigEndianValueHelper(Big Endian). Remember using the correct one.
+To extend Modbus.Net, first of all ValueHelper.cs in Modbus.Net is a really powerful tool that you can use to modify values in byte array.There are three ValueHelpers: LittleEndianLsbValueHelper(Little Endian), BigEndianLsbValueHelper(Big Endian) and BigEndianMsbValueHelper(Big Endian with bit reverse). Remember using the correct one.<br>
+If you want to write a new one, just write in namespace "Modbus.Net" in assmenly start with "Modbus.Net." and Modbus.Net will automatically load it.

 In this tutorial I will use Modbus.Net.Modbus to tell you how to implement your own protocol.

@@ -314,9 +315,9 @@ public class ReadDataModbusProtocol : ProtocolUnit

    public override IOutputStruct Unformat(byte[] messageBytes, ref int pos)
    {
-        byte slaveAddress = BigEndianValueHelper.Instance.GetByte(messageBytes, ref pos);
-        byte functionCode = BigEndianValueHelper.Instance.GetByte(messageBytes, ref pos);
-        byte dataCount = BigEndianValueHelper.Instance.GetByte(messageBytes, ref pos);
+        byte slaveAddress = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos);
+        byte functionCode = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos);
+        byte dataCount = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos);
        byte[] dataValue = new byte[dataCount];
        Array.Copy(messageBytes, 3, dataValue, 0, dataCount);
        return new ReadDataModbusOutputStruct(slaveAddress, functionCode, dataCount, dataValue);
@@ -368,8 +369,8 @@ public class ModbusTcpProtocolLinkerBytesExtend : ProtocolLinkerBytesExtend
        byte[] newFormat = new byte[6 + content.Length];
        int tag = 0;
        ushort leng = (ushort)content.Length;
-        Array.Copy(BigEndianValueHelper.Instance.GetBytes(tag), 0, newFormat, 0, 4);
-        Array.Copy(BigEndianValueHelper.Instance.GetBytes(leng), 0, newFormat, 4, 2);
+        Array.Copy(BigEndianLsbValueHelper.Instance.GetBytes(tag), 0, newFormat, 0, 4);
+        Array.Copy(BigEndianLsbValueHelper.Instance.GetBytes(leng), 0, newFormat, 4, 2);
        Array.Copy(content, 0, newFormat, 6, content.Length);
        return newFormat;
    }
--- a/Modbus.Net/Modbus.Net/Utility/BaseUtility.cs
+++ b/Modbus.Net/Modbus.Net/Utility/BaseUtility.cs
@@ -109,7 +109,7 @@ namespace Modbus.Net
            try
            {
                var typeName = getTypeAndCount.Key.FullName;
-                var bCount = BigEndianValueHelper.Instance.ByteLength[typeName];
+                var bCount = ValueHelper.ByteLength[typeName];
                var getReturnValue = await GetDatasAsync(startAddress,
                    (int)Math.Ceiling(bCount * getTypeAndCount.Value));
                var getBytes = getReturnValue;
@@ -230,7 +230,7 @@ namespace Modbus.Net
                var bAllCount = (
                    from getTypeAndCount in translateTypeAndCount
                    let typeName = getTypeAndCount.Key.FullName
-                    let bCount = BigEndianValueHelper.Instance.ByteLength[typeName]
+                    let bCount = ValueHelper.ByteLength[typeName]
                    select (int)Math.Ceiling(bCount * getTypeAndCount.Value)).Sum();
                var getReturnValue = await GetDatasAsync(startAddress, bAllCount);
                var getBytes = getReturnValue;
--- a/Samples/CrossLamp/Controllers/HomeController.cs
+++ b/Samples/CrossLamp/Controllers/HomeController.cs
@@ -35,7 +35,7 @@ namespace CrossLamp.Controllers
                }
                Lamp light = new Lamp();
                object[] lampsbyte = (await _utility.GetDatasAsync("0X 1", new KeyValuePair<Type, int>(typeof(bool), 7))).Datas;
-                bool[] lamps = BigEndianValueHelper.Instance.ObjectArrayToDestinationArray<bool>(lampsbyte);
+                bool[] lamps = BigEndianLsbValueHelper.Instance.ObjectArrayToDestinationArray<bool>(lampsbyte);
                if (lamps[0])
                {
                    light.MainLamp = LightLamp.Red.ToString();
--- a/Samples/TripleAdd/Controllers/HomeController.cs
+++ b/Samples/TripleAdd/Controllers/HomeController.cs
@@ -46,7 +46,7 @@ namespace TripleAdd.Controllers
                await utility.ConnectAsync();
            }
            object[] getNum = (await utility.GetDatasAsync("4X 1", new KeyValuePair<Type, int>(typeof(ushort), 4))).Datas;
-            ushort[] getNumUshorts = BigEndianValueHelper.Instance.ObjectArrayToDestinationArray<ushort>(getNum);
+            ushort[] getNumUshorts = BigEndianLsbValueHelper.Instance.ObjectArrayToDestinationArray<ushort>(getNum);
            return SetValue(getNumUshorts);
        }