Пример #1
0
 private bool IsAnIpType(ModbusType modbusType)
 {
     return(modbusType == ModbusType.Tcp ||
            modbusType == ModbusType.Udp ||
            modbusType == ModbusType.RtuOverTcp ||
            modbusType == ModbusType.RtuOverUdp);
 }
Пример #2
0
        /// <summary>
        /// 将Rtu 或者TCP 的报文数据部分提取出来
        /// </summary>
        /// <param name="modbusType"></param>
        /// <param name="rx"></param>
        /// <returns></returns>
        private static byte[] SplitData(ModbusType modbusType, byte[] rx)
        {
            int tcpDataHeadIndex = 9;
            // int tcpDataEndIndex = rx.Length-1;
            int rtuDataHeadIndex = 3;

            //int rtuDataEndIndex = rx.Length -3;
            byte[] buf = null;

            if (modbusType == ModbusType.RTU)
            {
                if (CheckDataCrc16(rx))
                {
                    int dataLen = Convert.ToInt32(rx[rtuDataHeadIndex - 1]);
                    buf = new byte[dataLen];
                    Buffer.BlockCopy(rx, rtuDataHeadIndex, buf, 0, dataLen);
                }
            }
            if (modbusType == ModbusType.Tcp)
            {
                int dataLen = Convert.ToInt32(rx[tcpDataHeadIndex - 1]);
                buf = new byte[dataLen];
                Buffer.BlockCopy(rx, tcpDataHeadIndex, buf, 0, dataLen);
            }

            return(buf);
        }
Пример #3
0
 public ModbusUtility(ModbusType connectionType, string connectionString, byte slaveAddress, byte masterAddress)
     : base(slaveAddress, masterAddress)
 {
     ConnectionString  = connectionString;
     ModbusType        = connectionType;
     AddressTranslator = new AddressTranslatorModbus();
 }
Пример #4
0
        public int Write(byte Addr, ModbusType type, UInt16 DataAddr, UInt16 DataValue)
        {
            byte[]       bytData = new byte[2];
            FunctionCode code    = FunctionCode.WriteQ;

            switch (type)
            {
            case ModbusType.I:
            case ModbusType.AI:
                return(2);

            case ModbusType.Q:
                code       = FunctionCode.WriteQ;
                bytData[0] = (byte)(DataValue > 0 ? 0xFF : 0x00);
                bytData[1] = 0;
                break;

            case ModbusType.V:
                code       = FunctionCode.WriteVW;
                bytData[1] = (byte)(DataValue & 0xFF);
                bytData[0] = (byte)(DataValue >> 8);
                break;
            }

            lock (this)
            {
                return(RtuData(Addr, code, DataAddr, bytData, 1));
            }
        }
Пример #5
0
 public ModbusMachine(ModbusType connectionType, string connectionString,
     IEnumerable<AddressUnit> getAddresses, bool keepConnect) : base(getAddresses, keepConnect)
 {
     BaseUtility = new ModbusUtility(connectionType, connectionString);
     AddressFormater = new AddressFormaterBase();
     AddressCombiner = new AddressCombinerContinus();
 }
Пример #6
0
 private void HandleConnectionRequest(ModbusType type)
 {
     if (type == ModbusType.Random)
     {
         _eventAggregator.GetEvent <RandomConnectionRequestEvent>().Publish();
     }
 }
Пример #7
0
        /// <summary>
        ///  将返回数据解析为int16 数组
        /// </summary>
        /// <param name="modbusType">modbusType类型</param>
        /// <param name="rx">完整返回报文</param>
        /// <returns></returns>
        public static short[] DataUnPackingToShort(ModbusType modbusType, byte[] rx)
        {
            if (rx == null)
            {
                return(null);
            }
            if (rx.Length < 2)
            {
                return(null);
            }
            byte[] byfer = SplitData(modbusType, rx);
            if (byfer == null)
            {
                return(null);
            }
            int dataLen = byfer.Length / 2;

            short[] s = new short[dataLen];

            int d = 0;

            for (int i = 0; i < byfer.Length; i = i + 2, d++)
            {
                s[d] = BitConverter.ToInt16(new byte[] { byfer[i + 1], byfer[i] }, 0);
            }
            return(s);
        }
Пример #8
0
        /// <summary>
        /// 将数据打包为 Modbus 和 Rtu 或者Tcp报文格式
        /// </summary>
        /// <param name="modbusType">协议类型</param>
        /// <param name="operationCode">操作码字节</param>
        /// <param name="station">单元字节</param>
        /// <param name="data">数据</param>
        /// <returns></returns>
        public static byte[] DataPacking(ModbusType modbusType, OperationCode operationCode, byte station, params byte[] data)
        {
            List <byte> list = new List <byte>();

            byte[] result = null;
            if (modbusType == ModbusType.Tcp)
            {
                list.AddRange(new byte[] { 0x00, 0x00, 0x00, 0x00 });
                byte[] length = BitConverter.GetBytes((short)(1 + 1 + data.Count()));
                list.Add(length[1]);
                list.Add(length[0]);
                list.Add(station);
                list.Add((byte)operationCode);
                list.AddRange(data);
                result = list.ToArray();
            }
            if (modbusType == ModbusType.RTU)
            {
                list.Add(station);
                list.Add((byte)operationCode);
                list.AddRange(data);
                byte[] crc = GetModbusCRC16_Byte(list.ToArray());
                list.AddRange(crc);
                result = list.ToArray();
            }
            string s = BytesToHexString(result);

            return(result);
        }
Пример #9
0
        /// <summary>
        /// 将返回数据解析为Double 数组
        /// </summary>
        /// <param name="modbusType">modbusType类型</param>
        /// <param name="rx">完整返回报文</param>
        /// <param name="pointNum">小数位数</param>
        /// <returns></returns>
        public static double[] DataUnPackingToDouble(ModbusType modbusType, byte[] rx, int pointNum)
        {
            int a = 10;

            if (pointNum == 0)
            {
                a = 0;
            }
            for (int i = 1; i < pointNum; i++)
            {
                a = a * 10;
            }


            byte[] byfer   = SplitData(modbusType, rx);
            int    dataLen = byfer.Length / 2;

            double[] s = new double[dataLen];

            int d = 0;

            for (int i = 0; i < byfer.Length; i = i + 2, d++)
            {
                s[d] = BitConverter.ToInt16(new byte[] { byfer[i + 1], byfer[i] }, 0);
                if (a != 0)
                {
                    s[d] = s[d] / a;
                }
            }
            return(s);
        }
Пример #10
0
 /// <summary>
 /// 解析通讯参数
 /// </summary>
 /// <returns></returns>
 private bool ParseParas()
 {
     if (CommParas.StartsWith("COM"))
     {
         mCommType = 1;
         string[] paras = CommParas.Split(new char[] { ',' });
         if ((paras != null) && (paras.Length == 4))
         {
             mComPort    = paras[0];
             mComTimeout = int.Parse(paras[1]);
             mRespDelay  = int.Parse(paras[2]);
             if (paras[3] == "RTU")
             {
                 MBType = ModbusType.RTU;
             }
             else if (paras[3] == "TCP")
             {
                 MBType = ModbusType.TCP;
             }
             else
             {
                 return(false);
             }
         }
         else
         {
             return(false);
         }
     }
     else
     {
         mCommType = 2;
         string[] paras = CommParas.Split(new char[] { ',', ':' });
         if ((paras != null) && (paras.Length == 5))
         {
             mNetIP      = paras[0];
             mNetPort    = int.Parse(paras[1]);
             mNetTimeout = int.Parse(paras[2]);
             mRespDelay  = int.Parse(paras[3]);
             if (paras[4] == "RTU")
             {
                 MBType = ModbusType.RTU;
             }
             else if (paras[4] == "TCP")
             {
                 MBType = ModbusType.TCP;
             }
             else
             {
                 return(false);
             }
         }
         else
         {
             return(false);
         }
     }
     return(true);
 }
Пример #11
0
 public ModbusMachine(ModbusType connectionType, string connectionString,
                      IEnumerable <AddressUnit> getAddresses, bool keepConnect) : base(getAddresses, keepConnect)
 {
     BaseUtility        = new ModbusUtility(connectionType, connectionString);
     AddressFormater    = new AddressFormaterModbus();
     AddressCombiner    = new AddressCombinerContinus(AddressTranslator);
     AddressCombinerSet = new AddressCombinerContinus(AddressTranslator);
 }
Пример #12
0
 public ModbusUtility(ModbusType connectionType, string connectionString, byte slaveAddress, byte masterAddress, Endian endian = Endian.BigEndianLsb)
     : base(slaveAddress, masterAddress)
 {
     Endian            = endian;
     ConnectionString  = connectionString;
     ModbusType        = connectionType;
     AddressTranslator = new AddressTranslatorModbus();
 }
Пример #13
0
 public ModbusMachine(ModbusType connectionType, string connectionString,
                      IEnumerable <AddressUnit> getAddresses, bool keepConnect, byte slaveAddress, byte masterAddress, Endian endian = Endian.BigEndianLsb)
     : base(getAddresses, keepConnect, slaveAddress, masterAddress)
 {
     BaseUtility        = new ModbusUtility(connectionType, connectionString, slaveAddress, masterAddress, endian);
     AddressFormater    = new AddressFormaterModbus();
     AddressCombiner    = new AddressCombinerContinus(AddressTranslator);
     AddressCombinerSet = new AddressCombinerContinus(AddressTranslator);
 }
Пример #14
0
        public static IMaster <Packet> Create(ModbusType type, IPort port)
        {
            IMaster <Packet> result;

            switch (type)
            {
            case ModbusType.Rtu: result = new Implementation.Master.Rtu {
                    Port = port
            }; break;

            default: throw new NotImplementedException();
            }
            return(result);
        }
Пример #15
0
        public int Read(byte Addr, ModbusType type, UInt16 DataAddr, out UInt16 DataValue)
        {
            DataValue = 0;

            byte[]       bytData = new byte[2];
            int          intRet;
            FunctionCode code = FunctionCode.ReadI;

            switch (type)
            {
            case ModbusType.I:
                code = FunctionCode.ReadI;
                break;

            case ModbusType.Q:
                code = FunctionCode.ReadQ;
                break;

            case ModbusType.V:
                code = FunctionCode.ReadVW;
                break;

            case ModbusType.AI:
                code = FunctionCode.ReadAIW;
                break;
            }

            lock (this)
            {
                intRet = RtuData(Addr, code, DataAddr, bytData, 1);
            }

            if (intRet == 0)
            {
                switch (type)
                {
                case ModbusType.I:
                case ModbusType.Q:
                    DataValue = bytData[0];
                    break;

                case ModbusType.V:
                case ModbusType.AI:
                    DataValue = (UInt16)(bytData[0] << 8 | bytData[1]);
                    break;
                }
            }
            return(intRet);
        }
Пример #16
0
        public int Write(byte Addr, ModbusType type, UInt16 DataAddr, UInt16[] DataValue, UInt16 DataNum)
        {
            byte[] bytData = new byte[1024];
            UInt16 i;

            FunctionCode code = FunctionCode.WriteMQ;

            switch (type)
            {
            case ModbusType.I:
            case ModbusType.AI:
                return(2);

            case ModbusType.Q:
                code = FunctionCode.WriteMQ;
                if (IsIOx8)
                {
                    for (i = 0; i < DataNum; i++)
                    {
                        bytData[i] = (byte)(DataValue[i]);
                    }
                    DataAddr *= 8;
                    DataNum  *= 8;
                }
                else
                {
                    for (i = 0; i < (DataNum + 7) / 8; i++)
                    {
                        bytData[i] = (byte)(DataValue[i]);
                    }
                }
                break;

            case ModbusType.V:
                code = FunctionCode.WriteMVW;
                for (i = 0; i < DataNum * 2; i++, i++)
                {
                    bytData[i + 1] = (byte)(DataValue[i / 2] & 0xFF);
                    bytData[i]     = (byte)(DataValue[i / 2] >> 8);
                }
                break;
            }

            lock (this)
            {
                return(RtuData(Addr, code, DataAddr, bytData, DataNum));
            }
        }
Пример #17
0
        private void HandleConnectionRequest(ModbusType modbusType)
        {
            if (!IsAnIpType(modbusType))
            {
                return;
            }

            var ipSettings = new IpSettings()
            {
                ModbusType = modbusType,
                Hostname   = Hostname,
                Port       = Port
            };

            _eventAggregator.GetEvent <ConnectionRequestEvent>().Publish(ipSettings);
        }
Пример #18
0
        private void HandleConnectionRequest(ModbusType modbusType)
        {
            if (!(modbusType == ModbusType.Rtu || modbusType == ModbusType.Ascii))
            {
                return;
            }

            var serialSettings = new SerialSettings()
            {
                ModbusType = modbusType,
                PortName   = PortName,
                BaudRate   = BaudRate,
                DataBits   = DataBits,
                Parity     = Parity,
                StopBits   = StopBits,
                Handshake  = Handshake
            };

            _eventAggregator.GetEvent <ConnectionRequestEvent>().Publish(serialSettings);
        }
Пример #19
0
        private string GetSettingsViewName(ModbusType modbusType)
        {
            switch (modbusType)
            {
            case ModbusType.Rtu:
            case ModbusType.Ascii:
                return(nameof(SerialSettingsView));

            case ModbusType.Tcp:
            case ModbusType.Udp:
            case ModbusType.RtuOverTcp:
            case ModbusType.RtuOverUdp:
                return(nameof(IpSettingsView));

#if DEBUG
            case ModbusType.Random:
                return(nameof(RandomSettingsView));
#endif
            default:
                throw new ArgumentException("modbusType");
            }
        }
Пример #20
0
        /// <summary>
        /// 创建Modbus主站
        /// </summary>
        /// <param name="serialPortComPortConfigInfo">串口端口配置信息</param>
        /// <param name="modbusType">协议类型</param>
        /// <returns>PlcModbus对象</returns>
        public static IModbus Create(SerialPortComPortConfigInfo serialPortComPortConfigInfo, ModbusType modbusType)
        {
            ModbusTransportMode modbusTransportMode = ModbusTransportMode.Rtu;

            if (modbusType == ModbusType.ModbusMasterAscii)
            {
                modbusTransportMode = ModbusTransportMode.Ascii;
            }

            return(new ModbusMasterByNModbus4(serialPortComPortConfigInfo, modbusTransportMode));
        }
Пример #21
0
 public ModbusUtility(int connectionType)
 {
     ConnectionString  = null;
     ModbusType        = (ModbusType)connectionType;
     AddressTranslator = new AddressTranslatorModbus();
 }
Пример #22
0
        public int Read(byte Addr, ModbusType type, UInt16 DataAddr, UInt16[] DataValue, UInt16 DataNum)
        {
            byte[]       bytData = new byte[1024];
            int          intRet;
            UInt16       i;
            FunctionCode code = FunctionCode.ReadI;

            switch (type)
            {
            case ModbusType.I:
                code = FunctionCode.ReadI;
                if (IsIOx8)
                {
                    DataAddr *= 8;
                    DataNum  *= 8;
                }
                break;

            case ModbusType.Q:
                code = FunctionCode.ReadQ;
                if (IsIOx8)
                {
                    DataAddr *= 8;
                    DataNum  *= 8;
                }
                break;

            case ModbusType.V:
                code = FunctionCode.ReadVW;
                break;

            case ModbusType.AI:
                code = FunctionCode.ReadAIW;
                break;
            }

            lock (this)
            {
                intRet = RtuData(Addr, code, DataAddr, bytData, DataNum);
            }

            if (intRet == 0)
            {
                switch (type)
                {
                case ModbusType.I:
                case ModbusType.Q:
                    for (i = 0; i < DataNum + 7 / 8; i++)
                    {
                        DataValue[i] = bytData[i];
                    }
                    break;

                case ModbusType.V:
                case ModbusType.AI:
                    for (i = 0; i < DataNum; i++)
                    {
                        DataValue[i] = (UInt16)(bytData[i * 2] << 8 | bytData[i * 2 + 1]);
                    }
                    break;
                }
            }
            return(intRet);
        }
Пример #23
0
 public ModbusUtility(ModbusType connectionType, string connectionString)
 {
     ConnectionString  = connectionString;
     ModbusType        = connectionType;
     AddressTranslator = new AddressTranslatorModbus();
 }
Пример #24
0
 public ModbusUtility(ModbusType connectionType, string connectionString)
 {
     ConnectionString = connectionString;
     ModbusType = connectionType;
     AddressTranslator = new AddressTranslatorBase();
 }
Пример #25
0
 public ModbusUtility(int connectionType)
 {
     ConnectionString = null;
     ModbusType = (ModbusType)connectionType;
     AddressTranslator = new AddressTranslatorBase();
 }
Пример #26
0
 public ModbusMachine(ModbusType connectionType, string connectionString,
                      IEnumerable <AddressUnit> getAddresses)
     : this(connectionType, connectionString, getAddresses, false)
 {
 }
Пример #27
0
 public ModbusMachine(ModbusType connectionType, string connectionString,
                      IEnumerable <AddressUnit> getAddresses, byte slaveAddress, byte masterAddress)
     : this(connectionType, connectionString, getAddresses, false, slaveAddress, masterAddress)
 {
 }
Пример #28
0
 public override void SetConnectionType(int connectionType)
 {
     ModbusType = (ModbusType) connectionType;
 }
Пример #29
0
 /// <summary>
 ///     设置协议类型
 /// </summary>
 /// <param name="connectionType">协议类型</param>
 public override void SetConnectionType(int connectionType)
 {
     ModbusType = (ModbusType)connectionType;
 }
Пример #30
0
 /// <summary>
 ///     构造函数
 /// </summary>
 /// <param name="connectionType">连接类型</param>
 /// <param name="connectionString">连接地址</param>
 /// <param name="getAddresses">读写的地址</param>
 /// <param name="slaveAddress">从站号</param>
 /// <param name="masterAddress">主站号</param>
 /// <param name="endian">端格式</param>
 public ModbusMachine(ModbusType connectionType, string connectionString,
                      IEnumerable <AddressUnit <TUnitKey> > getAddresses, byte slaveAddress, byte masterAddress,
                      Endian endian = Endian.BigEndianLsb)
     : this(connectionType, connectionString, getAddresses, false, slaveAddress, masterAddress, endian)
 {
 }
Пример #31
0
 private void OnViewLoaded()
 {
     SelectedModbusType = Settings.Default.ModbusType;
 }
Пример #32
0
 public ModbusMachine(ModbusType connectionType, string connectionString,
     IEnumerable<AddressUnit> getAddresses)
     : this(connectionType, connectionString, getAddresses, false)
 {
 }