Exemplo n.º 1
0
        private void HanlderWriteMultipleRegisterData(MasterWriteDataBase masterWriteData)
        {
            if (masterWriteData is WriteMultipleRegisterData)
            {
                //02 10 00 01 00 01 02 FF 01 33 41
                //02--从机地址
                //10--功能码
                //00 01--寄存器地址
                //00 01--寄存器数量
                //02--数据长度
                //FF 01--数据 -255
                //33 41--CRC
                WriteMultipleRegisterData _data = (WriteMultipleRegisterData)masterWriteData;
                using (ByteArrayBuilder builder = new ByteArrayBuilder())
                {
                    builder.Append(_data.SlaveID);                                  //高位在前
                    builder.Append((byte)ModbusBaseOrderCmd.WriteMultipleRegister); //功能码
                    builder.Append(ByteHelper.ToBytes(_data.Address, true));        //高位在前
                    builder.Append(ByteHelper.ToBytes(_data.Quantity, true));       //数量

                    byte _coilsCount = (byte)(_data.Value.Length * 2);
                    builder.Append(_coilsCount);
                    foreach (short item in _data.Value)
                    {
                        byte[] _registerValue = item.ToBytes(true);
                        builder.Append(_registerValue);
                    }

                    ModBusAppData = builder.ToArray();
                }
            }
        }
Exemplo n.º 2
0
        public void ModBusRTUPackageTest()
        {
            #region 单个寄存器写入

            byte[] _expectWriteSingleRegister = { 0x02, 0x06, 0x00, 0x01, 0x00, 0x03, 0x98, 0x38 };
            WriteSingleRegisterData _writeSingleRegisterData = new WriteSingleRegisterData(0x02, 1, 0x03);
            ModBusRTUPackage        _writeSingleRegister     = new ModBusRTUPackage(_writeSingleRegisterData);
            byte[] _actualWriteSingleRegister = _writeSingleRegister.ToArray();
            CollectionAssert.AreEqual(_expectWriteSingleRegister, _actualWriteSingleRegister);

            #endregion 单个寄存器写入

            #region 单个线圈写入

            byte[] _expectWriteSingleCoil            = { 0x02, 0x05, 0x00, 0x01, 0xFF, 0x00, 0xDD, 0xC9 };
            WriteSingleCoilData _writeSingleCoilData = new WriteSingleCoilData(0x02, 1, true);
            ModBusRTUPackage    _writeSingleCoil     = new ModBusRTUPackage(_writeSingleCoilData);
            byte[] _actualWriteSingleCoil            = _writeSingleCoil.ToArray();
            CollectionAssert.AreEqual(_expectWriteSingleCoil, _actualWriteSingleCoil);

            #endregion 单个线圈写入

            #region 多个线圈写入

            byte[]   _expectWriteMultipleCoil = { 0x02, 0x0F, 0x00, 0x01, 0x00, 0x0A, 0x02, 0xFF, 0x01, 0x70, 0x29 };
            BitArray _coilsValue = new BitArray(new bool[10] {
                true, true, true, true, true, true, true, true, true, false
            });
            WriteMultipleCoilsData _writeMultipleCoilData = new WriteMultipleCoilsData(0x02, 1, _coilsValue);
            ModBusRTUPackage       _writeMultipleCoil     = new ModBusRTUPackage(_writeMultipleCoilData);
            byte[] _actualWriteMultipleCoil = _writeMultipleCoil.ToArray();
            CollectionAssert.AreEqual(_expectWriteMultipleCoil, _actualWriteMultipleCoil);

            #endregion 多个线圈写入

            #region 多个寄存器写入

            byte[]  _expectWriteMultipleRegister = { 0x02, 0x10, 0x00, 0x01, 0x00, 0x01, 0x02, 0xFF, 0x01, 0x33, 0x41 };
            short[] _registersValue = { -255 };
            WriteMultipleRegisterData _writeWriteMultipleRegisterData = new WriteMultipleRegisterData(0x02, 1, _registersValue);
            ModBusRTUPackage          _writeMultipleRegister          = new ModBusRTUPackage(_writeWriteMultipleRegisterData);
            byte[] _actualWriteMultipleRegister = _writeMultipleRegister.ToArray();
            CollectionAssert.AreEqual(_expectWriteMultipleRegister, _actualWriteMultipleRegister);

            #endregion 多个寄存器写入
        }