.NET 版本

1.SDK下载

JT705SDK(JT705SDK_V2.rar) 下载地址
JT705SDK测试工具(JT705SDK_Test.rar) 下载地址
如果需要测试工具及SDK开发源码，请与商务申请

2.集成开发说明

2.1.集成开发语言及框架说明

JT705SDK（Jt705DataParser.dll）及测试工具（Test.exe）是基于C#语言，.NET Framework 4.6.1目标框架开发的。该SDK的集成开发环境也是需要依赖于C#语言以及.NET Framework 4.6.1目标框架。

2.2.集成说明

（1）将Jt705DataParser.dll引入到自己的网关程序中，引入方法如下：
鼠标右键项目下的”引用”，选择”添加引用(R)…”

选择下图中”浏览(B)…”，找到你解压JT705SDK_V2.rar后的文件夹，选中Jt705DataParser.dll与对应的Json字符串序列化/反序列化包Newtonsoft.Json.dll即可完成对SDK的引用

（2）调用Jt705DataParser.dll中的解析方法receiveData
receiveData()是一个重载方法，你可以传入16进制字符串或者byte[],一般我们网关程序接收到的设备数据是以二进制流进行传输的，所以我们这里建议使用此重载方法receiveData(byte[] bytes);
当然如果你想通过16进制字符串进行测试，也可以使用receiveData(string strData)；
strData：就是我们接收到的设备数据转成16进制后的字符串

2.3.核心代码

Jt705DataParser.dll
(1)解析类DataParser.cs

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Jt705DataParser
{
    public class DataParser
    {
        private static byte[] endbytes = null;// 上一次未处理的剩余字节

        /// <summary>
        /// 解析16进制原始数据
        /// </summary>
        /// <param name="strData"></param>
        /// <returns></returns>
        public static string receiveData(string strData)
        {
            byte[] bytes = Common.HexStringToBytes(strData);
            return receiveData(bytes);
        }

        /// <summary>
        /// 解析2进制原始数据
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static string receiveData(byte[] bytes)
        {
            byte[] newBytes = null;
            if (endbytes != null && endbytes.Length > 0)
            {
                newBytes = new byte[endbytes.Length + bytes.Length];
                bytes = Common.CombineBytes(endbytes, bytes);
            }
            else
            {
                newBytes = new byte[bytes.Length];
                newBytes = bytes;
            }
            int i = 0;//初始化byte[]下标
            byte[] parserBytes = null;//去除正确包头之前的数据后的数据
            foreach (var item in newBytes)
            {
                if (item == 0x7E)
                {
                    parserBytes = new byte[newBytes.Length - i];
                    parserBytes = newBytes.Skip(i).Take(newBytes.Length - i).ToArray();
                    return parserLocation(parserBytes);
                }
                else if (item == '(')
                {
                    parserBytes = new byte[newBytes.Length - i];
                    parserBytes = newBytes.Skip(i).Take(newBytes.Length - i).ToArray();
                    return parserCommand(parserBytes);
                }
                i++;
            }
            return null;
        }

        private static string parserLocation(byte[] bytes)
        {
            byte[] frame = PacketUtil.decodePacket(bytes);
            if (frame == null)
            {
                endbytes = bytes;
                return null;
            }
            //定义定位数据实体类
            Result model = new Result();
            //消息ID
            int msgId = Common.SwapUInt16(BitConverter.ToUInt16(frame, 1));
            //消息体属性
            int msgBodyAttr = Common.SwapUInt16(BitConverter.ToUInt16(frame, 3));
            //消息体长度
            int msgBodyLen = msgBodyAttr & 0x03FF;
            byte[] terminalNumArr = bytes.Skip(5).Take(6).ToArray();
            model.DeviceID = Common.ByteToHexStr(terminalNumArr).TrimStart('0');
            //消息流水号
            int msgFlowId = Common.SwapUInt16(BitConverter.ToUInt16(frame, 11));
            //消息体
            byte[] msgBodyArr = bytes.Skip(13).Take(msgBodyLen).ToArray();
            if (msgId == 0x0200)
            {
                //解析消息体
                LocationData locationData = PacketUtil.parseLocationBody(msgBodyArr);
                locationData.Index = msgFlowId;
                locationData.DataLength = msgBodyLen;
                model.MsgType = "Location";
                model.DataBody = locationData;
                string replyMsg = PacketUtil.replyBinaryMessage(terminalNumArr, msgFlowId);
                model.ReplyMsg = replyMsg;
            }
            else
            {
                model.MsgType = "heartbeat";
            }
            return JsonConvert.SerializeObject(model);
        }

        /// <summary>
        /// 解析指令数据
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        private static string parserCommand(byte[] bytes)
        {
            Result result = new Result();
            byte[] newBytes = null;
            int tailIndex = Common.BytesIndexOf(bytes, 0x29) + 1;
            if (tailIndex > 0)
            {
                if (bytes.Length > tailIndex)
                {
                    endbytes = bytes.Skip(tailIndex).Take(bytes.Length - tailIndex).ToArray();
                }
                newBytes = bytes.Skip(0).Take(tailIndex).ToArray();
            }
            else
            {
                endbytes = new byte[bytes.Length];
                endbytes = bytes;
            }
            if (newBytes != null && newBytes.Length > 0)
            {
                //转换成（）带括号的数据
                string msgAscii = Common.ByteToASCII(newBytes);
                //按逗号拆分字符串
                char[] p = new char[] { ',' };
                //返回的数组中，包含空字符串
                string[] msgArrays = msgAscii.Replace("(", "").Replace(")", "").Split(p, StringSplitOptions.None);
                result.DeviceID = msgArrays[0];
                string msgType = string.Empty;
                if (msgArrays.Length > 5)
                {
                    msgType = msgArrays[3] + msgArrays[4];
                }
                else
                {
                    return null;
                }
                result.MsgType = msgType;
                result.DataBody = msgAscii;
                string replyMsg = string.Empty;
                if (msgType.Equals("BASE2") && msgArrays[5].ToUpper().Equals("TIME"))
                {
                    replyMsg = PacketUtil.replyBASE2Message(msgArrays);
                }
                result.ReplyMsg = replyMsg;
                return JsonConvert.SerializeObject(result);
            }
            else
            {
                return null;
            }
        }
    }
}

（2）公共方法类：Common.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace Jt705DataParser
{
    public class Common
    {

        /// <summary>
        /// 16进制格式字符串转字节数组
        /// </summary>
        /// <param name="hexString"></param>
        /// <returns></returns>
        public static byte[] HexStringToBytes(string hexString)
        {
            hexString = Regex.Replace(hexString, @".{2}", "$0 ");
            //以 ' ' 分割字符串，并去掉空字符
            string[] chars = hexString.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            byte[] returnBytes = new byte[chars.Length];
            //逐个字符变为16进制字节数据
            for (int i = 0; i < chars.Length; i++)
            {
                returnBytes[i] = Convert.ToByte(chars[i], 16);
            }
            return returnBytes;
        }

        /// <summary>
        /// 合并数组
        /// </summary>
        /// <param name="bytes1"></param>
        /// <param name="bytes2"></param>
        /// <returns></returns>
        public static byte[] CombineBytes(byte[] bytes1, byte[] bytes2)
        {
            List<byte> tmp = new List<byte>(bytes1.Length + bytes2.Length);
            tmp.AddRange(bytes1);
            tmp.AddRange(bytes2);
            byte[] merged = tmp.ToArray();
            return merged;
        }

        /// <summary>
        /// 报告指定的 System.Byte[] 在此实例中的第一个匹配项的索引。
        /// </summary>
        /// <param name="srcBytes">被执行查找的 System.Byte[]。</param>
        /// <param name="searchBytes">要查找的 System.Byte[]。</param>
        /// <returns>如果找到该字节数组，则为 searchBytes 的索引位置；如果未找到该字节数组，则为 -1。如果 searchBytes 为 null 或者长度为0，则返回值为 -1。</returns>
        public static int BytesIndexOf(byte[] srcBytes, byte searchBytes)
        {
            if (srcBytes == null) { return -1; }
            if (srcBytes.Length == 0) { return -1; }
            for (int i = 0; i < srcBytes.Length; i++)
            {
                if (srcBytes[i] == searchBytes)
                {
                    return i;
                }
            }
            return -1;
        }

        /// <summary>
        /// 16进制字符串转ASCII
        /// </summary>
        /// <param name="Data"></param>
        /// <param name="istrans"></param>
        /// <returns></returns>
        public static string HexStrToAsciiString(string Data, bool istrans)
        {
            if (istrans)
            {
                Data = Regex.Replace(Data, @"(?is)(?<=^([0-9a-f]{2})+)(?!$)", " ");
                Data = Data.Replace("3D 00", "3D ").Replace("3D 11", "2C ").Replace("3D 14", "28 ").Replace("3D 15", "29 ").Replace(" ", "");
            }
            int count = Data.Length / 2;
            string strContent = "";
            char[] num = new char[count];
            for (int i = 0; i < count; i++)
            {
                string str = Data.Substring(i * 2, 2);
                byte by = Convert.ToByte(Convert.ToInt32(str, 16));
                num[i] = Convert.ToChar(by);
                strContent += num[i].ToString();
            }
            return strContent;
        }

        /// <summary>
        /// 二进制转ASCII
        /// </summary>
        /// <param name="bt"></param>
        /// <returns></returns>
        public static string ByteToASCII(byte[] bt)
        {
            string lin = "";
            for (int i = 0; i < bt.Length; i++)
            {
                lin = lin + bt[i] + " ";
            }
            string[] ss = lin.Trim().Split(new char[] { ' ' });
            char[] c = new char[ss.Length];
            int a;
            for (int i = 0; i < c.Length; i++)
            {
                a = Convert.ToInt32(ss[i]);
                c[i] = Convert.ToChar(a);
            }

            string b = new string(c);
            return b;
        }

        /// <summary>
        /// 时间格式转换
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static DateTime GetDataTime(byte[] bytes)
        {
            return DateTime.ParseExact(ByteToHexStr(bytes), "yyMMddHHmmss", System.Globalization.CultureInfo.CurrentCulture);
        }

        public static DateTime GetDataTime(string strdate)
        {
            return DateTime.ParseExact(strdate, "yyMMddHHmmss", System.Globalization.CultureInfo.CurrentCulture);
        }

        /// <summary>
        /// 获取二进制第index位的值
        /// </summary>
        /// <param name="number"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        public static int getBitValue(long number, int index)
        {
            return (number & (1 << index)) > 0 ? 1 : 0;
        }

        /// <summary>
        /// 字节数组转16进制字符串
        /// </summary>
        /// <param name="byteDatas"></param>
        /// <returns></returns>
        public static string ByteToHexStr(byte[] byteDatas)
        {
            StringBuilder builder = new StringBuilder();
            for (int i = 0; i < byteDatas.Length; i++)
            {
                builder.Append(string.Format("{0:X2}", byteDatas[i]));
            }
            return builder.ToString().Trim();
        }

        public static ushort SwapUInt16(ushort v)
        {
            return (ushort)(((v & 0xff) << 8) | ((v >> 8) & 0xff));
        }

        public static uint SwapUInt32(uint v)
        {
            return (uint)(((SwapUInt16((ushort)v) & 0xffff) << 0x10) |
                           (SwapUInt16((ushort)(v >> 0x10)) & 0xffff));
        }

        /// <summary>
        /// Short转Bytes
        /// </summary>
        /// <param name="number"></param>
        /// <returns></returns>
        public static byte[] ShortToBytes(short number)
        {
            byte byte2 = (byte)(number >> 8);
            byte byte1 = (byte)(number & 255);
            byte[] bytes = new byte[2];
            bytes[0] = byte1;
            bytes[1] = byte2;
            return bytes.Reverse().ToArray();
        }

        /// <summary>
        /// 随机short
        /// </summary>
        /// <returns></returns>
        public static short RandomNumber(int min, int max)
        {
            Random rd = new Random();
            return (short)rd.Next(min, max);
        }

        /// <summary>
        /// 计算校验码
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static byte xor(List<byte> bytes)
        {
            int checksum = 0;
            foreach (byte b in bytes)
            {
                checksum ^= b;
            }
            return (byte)(checksum & 0xff);
        }

        /// <summary>
        /// 转义
        /// </summary>
        /// <param name="inBytes"></param>
        /// <returns></returns>
        public static byte[] escape(List<byte> inBytes)
        {
            List<byte> outBytes = new List<byte>();
            foreach (byte b in inBytes)
            {
                if (b == 0x7E)
                {
                    outBytes.AddRange(HexStringToBytes("7D02"));
                }
                else if (b == 0x7D)
                {
                    outBytes.AddRange(HexStringToBytes("7D01"));
                }
                else
                {
                    outBytes.Add(b);
                }
            }
            return outBytes.ToArray();
        }
    }
}

(3)解包工具类PacketUtil.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Jt705DataParser
{
    public class PacketUtil
    {

        public static byte[] decodePacket(byte[] bytes)
        {
            //查找消息尾
            byte[] msgBodyNoHeader = bytes.Skip(1).Take(bytes.Length - 1).ToArray();
            int tailIndex = Common.BytesIndexOf(msgBodyNoHeader, 0x7E);
            if (tailIndex <= 0)
            {
                return null;
            }
            return unescape(bytes, tailIndex).ToArray();
        }
        /// <summary>
        /// 反转义
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="bodyLen"></param>
        /// <returns></returns>
        public static List<byte> unescape(byte[] bytes, int bodyLen)
        {
            int i = 0;
            List<byte> frame = new List<byte>();
            while (i < bodyLen)
            {
                byte b = bytes[i];
                if (b == 0x7D)
                {
                    byte nextByte = bytes[i + 1];
                    if (nextByte == 0x01)
                    {
                        frame.Add(0x7D);
                    }
                    else if (nextByte == 0x02)
                    {
                        frame.Add(0x7E);
                    }
                    else
                    {
                        //异常数据
                        frame.Add(b);
                        frame.Add(nextByte);
                    }
                    i += 2;
                }
                else
                {
                    frame.Add(b);
                    i++;
                }
            }
            return frame;
        }

        /// <summary>
        /// 解析定位消息体
        /// </summary>
        /// <param name="msgBodyBuf"></param>
        /// <returns></returns>
        public static LocationData parseLocationBody(byte[] msgBodyBuf)
        {
            //报警标志
            long alarmFlag = Common.SwapUInt32(BitConverter.ToUInt32(msgBodyBuf, 0));
            //状态
            long status = Common.SwapUInt32(BitConverter.ToUInt32(msgBodyBuf, 4));
            //纬度
            double lat = Common.SwapUInt32(BitConverter.ToUInt32(msgBodyBuf, 8)) * 0.000001;
            //经度
            double lon = Common.SwapUInt32(BitConverter.ToUInt32(msgBodyBuf, 12)) * 0.000001;
            //海拔高度,单位为米
            int altitude = Common.SwapUInt16(BitConverter.ToUInt16(msgBodyBuf, 16));
            //速度
            double speed = Common.SwapUInt16(BitConverter.ToUInt16(msgBodyBuf, 18)) * 0.1;
            //方向
            int direction = Common.SwapUInt16(BitConverter.ToUInt16(msgBodyBuf, 20));
            //定位时间
            DateTime gpsZonedDateTime = Common.GetDataTime(msgBodyBuf.Skip(22).Take(6).ToArray());
            //根据状态位的值判断是否南纬和西经
            if (Common.getBitValue(status, 2) == 1)
            {
                lat = -lat;
            }
            if (Common.getBitValue(status, 3) == 1)
            {
                lon = -lon;
            }
            //定位状态
            int locationType = Common.getBitValue(status, 18);
            if (locationType == 0)
            {
                locationType = Common.getBitValue(status, 1);
            }
            if (locationType == 0)
            {
                locationType = Common.getBitValue(status, 6) > 0 ? 2 : 0;
            }
            //报警状态
            int alarm = -1;
            if (Common.getBitValue(alarmFlag, 16) == 1)
            {
                alarm = (int)AlarmTypeEnum.ALARM_1;
            }
            //后盖状态
            int backCover = Common.getBitValue(status, 7);
            //唤醒源
            long awaken = (status >> 24) & 0x0f;

            LocationData locationData = new LocationData();
            locationData.GpsTime = gpsZonedDateTime;
            locationData.Latitude = lat;
            locationData.Longitude = lon;
            locationData.LocationType = locationType;
            locationData.Speed = (int)speed;
            locationData.Direction = direction;
            locationData.Alarm = alarm;
            locationData.BackCover = backCover;
            locationData.Awaken = (int)awaken;
            //处理附加信息
            if (msgBodyBuf.Length > 28)
            {
                byte[] extraBytes = msgBodyBuf.Skip(28).Take(msgBodyBuf.Length - 28).ToArray();
                parseExtraInfo(extraBytes, locationData);
            }
            return locationData;
        }

        /// <summary>
        /// 解析附加信息
        /// </summary>
        /// <param name="msgBody"></param>
        /// <param name="location"></param>
        private static void parseExtraInfo(byte[] msgBody, LocationData location)
        {
            byte[] extraInfoBuf = null;
            while (msgBody.Length > 1)
            {
                int extraInfoId = msgBody[0];
                int extraInfoLen = msgBody[1];
                if (msgBody.Length - 2 < extraInfoLen)
                {
                    break;
                }
                extraInfoBuf = msgBody.Skip(2).Take(extraInfoLen).ToArray();
                msgBody = msgBody.Skip(2 + extraInfoLen).Take(msgBody.Length - (2 + extraInfoLen)).ToArray();
                switch (extraInfoId)
                {
                    //锁事件
                    case 0x0B:
                        LockEvent lockEvent = new LockEvent();
                        //锁事件
                        int type = extraInfoBuf[0];
                        lockEvent.Type = type;
                        if (type == 0x01 || type == 0x02 || type == 0x03 || type == 0x05 || type == 0x1E || type == 0x1F)
                        {
                            byte[] passwordBytes = extraInfoBuf.Skip(1).Take(6).ToArray();
                            string password = Common.ByteToASCII(passwordBytes);
                            lockEvent.Password = password;
                            int unlockStatus = extraInfoBuf[7];
                            if (unlockStatus == 0xff)
                            {
                                lockEvent.UnLockStatus = 0;
                            }
                            else
                            {
                                if (unlockStatus > 0 && unlockStatus < 100)
                                {
                                    lockEvent.FenceId = unlockStatus;
                                }
                                lockEvent.UnLockStatus = 1;
                            }
                        }
                        else if (type == 0x06 || type == 0x07 || type == 0x08 || type == 0x10 || type == 0x11 || type == 0x18 || type == 0x19 || type == 0x20 || type == 0x28 || type == 0x29)
                        {
                            byte[] passwordBytes = extraInfoBuf.Skip(0).Take(6).ToArray();
                            string password = Common.ByteToASCII(passwordBytes);
                            lockEvent.Password = password;
                            lockEvent.UnLockStatus = 0;
                        }
                        else if (type == 0x22)
                        {
                            long cardId = Common.SwapUInt32(BitConverter.ToUInt32(extraInfoBuf, 0));
                            if (cardId != 0)
                            {
                                lockEvent.CardNo = cardId.ToString().PadLeft(10, '0');
                            }
                            if (extraInfoBuf.Length > 4)
                            {
                                int unlockStatus = extraInfoBuf[4];
                                if (unlockStatus == 0xff)
                                {
                                    lockEvent.UnLockStatus = 0;
                                }
                                else
                                {
                                    if (unlockStatus > 0 && unlockStatus < 100)
                                    {
                                        lockEvent.FenceId = unlockStatus;
                                    }
                                    lockEvent.UnLockStatus = 1;
                                }
                            }
                        }
                        else if (type == 0x23 || type == 0x2A || type == 0x2B) {
                            long cardId = Common.SwapUInt32(BitConverter.ToUInt32(extraInfoBuf, 0));
                            if (cardId != 0)
                            {
                                lockEvent.CardNo = cardId.ToString().PadLeft(10, '0');
                            }
                        }
                        location.LockEvent = lockEvent;
                        break;
                    //陀螺仪三轴数据
                    case 0x0C:
                        int x = Common.SwapUInt16(BitConverter.ToUInt16(extraInfoBuf, 0));
                        int y = Common.SwapUInt16(BitConverter.ToUInt16(extraInfoBuf, 2));
                        int z = Common.SwapUInt16(BitConverter.ToUInt16(extraInfoBuf, 4));
                        x = x > 32768 ? (x - 65536) : x;
                        y = y > 32768 ? (y - 65536) : y;
                        z = z > 32768 ? (z - 65536) : z;
                        location.Posture = string.Format("x:{0};y:{1};z:{2}", x, y, z);
                        break;
                    //无线通信网络信号强度
                    case 0x30:
                        int fCellSignal = extraInfoBuf[0];
                        location.GSMSignal = fCellSignal;
                        break;
                    //卫星数
                    case 0x31:
                        int fGPSSignal = extraInfoBuf[0];
                        location.GpsSignal = fGPSSignal;
                        break;
                    //电池电量百分比
                    case 0xD4:
                        int fBattery = extraInfoBuf[0];
                        location.Battery = fBattery;
                        break;
                    //电池电压
                    case 0xD5:
                        int fVoltage = Common.SwapUInt16(BitConverter.ToUInt16(extraInfoBuf, 0));
                        location.Voltage = fVoltage * 0.01;
                        break;
                    case 0xF9:
                        //版本号
                        int version = Common.SwapUInt16(BitConverter.ToUInt16(extraInfoBuf, 0));
                        location.ProtocolVersion=version;
                        break;
                    case 0xFD:
                        //小区码信息
                        int mcc = Common.SwapUInt16(BitConverter.ToUInt16(extraInfoBuf, 0));
                        location.MCC = mcc;
                        int mnc = extraInfoBuf[2];
                        location.MNC = mnc;
                        long cellId = Common.SwapUInt32(BitConverter.ToUInt32(extraInfoBuf, 3));
                        location.CELLID = cellId;
                        int lac = Common.SwapUInt16(BitConverter.ToUInt16(extraInfoBuf, 7));
                        location.LAC = lac;
                        break;
                    case 0xFC:
                        int fenceId = extraInfoBuf[0];
                        location.FenceId=fenceId;
                        break;
                    case 0xFE:
                        long mileage = Common.SwapUInt32(BitConverter.ToUInt32(extraInfoBuf, 0));
                        location.Mileage = mileage;
                        break;
                    default:
                        break;
                }
            }
        }

        /// <summary>
        /// 温度解析
        /// </summary>
        /// <param name="temperatureInt"></param>
        /// <returns></returns>
        private static double parseTemperature(int temperatureInt)
        {
            if (temperatureInt == 0xFFFF)
            {
                return -1000;
            }
            double temperature = ((short)(temperatureInt << 4) >> 4) * 0.1;
            if ((temperatureInt >> 12) > 0)
            {
                temperature = -temperature;
            }
            return temperature;
        }

        /// <summary>
        /// 回复内容
        /// </summary>
        /// <param name="terminalNumArr"></param>
        /// <param name="msgFlowId"></param>
        /// <returns></returns>
        public static string replyBinaryMessage(byte[] terminalNumArr, int msgFlowId)
        {
            List<byte> byteList = new List<byte>();
            byteList.AddRange(Common.HexStringToBytes("8001"));
            byteList.AddRange(Common.HexStringToBytes("0005"));
            byteList.AddRange(terminalNumArr);
            byteList.AddRange(Common.ShortToBytes(Common.RandomNumber(0, 65534)));
            byteList.AddRange(Common.ShortToBytes((short)msgFlowId));
            byteList.AddRange(Common.HexStringToBytes("0200"));
            byteList.Add(0x00);
            byteList.Add(Common.xor(byteList));
            byte[] bytes = Common.escape(byteList);
            List<byte> replyList = new List<byte>();
            replyList.Add(0x7E);
            replyList.AddRange(bytes);
            replyList.Add(0x7E);
            return Common.ByteToHexStr(replyList.ToArray());
        }

        /// <summary>
        /// 授时
        /// </summary>
        /// <param name="itemList"></param>
        /// <returns></returns>
        public static string replyBASE2Message(string[] itemList)
        {
            try
            {
                string strBase2Reply = string.Format("({0},{1},{2},{3},{4},{5})", itemList[0], itemList[1]
                        , itemList[2], itemList[3], itemList[4], DateTime.UtcNow.ToString("yyyyMMddHHmmss"));
                return strBase2Reply;
            }
            catch (Exception e)
            {
                return "";
            }
        }
    }
}

2.4.返回消息及说明

（1）心跳数据
原始数据：

7E000200007501804283100001267E

返回消息：

{"DeviceID":"750180428310","MsgType":"heartbeat"}

返回消息描述

{"DeviceID":设备ID,"MsgType":消息类型（heartbeat：心跳）}

（2）定位数据
原始数据（不带锁事件）：

7E020000428560090010140E56000000002234004201588F9506CA3D93000B00120000201210073024D40127D502017B30011E310106FE040000001BFD090000000000000000000C0600000000FFDFD47E

返回消息：

{
    "DeviceID": "856009001014",
    "DataBody": {
        "GpsTime": "2020-12-10T07:30:24Z",
        "MNC": 0,
        "FenceId": 0,
        "BackCover": 0,
        "Index": 3670,
        "Latitude": 22.581141,
        "Awaken": 2,
        "ProtocolVersion": 0,
        "Direction": 0,
        "Posture": "x:0;y:0;z:-33",
        "Battery": 39,
        "GpsSignal": 6,
        "Voltage": 3.79,
        "Speed": 1,
        "LockStatus": 1,
        "Mileage": 27,
        "MCC": 0,
        "Longitude": 113.917331,
        "LAC": 0,
        "Alarm": -1,
        "DataLength": 66,
        "CELLID": 0,
        "LockRope": 1,
        "LocationType": 1,
        "Altitude": 11,
        "GSMSignal": 30
    },
    "ReplyMsg": "7e80010005856009001014d81b0e56020000f57e",
    "MsgType": "Location"
}

返回消息描述

{
    "DeviceID": "790011000094",
    "DataBody": {
        "GpsTime": 定位时间（UTC时间）,
        "Latitude": 纬度（WGS84）,
        "Longitude": 经度（WGS84）,
        "MCC": 小区码信息MCC,
        "MNC": 小区码信息MNC,
        "LAC": 小区码信息LAC,
        "CELLID": 小区码信息CI,
        "FenceId": 电子围栏Id,
        "BackCover": 后盖状态（1：开；0：关）,
        "Index": 流水号,
        "Awaken": 唤醒源 （1：RTC闹钟唤醒，2：Gsens震动唤醒 3：开盖唤醒 4：剪绳唤醒 5：充电唤醒 6：刷卡唤醒7：Lora唤醒8：VIP号码唤醒9：非VIP唤醒10：蓝牙唤醒）
        "ProtocolVersion":协议版本号,
        "Direction": 正北为0，顺时针0-360,
        "Battery": 电量值（0~100%）,
        "GpsSignal": GPS当前接收到的卫星颗数,
        "Voltage": 电压值，单位V,
        "Speed": 速度，单位km/h,
        "LockStatus": 锁状态（0：关；1：开）,
        "LockRope": 锁绳状态（0：插入；1：拔出）,
        "Mileage": 里程值，单位km,
        "Alarm": 报警类型（1：超速报警；2：低电报警；3：主机开盖报警；4：进围栏报警；5:出围栏报警）,
        "DataLength": 数据长度（字节数）,
        "LocationType": 定位方式（0：不定位；1：GPS定位；2：基站定位）,
        "Altitude": 海拔高度km,
        "GSMSignal": GSM信号值，
        "Posture":姿态（x:正180度，负180度;y:正90度，负90度;z:正180度，负180度）
    },
    "ReplyMsg": 需要回复终端的内容（为空则表示不需要回复）,
    "MsgType": 数据类型（Location：定位数据）
}

原始数据（带锁事件）：

7E0200004C8560090010140E54000000000224004201588F9506CA3D93000B00120000201210073017D40127D502017B30011E310106FE040000001BFD090000000000000000000B0805383838383838650C0600000000FFC5A27E

返回消息：

{
    "DeviceID": "856009001014",
    "DataBody": {
        "GpsTime": "2020-12-10T07:30:17Z",
        "MNC": 0,
        "FenceId": 0,
        "BackCover": 0,
        "Index": 3668,
        "Latitude": 22.581141,
        "Awaken": 2,
        "ProtocolVersion": 0,
        "Direction": 0,
        "Posture": "x:0;y:0;z:-59",
        "Battery": 39,
        "GpsSignal": 6,
        "Voltage": 3.79,
        "LockEvent": {
            "Type": 5,
            "FenceId": -1,
            "UnLockStatus": 1,
            "Password": "888888"
        },
        "Speed": 1,
        "LockStatus": 1,
        "Mileage": 27,
        "MCC": 0,
        "Longitude": 113.917331,
        "LAC": 0,
        "Alarm": -1,
        "DataLength": 76,
        "CELLID": 0,
        "LockRope": 0,
        "LocationType": 1,
        "Altitude": 11,
        "GSMSignal": 30
    },
    "ReplyMsg": "7e80010005856009001014c8750e54020000897e",
    "MsgType": "Location"
}

返回消息描述

{
    "DeviceID": "790011000094",
    "DataBody": {
        "GpsTime": 定位时间（UTC时间）,
        "Latitude": 纬度（WGS84）,
        "Longitude": 经度（WGS84）,
        "MCC": 小区码信息MCC,
        "MNC": 小区码信息MNC,
        "LAC": 小区码信息LAC,
        "CELLID": 小区码信息CI,
        "FenceId": 电子围栏Id,
        "BackCover": 后盖状态（1：开；0：关）,
        "Index": 流水号,
        "Awaken": 唤醒源 （1：RTC闹钟唤醒，2：Gsens震动唤醒 3：开盖唤醒 4：剪绳唤醒 5：充电唤醒 6：刷卡唤醒7：Lora唤醒8：VIP号码唤醒9：非VIP唤醒10：蓝牙唤醒）
        "ProtocolVersion":协议版本号,
        "Direction": 正北为0，顺时针0-360,
        "Battery": 电量值（0~100%）,
        "GpsSignal": GPS当前接收到的卫星颗数,
        "Voltage": 电压值，单位V,
        "Speed": 速度，单位km/h,
        "LockStatus": 锁状态（0：关；1：开）,
        "LockRope": 锁绳状态（0：插入；1：拔出）,
        "Mileage": 里程值，单位km,
        "Alarm": 报警类型（1：超速报警；2：低电报警；3：主机开盖报警；4：进围栏报警；5:出围栏报警）,
        "LockEvent": {
            "Type": 事件类型（参见附件1）,
            "FenceId": 事件关联的围栏ID（-1：与围栏无关）,
            "UnLockStatus": 开锁状态（1：开锁成功；0：开锁失败）,
            "Password": 开锁密码
            "CardNo":如果事件类型为刷卡开锁，这里表示的是卡号
        },
        "DataLength": 数据长度（字节数）,
        "LocationType": 定位方式（0：不定位；1：GPS定位；2：基站定位）,
        "Altitude": 海拔高度km,
        "GSMSignal": GSM信号值,
        "Posture":姿态（x:正180度，负180度;y:正90度，负90度;z:正180度，负180度）
    },
    "ReplyMsg": 需要回复终端的内容（为空则表示不需要回复）,
    "MsgType": 数据类型（Location：定位数据）
}

（3）指令数据解析
原始数据：

283835363030393030313035382C362C3030312C424153452C322C323032313037323430353531353529

返回消息：

{
    "DeviceID": "856009001058",
    "DataBody": "(856009001058,6,001,BASE,2,20210724055155)",
    "ReplyMsg": "",
    "MsgType": "BASE2"
}

返回消息描述

{
    "DeviceID": 设备ID,
    "DataBody": 消息体内容,
    "ReplyMsg": 回复设备的消息（为空则表示不需要回复）,
    "MsgType": 指令类型
}

3.指令消息

3.1.查询终端基本信息

消息体内容（DataBody）：

(700160818000,1,001,BASE,1,1,20150418_G300,0,BeiHuan,1137B03SIM900M64_ST_MMS,89860042191130272549,012207005620932,460,00,4243,6877)

消息体内容描述：

3.2.授时(同步GMT时间)

消息体内容（DataBody）：

(700160818000,1,001,BASE,2,20111018123820)

消息体内容描述：

3.3.远程重启终端

消息体内容（DataBody）：

(700160818000,1,001,BASE,3)

消息体内容描述：

3.4.恢复出厂设置

消息体内容（DataBody）：

(700160818000,1,001,BASE,4)

消息体内容描述：

3.5.设置报警开关指令

消息体内容（DataBody）：

(700160818000,1,001,BASE,5, 1,1,1,1,1,1,1,1,1,1,1)

消息体内容描述：

3.6.查询/设置上传间隔和休眠定时唤醒间隔

消息体内容（DataBody）：

(700160818000,1,001,BASE,6,60,30)

消息体内容描述：

3.7.查询/设置终端休眠模式

消息体内容（DataBody）：

(700160818000,1,001,BASE,7,1)

消息体内容描述：

3.8.查询/设置终端本地时差

消息体内容（DataBody）：

(2310915002,1,001,BASE,8, 480)

消息体内容描述：

3.9.查询/设置终端本地时差

消息体内容（DataBody）：

(700160818000,1,001,BASE,9,8613998765432,0,0,0,0)

消息体内容描述：

3.10.查询/设置主从IP地址与端口号、APN及用户名与密码等参数

消息体内容（DataBody）：

(700160818000,1,001,BASE,10,211.154.112.98,1088,211.154.112.98,1088,CMNET,abc,123456)

消息体内容描述：

3.11.查询/设置/删除设备工作闹钟

消息体内容（DataBody）：

(700160818000,1,001,BASE,32,1,480)

消息体内容描述：

3.12.查询/设置仅支持VIP号码

消息体内容（DataBody）：

(700160818000,1,001,BASE,40,1)

消息体内容描述：

3.13.查询/设置里程统计相关参数

消息体内容（DataBody）：

(700160818000,1,001,BASE,43,10,10)

消息体内容描述：

3.14.查询/设置静态飘移处理功能

消息体内容（DataBody）：

(700160818000,1,001,BASE,44,1)

消息体内容描述：

3.15.查询/设置GPS追踪定位模式功能

消息体内容（DataBody）：

(700160818000,1,001,BASE,45,1)

消息体内容描述：

3.16.查询/设置GPS定位判定门限参数(防GPS定位漂移)

消息体内容（DataBody）：

(700160818000,1,001,BASE,46,5,25,6)

消息体内容描述：

3.17.查询/设置GPS定位判定门限参数(防GPS定位漂移)

消息体内容（DataBody）：

(700160818000,1,001,BASE,47,1)

消息体内容描述：

3.18.设置报警开关指令

消息体内容（DataBody）：

(700160818000,1,001,BASE,48, 1,1,1,1,1,1,1,1,1,1,1,1,1)

消息体内容描述：

3.19.查询/设置震动检测阈值

消息体内容（DataBody）：

(700160818000,1,001,GSENS,1, 500)

消息体内容描述：

3.20.电池产品入库前进入休眠

消息体内容（DataBody）：

(700160818000,1,001,DEBUG,7)

消息体内容描述：

3.20.电池产品入库前进入休眠

消息体内容（DataBody）：

(700160818000,1,001,DEBUG,15, 10)

消息体内容描述：

3.21.查询物联卡信息

消息体内容（DataBody）：

(700160818000,1,001,DEBUG,27, ICCID, IMSI)

消息体内容描述：

3.22.查询/清除历史(盲区)数据

消息体内容（DataBody）：

(700160818000,1,001,DEBUG,29, 0)

消息体内容描述：

3.23.查询/设置超速报警速度

消息体内容（DataBody）：

(700160818000,1,001,DEBUG,30,120,10)

消息体内容描述：

3.24.查询/设置低电报警数值

消息体内容（DataBody）：

(700160818000,1,001,DEBUG,31,5)

消息体内容描述：

3.25.查询/设置关闭看门狗作用

消息体内容（DataBody）：

(700160818000,1,001,DEBUG,38,0)

消息体内容描述：

3.26.设置/查询区域详细节点信息

消息体内容（DataBody）：

(700160818000,1,001,GFCE,7,8,15,1,10,11323.1234…)

消息体内容描述：

3.27.清除设置的全部区域点信息

消息体内容（DataBody）：

(700160818000,1,001,GFCE,8,1)

消息体内容描述：

3.28.查询/设置没有关锁报警提醒时间间隔

消息体内容（DataBody）：

(700160818000,1,001,ELOCK,2, 1)

消息体内容描述：

3.29.终端上报动态密码

消息体内容（DataBody）：

(700160818000,1,001,ELOCK,3,123456)

消息体内容描述：

3.30.设置/修改远程开锁静态密码

消息体内容（DataBody）：

(700160818000,1,001,ELOCK,4,666666)

消息体内容描述：

3.31.凭静态或动态密码开锁

消息体内容（DataBody）：

(700160818000,1,001,ELOCK,5,1)

消息体内容描述：

3.32.查询/设置围栏外禁止开锁

消息体内容（DataBody）：

(700160818000,1,001,ELOCK,7,1,2,3,4)

消息体内容描述：

3.33.动态密码权限处理(不对外公开)

消息体内容（DataBody）：

(700160818000,1,001,ELOCK,7,1)

消息体内容描述：

3.34.查询/增删/开锁授权号

消息体内容（DataBody）实例1：

(700160818000,1,001, ELOCK,15,0,2,20,2,1,0013953759, 0013953758, 0013953757，，，，，，，，，，，，，)

消息体内容描述：

消息体内容（DataBody）实例2：

(700160818000,1,001,ELOCK,15,1,3,200)

消息体内容描述：

消息体内容（DataBody）实例3：

(700160818000,1,001,ELOCK,15,2,3)

消息体内容描述：

消息体内容（DataBody）实例4：

(700160818000,1,001, ELOCK,15,3,0)

消息体内容描述：

3.35.现场刷卡授权模式配置指令

消息体内容（DataBody）实例1：

(700160818000,1,001, ELOCK,16,2,0013953759,0013953751)

消息体内容描述：

消息体内容（DataBody）实例2：

(700160818000,1,001, ELOCK,16,0)

消息体内容描述：

3.36.通知设备MCU升级

消息体内容（DataBody）：

(700160818000,1,001,OTA,1,1,20120102)

消息体内容描述：

3.37.发送Firmware数据包

消息体内容（DataBody）：

(700160818000,1,001,OTA,2,0,200,100)

消息体内容描述：

3.38.取消Firmware升级

消息体内容（DataBody）：

(700160818000,1,001,OTA,3,1,20120222)

消息体内容描述：

3.39.完成Firmware传输

消息体内容（DataBody）：

(700160818000,1,001,OTA,4,1)

消息体内容描述：

3.40.查询发送下条Firmware数据包序号

消息体内容（DataBody）：

(700160818000,1,001,OTA,5,1,200)

消息体内容描述：

3.41.查询当前stm32固件的版本号

消息体内容（DataBody）：

(700160818000,1,001,OTA,6,JT705A_V103R001)

消息体内容描述：

附件1