一组RS485设备操作命令

最新推荐文章于 2023-08-20 23:20:05 发布
最新推荐文章于 2023-08-20 23:20:05 发布
阅读量421 收藏
点赞数
原文链接：http://www.cnblogs.com/wdfrog/p/4606976.html
版权 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ZNJM2.Win
{
    public class CommandBase
    {
        public byte Addr { get; set; }

        public List<byte> CmdBytes { get; protected set; }
        public string Name { get; set; }
        public Object Result { get; set; }
        public DateTime? BTime { get; set; }
        public DateTime? ETime { get; set; }
        public int delayMillis { get; set; }
        protected Func<byte[], int, byte[]> CRC { get; set; }
        /// <summary>
        /// 执行次数
        /// </summary>
        public long? RunCount { get; set; }
        /// <summary>
        /// 错误次数
        /// 每次成功执行后设置成0
        /// </summary>
        public long? ErrCount { get; set; }
        public Exception Err { get; set; }

        public List<byte> ReturnBytes { get; set; }


        /// <summary>
        ///  如 01 02,
        ///     01-02,
        ///     0102,
        ///   等形式
        /// </summary>
        public string CmdText { get; set; }
        public string CmdHexString
        {
            get
            {
                return BitConverter.ToString(CmdBytes.ToArray());
            }
        }
        public CommandBase()
        {
            CmdBytes=new List<byte>();
            ReturnBytes = new List<byte>();
            Addr = 0x01;
            ErrCount = 0;
            RunCount = 0;
            CRC = CRCUtil.CRC16;

        }

        #region 方法

        /// <summary>
        /// 生成命令的字节数组
        ///  如 01 02
        ///     01-02
        ///     0102
        ///   等形式
        /// </summary>
        /// <param name="cmd"></param>
        /// <returns></returns>
        public virtual List<byte> ParserCmd()
        {
            var cmdBytes = ParserCmdWithoutCRC();
            var crc2 = CRC(cmdBytes, cmdBytes.Length);


            CmdBytes = new List<byte>(cmdBytes.Concat(crc2));
            return CmdBytes;

        }

        protected virtual byte[] ParserCmdWithoutCRC()
        {
            string cmdText = CmdText;
            var cmd = cmdText.Replace(" ", "").Replace("-", "").Trim();
            if (string.IsNullOrWhiteSpace(cmd))
            {
                throw new Exception("空字符串!");
            }
            if ((cmd.Length % 2) != 0)
            {
                throw new Exception("命令字符窜长度必须是2的倍数!");
            }
            cmd = BitConverter.ToString(new byte[] { Addr }) + cmd;
            var cmdBytes = new byte[cmd.Length / 2];
            for (int i = 0; i < cmd.Length; i = i + 2)
            {
                cmdBytes[i / 2] = byte.Parse(cmd.Substring(i, 2), System.Globalization.NumberStyles.HexNumber);
            }
            return cmdBytes;
        }

        protected virtual bool VerifyResult()
        {

            if (ReturnBytes.Count <= 0)
            {
                Err=new Exception("零长度返回!");
                ErrCount++;
                return false;

            }
            if (ReturnBytes.Count <= 2)
            {
                Err = new Exception("返回字节少于2!");
                ErrCount++;
                return false;
            }

            //CRC Check\
            var len = ReturnBytes.Count;
            var crc = CRC(ReturnBytes.ToArray(), len-2);
            if (crc[0] != ReturnBytes[len - 2] || crc[1] != ReturnBytes[len - 1])
            {
                Err = new Exception("CRC校验错误!");
                ErrCount++;
                return false;
            }

            if (ReturnBytes[0] != Addr)
            {
                Err = new Exception("非期望的设备地址!");
                ErrCount++;
                return false;
            }
            if (ReturnBytes[1] != CmdBytes[1])
            {
                Err = new Exception("非期望的命令!");
                ErrCount++;
                return false;
            }




            return true;
        }

        public virtual bool ParserReturn()
        {
            return VerifyResult();
           
        }
        #endregion
    }
    public class RFIDCmdBase : CommandBase
    {
        public RFIDCmdBase()
        {

            CRC = CRCUtil.CRC16ForRFID;

        }


        /// <summary>
        /// 生成命令的字节数组
        ///  如 01 02
        ///     01-02
        ///     0102
        ///   等形式
        /// </summary>
        /// <param name="cmd"></param>
        /// <returns></returns>
        public override List<byte> ParserCmd()
        {
            var cmdBytes = ParserCmdWithoutCRC();
            var crc2 = CRC(cmdBytes, cmdBytes.Length);


            CmdBytes = new List<byte>(cmdBytes.Concat(crc2));
            return CmdBytes;

        }

        protected override byte[] ParserCmdWithoutCRC()
        {
            string cmdText = CmdText;
            var cmd = cmdText.Replace(" ", "").Replace("-", "").Trim();
            if (string.IsNullOrWhiteSpace(cmd))
            {
                throw new Exception("空字符串!");
            }
            if ((cmd.Length % 2) != 0)
            {
                throw new Exception("命令字符窜长度必须是2的倍数!");
            }
            cmd = BitConverter.ToString(new byte[] { Addr }) + cmd;
            var cmdBytes = new byte[cmd.Length / 2];
            for (int i = 0; i < cmd.Length; i = i + 2)
            {
                cmdBytes[i / 2] = byte.Parse(cmd.Substring(i, 2), System.Globalization.NumberStyles.HexNumber);
            }


            var lenV = (byte)(cmdBytes.Length + 2); //添加命令长度
            return new byte[] { lenV }.Concat(cmdBytes).ToArray();

          
        }

        protected override bool VerifyResult()
        {

            if (ReturnBytes.Count <= 0)
            {
                Err = new Exception("零长度返回!");
                ErrCount++;
                return false;

            }
            if (ReturnBytes.Count <= 5)
            {
                Err = new Exception("返回字节少于5!");
                ErrCount++;
                return false;
            }

            //CRC Check\
            var len = ReturnBytes.Count;
            var crc = CRC(ReturnBytes.ToArray(), len - 2);
            if (crc[0] != ReturnBytes[len - 2] || crc[1] != ReturnBytes[len - 1])
            {
                Err = new Exception("CRC校验错误!");
                ErrCount++;
                return false;
            }

            if (ReturnBytes[1] != Addr)
            {
                Err = new Exception("非期望的设备地址!");
                ErrCount++;
                return false;
            }
            if (ReturnBytes[2] != CmdBytes[2])
            {
                Err = new Exception("非期望的命令!");
                ErrCount++;
                return false;
            }




            return true;
        }

    }

}
View Code 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;

namespace ZNJM2.Win
{
    #region 开关命令
    public class PowerSwitchQuery : CommandBase
    {
        public PowerSwitchQuery(byte addr)
        {
            Addr = addr;
            CmdText = "03";
            CmdBytes = ParserCmd();
            Name = "开关-状态";
        }

        public override bool ParserReturn()
        {
            bool flag = false;
            flag = base.VerifyResult();
            if (flag && ReturnBytes.Count >= 5)
            {
                flag = true;
                Result = ReturnBytes[2] == 0 ? "Off" : "On";
                ErrCount = 0;
                Err = null;
             

            }
            
            return flag;


        }
    }

    public class PowerSwitchOn : CommandBase
    {
        public PowerSwitchOn(byte addr)
        {
            Addr = addr;
            CmdText = "0601";
            CmdBytes = ParserCmd();
            Name = "开关-打开";
        }
    }

    public class PowerSwitchOff : CommandBase
    {
        public PowerSwitchOff(byte addr)
        {
            Addr = addr;
            CmdText = "0600";
            CmdBytes = ParserCmd();
            Name = "开关-关闭";
        }
    }
    #endregion

    #region 计米器
    public class LengthCounterQuery : CommandBase
    {
        public LengthCounterQuery(byte addr)
        {
            Addr = addr;
            CmdText = "03 00 01";
            ParserCmd();
            Name = "计米器-读数";
        }

        public override bool ParserReturn()
        {
            var flag=base.ParserReturn();

            if (ReturnBytes.Count > 6 && flag)
            {

                var vhex = BitConverter.ToString(new byte[] { ReturnBytes[5], ReturnBytes[6], ReturnBytes[3], ReturnBytes[4] });
                var value = int.Parse(vhex.Replace("-", ""), NumberStyles.HexNumber);
                Result = value;
                ErrCount = 0;
                Err = null;
                

            }
            return flag;
                 
        }

    }

    //清空读数
    public class LengthCounterCls : CommandBase
    {
        public LengthCounterCls(byte addr)
        {
            Addr = addr;
            CmdText = "06 00 0C 01";
            ParserCmd();
            Name = "计米器-清零";
        }

    }
    #endregion

    #region 电表

        //public class VoltageQuery : CommandBase
        //{
        //    public VoltageQuery(byte addr)
        //    {
        //        Addr = addr;
        //        CmdText = "03-00-0C-00-02";
        //        CmdBytes = ParserCmd();
        //        Name = "电表-电压";
        //    }
        //    public override bool ParserReturn()
        //    {
        //        bool flag = false;
        //        flag = base.VerifyResult();
        //        if (flag && ReturnBytes.Count >= 7)
        //        {
        //            flag = true;
        //            Result = BitConverter.ToString(ReturnBytes.ToArray(), 0);
        //            Console.WriteLine(Result.ToString());

        //            var tempArr = new byte[4];
        //            ReturnBytes.CopyTo(3, tempArr, 0, 4);

        //            Result = BitConverter.ToSingle(tempArr.Reverse().ToArray(), 0);


        //            ErrCount = 0;
        //            Err = null;


        //        }

        //        return flag;


        //    }
        //}
        //public class ElectricCurrent : CommandBase
        //{
        //    public ElectricCurrent(byte addr)
        //    {
        //        Addr = addr;
        //        CmdText = "03-00-0A-00-02";
        //        CmdBytes = ParserCmd();
        //        Name = "电表-电流";
        //    }
        //    public override bool ParserReturn()
        //    {
        //        bool flag = false;
        //        flag = base.VerifyResult();
        //        if (flag && ReturnBytes.Count >= 7)
        //        {
        //            flag = true;
        //            Result = BitConverter.ToString(ReturnBytes.ToArray(), 0);
        //            Console.WriteLine(Result.ToString());
        //            ===========
        //            var tempArr = new byte[4];
        //            ReturnBytes.CopyTo(3, tempArr, 0, 4);

        //            Result = BitConverter.ToSingle(tempArr.Reverse().ToArray(), 0);

        //            ErrCount = 0;
        //            Err = null;


        //        }

        //        return flag;


        //    }
        //}
        //public class ElectricEnergy : CommandBase
        //{
        //    public ElectricEnergy(byte addr)
        //    {
        //        Addr = addr;
        //        CmdText = "03-00-1A-00-02";
        //        CmdBytes = ParserCmd();
        //        Name = "电表-电能";
        //    }
        //    public override bool ParserReturn()
        //    {
        //        bool flag = false;
        //        flag = base.VerifyResult();
        //        if (flag && ReturnBytes.Count >= 7)
        //        {
        //            flag = true;
        //            Result = BitConverter.ToString(ReturnBytes.ToArray(), 0);
        //            Console.WriteLine(Result.ToString());
        //           // ===========
        //            var tempArr = new byte[4];
        //            ReturnBytes.CopyTo(3, tempArr, 0, 4);

        //            Result = BitConverter.ToSingle(tempArr.Reverse().ToArray(), 0);

        //            ErrCount = 0;
        //            Err = null;


        //        }

        //        return flag;


        //    }
        //}
    #endregion


    #region 电表DDS238-1Z系列
        public class VoltageQuery : CommandBase
        {
            public VoltageQuery(byte addr)
            {
                Addr = addr;
                CmdText = "03-00-0C-00-01";
                CmdBytes = ParserCmd();
                Name = "电表-电压";
            }
            public override bool ParserReturn()
            {
                bool flag = false;
                flag = base.VerifyResult();
                if (flag && ReturnBytes.Count >= 7)
                {
                    flag = true;
                    Result = BitConverter.ToString(ReturnBytes.ToArray(), 0);
                    Console.WriteLine(Result.ToString());

                    var tempArr = new byte[2];
                    ReturnBytes.CopyTo(3, tempArr, 0, tempArr.Length);

                    Result = BitConverter.ToUInt16(tempArr.Reverse().ToArray(), 0) * 0.1;


                    ErrCount = 0;
                    Err = null;


                }

                return flag;


            }
        }
        public class ElectricCurrent : CommandBase
        {
            public ElectricCurrent(byte addr)
            {
                Addr = addr;
                CmdText = "03-00-0d-00-01";
                CmdBytes = ParserCmd();
                Name = "电表-电流";
            }
            public override bool ParserReturn()
            {
                bool flag = false;
                flag = base.VerifyResult();
                if (flag && ReturnBytes.Count >= 5)
                {
                    flag = true;
                    Result = BitConverter.ToString(ReturnBytes.ToArray(), 0);
                    Console.WriteLine(Result.ToString());
                   // ===========
                    var tempArr = new byte[2];
                    ReturnBytes.CopyTo(3, tempArr, 0, tempArr.Length);

                    Result = BitConverter.ToUInt16(tempArr.Reverse().ToArray(), 0) * 0.01;

                    ErrCount = 0;
                    Err = null;


                }

                return flag;


            }
        }
        public class ElectricEnergy : CommandBase
        {
            public ElectricEnergy(byte addr)
            {
                Addr = addr;
                CmdText = "03-00-00-00-02";
                CmdBytes = ParserCmd();
                Name = "电表-电能";
            }
            public override bool ParserReturn()
            {
                bool flag = false;
                flag = base.VerifyResult();
                if (flag && ReturnBytes.Count >= 7)
                {
                    flag = true;
                    Result = BitConverter.ToString(ReturnBytes.ToArray(), 0);
                    Console.WriteLine(Result.ToString());
                    // ===========
                    var tempArr = new byte[4];
                    ReturnBytes.CopyTo(3, tempArr, 0, tempArr.Length);

                    Result = BitConverter.ToUInt32(tempArr.Reverse().ToArray(), 0) * 0.01;

                    ErrCount = 0;
                    Err = null;


                }

                return flag;


            }
        }

        public class ElectricFrequency : CommandBase
        {
            public ElectricFrequency(byte addr)
            {
                Addr = addr;
                CmdText = "03-00-11-00-01";
                CmdBytes = ParserCmd();
                Name = "电表-频率";
            }
            public override bool ParserReturn()
            {
                bool flag = false;
                flag = base.VerifyResult();
                if (flag && ReturnBytes.Count >= 7)
                {
                    flag = true;
                    Result = BitConverter.ToString(ReturnBytes.ToArray(), 0);
                    Console.WriteLine(Result.ToString());
                    // ===========
                    var tempArr = new byte[2];
                    ReturnBytes.CopyTo(3, tempArr, 0, tempArr.Length);

                    Result = BitConverter.ToUInt16(tempArr.Reverse().ToArray(), 0) * 0.01;

                    ErrCount = 0;
                    Err = null;


                }

                return flag;


            }
        }
    #endregion

#region RFID指令

     public class RFIDGetReaderInfo : RFIDCmdBase
        {
            /// <summary>
            /// 功率
            /// </summary>
            public byte Power { get; set; }
            /// <summary>
            /// 命令最大响应时间
            /// 单位100ms
            /// </summary>
            public byte CmdDelay { get; set; }
            public RFIDGetReaderInfo(byte addr)
        {
            Addr = addr;
            CmdText = "21";
            CmdBytes = ParserCmd();
            Name = "标签-获取读卡器信息";
           
        }
       
             public override bool ParserReturn()
        {
     

            bool flag = true;
            flag = base.VerifyResult();
            var RetArr=ReturnBytes.ToArray();
            var status = BitConverter.ToString(RetArr,3,1);
            if (ReturnBytes[3] != 0x00)
            {
                Err = new Exception(string.Format("返回的命令状态是{0},非期望的{1}",status,0x00));
                ErrCount++;
                return false;
            }
            if (flag && ReturnBytes.Count >= 7)
            {
                flag = true;
                Result = BitConverter.ToString(RetArr, 0);
                //Console.WriteLine(Result.ToString());


                Power = RetArr[0x0A];
                CmdDelay = RetArr[0x0B];

                ErrCount = 0;
                Err = null;


            }

            return flag;


        }
        }
     public class RFIDQueryTID : RFIDCmdBase
    {

         public int? LblNum { get; set; }
         public List<String> LblList { get; set; }
        public RFIDQueryTID(byte addr)
        {
            Addr = addr;
            CmdText = "01 02 04";
            LblList = new List<string>();
            CmdBytes = ParserCmd();
            Name = "标签-查询TID";
           
        }
       
        public override bool ParserReturn()
        {
            LblNum = 0;
            LblList.Clear();

            bool flag = true;
            flag = base.VerifyResult();
            var RetArr=ReturnBytes.ToArray();
            var status = BitConverter.ToString(RetArr,3,1);
            if (ReturnBytes[3] != 0x01)
            {
                Err = new Exception(string.Format("返回的命令状态是{0},非期望的{1}",status,0x01));
                ErrCount++;
                return false;
            }
            if (flag && ReturnBytes.Count >= 7)
            {
                flag = true;
                Result = BitConverter.ToString(RetArr, 0);
                //Console.WriteLine(Result.ToString());


                LblNum = ReturnBytes[4];
                int offset=5;
                for (int i = 0; i < LblNum; i++)
                {
                    var lblLen=ReturnBytes[offset];
                    var tmpArr=new byte[lblLen];
                    var startIndex=offset +1;
                    Array.Copy(RetArr, startIndex, tmpArr, 0, lblLen);
                    LblList.Add(BitConverter.ToString(tmpArr).Replace("-", ""));
                    offset += lblLen + 1;

                }
                


                ErrCount = 0;
                Err = null;


            }

            return flag;


        }
    }
     public class RFIDQueryEPC : RFIDCmdBase
     {

         public int? LblNum { get; set; }
         public List<String> LblList { get; set; }
         public List<List<byte>> LblBytesList { get; set; }
         public RFIDQueryEPC(byte addr)
         {
             Addr = addr;
             CmdText = "01";
             LblList = new List<string>();
             LblBytesList = new List<List<byte>>();
             CmdBytes = ParserCmd();
             Name = "标签-查询EPC";

         }

         public override bool ParserReturn()
         {
             LblNum = 0;
             LblList.Clear();

             bool flag = true;
             flag = base.VerifyResult();
             var RetArr = ReturnBytes.ToArray();
             var status = BitConverter.ToString(RetArr, 3, 1);
             if (ReturnBytes[3] != 0x01)
             {
                 Err = new Exception(string.Format("返回的命令状态是{0},非期望的{1}", status, 0x01));
                 ErrCount++;
                 return false;
             }
             if (flag && ReturnBytes.Count >= 7)
             {
                 flag = true;
                 Result = BitConverter.ToString(RetArr, 0);
                 //Console.WriteLine(Result.ToString());


                 LblNum = ReturnBytes[4];
                 int offset = 5;
                 for (int i = 0; i < LblNum; i++)
                 {
                     var lblLen = ReturnBytes[offset];
                     var tmpArr = new byte[lblLen];
                     var startIndex = offset + 1;
                     Array.Copy(RetArr, startIndex, tmpArr, 0, lblLen);
                     LblList.Add(BitConverter.ToString(tmpArr).Replace("-", ""));
                     LblBytesList.Add(tmpArr.ToList());
                     offset += lblLen + 1;

                 }



                 ErrCount = 0;
                 Err = null;


             }

             return flag;


         }
     }
     public class RFIDQueryTopOne : RFIDCmdBase
     {
         public int? LblNum { get; set; }
         public List<String> LblList { get; set; }
         public RFIDQueryTopOne(byte addr)
        {
            Addr = addr;
            CmdText = "0F";
            LblList = new List<string>();
            CmdBytes = ParserCmd();
            Name = "标签-查询单张";
           
        }
       
        public override bool ParserReturn()
        {
            LblNum = 0;
            LblList.Clear();

            bool flag = true;
            flag = base.VerifyResult();
            var RetArr=ReturnBytes.ToArray();
            var status = BitConverter.ToString(RetArr,3,1);
            if (ReturnBytes[3] != 0x01)
            {
                Err = new Exception(string.Format("返回的命令状态是{0},非期望的{1}",status,0x01));
                ErrCount++;
                return false;
            }
            if (flag && ReturnBytes.Count >= 7)
            {
                flag = true;
                Result = BitConverter.ToString(RetArr, 0);
                //Console.WriteLine(Result.ToString());


                LblNum = ReturnBytes[4];
                int offset=5;
                for (int i = 0; i < LblNum; i++)
                {
                    var lblLen=ReturnBytes[offset];
                    var tmpArr=new byte[lblLen];
                    var startIndex=offset +1;
                    Array.Copy(RetArr, startIndex, tmpArr, 0, lblLen);
                    LblList.Add(BitConverter.ToString(tmpArr).Replace("-", ""));
                    offset += lblLen + 1;

                }
                


                ErrCount = 0;
                Err = null;


            }

            return flag;


        }
     }
     public class RFIDSetPower : RFIDCmdBase
     {
         /// <summary>
         /// 
         /// </summary>
         /// <param name="addr"></param>
         /// <param name="power">功率 1-30</param>
         public RFIDSetPower(byte addr,byte power)
        {
            Addr = addr;
            CmdText = "2f" + BitConverter.ToString(new byte[]{power});
          
            CmdBytes = ParserCmd();
            Name = "标签-设置功率";
           
        }
         public override bool ParserReturn()
         {
        

             bool flag = true;
             flag = base.VerifyResult();
             var RetArr = ReturnBytes.ToArray();
             var status = BitConverter.ToString(RetArr, 3, 1);
             if (ReturnBytes[3] != 0x00)
             {
                 Err = new Exception(string.Format("返回的命令状态是{0},非期望的{1}", status, 0x01));
                 ErrCount++;
                 return false;
             }
             if (flag && ReturnBytes.Count >= 7)
             {
                 flag = true;
                 Result = "成功";

                 ErrCount = 0;
                 Err = null;


             }

             return flag;


         }
     }
     public class RFIDReadUserArea : RFIDCmdBase
     {


         public List<byte> ResultBytes { get; private set; }
         public List<byte> EPC { get; set; }
         private byte WordPtr { get; set; }
         private byte Num { get; set; }

         private RFIDReadUserArea()
         {
             CmdText = "02";
             ResultBytes = new List<byte>();
             Name = "标签-查询用户区域数据";
         }
         /// <summary>
         /// 
         /// </summary>
         /// <param name="addr"></param>
         /// <param name="startAdd">开始位置（单位：字）</param>
         /// <param name="wordLen">字数，一个字二字节</param>
         public RFIDReadUserArea(byte addr,byte[] EPCArr,byte startAdd,byte wordLen):this()
         {
             Addr = addr;
             WordPtr = startAdd;
             Num = wordLen;
             

             if(EPCArr!=null)EPC = new List<byte>(EPCArr);
             CmdBytes = ParserCmd();
             
             
            

         }
         /// <summary>
         /// 
         /// </summary>
         /// <param name="addr"></param>
         /// <param name="startAdd">开始位置（单位：字）</param>
         /// <param name="wordLen">字数，一个字二字节</param>
         public RFIDReadUserArea(byte addr, string EPCStr, byte startAdd, byte wordLen):this()
         {

             Addr = addr;
             WordPtr = startAdd;
             Num = wordLen;
             
             #region EPC
             var epc = EPCStr.Replace("-", "").Replace(" ", "");
             var epcdBytes = new byte[epc.Length / 2];
             for (int i = 0; i < epc.Length; i = i + 2)
             {
                 epcdBytes[i / 2] = byte.Parse(epc.Substring(i, 2), System.Globalization.NumberStyles.HexNumber);
             }
              EPC = new List<byte>(epcdBytes);
             #endregion

              CmdBytes = ParserCmd();
             

            



         }
         protected override byte[] ParserCmdWithoutCRC()
         {
             string cmdText = CmdText;
             var cmd = cmdText.Replace(" ", "").Replace("-", "").Trim();
             if (string.IsNullOrWhiteSpace(cmd))
             {
                 throw new Exception("空字符串!");
             }
             if ((cmd.Length % 2) != 0)
             {
                 throw new Exception("命令字符窜长度必须是2的倍数!");
             }
             cmd = BitConverter.ToString(new byte[] { Addr }) + cmd;
             var cmdBytes = new byte[cmd.Length / 2];
             for (int i = 0; i < cmd.Length; i = i + 2)
             {
                 cmdBytes[i / 2] = byte.Parse(cmd.Substring(i, 2), System.Globalization.NumberStyles.HexNumber);
             }
             //构建命令的data部分
             var data=new List<byte>();
             data.Add((byte)(EPC.Count / 2));//ENum
             data.AddRange(EPC);//EPC
             data.Add(0x03);//Mem
             data.Add(WordPtr);
             data.Add(Num);
             data.AddRange(new byte[] { 00, 00, 00, 00 });//Pwd
             #region 掩模
             //一字节为单位
             //不设置表示对整个EPC序列进行匹配
             //设置后，只对设置指定的开始位置到设定的字节数个字节进行匹配
             //如设置0开始,3字节，则进行的匹配是 xx-xx-xx-_________________
             //即只匹配前三个字节
             //data.AddRange(new byte[] { 0x0B, 0x01 });
             #endregion


             var lenV = (byte)(cmdBytes.Length + data.Count+ 2 ); //添加命令长度
             return new byte[] { lenV }.Concat(cmdBytes).Concat(data).ToArray();
         }
         public override bool ParserReturn()
         {

             ResultBytes.Clear();

             bool flag = true;
             flag = base.VerifyResult();
             var RetArr = ReturnBytes.ToArray();
             var status = BitConverter.ToString(RetArr, 3, 1);
             if (ReturnBytes[3] != 0x00)
             {
                 Err = new Exception(string.Format("返回的命令状态是{0},非期望的{1}", status, 0x00));
                 ErrCount++;
                 return false;
             }
             if (flag && ReturnBytes.Count >= (4 + (Num * 2) +2))
             {
                 flag = true;
              

                 var tmpArr = new byte[Num * 2];
                 Array.Copy(RetArr, 4, tmpArr, 0, tmpArr.Length);
                 ResultBytes.AddRange(tmpArr);
                 Result = BitConverter.ToString(tmpArr);



                 ErrCount = 0;
                 Err = null;


             }

             return flag;


         }
     }

     public class RFIDWriteUserArea : RFIDCmdBase
     {


         public List<byte> ResultBytes { get; set; }
         public List<byte> EPC { get; set; }
         private byte WordPtr { get; set; }
         private byte Num { get; set; }
         private byte[] Data { get; set; }
         private RFIDWriteUserArea()
         {
             CmdText = "03";
             ResultBytes = new List<byte>();
             Name = "标签-写用户区域数据";
         }
         /// <summary>
         /// 
         /// </summary>
         /// <param name="addr"></param>
         /// <param name="startAdd">开始位置（单位：字）</param>
         /// <param name="datas">要写入的字，一个字二字节,datas长度必须是2的整数倍</param>
         public RFIDWriteUserArea(byte addr, byte[] EPCArr, byte startAdd, byte[] datas)
             : this()
         {
             Addr = addr;
             WordPtr = startAdd;
             Data = datas;
             if ((datas.Length % 2) != 0)
             {
                 throw new Exception("数据长度必须是2的整数倍!");
             }

             if (EPCArr != null) EPC = new List<byte>(EPCArr);
             CmdBytes = ParserCmd();




         }
         /// <summary>
         /// 
         /// </summary>
         /// <param name="addr"></param>
         /// <param name="startAdd">开始位置（单位：字）</param>
         /// <param name="data">Unicode</param>
         public RFIDWriteUserArea(byte addr, string EPCStr, byte startAdd, string data)
             : this()
         {

             Addr = addr;
             WordPtr = startAdd;

             #region Data
             Data = Encoding.Unicode.GetBytes(data);
             #endregion
             #region EPC
             var epc = EPCStr.Replace("-", "").Replace(" ", "");
             var epcdBytes = new byte[epc.Length / 2];
             for (int i = 0; i < epc.Length; i = i + 2)
             {
                 epcdBytes[i / 2] = byte.Parse(epc.Substring(i, 2), System.Globalization.NumberStyles.HexNumber);
             }
             EPC = new List<byte>(epcdBytes);
             #endregion

             CmdBytes = ParserCmd();






         }
         protected override byte[] ParserCmdWithoutCRC()
         {
             string cmdText = CmdText;
             var cmd = cmdText.Replace(" ", "").Replace("-", "").Trim();
             if (string.IsNullOrWhiteSpace(cmd))
             {
                 throw new Exception("空字符串!");
             }
             if ((cmd.Length % 2) != 0)
             {
                 throw new Exception("命令字符窜长度必须是2的倍数!");
             }
             cmd = BitConverter.ToString(new byte[] { Addr }) + cmd;
             var cmdBytes = new byte[cmd.Length / 2];
             for (int i = 0; i < cmd.Length; i = i + 2)
             {
                 cmdBytes[i / 2] = byte.Parse(cmd.Substring(i, 2), System.Globalization.NumberStyles.HexNumber);
             }
             //构建命令的data部分
             var data = new List<byte>();
             var dataWords =(Data.Length / 2) ;
             data.Add((byte)dataWords);//WNUM
             data.Add((byte)(EPC.Count / 2));//ENum
             data.AddRange(EPC);//EPC
             data.Add(0x03);//Mem,0x03是用户区
             data.Add(WordPtr);
             data.AddRange(Data);
             data.AddRange(new byte[] { 00, 00, 00, 00 });//Pwd
             #region 掩模
             //一字节为单位
             //不设置表示对整个EPC序列进行匹配
             //设置后，只对设置指定的开始位置到设定的字节数个字节进行匹配
             //如设置0开始,3字节，则进行的匹配是 xx-xx-xx-_________________
             //即只匹配前三个字节
             //data.AddRange(new byte[] { 0x0B, 0x01 });
             #endregion


             var lenV = (byte)(cmdBytes.Length + data.Count + 2); //添加命令长度
             

             return new byte[] { lenV }.Concat(cmdBytes).Concat(data).ToArray();
         }
         public override bool ParserReturn()
         {

             ResultBytes.Clear();

             bool flag = true;
             flag = base.VerifyResult();
             var RetArr = ReturnBytes.ToArray();
             var status = BitConverter.ToString(RetArr, 3, 1);
             if (ReturnBytes[3] != 0x00)
             {
                 Err = new Exception(string.Format("返回的命令状态是{0},非期望的{1}", status, "0x00"));
                 ErrCount++;
                 return false;
             }
             if (flag && ReturnBytes.Count >= 6)
             {
                 flag = true;


                 Result = "写入成功!";



                 ErrCount = 0;
                 Err = null;


             }

             return flag;


         }
     }
#endregion
}
View Code 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ZNJM2.Win
{
    #region 校验
    public static class CRCUtil
    {
        private static readonly byte[] aucCRCHi = {
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
            0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
            0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40
        };
        private static readonly byte[] aucCRCLo = {
            0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7,
            0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E,
            0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, 0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9,
            0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC,
            0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
            0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32,
            0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D,
            0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A, 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 
            0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF,
            0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
            0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1,
            0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4,
            0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 
            0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA,
            0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
            0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0,
            0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97,
            0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C, 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E,
            0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89,
            0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
            0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83,
            0x41, 0x81, 0x80, 0x40
        };
        /// <summary>
        /// CRC效验
        /// </summary>
        /// <param name="pucFrame">效验数据</param>
        /// <param name="usLen">数据长度</param>
        /// <returns>效验结果</returns>
        public static byte[] CRC16(byte[] pucFrame, int usLen)
        {
            int i = 0;
            byte ucCRCHi = 0xFF;
            byte ucCRCLo = 0xFF;
            UInt16 iIndex = 0x0000;

            while (usLen-- > 0)
            {
                iIndex = (UInt16)(ucCRCLo ^ pucFrame[i++]);
                ucCRCLo = (byte)(ucCRCHi ^ aucCRCHi[iIndex]);
                ucCRCHi = aucCRCLo[iIndex];
            }

            var tmpArr = BitConverter.GetBytes((ucCRCHi << 8 | ucCRCLo));
            var bytes = new byte[] { tmpArr[0], tmpArr[1] };
            return bytes;

        }

        public static byte[] CRC16ForRFID(byte[] datas, int len)
        {
            uint i, j;
            uint crc16 = 0xffff;
            for (i = 0; i < len; i++)
            {
                crc16 ^= datas[i];
                for (j = 0; j < 8; j++)
                {
                    if ((crc16 & 0x01) == 1)
                    {
                        //标准crc16使用0xA001,RFID里使用0x8408
                        //crc16 = (crc16 >> 1) ^ 0xA001;
                        crc16 = (crc16 >> 1) ^ 0x8408;
                    }
                    else
                    {
                        crc16 = crc16 >> 1;
                    }
                }
            }
            var bs = BitConverter.GetBytes(crc16);
            return new byte[] { bs[0], bs[1] };
        }

        public static byte[] Crc16(byte[] datas, int length)
        {
            uint i, j;
            uint crc16 = 0xffff;
            for (i = 0; i < length; i++)
            {
                crc16 ^= datas[i];
                for (j = 0; j < 8; j++)
                {
                    if ((crc16 & 0x01) == 1)
                    {
                        
                        crc16 = (crc16 >> 1) ^ 0xA001;
   
                    }
                    else
                    {
                        crc16 = crc16 >> 1;
                    }
                }
            }
            var bs = BitConverter.GetBytes(crc16);
            return new byte[] { bs[0], bs[1] };
        }

        public static byte[] ParserHexStr(string str)
        {
            string cmdText = str;
            var cmd = cmdText.Replace(" ", "").Replace("-", "").Trim();
            if (string.IsNullOrWhiteSpace(cmd))
            {
                throw new Exception("空字符串!");
            }
            if ((cmd.Length % 2) != 0)
            {
                throw new Exception("命令字符窜长度必须是2的倍数!");
            }
        
            var cmdBytes = new byte[cmd.Length / 2];
            for (int i = 0; i < cmd.Length; i = i + 2)
            {
                cmdBytes[i / 2] = byte.Parse(cmd.Substring(i, 2), System.Globalization.NumberStyles.HexNumber);
            }
            return cmdBytes;
        }
    }
    #endregion
}
View Code 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO.Ports;
using System.Threading;
using System.Net;

namespace ZNJM2.Win
{
    public partial class Form3 : Form
    {


        private bool Enable = false;
        public Form3()
        {
            InitializeComponent();
        }
        public SerialPort COMPort { get; private set; }

        private void EnsureCOMPortOpen()
        {
            if (COMPort == null)
            {
                //配置COMPort
                COMPort = new SerialPort("COM2", 57600, Parity.None, 8, StopBits.One);
                COMPort.Encoding = Encoding.ASCII;
                COMPort.ReadTimeout = 1000;
                COMPort.WriteTimeout = 500;
                COMPort.ReadBufferSize = 512;
                COMPort.WriteBufferSize = 512;
             
                //COMPort.DtrEnable = true;
            }
            if (!COMPort.IsOpen)
            {
                COMPort.Open();
            }
            Thread.Sleep(100);
        }
        private void button1_Click(object sender, EventArgs e)
        {
            Enable = true;
          
            ThreadPool.QueueUserWorkItem(o =>
            {
                Do();
            }, null);
            button1.Enabled = false;
            button2.Enabled = true;
        }
        public void Do()
        {
            try
            {
               
                EnsureCOMPortOpen();
                Console.WriteLine("串口打开!");
                byte[] buffer = new byte[COMPort.ReadBufferSize];
                List<byte> myBuff=new List<byte>();

                //D7-A3-88-40 4.27
                //00 00 01 ab

                var cmds = new List<CommandBase>();
                //cmds.Add(new VoltageQuery(01));
                //cmds.Add(new ElectricCurrent(01));
                //cmds.Add(new ElectricEnergy(01));
                //cmds.Add(new ElectricFrequency(01));
                //cmds.Add(new RFIDQueryTID(00));
                //cmds.Add(new RFIDQueryEPC(00));
                //cmds.Add(new RFIDSetPower(00, 5));
                //cmds.Add(new RFIDQueryTopOne(00));
               // cmds.Add(new RFIDGetReaderInfo(00));


                string strV = "张三李四网无123456789abc";
                var writeBytes = new List<byte>();
                writeBytes.AddRange(BitConverter.GetBytes(DateTime.Now.Ticks));
                writeBytes.AddRange(Encoding.UTF8.GetBytes(strV));
                var readWords = 0;
                if ((writeBytes.Count % 2) == 0)
                {
                    readWords = writeBytes.Count / 2;
                }
                else
                {
                    readWords = (writeBytes.Count / 2) + 1;
                    writeBytes.Add(0x00);
                }
                Console.WriteLine(BitConverter.ToString(writeBytes.ToArray()));
               

                cmds.Add(new RFIDWriteUserArea(00, CRCUtil.ParserHexStr("E20040807212025312409A77"), 00, writeBytes.ToArray()));
                cmds.Add(new RFIDReadUserArea(00, "E20040807212025312409A77", 00, (byte)readWords));
                //cmds.Add(new RFIDReadUserArea(00, "E20040807212023812309C8B", 00, 1));
                while (Enable)
                {
                    foreach (var cmd in cmds)
                    {
                        Console.WriteLine("==========================");
                        Console.WriteLine(cmd.Name);
                   
                        COMPort.Write(cmd.CmdBytes.ToArray(), 0, cmd.CmdBytes.Count);
                        Thread.Sleep(100 * 3);

                        int len = COMPort.Read(buffer, 0, buffer.Length);
               

                        byte[] tempArr = new byte[len];
                        Array.Copy(buffer, tempArr, len);
                        cmd.ReturnBytes = new List<byte>(tempArr);

                        Console.WriteLine("RAW:" +BitConverter.ToString(tempArr));

                        if (cmd.ParserReturn())
                        {
                            #region
                            if (cmd is RFIDReadUserArea)
                            {
                                var t = (RFIDReadUserArea)cmd;
                                Console.WriteLine("ReadData:" +t.Result);
                         

                                var dt=new DateTime( BitConverter.ToInt64(t.ResultBytes.ToArray(), 0));
                                Console.WriteLine(dt.ToString());
                                Console.WriteLine("UTF-8:" + Encoding.UTF8.GetString(t.ResultBytes.ToArray(), 8,t.ResultBytes.Count -8 ));
                            }
                            if (cmd is RFIDWriteUserArea)
                            {
                                Console.WriteLine("ReadData:" + cmd.Result);
                            }
                            #endregion
                            #region QueryTID
                            if (cmd is RFIDQueryTID)
                            {

                                Console.WriteLine("LblNum:" + ((RFIDQueryTID)cmd).LblNum);
                                foreach (var lbl in ((RFIDQueryTID)cmd).LblList)
                                {
                                    Console.WriteLine(lbl);
                                }
                            }
                            #endregion
                            #region RFIDQueryEPC
                            if (cmd is RFIDQueryEPC)
                            {

                                Console.WriteLine("LblNum:" + ((RFIDQueryEPC)cmd).LblNum);

                                foreach (var lbl in ((RFIDQueryEPC)cmd).LblList)
                                {
                                    
                                    Console.WriteLine(lbl);
                                }
                            }
                            #endregion
                            #region RFIDGetReaderInfo
                            if (cmd is RFIDGetReaderInfo)
                            {

                                Console.WriteLine("Power:" + ((RFIDGetReaderInfo)cmd).Power);
                                Console.WriteLine("CmdDelay:" + ((RFIDGetReaderInfo)cmd).CmdDelay);
                            }
                            #endregion
                            if (cmd is RFIDQueryTopOne)
                            {
                                Console.WriteLine("LblNum:" + ((RFIDQueryTopOne)cmd).LblNum);
                                foreach (var lbl in ((RFIDQueryTopOne)cmd).LblList)
                                {
                                    Console.WriteLine(lbl);
                                }
                            }
                        }
                        else
                        {
                            Console.WriteLine(cmd.Err.ToString());
                           // COMPort.Read(buffer, 0, buffer.Length);
                        }
              
                    }
                    //using (WebClient wc = new WebClient())
                    //{
                    //    var url = string.Format(@"http://192.168.9.6:7896/Default.aspx?rnd={0}&m=U&V={1}&I={2}&E={3}",
                    //        DateTime.Now.Ticks,
                    //        cmds.OfType<VoltageQuery>().FirstOrDefault().Result,
                    //        cmds.OfType<ElectricCurrent>().FirstOrDefault().Result,
                    //        cmds.OfType<ElectricEnergy>().FirstOrDefault().Result
                    //        );
                    //    Console.WriteLine(url);
                    //    wc.DownloadString(url);
                    //    wc.Dispose();
                    //}
                    Thread.Sleep(1000 * 2);


                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);

            }
            finally
            {
                if (COMPort != null && COMPort.IsOpen)
                {
                    COMPort.Close();
                }
                if (Enable)
                {
                    ThreadPool.QueueUserWorkItem(o =>
                    {
                        Do();
                    }, null);
                }
                Console.WriteLine("结束!");
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            Enable = false;
            button1.Enabled = true;
            button2.Enabled = false;
        }
    }
}
View Code

 

转载于:https://www.cnblogs.com/wdfrog/p/4606976.html

weixin_30752699
关注
RS485命令式电机驱动器，极大简化软硬件设计
gnikam的博客
05-04 2740
到目前为止，在需要使电机驱动器控制电机时，还在使用通常的方案：选好电机驱动器和电机后，根据电机驱动器设计上位机控制板，上位机与电机控制板之间通过几条TTL控制线连接，然后设计控制程序驱动电机控制板：PWM、中断、计数等。相信绝大部分人都是选用这种方案，而且觉的没毛病，很好呀。其实以上方案有几个问题：1. 上位机控制板与电机驱动板之间的连接线过多。在只有一个电机需要控制的情况下，这一点还不重要。但如...
java rs485
wangshenya的博客
10-09 2429
记一次java RS485串口编程 1.项目需求 通过web界面对加油站灯光相关控制 2.具体需求(根据需求文档) 2.1 适用范围 主控制模块通过RS485和中心通信 2.2 传输协议 （1）数据传输模式：异步基带数据传输模式，采用RS-485，RS232串行接口，单工通讯工作方式，多字节参数，高字节先发 （2）数据传输速率：默认115200bit/s。 （3）数据格式 1个起始位，8个数据位，1个停止位，无奇偶校验，共10位。 2.3 帧格式 字节数 数据内容 数
05 RS485
小胡同学的工程师学习之路
01-02 591
RS485 是一种通用的通信标准，广泛用于数据采集和控制应用中。它的主要优点之一是它允许将多个 RS485 设备放在同一条总线上，这使得多个节点可以相互连接。RS-485（目前称为EIA/TIA-485）是通信物理层的标准接口，一种信号传输方式。串行 EIA-485 连接是使用两根或三根电线的电缆完成的：一根数据线、一根带反转数据的电线，通常还有一根零线（接地，0 V）。这样，发射器和接收器通过 22 或 24 AWG 实心线的双绞线电缆交换数据。这里的主要思想是通过两根电线传输一个信号。
RS485通讯协议使用手册
09-16
1. RS485通讯协议………………………………………………………………… 1 2. 仪表分类说明…………………………………………………………………… 8 2.1. XMA5000 ………………………………………………………………………… 9 2.2. XMB5000 …………………………………………………………………………11 2.3. XMD5000 …………………………………………………………………………12 2.4. XMDT5000 ………………………………………………………………………14 2.5. XME5000 …………………………………………………………………………14 2.6. XMG5000 …………………………………………………………………………14 2.7. XMG6000 …………………………………………………………………………15 2.8. XMG7000 …………………………………………………………………………15 2.9. XMGA5000…………………………………………………………………………16 2.10. XMH5000 …………………………………………………………………………18 2.11. XMHG5000…………………………………………………………………………18 2.12. XMI5000 …………………………………………………………………………18 2.13. XMJ5000 …………………………………………………………………………19 2.14. XML5000 …………………………………………………………………………20 2.15. XMLH5000…………………………………………………………………………21 2.16. XMPHB5000 ………………………………………………………………………21 2.17. XMPHG5000 ………………………………………………………………………21 2.18. XMPHGA5000………………………………………………………………………21 2.19. XMR5000 …………………………………………………………………………21 2.20. XMS5000 …………………………………………………………………………21 2.21. XMT6000 …………………………………………………………………………22 2.22. XMZ5000 …………………………………………………………………………23
RS232、RS422、RS485硬件及RS指令、RS2指令应用知识学习
最新发布
好记性不如烂笔头
08-20 7552
常用硬件接口RS232/RS422/RS485，以下为DB9公母头PIN脚对应信号，图三是RS485两线制接法。
FreeRTOS+RS485多机通信_freertos485_freertos485通讯_freertos_freertos+4
10-02
FreeRTOS是一个轻量级、高效的实时操作系统，广泛应用于嵌入式系统中，而RS485是一种常用的标准接口，用于长距离、多设备之间的串行通信。 首先，我们要理解FreeRTOS的基本概念。FreeRTOS是一个开放源码的实时操作...
rs485与modbus流程图_关于RS485和MODBUS的快速入门教程（值得收藏）
weixin_35075740的博客
01-14 1383
什么是RS485？ RS485是串行传输标准，有点像RS232，但使用其他电信号。RS485的一个重要优点是可以将多个RS485设备放在同一总线上。因此，您不必在主机上乘以RS485接口来询问多个设备。但是，有一个小技巧：在总线的每一端，你必须放一个总线端接器。有时这意味着您必须在端子上拧一个小电阻，或者只需将开关移到适当的位置即可。RS485总线通常只由两根导线和四极电阻组成......
基于PLC网络的设备组通讯应用.pdf
08-07
在网络化PLC控制系统中，通常会设置一个总PLC，它不直接参与设备控制，而是负责协调PLC之间的通讯，处理命令，并承担必要的算法任务。这样的结构使得设备组的通讯更加高效，尤其在多机组进行大闭环PID控制时效果最佳...
RS485通信和Modbus通信协议汇总
weixin_39793752的博客
08-06 6万+
1. 主从模式 RS-485上的软件层协议ModBus主要依赖于主从模式。主从模式是指在半双工通讯方式上，2个或者2个以上的设备组成的通讯系统中： (1) 至少且只有一个主机，其他的都是从机 (2) 不管任何时候，从机都不能主动向主机发送数据 (3) 主机具有访问从机的权限，从机不可以主动访问从机，任何一次数据交换，都要由主机发起 (4)不管是主机还是从机，系统一旦上电，都要把自己置于接收状...
modbus命令小工具
11-09
modbus命令小工具
modbus 协议在RS485实现
lcydhr的专栏
10-23 7005
转载自http://www.51hei.com/bbs/dpj-23230-1.html，被TCP虐了几个月的“算法工程师”又要经受modbus的考验了，TCP都熬过来了，这个小东西轻松面对！ 在工业控制、电力通讯、智能仪表等领域，通常情况下是采用串口通信的方式进行数据交换。最初采用的方式是RS232接口，由于工业现场比较复杂，各种电气设备会在环境中产生比较多的电磁干扰，会导致信号传输错误。除此
Modbus 485继电器开、关、读 串口指令
qq_34677276的博客
11-14 5997
开继电器1： 01 06 00 00 00 01 48 0A 关继电器1： 01 06 00 00 00 00 89 CA 开继电器2： 01 06 00 01 00 01 19 CA 关继电器2： 01 06 00 01 00 00 D8 0A 开继电器3： 01 06 00 02 00 01 E9 CA 关继电器3： 01 06 00 02 00 00 28 0A 开继电器4： 01 06 00 03 00 01 B8 0A 关继电器4： 01 06 00 03 00 00 79 CA 开继电器5： 0
ModeBus RTU 485调试
wangdefa12xx的博客
08-12 2013
ModeBus RTU485
RS-485通信协议(ModBus版)
郑州科煊
08-03 1万+
地址码：1个字节，从机（设备）在485总线中的唯一地址，出厂默认位0x01。地址码：1个字节，设备在485总线中的唯一地址，出厂默认位0x01。地址码：1个字节，设备在485总线中的唯一地址，出厂默认位0x01。寄存器起始地址：2个字节，存储从机（设备）参数、传感器数据等。功能码：1个字节，主机发送命令的类别，问询帧指定为0x03。功能码：1个字节，主机发送命令的类别，问询帧指定为0x03。功能码：1个字节，主机发送命令的类别，写入帧指定为0x06。数据字节个数：1个字节，数据1~数据n的字节个数。...
基于RS485接口的Modbus-Rtu通讯测试
weixin_44173266的博客
02-28 2837
基于RS485接口的Modbus-Rtu通讯测试
RS485详述（学习使用）
weixin_46046597的博客
03-28 7015
数据通信：要实现数据通信的必须由物理接口，电气标准（逻辑电平标准）、通信时序标准三部分组成。物理接口： 接口形状电平标准： 逻辑电平标准规定了多少电压代表0，多少电压代表1等信息通信时序标准： 时序标准指的是和实际电压的逻辑值（0和1）在时间轴上的标准，简单讲，时序标准规定了逻辑信号的格式，什么时候该收或发1，什么时候该收或发0。
终于讲透了，史上最详细的RS485串口通讯！
热门推荐
嵌入式Linux
01-09 18万+
RS485接口组成的半双工网络，一般是两线制，多采用屏蔽双绞线传输，这种接线方式为总线式拓扑结构在同一总线上最多可以挂接32个结点。我们知道，最初数据是模拟信号输出简单过程量，后来仪表接...
485通讯协议_RS485通讯基础及通讯应用详解
weixin_39721807的博客
11-27 1万+
要搞清楚RS485通讯我们要先搞明白什么是通讯，通讯就是两个设备之间0、1代码的传递，0-低电平，1-高电平。举例：plc向变频器从机1和变频器从机2传递数据，首先变频器从机1和变频器从机2设备之间必须通过电缆连接（硬件连接）。如果变频器从机1和变频器从机设备发送101010这样一串代码，那么变频器从机1就要在他的通讯端口产生如下图所示的高低电平的组合，通过电缆这个介质变频器从机2设备的通讯端口就...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值