public static byte[][] ReadRegisters(byte slaveAddress, ushort startAddress, ushort numberOfPoints, IModbusMaster master, uint wordSize, Func <byte[], byte[]> endianConverter, bool wordSwap = false)
        {
            var registerMultiplier = RegisterFunctions.GetRegisterMultiplier(wordSize);
            var registersToRead    = (ushort)(numberOfPoints * registerMultiplier);
            var values             = master.ReadHoldingRegisters(slaveAddress, startAddress, registersToRead);

            if (wordSwap)
            {
                Array.Reverse(values);
            }
            return(RegisterFunctions.ConvertRegistersToValues(values, registerMultiplier).Select(endianConverter).ToArray());
        }
        public static void WriteRegistersFunc(byte slaveAddress, ushort startAddress, byte[][] data, IModbusMaster master, uint wordSize, Func <byte[], byte[]> endianConverter, bool wordSwap = false)
        {
            var wordByteArraySize = RegisterFunctions.GetRegisterMultiplier(wordSize) * 2;

            if (data.Any(e => e.Length != wordByteArraySize))
            {
                throw new ArgumentException("All data values must be of the correct word length.");
            }
            var dataCorrectEndian = data.Select(endianConverter).ToArray();
            var registerValues    = RegisterFunctions.ConvertValuesToRegisters(dataCorrectEndian);

            if (wordSwap)
            {
                Array.Reverse(registerValues);
            }
            master.WriteMultipleRegisters(slaveAddress, startAddress, registerValues);
        }
        private static byte[] PadBytesToWordSize(uint wordSize, byte[] source, bool frontPadding)
        {
            var targetLength = RegisterFunctions.GetRegisterMultiplier(wordSize) * 2;
            var target       = new byte[targetLength];

            if (source.Length > target.Length)
            {
                throw new ArgumentException("Source bytes can not greater than target");
            }
            var offset = frontPadding
        ? target.Length - source.Length
        : 0;

            Array.Copy(
                source, 0, target, offset, source.Length);
            return(target);
        }
        public static byte[][] CharsToByteValueArrays(char[] data, uint wordSize, bool frontPadding = true, bool singleCharPerRegister = true)
        {
            var bytesPerWord = RegisterFunctions.GetRegisterMultiplier(wordSize) * 2;

            if (!singleCharPerRegister)
            {
                var remainder     = data.Length % bytesPerWord;
                var registerBytes = remainder > 0
          ? data.Length + (bytesPerWord - remainder)
          : data.Length;
                var byteArray = new byte[registerBytes];
                for (var index = 0; index < byteArray.Length; index++)
                {
                    byteArray[index] = index < data.Length
            ? Convert.ToByte(data[index])
            : Convert.ToByte('\0'); //Unicode Null Charector
                }
                var byteValueArrays = new byte[byteArray.Length / bytesPerWord][];
                for (var index = 0; index < byteValueArrays.Length; index++)
                {
                    var offset = index * bytesPerWord;
                    byteValueArrays[index] = new ArraySegment <byte>(byteArray, offset, bytesPerWord).ToArray();
                }
                return(byteValueArrays);
            }
            return((frontPadding)
        ? data.Select(e =>
            {
                var bytes = new byte[bytesPerWord];
                bytes[bytes.Length - 1] = Convert.ToByte(e);
                return bytes;
            }).ToArray()
        : data.Select(e =>
            {
                var bytes = new byte[bytesPerWord];
                bytes[0] = Convert.ToByte(e);
                return bytes;
            }).ToArray());
        }
 public static byte[][] FloatToByteValueArrays(float[] data, uint wordSize, bool frontPadding = true)
 => data.Select(e => RegisterFunctions.PadBytesToWordSize(
                    wordSize, BitConverter.GetBytes(e), frontPadding)).ToArray();