From c9225508b3e6000e6149e1cb0ed21af78314c6f8 Mon Sep 17 00:00:00 2001 From: "SmallChi(Koike)" <564952747@qq.com> Date: Sun, 7 Feb 2021 22:06:42 +0800 Subject: [PATCH] =?UTF-8?q?1.=E5=AE=8C=E5=96=84=E7=BB=84=E5=8C=85=E7=9A=84?= =?UTF-8?q?=E9=95=BF=E5=BA=A6=E6=A0=A1=E9=AA=8C=202.=E5=AE=8C=E5=96=84?= =?UTF-8?q?=E6=8C=87=E4=BB=A4=E6=B6=88=E6=81=AF=E6=B3=A8=E9=87=8A=203.?= =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E9=83=A8=E5=88=86=E5=8F=82=E6=95=B0=E8=AE=BE?= =?UTF-8?q?=E7=BD=AE=E7=BB=84=E5=8C=85=E9=95=BF=E5=BA=A6=E6=9C=89=E9=97=AE?= =?UTF-8?q?=E9=A2=98=E7=9A=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Extensions/JT808ValidationExtensions.cs | 15 + src/JT808.Protocol/JT808.Protocol.xml | 5173 ++++++++++++++--- .../MessageBody/JT808_0x0200_0x12.cs | 30 +- .../MessageBody/JT808_0x0200_0x13.cs | 30 +- .../MessageBody/JT808_0x0200_0x25.cs | 30 +- .../MessageBody/JT808_0x0200_0x2A.cs | 30 +- .../MessageBody/JT808_0x0200_0x2B.cs | 30 +- .../MessageBody/JT808_0x0200_0x30.cs | 30 +- .../MessageBody/JT808_0x0200_0x31.cs | 29 +- .../MessageBody/JT808_0x0201.cs | 27 +- .../MessageBody/JT808_0x0301.cs | 28 +- .../MessageBody/JT808_0x0302.cs | 28 +- .../MessageBody/JT808_0x0303.cs | 29 +- .../MessageBody/JT808_0x0500.cs | 27 +- .../MessageBody/JT808_0x0608.cs | 26 +- .../MessageBody/JT808_0x0700.cs | 31 +- .../MessageBody/JT808_0x0701.cs | 32 +- .../MessageBody/JT808_0x0702.cs | 31 +- .../MessageBody/JT808_0x0704.cs | 27 +- .../MessageBody/JT808_0x0705.cs | 27 +- .../MessageBody/JT808_0x0800.cs | 27 +- .../MessageBody/JT808_0x0801.cs | 27 +- .../MessageBody/JT808_0x0802.cs | 27 +- .../MessageBody/JT808_0x0805.cs | 27 +- .../MessageBody/JT808_0x0900.cs | 27 +- .../MessageBody/JT808_0x0901.cs | 27 +- .../MessageBody/JT808_0x0A00.cs | 27 +- .../MessageBody/JT808_0x8001.cs | 30 +- .../MessageBody/JT808_0x8003.cs | 29 +- .../MessageBody/JT808_0x8004.cs | 27 +- .../MessageBody/JT808_0x8100.cs | 27 +- .../MessageBody/JT808_0x8103.cs | 31 +- .../MessageBody/JT808_0x8103_0x0001.cs | 25 +- .../MessageBody/JT808_0x8103_0x0002.cs | 27 +- .../MessageBody/JT808_0x8103_0x0003.cs | 27 +- .../MessageBody/JT808_0x8103_0x0004.cs | 27 +- .../MessageBody/JT808_0x8103_0x0005.cs | 27 +- .../MessageBody/JT808_0x8103_0x0006.cs | 27 +- .../MessageBody/JT808_0x8103_0x0007.cs | 27 +- .../MessageBody/JT808_0x8103_0x0010.cs | 27 +- .../MessageBody/JT808_0x8103_0x0011.cs | 27 +- .../MessageBody/JT808_0x8103_0x0012.cs | 27 +- .../MessageBody/JT808_0x8103_0x0013.cs | 27 +- .../MessageBody/JT808_0x8103_0x0014.cs | 27 +- .../MessageBody/JT808_0x8103_0x0015.cs | 27 +- .../MessageBody/JT808_0x8103_0x0016.cs | 24 +- .../MessageBody/JT808_0x8103_0x0017.cs | 24 +- .../MessageBody/JT808_0x8103_0x0018.cs | 27 +- .../MessageBody/JT808_0x8103_0x0019.cs | 31 +- .../MessageBody/JT808_0x8103_0x001A.cs | 26 +- .../MessageBody/JT808_0x8103_0x001B.cs | 28 +- .../MessageBody/JT808_0x8103_0x001C.cs | 27 +- .../MessageBody/JT808_0x8103_0x001D.cs | 26 +- .../MessageBody/JT808_0x8103_0x0020.cs | 32 +- .../MessageBody/JT808_0x8103_0x0021.cs | 31 +- .../MessageBody/JT808_0x8103_0x0022.cs | 27 +- .../MessageBody/JT808_0x8103_0x0023.cs | 30 +- .../MessageBody/JT808_0x8103_0x0024.cs | 30 +- .../MessageBody/JT808_0x8103_0x0025.cs | 27 +- .../MessageBody/JT808_0x8103_0x0026.cs | 30 +- .../MessageBody/JT808_0x8103_0x0027.cs | 27 +- .../MessageBody/JT808_0x8103_0x0028.cs | 28 +- .../MessageBody/JT808_0x8103_0x0029.cs | 27 +- .../MessageBody/JT808_0x8103_0x002C.cs | 27 +- .../MessageBody/JT808_0x8103_0x002D.cs | 26 +- .../MessageBody/JT808_0x8103_0x002E.cs | 27 +- .../MessageBody/JT808_0x8103_0x002F.cs | 27 +- .../MessageBody/JT808_0x8103_0x0030.cs | 27 +- .../MessageBody/JT808_0x8103_0x0031.cs | 27 +- .../MessageBody/JT808_0x8103_0x0032.cs | 27 +- .../MessageBody/JT808_0x8103_0x0040.cs | 27 +- .../MessageBody/JT808_0x8103_0x0041.cs | 27 +- .../MessageBody/JT808_0x8103_0x0042.cs | 27 +- .../MessageBody/JT808_0x8103_0x0043.cs | 27 +- .../MessageBody/JT808_0x8103_0x0044.cs | 27 +- .../MessageBody/JT808_0x8103_0x0045.cs | 27 +- .../MessageBody/JT808_0x8103_0x0046.cs | 27 +- .../MessageBody/JT808_0x8103_0x0047.cs | 27 +- .../MessageBody/JT808_0x8103_0x0048.cs | 27 +- .../MessageBody/JT808_0x8103_0x0049.cs | 27 +- .../MessageBody/JT808_0x8103_0x0050.cs | 27 +- .../MessageBody/JT808_0x8103_0x0051.cs | 27 +- .../MessageBody/JT808_0x8103_0x0052.cs | 27 +- .../MessageBody/JT808_0x8103_0x0053.cs | 28 +- .../MessageBody/JT808_0x8103_0x0054.cs | 28 +- .../MessageBody/JT808_0x8103_0x0055.cs | 27 +- .../MessageBody/JT808_0x8103_0x0056.cs | 27 +- .../MessageBody/JT808_0x8103_0x0057.cs | 26 +- .../MessageBody/JT808_0x8103_0x0058.cs | 27 +- .../MessageBody/JT808_0x8103_0x0059.cs | 27 +- .../MessageBody/JT808_0x8103_0x005A.cs | 27 +- .../MessageBody/JT808_0x8103_0x005B.cs | 27 +- .../MessageBody/JT808_0x8103_0x005C.cs | 27 +- .../MessageBody/JT808_0x8103_0x005D.cs | 27 +- .../MessageBody/JT808_0x8103_0x005E.cs | 27 +- .../MessageBody/JT808_0x8103_0x0064.cs | 31 +- .../MessageBody/JT808_0x8103_0x0065.cs | 31 +- .../MessageBody/JT808_0x8103_0x0070.cs | 27 +- .../MessageBody/JT808_0x8103_0x0071.cs | 27 +- .../MessageBody/JT808_0x8103_0x0072.cs | 27 +- .../MessageBody/JT808_0x8103_0x0073.cs | 27 +- .../MessageBody/JT808_0x8103_0x0074.cs | 27 +- .../MessageBody/JT808_0x8103_0x0080.cs | 27 +- .../MessageBody/JT808_0x8103_0x0081.cs | 27 +- .../MessageBody/JT808_0x8103_0x0082.cs | 27 +- .../MessageBody/JT808_0x8103_0x0083.cs | 27 +- .../MessageBody/JT808_0x8103_0x0084.cs | 29 +- .../MessageBody/JT808_0x8103_0x0090.cs | 29 +- .../MessageBody/JT808_0x8103_0x0091.cs | 29 +- .../MessageBody/JT808_0x8103_0x0092.cs | 29 +- .../MessageBody/JT808_0x8103_0x0093.cs | 29 +- .../MessageBody/JT808_0x8103_0x0094.cs | 29 +- .../MessageBody/JT808_0x8103_0x0095.cs | 8 +- .../MessageBody/JT808_0x8103_0x0100.cs | 19 +- .../MessageBody/JT808_0x8103_0x0101.cs | 23 +- .../MessageBody/JT808_0x8103_0x0102.cs | 29 +- .../MessageBody/JT808_0x8103_0x0103.cs | 29 +- .../MessageBody/JT808_0x8103_0x0110.cs | 6 +- .../MessageBody/JT808_0x8103_BodyBase.cs | 3 + .../JT808_0x8103_CustomBodyBase.cs | 3 + .../MessageBody/JT808_0x8104.cs | 6 + .../MessageBody/JT808_0x8105.cs | 35 +- .../MessageBody/JT808_0x8106.cs | 26 +- .../MessageBody/JT808_0x8107.cs | 7 +- .../MessageBody/JT808_0x8108.cs | 28 +- .../MessageBody/JT808_0x8201.cs | 7 +- .../MessageBody/JT808_0x8202.cs | 29 +- .../MessageBody/JT808_0x8203.cs | 27 +- .../MessageBody/JT808_0x8204.cs | 11 +- .../MessageBody/JT808_0x8300.cs | 27 +- .../MessageBody/JT808_0x8301.cs | 29 +- .../MessageBody/JT808_0x8302.cs | 33 +- .../MessageBody/JT808_0x8303.cs | 28 +- .../MessageBody/JT808_0x8304.cs | 27 +- .../MessageBody/JT808_0x8400.cs | 29 +- .../MessageBody/JT808_0x8401.cs | 27 +- .../MessageBody/JT808_0x8500.cs | 26 +- .../MessageBody/JT808_0x8500_0x0001.cs | 27 +- .../MessageBody/JT808_0x8500_ControlType.cs | 3 + 139 files changed, 7500 insertions(+), 1289 deletions(-) diff --git a/src/JT808.Protocol/Extensions/JT808ValidationExtensions.cs b/src/JT808.Protocol/Extensions/JT808ValidationExtensions.cs index 0cabe2c..95b97d9 100644 --- a/src/JT808.Protocol/Extensions/JT808ValidationExtensions.cs +++ b/src/JT808.Protocol/Extensions/JT808ValidationExtensions.cs @@ -24,6 +24,21 @@ namespace JT808.Protocol.Extensions return value; } + /// + /// 验证字符串最大长度 + /// + /// + /// + /// + public static string ValiMaxString(this string value, in string fieldName, in int maxLength) + { + if (length > maxLength) + { + throw new JT808Exception(JT808ErrorCode.VailLength, $"{fieldName}:{length}>max length[{maxLength}]"); + } + return value; + } + /// /// 验证数组长度 /// diff --git a/src/JT808.Protocol/JT808.Protocol.xml b/src/JT808.Protocol/JT808.Protocol.xml index e92ee6a..b4d8645 100644 --- a/src/JT808.Protocol/JT808.Protocol.xml +++ b/src/JT808.Protocol/JT808.Protocol.xml @@ -6068,6 +6068,11 @@ + + + 进出区域/路线报警附加信息 + + 位置类型 @@ -6089,1791 +6094,5114 @@ 1：出 - + - 路段 ID + JT808_0x0200_0x12 - + - 路段行驶时间 - 单位为秒（s) + 6 byte - + - 结果 0：不足；1：过长 + + + + - + - 扩展车辆信号状态位 + + + + - + - IO状态位 + + + + - + - 模拟量 bit0-15，AD0；bit16-31，AD1 + 路段行驶时间不足/过长报警附加信息 - + - 无线通信网络信号强度 + JT808_0x0200_0x13 - + - GNSS 定位卫星数 + 7 byte - + - 位置附加信息 + 路段 ID - + - 附加信息Id + 路段行驶时间 + 单位为秒（s) - + - 附加信息长度 + 结果 0：不足；1：过长 - + - 自定义位置附加信息 + + + + - + - 自定义附加信息Id + + + + - + - 自定义附加信息长度 + + + + - + - 位置信息查询应答 + 扩展车辆信号状态位 - + - 应答流水号 - 对应的终端注册消息的流水号 + 扩展车辆信号状态位 - + - 位置信息汇报见 8.12 + JT808_0x0200_0x25 - + - 事件报告 - 0x0301 + 4 byte - + - 事件 ID + + + + - + - 提问应答 - 0x0302 + + + + - + - 应答流水号 - 对应的提问下发消息的流水号 + + + + - + - 答案 ID - 提问下发中附带的答案 ID + IO状态位 - + - 信息点播/取消 - 0x0303 + IO状态位 - + - 信息类型 + JT808_0x0200_0x2A - + - 点播/取消标志 + AttachInfoLength - + - 车辆控制应答 + + + + - + - 应答流水号 - 对应的终端注册消息的流水号 + + + + - + - 位置信息汇报消息体 + + + + - + - 查询区域或线路数据应答 + 模拟量 - + - 查询类型 + 模拟量 bit0-15，AD0；bit16-31，AD1 - + - 查询的区域或线路的ID数量 + JT808_0x0200_0x2B - + - 查询的区域或线路的ID + 4 byte - + - 设置圆形区域 - 查询类型为1 + + + + - + - 设置矩形区域 - 查询类型为2 + + + + - + - 设置多边形区域 - 查询类型为3 + + + + - + - 设置路线 - 查询类型为4 + 无线通信网络信号强度 - + - 行驶记录仪数据上传 - 0x0700 + 无线通信网络信号强度 - + - 应答流水号 + JT808_0x0200_0x30 - + - 命令字 + AttachInfoLength - + - 电子运单上报 - 0x0701 + + + + - + - 电子运单长度 + + + + - + - 电子运单内容 - 注意:需要具体的实现 + + + + - + - 电子运单内容基类 - 注意:需要具体的实现 + GNSS 定位卫星数 - + - 驾驶员身份信息采集上报 + GNSS 定位卫星数 - + - 状态 - 0x01：从业资格证 IC 卡插入（驾驶员上班）； - 0x02：从业资格证 IC 卡拔出（驾驶员下班）。 + JT808_0x0200_0x31 - + - 插卡/拔卡时间，YY-MM-DD-hh-mm-ss； - 以下字段在状态为 0x01 时才有效并做填充。 - BCD[6] + 1 byte - + - IC 卡读取结果 - 0x00：IC 卡读卡成功； - 0x01：读卡失败，原因为卡片密钥认证未通过； - 0x02：读卡失败，原因为卡片已被锁定； - 0x03：读卡失败，原因为卡片被拔出； - 0x04：读卡失败，原因为数据校验错误。 - 以下字段在 IC 卡读取结果等于 0x00 时才有效。 + + + + - + - 驾驶员姓名长度 + + + + - + - 驾驶员姓名 + + + + - + - 从业资格证编码 - 长度 20 位，不足补 0x00。 + 位置附加信息 - + - 发证机构名称长度 + 附加信息Id - + - 发证机构名称 + 附加信息长度 - + - 证件有效期 BCD[4] + 自定义位置附加信息 - + - 驾驶员身份证号 长度20 不足补0 - 2019版本 + 自定义附加信息Id - + - 定位数据批量上传 + 自定义附加信息长度 - + - 数据项个数 + 位置信息查询应答 - + - 位置数据类型 + 0x0201 - + - 位置汇报数据集合 + 位置信息查询应答 - + - 位置数据类型 + 应答流水号 + 对应的终端注册消息的流水号 - + - CAN 总线数据上传 - 0x0705 + 位置信息汇报见 8.12 - + - 数据项个数 - 包含的 CAN 总线数据项个数，>0 + + + + - + - CAN 总线数据接收时间 - 第 1 条 CAN 总线数据的接收时间，hh-mm-ss-msms + + + + - + - CAN 总线数据项 + + + + - + - 多媒体事件信息上传 - 0x0800 + 事件报告 + 0x0301 + 2019版本已作删除 - + - 多媒体数据 ID + 0x0301 - + - 多媒体类型 - 0：图像；1：音频；2：视频； - + 事件报告 - + - 多媒体格式编码 - 0：JPEG；1：TIF；2：MP3；3：WAV；4：WMV；其他保留 - + 事件 ID - + - 事件项编码 - 0：平台下发指令； - 1：定时动作； - 2：抢劫报警触发； - 3：碰撞侧翻报警触发； - 4：门开拍照； - 5：门关拍照； - 6：车门由开变关，时速从＜20 公里到超过 20 公里； - 7：定距拍照； - 其他保留 + + + + - + - 通道 ID + + + + - + - 多媒体数据上传 - 0x0801 + + + + - + - 多媒体 ID + 提问应答 + 0x0302 + 2019版本已作删除 - + - 多媒体类型 - + 0x0302 - + - 多媒体格式编码 - 0：JPEG；1：TIF；2：MP3；3：WAV；4：WMV；其他保留 - + 提问应答 - + - 事件项编码 - + 应答流水号 + 对应的提问下发消息的流水号 - + - 通道 ID + 答案 ID + 提问下发中附带的答案 ID - + - 位置信息汇报(0x0200)消息体 - 表示拍摄或录制的起始时刻的位置基本信息数据 + + + + - + - 多媒体数据包 + + + + - + - 存储多媒体数据检索应答 - 0x0802 + + + + - + - 应答流水号 - 对应的多媒体数据检索消息的流水号 + 信息点播/取消 + 0x0303 + 2019版本已作删除 - + - 多媒体数据总项数 - 满足检索条件的多媒体数据总项数 + 0x0303 - + - 检索项集合 + 信息点播_取消 - + - 摄像头立即拍摄命令应答 - 0x0805 + 信息类型 - + - 应答流水号 - 对应平台摄像头立即拍摄命令的消息流水号 + 点播/取消标志 - + - 结果 - 0：成功；1：失败；2：通道不支持。以下字段在结果=0 时才有效。 + + + + - + - 多媒体ID个数 - 拍摄成功的多媒体个数 + + + + - + - 多媒体ID列表 + + + + - + - 数据上行透传 + 车辆控制应答 - + - 透传消息类型 + 0x0500 - + - 透传数据 + 车辆控制应答 - + - 透传消息内容 + 应答流水号 + 对应的终端注册消息的流水号 - + - 数据上行透传 + 位置信息汇报消息体 - + - 透传消息类型 + + + + - + - 数据压缩上报 - 0x0901 + + + + - + - 未压缩消息长度 + + + + - + - 未压缩消息体 - 压缩消息体为需要压缩的消息经过 GZIP 压缩算法后的消息 - 可实现 refJT808.Protocol.IJT808ICompress 自定义压缩算法 + 查询区域或线路数据应答 - + - 终端 RSA 公钥 - 0x0A00 + 0x0608 - + - e - 终端 RSA 公钥{e,n}中的 e + 查询区域或线路数据应答 - + - n - RSA 公钥{e,n}中的 n + 查询类型 - + - 平台通用应答 + 查询的区域或线路的ID数量 - + - 应答消息流水号 + 查询的区域或线路的ID - + - 应答消息Id - + 设置圆形区域 + 查询类型为1 - + - + 设置矩形区域 + 查询类型为2 - + - 补传分包请求 - 0x8003 + 设置多边形区域 + 查询类型为3 - + - 原始消息流水号 - 对应要求补传的原始消息第一包的消息流水号 + 设置路线 + 查询类型为4 - + - 重传包总数 - 2013 byte - 2019 ushort + + + + - + - 重传包 ID 列表 - BYTE[2*n] - 重传包序号顺序排列，如“包 ID1 包 ID2......包 IDn”。 + + + + - + - 查询服务器时间应答 - 2019版本 + + + + - + - 终端注册应答 + 行驶记录仪数据上传 + 0x0700 - + + + 0x0700 + + + + + 行驶记录仪数据上传 + + + 应答流水号 - 对应的终端注册消息的流水号 - + - 结果 + 命令字 - + - 鉴权码 - 只有在成功后才有该字段 + 行车记录仪上行数据包 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 电子运单上报 + 0x0701 + + + + + 0x0701 + + + + + 电子运单上报 + + + + + 电子运单长度 + + + + + 电子运单内容 + + + + + 电子运单内容 + 注意:需要具体的实现 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 电子运单内容基类 + 注意:需要具体的实现 + + + + + 驾驶员身份信息采集上报 + + + + + 0x0702 + + + + + Description + + + + + 状态 + 0x01：从业资格证 IC 卡插入（驾驶员上班）； + 0x02：从业资格证 IC 卡拔出（驾驶员下班）。 + + + + + 插卡/拔卡时间，YY-MM-DD-hh-mm-ss； + 以下字段在状态为 0x01 时才有效并做填充。 + BCD[6] + + + + + IC 卡读取结果 + 0x00：IC 卡读卡成功； + 0x01：读卡失败，原因为卡片密钥认证未通过； + 0x02：读卡失败，原因为卡片已被锁定； + 0x03：读卡失败，原因为卡片被拔出； + 0x04：读卡失败，原因为数据校验错误。 + 以下字段在 IC 卡读取结果等于 0x00 时才有效。 + + + + + 驾驶员姓名长度 + + + + + 驾驶员姓名 + + + + + 从业资格证编码 + 长度 20 位，不足补 0x00。 + + + + + 发证机构名称长度 + + + + + 发证机构名称 + + + + + 证件有效期 BCD[4] + + + + + 驾驶员身份证号 长度20 不足补0 + 2019版本 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 定位数据批量上传 + + + + + 0x0704 + + + + + 定位数据批量上传 + + + + + 数据项个数 + + + + + 位置数据类型 + + + + + 位置汇报数据集合 + + + + + 位置数据类型 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + CAN 总线数据上传 + 0x0705 + + + + + 0x0705 + + + + + CAN总线数据上传 + + + + + 数据项个数 + 包含的 CAN 总线数据项个数，>0 + + + + + CAN 总线数据接收时间 + 第 1 条 CAN 总线数据的接收时间，hh-mm-ss-msms + + + + + CAN 总线数据项 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 多媒体事件信息上传 + 0x0800 + + + + + 0x0800 + + + + + 多媒体事件信息上传 + + + + + 多媒体数据 ID + + + + + 多媒体类型 + 0：图像；1：音频；2：视频； + + + + + + 多媒体格式编码 + 0：JPEG；1：TIF；2：MP3；3：WAV；4：WMV；其他保留 + + + + + + 事件项编码 + 0：平台下发指令； + 1：定时动作； + 2：抢劫报警触发； + 3：碰撞侧翻报警触发； + 4：门开拍照； + 5：门关拍照； + 6：车门由开变关，时速从＜20 公里到超过 20 公里； + 7：定距拍照； + 其他保留 + + + + + 通道 ID + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 多媒体数据上传 + 0x0801 + + + + + 0x0801 + + + + + 多媒体数据上传 + + + + + 多媒体 ID + + + + + 多媒体类型 + + + + + + 多媒体格式编码 + 0：JPEG；1：TIF；2：MP3；3：WAV；4：WMV；其他保留 + + + + + + 事件项编码 + + + + + + 通道 ID + + + + + 位置信息汇报(0x0200)消息体 + 表示拍摄或录制的起始时刻的位置基本信息数据 + + + + + 多媒体数据包 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 存储多媒体数据检索应答 + 0x0802 + + + + + 0x0802 + + + + + 存储多媒体数据检索应答 + + + + + 应答流水号 + 对应的多媒体数据检索消息的流水号 + + + + + 多媒体数据总项数 + 满足检索条件的多媒体数据总项数 + + + + + 检索项集合 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 摄像头立即拍摄命令应答 + 0x0805 + + + + + 0x0805 + + + + + 摄像头立即拍摄命令应答 + + + + + 应答流水号 + 对应平台摄像头立即拍摄命令的消息流水号 + + + + + 结果 + 0：成功；1：失败；2：通道不支持。以下字段在结果=0 时才有效。 + + + + + 多媒体ID个数 + 拍摄成功的多媒体个数 + + + + + 多媒体ID列表 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 数据上行透传 + + + + + 0x0900 + + + + + 数据上行透传 + + + + + 透传消息类型 + + + + + 透传数据 + + + + + 透传消息内容 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 数据上行透传 + + + + + 透传消息类型 + + + + + 数据压缩上报 + 0x0901 + + + + + 0x0901 + + + + + 数据压缩上报 + + + + + 未压缩消息长度 + + + + + 未压缩消息体 + 压缩消息体为需要压缩的消息经过 GZIP 压缩算法后的消息 + 可实现 refJT808.Protocol.IJT808ICompress 自定义压缩算法 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 终端 RSA 公钥 + 0x0A00 + + + + + 0x0A00 + + + + + 终端RSA公钥 + + + + + e + 终端 RSA 公钥{e,n}中的 e + + + + + n + RSA 公钥{e,n}中的 n + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 平台通用应答 + + + + + 0x8001 + + + + + 平台通用应答 + + + + + 应答消息流水号 + + + + + 应答消息Id + + + + + + 返回结果 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 补传分包请求 + 0x8003 + + + + + 0x8003 + + + + + 补传分包请求 + + + + + 原始消息流水号 + 对应要求补传的原始消息第一包的消息流水号 + + + + + 重传包总数 + 2013 byte + 2019 ushort + + + + + 重传包 ID 列表 + BYTE[2*n] + 重传包序号顺序排列，如“包 ID1 包 ID2......包 IDn”。 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 查询服务器时间应答 + 2019版本 + + + + + 0x8004 + + + + + 查询服务器时间应答 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 终端注册应答 + + + + + 0x8100 + + + + + 终端注册应答 + + + + + 应答流水号 + 对应的终端注册消息的流水号 + + + + + 结果 + + + + + 鉴权码 + 只有在成功后才有该字段 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 设置终端参数 + + + + + 0x8103 + + + + + 设置终端参数 + + + + + 参数总数 + + + + + 参数列表 + + + + + 自定义参数列表 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 终端心跳发送间隔，单位为秒（s） + 0x8103_0x0001 + + + + + 0x0001 + + + + + 数据 长度 + 4 byte + + + + + 终端心跳发送间隔，单位为秒（s） + + + + + + + + + + + + + + + + + + + + + + + + + + + + + TCP 消息应答超时时间，单位为秒（s） + 0x8103_0x0002 + + + + + 0x0002 + + + + + 数据长度 + 4 byte + + + + + TCP 消息应答超时时间，单位为秒（s） + + + + + + + + + + + + + + + + + + + + + + + + + + + + + TCP 消息重传次数 + 0x8103_0x0003 + + + + + 0x0003 + + + + + 数据长度 + 4 byte + + + + + TCP 消息重传次数 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + UDP 消息应答超时时间，单位为秒（s） + 0x8103_0x0004 + + + + + 0x0004 + + + + + 数据长度 + 4 byte + + + + + UDP 消息应答超时时间，单位为秒（s） + + + + + + + + + + + + + + + + + + + + + + + + + + + + + UDP 消息重传次数 + 0x8103_0x0005 + + + + + 0x0005 + + + + + 数据长度 + 4 byte + + + + + UDP 消息重传次数 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + SMS 消息应答超时时间，单位为秒（s） + 0x8103_0x0006 + + + + + 0x0006 + + + + + 数据长度 + byte 4 + + + + + SMS 消息应答超时时间，单位为秒（s） + + + + + + + + + + + + + + + + + + + + + + + + + + + + + SMS 消息重传次数 + 0x8103_0x0007 + + + + + 0x0007 + + + + + 数据长度 + 4 byte + + + + + SMS 消息重传次数 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 主服务器 APN，无线通信拨号访问点。若网络制式为 CDMA，则该处为PPP 拨号号码 + + + + + 0x0010 + + + + + 数据长度 + n byte + + + + + 主服务器 APN，无线通信拨号访问点。若网络制式为 CDMA，则该处为PPP 拨号号码 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 主服务器无线通信拨号用户名 + + + + + 0x0011 + + + + + 数据长度 + n byte + + + + + 主服务器无线通信拨号用户名 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 主服务器无线通信拨号密码 + + + + + 0x0012 + + + + + 数据长度 + n byte + + + + + 主服务器无线通信拨号密码 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 主服务器地址,IP 或域名 + + + + + 0x0013 + + + + + 数据长度 + n byte + + + + + 主服务器地址,IP 或域名 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 备份服务器 APN，无线通信拨号访问点 + + + + + 0x0014 + + + + + 数据长度 + n byte + + + + + 备份服务器 APN，无线通信拨号访问点 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 备份服务器无线通信拨号用户名 + + + + + 0x0015 + + + + + 数据长度 + n byte + + + + + 备份服务器无线通信拨号用户名 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 备份服务器无线通信拨号密码 + + + + + 0x0016 + + + + + 数据 长度 + + + + + 备份服务器无线通信拨号密码 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 备份服务器地址,IP 或域名 + + + + + 0x0017 + + + + + 数据 长度 + + + + + 备份服务器地址,IP 或域名 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 服务器 TCP 端口 + + + + + 0x0018 + + + + + 数据长度 + 4 byte + + + + + 服务器 TCP 端口 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 服务器 UDP 端口 + + + + + 0x0019 + + + + + 数据长度 + n byte + + + + + 服务器 UDP 端口 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 道路运输证 IC 卡认证主服务器 IP 地址或域名 + + + + + 0x001A + + + + + 数据长度 + + + + + 道路运输证 IC 卡认证主服务器 IP 地址或域名 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 道路运输证 IC 卡认证主服务器 TCP 端口 + + + + + 0x001B + + + + + 数据长度 + 4 byte + + + + + 道路运输证 IC 卡认证主服务器 TCP 端口 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 道路运输证 IC 卡认证主服务器 UDP 端口 + + + + + 0x001C + + + + + 数据长度 + 4 byte + + + + + 道路运输证 IC 卡认证主服务器 UDP 端口 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 道路运输证 IC 卡认证备份服务器 IP 地址或域名，端口同主服务器 + + + + + 0x001D + + + + + 数据长度 + + + + + 道路运输证 IC 卡认证备份服务器 IP 地址或域名，端口同主服务器 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 位置汇报策略，0：定时汇报；1：定距汇报；2：定时和定距汇报 + + + + + 0x0020 + + + + + 数据长度 + 4 byte + + + + + 位置汇报策略， + 0：定时汇报； + 1：定距汇报； + 2：定时和定距汇报 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 位置汇报方案，0：根据 ACC 状态； 1：根据登录状态和 ACC 状态，先判断登录状态，若登录再根据 ACC 状态 + + + + + 0x0021 + + + + + 数据长度 + 4 byte + + + + + 位置汇报方案， + 0：根据 ACC 状态； + 1：根据登录状态和 ACC 状态，先判断登录状态，若登录再根据 ACC 状态 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 驾驶员未登录汇报时间间隔，单位为秒（s），>0 + + + + + 0x0022 + + + + + 数据长度 + 4 byte + + + + + 驾驶员未登录汇报时间间隔，单位为秒（s），>0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 从服务器APN。该值为空时，终端应使用主服务器相同配置 + 2019版本 + + + + + 0x0023 + + + + + 数据长度 + n byte + + + + + 参数值 + 从服务器APN + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 从服务器无线通信拨号用户名。该值为空时，终端应使用主服务器相同配置 + 2019版本 + + + + + 0x0024 + + + + + 数据长度 + n byte + + + + + 参数值 + 从服务器无线通信拨号用户名 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 从服务器无线通信拨号密码。该值为空，终端应使用主服务器相同配置 + 2019版本 + + + + + 0x0025 + + + + + 数据 长度 + + + + + 参数值 + 从服务器无线通信拨号密码 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 从服务器备份地址IP。该值为空，终端应使用主服务器相同配置 + 2019版本 + + + + + 0x0026 + + + + + 数据长度 + n byte + + + + + 参数值 + 从服务器备份地址IP + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 休眠时汇报时间间隔，单位为秒（s），>0 + + + + + 0x0027 + + + + + 数据长度 + 4 byte + + + + + 休眠时汇报时间间隔，单位为秒（s），>0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 紧急报警时汇报时间间隔，单位为秒（s），>0 + + + + + 0x0028 + + + + + 数据长度 + 4 byte + + + + + 参数值 + 紧急报警时汇报时间间隔，单位为秒（s），>0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 缺省时间汇报间隔，单位为秒（s），>0 + + + + + 0x0029 + + + + + 数据长度 + 4 byte + + + + + 缺省时间汇报间隔，单位为秒（s），>0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 缺省距离汇报间隔，单位为米（m），>0 + + + + + 0x002C + + + + + 数据长度 + 4 byte + + + + + 缺省距离汇报间隔，单位为米（m），>0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 驾驶员未登录汇报距离间隔，单位为米（m），>0 + + + + + 0x002D + + + + + 数据长度 + 4 byte + + + + + 驾驶员未登录汇报距离间隔，单位为米（m），>0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 休眠时汇报距离间隔，单位为米（m），>0 + + + + + 0x002E + + + + + 数据长度 + 4 byte + + + + + 休眠时汇报距离间隔，单位为米（m），>0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 紧急报警时汇报距离间隔，单位为米（m），>0 + + + + + 0x002F + + + + + 数据长度 + 4 byte + + + + + 紧急报警时汇报距离间隔，单位为米（m），>0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 拐点补传角度，小于180 + + + + + 0x0030 + + + + + 数据长度 + 4 byte + + + + + 拐点补传角度，小于180 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 电子围栏半径（非法位移阈值），单位为米 + + + + + 0x0031 + + + + + 数据长度 + 2 byte + + + + + 电子围栏半径（非法位移阈值），单位为米 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 违规行驶时段范围 + + + + + 0x0032 + + + + + 数据长度 + 4 byte + + + + + 违规行驶时段范围（非法位移阈值），单位为米 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 监控平台电话号码 + + + + + 0x0040 + + + + + 数据长度 + n byte + + + + + 监控平台电话号码 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 复位电话号码，可采用此电话号码拨打终端电话让终端复位 + + + + + 0x0041 + + + + + 数据长度 + n byte + + + + + 复位电话号码，可采用此电话号码拨打终端电话让终端复位 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 恢复出厂设置电话号码，可采用此电话号码拨打终端电话让终端恢复出厂设置 + + + + + 0x0042 + + + + + 数据长度 + n byte + + + + + 恢复出厂设置电话号码，可采用此电话号码拨打终端电话让终端恢复出厂设置 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 监控平台 SMS 电话号码 + + + + + 0x0043 + + + + + 数据长度 + n byte + + + + + 监控平台 SMS 电话号码 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 接收终端 SMS 文本报警号码 + + + + + 0x0044 + + + + + 数据长度 + n byte + + + + + 接收终端 SMS 文本报警号码 - + - 设置终端参数 + + + + - + - 参数总数 + + + + - + - 参数列表 + + + + - + - 终端心跳发送间隔，单位为秒（s） - 0x8103_0x0001 + 终端电话接听策略，0：自动接听；1：ACC ON 时自动接听，OFF 时手动接听 - + - 数据 长度 + 0x0045 - + - 终端心跳发送间隔，单位为秒（s） + 数据长度 + 4 byte - + - TCP 消息应答超时时间，单位为秒（s） - 0x8103_0x0002 + 终端电话接听策略，0：自动接听；1：ACC ON 时自动接听，OFF 时手动接听 - + - 数据 长度 + + + + - + - TCP 消息应答超时时间，单位为秒（s） + + + + - + - TCP 消息重传次数 - 0x8103_0x0003 + + + + - + - 数据 长度 + 每次最长通话时间，单位为秒（s），0 为不允许通话，0xFFFFFFFF 为不限制 - + - TCP 消息重传次数 + 0x0046 - + - UDP 消息应答超时时间，单位为秒（s） - 0x8103_0x0004 + 数据长度 + 4 byte - + - 数据 长度 + 每次最长通话时间，单位为秒（s），0 为不允许通话，0xFFFFFFFF 为不限制 - + - UDP 消息应答超时时间，单位为秒（s） + + + + - + - UDP 消息重传次数 - 0x8103_0x0005 + + + + - + - 数据 长度 + + + + - + - UDP 消息重传次数 + 当月最长通话时间，单位为秒（s），0 为不允许通话，0xFFFFFFFF 为不限制 - + - SMS 消息应答超时时间，单位为秒（s） - 0x8103_0x0006 + 0x0047 - + - 数据 长度 + 数据长度 + 4 byte - + - SMS 消息应答超时时间，单位为秒（s） + 当月最长通话时间，单位为秒（s），0 为不允许通话，0xFFFFFFFF 为不限制 - + - SMS 消息重传次数 - 0x8103_0x0007 + + + + - + - 数据 长度 + + + + - + - SMS 消息重传次数 + + + + - + - 主服务器 APN，无线通信拨号访问点。若网络制式为 CDMA，则该处为PPP 拨号号码 + 监听电话号码 - + - 数据 长度 + 0x0048 - + - 主服务器 APN，无线通信拨号访问点。若网络制式为 CDMA，则该处为PPP 拨号号码 + 数据长度 + n byte - + - 主服务器无线通信拨号用户名 + 监听电话号码 - + - 数据 长度 + + + + - + - 主服务器无线通信拨号用户名 + + + + - + - 主服务器无线通信拨号密码 + + + + - + - 数据 长度 + 监管平台特权短信号码 - + - 主服务器无线通信拨号密码 + 0x0049 - + - 主服务器地址,IP 或域名 + 数据长度 + n byte - + - 数据 长度 + 监管平台特权短信号码 - + - 主服务器地址,IP 或域名 + + + + - + - 备份服务器 APN，无线通信拨号访问点 + + + + - + - 数据 长度 + + + + - + - 备份服务器 APN，无线通信拨号访问点 + 报警屏蔽字，与位置信息汇报消息中的报警标志相对应，相应位为 1则相应报警被屏蔽 - + - 备份服务器无线通信拨号用户名 + 0x0050 - + - 数据 长度 + 数据长度 + 4 byte - + - 备份服务器无线通信拨号用户名 + 报警屏蔽字，与位置信息汇报消息中的报警标志相对应，相应位为 1则相应报警被屏蔽 - + - 备份服务器无线通信拨号密码 + + + + - + - 数据 长度 + + + + - + - 备份服务器无线通信拨号密码 + + + + - + - 备份服务器地址,IP 或域名 + 报警发送文本 SMS 开关，与位置信息汇报消息中的报警标志相对应，相应位为 1 则相应报警时发送文本 SMS - + - 数据 长度 + 0x0051 - + - 备份服务器地址,IP 或域名 + 数据长度 + 4 byte - + - 服务器 TCP 端口 + 报警发送文本 SMS 开关，与位置信息汇报消息中的报警标志相对应，相应位为 1 则相应报警时发送文本 SMS - + - 数据 长度 + + + + - - - 服务器 TCP 端口 - - - + - 服务器 UDP 端口 + + + + - + - 数据 长度 + + + + - - - 服务器 UDP 端口 - - - + - 道路运输证 IC 卡认证主服务器 IP 地址或域名 + 报警拍摄开关，与位置信息汇报消息中的报警标志相对应，相应位为1 则相应报警时摄像头拍摄 - + - 数据 长度 + 0x0052 - + - 道路运输证 IC 卡认证主服务器 IP 地址或域名 + 数据长度 + 4 byte - + - 道路运输证 IC 卡认证主服务器 TCP 端口 + 报警拍摄开关，与位置信息汇报消息中的报警标志相对应，相应位为1 则相应报警时摄像头拍摄 - + - 数据 长度 + + + + - - - 道路运输证 IC 卡认证主服务器 TCP 端口 - + + + + + + + - + - 道路运输证 IC 卡认证主服务器 UDP 端口 + + + + - + - 数据 长度 + 报警拍摄存储标志，与位置信息汇报消息中的报警标志相对应，相应位为 1 则对相应报警时拍的照片进行存储，否则实时上传 - - - 道路运输证 IC 卡认证主服务器 UDP 端口 - + + + 0x0053 + - + - 道路运输证 IC 卡认证备份服务器 IP 地址或域名，端口同主服务器 + 数据长度 + 4 byte - + - 数据 长度 + 报警拍摄存储标志，与位置信息汇报消息中的报警标志相对应，相应位为 1 则对相应报警时拍的照片进行存储，否则实时上传 - + - 道路运输证 IC 卡认证备份服务器 IP 地址或域名，端口同主服务器 + + + + - + - 位置汇报策略，0：定时汇报；1：定距汇报；2：定时和定距汇报 + + + + - + - 数据 长度 + + + + - + - 位置汇报策略，0：定时汇报；1：定距汇报；2：定时和定距汇报 + 关键标志，与位置信息汇报消息中的报警标志相对应，相应位为 1 则对相应报警为关键报警 - + - 位置汇报方案，0：根据 ACC 状态； 1：根据登录状态和 ACC 状态，先判断登录状态，若登录再根据 ACC 状态 + 0x0054 - + - 数据 长度 + 数据长度 + 4 byte - + - 位置汇报方案，0：根据 ACC 状态； 1：根据登录状态和 ACC 状态，先判断登录状态，若登录再根据 ACC 状态 + 关键标志，与位置信息汇报消息中的报警标志相对应，相应位为 1 则对相应报警为关键报警 - + - 驾驶员未登录汇报时间间隔，单位为秒（s），>0 + + + + - + - 数据 长度 + + + + - + - 驾驶员未登录汇报时间间隔，单位为秒（s），>0 + + + + - + - 从服务器APN。该值为空时，终端应使用主服务器相同配置 - 2019版本 + 最高速度，单位为公里每小时（km/h） - + - 数据 长度 + 0x0055 - + - + 数据长度 + 4 byte - + - 从服务器无线通信拨号用户名。该值为空时，终端应使用主服务器相同配置 - 2019版本 + 最高速度，单位为公里每小时（km/h） - + - 数据 长度 + + + + - + + + + - + - 从服务器无线通信拨号密码。该值为空，终端应使用主服务器相同配置 - 2019版本 + + + + - + - 数据 长度 + 超速持续时间，单位为秒（s） - + - + 0x0056 - + - 从服务器备份地址IP。该值为空，终端应使用主服务器相同配置 - 2019版本 + 数据长度 + 4 byte - + - 数据 长度 + 超速持续时间，单位为秒（s） - + + + + - + - 休眠时汇报时间间隔，单位为秒（s），>0 + + + + - + - 数据 长度 + + + + - + - 休眠时汇报时间间隔，单位为秒（s），>0 + 连续驾驶时间门限，单位为秒（s） - + - 紧急报警时汇报时间间隔，单位为秒（s），>0 + 0x0057 - + - 数据 长度 + 数据长度 - + - 紧急报警时汇报时间间隔，单位为秒（s），>0 + 连续驾驶时间门限，单位为秒（s） - + - 缺省时间汇报间隔，单位为秒（s），>0 + + + + - + - 数据 长度 + + + + - + - 缺省时间汇报间隔，单位为秒（s），>0 + + + + - + - 缺省距离汇报间隔，单位为米（m），>0 + 当天累计驾驶时间门限，单位为秒（s） - + - 数据 长度 + 0x0058 - + - 缺省距离汇报间隔，单位为米（m），>0 + 数据长度 + 4 byte - + - 驾驶员未登录汇报距离间隔，单位为米（m），>0 + 当天累计驾驶时间门限，单位为秒（s） - + - 数据 长度 + + + + - + - 驾驶员未登录汇报距离间隔，单位为米（m），>0 + + + + - + - 休眠时汇报距离间隔，单位为米（m），>0 + + + + - + - 数据 长度 + 最小休息时间，单位为秒（s） - + - 休眠时汇报距离间隔，单位为米（m），>0 + 0x0059 - + - 紧急报警时汇报距离间隔，单位为米（m），>0 + 数据长度 + 4 byte - + - 数据 长度 + 最小休息时间，单位为秒（s） - + - 紧急报警时汇报距离间隔，单位为米（m），>0 + + + + - + - 拐点补传角度，小于180 + + + + - + - 数据 长度 + + + + - + - 拐点补传角度，小于180 + 最长停车时间，单位为秒（s） - + - 电子围栏半径（非法位移阈值），单位为米 + 0x005A - + - 数据 长度 + 数据长度 + 4 byte - + - 电子围栏半径（非法位移阈值），单位为米 + 最长停车时间，单位为秒（s） - + - 违规行驶时段范围 + + + + - + - 数据 长度 + + + + - + - 违规行驶时段范围（非法位移阈值），单位为米 + + + + - + - 监控平台电话号码 + 超速报警预警差值，单位为 1/10Km/h - + - 数据 长度 + 0x005B - + - 监控平台电话号码 + 数据长度 + 2 byte - + - 复位电话号码，可采用此电话号码拨打终端电话让终端复位 + 超速报警预警差值，单位为 1/10Km/h - + - 数据 长度 + + + + - + - 复位电话号码，可采用此电话号码拨打终端电话让终端复位 + + + + - + - 恢复出厂设置电话号码，可采用此电话号码拨打终端电话让终端恢复出厂设置 + + + + - + - 数据 长度 + 疲劳驾驶预警差值，单位为秒（s），>0 - + - 恢复出厂设置电话号码，可采用此电话号码拨打终端电话让终端恢复出厂设置 + 0x005C - + - 监控平台 SMS 电话号码 + 数据长度 + 2 byte - + - 数据 长度 + 疲劳驾驶预警差值，单位为秒（s），>0 - + - 监控平台 SMS 电话号码 + + + + - + - 接收终端 SMS 文本报警号码 + + + + - + - 数据 长度 + + + + - + - 接收终端 SMS 文本报警号码 + 碰撞报警参数设置 + b7-b0： 碰撞时间，单位 4ms； + b15-b8：碰撞加速度，单位 0.1g，设置范围在：0-79 之间，默认为10。 - + - 终端电话接听策略，0：自动接听；1：ACC ON 时自动接听，OFF 时手动接听 + 0x005D - + - 数据 长度 + 数据长度 + 2 byte - + - 终端电话接听策略，0：自动接听；1：ACC ON 时自动接听，OFF 时手动接听 + 碰撞报警参数设置 + b7-b0： 碰撞时间，单位4ms； + b15-b8：碰撞加速度，单位 0.1g，设置范围在：0-79 之间，默认为10。 - + - 每次最长通话时间，单位为秒（s），0 为不允许通话，0xFFFFFFFF 为不限制 + + + + - + - 数据 长度 + + + + - + - 每次最长通话时间，单位为秒（s），0 为不允许通话，0xFFFFFFFF 为不限制 + + + + - + - 当月最长通话时间，单位为秒（s），0 为不允许通话，0xFFFFFFFF 为不限制 + 侧翻报警参数设置： + 侧翻角度，单位 1 度，默认为 30 度 - + - 数据 长度 + 0x005E - + - 当月最长通话时间，单位为秒（s），0 为不允许通话，0xFFFFFFFF 为不限制 + 数据长度 + 2 byte - + - 监听电话号码 + 侧翻报警参数设置： + 侧翻角度，单位 1 度，默认为 30 度 - + - 数据 长度 + + + + - + - 监听电话号码 + + + + - + - 监管平台特权短信号码 + + + + - + - 数据 长度 + 定时拍照控制，见 表 14 - + - 监管平台特权短信号码 + 0x0064 - + - 报警屏蔽字，与位置信息汇报消息中的报警标志相对应，相应位为 1则相应报警被屏蔽 + 数据长度 + 4 byte - + - 数据 长度 + 定时拍照控制，见808表 14 - + - 报警屏蔽字，与位置信息汇报消息中的报警标志相对应，相应位为 1则相应报警被屏蔽 + + + + - + - 报警发送文本 SMS 开关，与位置信息汇报消息中的报警标志相对应，相应位为 1 则相应报警时发送文本 SMS + + + + - + - 数据 长度 + + + + - + - 报警发送文本 SMS 开关，与位置信息汇报消息中的报警标志相对应，相应位为 1 则相应报警时发送文本 SMS + 定距拍照控制，见 表 15 - + - 报警拍摄开关，与位置信息汇报消息中的报警标志相对应，相应位为1 则相应报警时摄像头拍摄 + 0x0065 - + - 数据 长度 + 数据长度 + 4 byte - + - 报警拍摄开关，与位置信息汇报消息中的报警标志相对应，相应位为1 则相应报警时摄像头拍摄 + 定距拍照控制，见808表15 - + - 报警拍摄存储标志，与位置信息汇报消息中的报警标志相对应，相应位为 1 则对相应报警时拍的照片进行存储，否则实时上传 + + + + - + - 数据 长度 + + + + - + - 报警拍摄存储标志，与位置信息汇报消息中的报警标志相对应，相应位为 1 则对相应报警时拍的照片进行存储，否则实时上传 + + + + - + - 关键标志，与位置信息汇报消息中的报警标志相对应，相应位为 1 则对相应报警为关键报警 + 图像/视频质量，1-10，1 最好 - + - 数据 长度 + 0x0070 - + - 关键标志，与位置信息汇报消息中的报警标志相对应，相应位为 1 则对相应报警为关键报警 + 数据长度 + 4 byte - + - 最高速度，单位为公里每小时（km/h） + 图像/视频质量，1-10，1 最好 - + - 数据 长度 + + + + - + - 最高速度，单位为公里每小时（km/h） + + + + - + - 超速持续时间，单位为秒（s） + + + + - + - 数据 长度 + 亮度，0-255 - + - 超速持续时间，单位为秒（s） + 0x0071 - + - 连续驾驶时间门限，单位为秒（s） + 数据长度 + 4 byte - + - 数据 长度 + 亮度，0-255 - + - 连续驾驶时间门限，单位为秒（s） + + + + - + - 当天累计驾驶时间门限，单位为秒（s） + + + + - + - 数据 长度 + + + + - + - 当天累计驾驶时间门限，单位为秒（s） + 对比度，0-127 - + - 最小休息时间，单位为秒（s） + 0x0072 - + - 数据 长度 + 数据长度 + 4 byte - + - 最小休息时间，单位为秒（s） + 对比度，0-127 - + - 最长停车时间，单位为秒（s） + + + + - + - 数据 长度 + + + + - + - 最长停车时间，单位为秒（s） + + + + - + - 超速报警预警差值，单位为 1/10Km/h + 饱和度，0-127 - + - 数据 长度 + 0x0073 - + - 超速报警预警差值，单位为 1/10Km/h + 数据长度 + 4 byte - + - 疲劳驾驶预警差值，单位为秒（s），>0 + 饱和度，0-127 - + - 数据 长度 + + + + - + - 疲劳驾驶预警差值，单位为秒（s），>0 + + + + - + - 碰撞报警参数设置 - b7-b0： 碰撞时间，单位 4ms； - b15-b8：碰撞加速度，单位 0.1g，设置范围在：0-79 之间，默认为10。 + + + + - + - 数据 长度 + 色度，0-255 - + - 碰撞报警参数设置 - b7-b0： 碰撞时间，单位4ms； - b15-b8：碰撞加速度，单位 0.1g，设置范围在：0-79 之间，默认为10。 + 0x0074 - + - 侧翻报警参数设置： - 侧翻角度，单位 1 度，默认为 30 度 + 数据长度 + 4 byte - + - 数据 长度 + 色度，0-255 - + - 侧翻报警参数设置： - 侧翻角度，单位 1 度，默认为 30 度 + + + + - + - 定时拍照控制，见 表 14 + + + + - + - 数据 长度 + + + + - + - 定时拍照控制，见 表 14 + 车辆里程表读数，1/10km - + - 定距拍照控制，见 表 15 + 0x0080 - + - 数据 长度 + 数据长度 + 4 byte - + - 定距拍照控制，见 表 15 + 车辆里程表读数，1/10km - + - 图像/视频质量，1-10，1 最好 + + + + - + - 数据 长度 + + + + - + - 图像/视频质量，1-10，1 最好 + + + + - + - 亮度，0-255 + 车辆所在的省域 ID - + - 数据 长度 + 0x0081 - + - 亮度，0-255 + 数据长度 + 2 byte - + - 对比度，0-127 + 车辆所在的省域 ID - + - 数据 长度 + + + + - + - 对比度，0-127 + + + + - + - 饱和度，0-127 + + + + - + - 数据 长度 + 车辆所在的市域 ID - + - 饱和度，0-127 + 0x0082 - + - 色度，0-255 + 数据长度 + 2 byte - + - 数据 长度 + 车辆所在的市域 ID - + - 色度，0-255 + + + + - + - 车辆里程表读数，1/10km + + + + - + - 数据 长度 + + + + - + - 车辆里程表读数，1/10km + 公安交通管理部门颁发的机动车号牌 - + - 车辆所在的省域 ID + 0x0083 - + - 数据 长度 + 数据长度 + n byte - + - 车辆所在的省域 ID + 公安交通管理部门颁发的机动车号牌 - + - 车辆所在的市域 ID + + + + - + - 数据 长度 + + + + - + - 车辆所在的市域 ID + + + + - + - 公安交通管理部门颁发的机动车号牌 + 车牌颜色，按照 JT/T415-2006 的 5.4.12 - + - 数据 长度 + 0x0084 - + - 公安交通管理部门颁发的机动车号牌 + 数据长度 + n byte - + 车牌颜色，按照 JT/T415-2006 的 5.4.12 - + - 数据 长度 + + + + - + - 车牌颜色，按照 JT/T415-2006 的 5.4.12 + + + + + + + + + + + + @@ -7884,9 +11212,15 @@ bit3，0：禁用 Galileo 定位， 1：启用 Galileo 定位。 + + + 0x0090 + + - 数据 长度 + 数据长度 + 1 byte @@ -7898,6 +11232,30 @@ bit3，0：禁用 Galileo 定位， 1：启用 Galileo 定位。 + + + + + + + + + + + + + + + + + + + + + + + + GNSS 波特率，定义如下： @@ -7906,9 +11264,15 @@ 0x04：57600；0x05：115200。 + + + 0x0091 + + - 数据 长度 + 数据长度 + 1 byte @@ -7919,6 +11283,30 @@ 0x04：57600；0x05：115200。 + + + + + + + + + + + + + + + + + + + + + + + + GNSS 模块详细定位数据输出频率，定义如下： @@ -7927,9 +11315,15 @@ 0x04：4000ms。 + + + 0x0092 + + - 数据 长度 + 数据长度 + 1 byte @@ -7940,14 +11334,44 @@ 0x04：4000ms。 + + + + + + + + + + + + + + + + + + + + + + + + GNSS 模块详细定位数据采集频率，单位为秒，默认为 1。 + + + 0x0093 + + - 数据 长度 + 数据长度 + 4 byte @@ -7955,6 +11379,30 @@ GNSS 模块详细定位数据采集频率，单位为秒，默认为 1。 + + + + + + + + + + + + + + + + + + + + + + + + GNSS 模块详细定位数据上传方式 @@ -7966,9 +11414,15 @@ 0x0D，按累计条数上传，达到上传条数后自动停止上传。 + + + 0x0094 + + - 数据 长度 + 数据长度 + 1 byte @@ -7982,6 +11436,30 @@ 0x0D，按累计条数上传，达到上传条数后自动停止上传。 + + + + + + + + + + + + + + + + + + + + + + + + GNSS 模块详细定位数据上传设置： @@ -7992,9 +11470,15 @@ 上传方式为 0x0D 时，单位为条。 + + + 0x0095 + + - 数据 长度 + 数据长度 + 4 byte @@ -8012,6 +11496,11 @@ CAN 总线通道 1 采集时间间隔(ms)，0 表示不采集 + + + 0x0100 + + 数据 长度 @@ -8022,6 +11511,22 @@ CAN 总线通道 1 采集时间间隔(ms)，0 表示不采集 + + + + + + + + + + + + + + + + CAN 总线通道 1 上传时间间隔(s)，0 表示不上传 @@ -8037,14 +11542,44 @@ CAN 总线通道 1 上传时间间隔(s)，0 表示不上传 + + + + + + + + + + + + + + + + + + + + + + + + CAN 总线通道 2 采集时间间隔(ms)，0 表示不采集 + + + 0x0102 + + - 数据 长度 + 数据长度 + 4 byte @@ -8052,14 +11587,44 @@ CAN 总线通道 2 采集时间间隔(ms)，0 表示不采集 + + + + + + + + + + + + + + + + + + + + + + + + CAN 总线通道 2 上传时间间隔(s)，0 表示不上传 + + + 0x0103 + + - 数据 长度 + 数据长度 + 2 byte @@ -8067,6 +11632,30 @@ CAN 总线通道 2 上传时间间隔(s)，0 表示不上传 + + + + + + + + + + + + + + + + + + + + + + + + CAN 总线 ID 单独采集设置： @@ -8077,9 +11666,15 @@ bit28-bit0 表示 CAN 总线 ID。 + + + 0x0110 + + - 数据 长度 + 数据长度 + 8 byte @@ -8107,6 +11702,11 @@ bit28-bit0 表示 CAN 总线 ID。 + + + 终端参数设置 + + 参数 ID @@ -8117,6 +11717,11 @@ 参数长度 + + + 自定义终端参数设置 + + 参数 ID diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0200_0x12.cs b/src/JT808.Protocol/MessageBody/JT808_0x0200_0x12.cs index 7a7a883..5ea9714 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0200_0x12.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0200_0x12.cs @@ -7,6 +7,9 @@ using System.Text.Json; namespace JT808.Protocol.MessageBody { + /// + /// 进出区域/路线报警附加信息 + /// public class JT808_0x0200_0x12 : JT808_0x0200_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { /// @@ -29,9 +32,20 @@ namespace JT808.Protocol.MessageBody /// 1：出 /// public JT808DirectionType Direction { get; set; } + /// + /// JT808_0x0200_0x12 + /// public override byte AttachInfoId { get; set; } = JT808Constants.JT808_0x0200_0x12; + /// + /// 6 byte + /// public override byte AttachInfoLength { get; set; } = 6; - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0200_0x12 value = new JT808_0x0200_0x12(); @@ -46,7 +60,12 @@ namespace JT808.Protocol.MessageBody value.Direction = (JT808DirectionType)reader.ReadByte(); writer.WriteNumber($"[{((byte)value.Direction).ReadNumber()}]方向-{value.Direction.ToString()}", (byte)value.Direction); } - + /// + /// + /// + /// + /// + /// public JT808_0x0200_0x12 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0200_0x12 value = new JT808_0x0200_0x12(); @@ -57,7 +76,12 @@ namespace JT808.Protocol.MessageBody value.Direction = (JT808DirectionType)reader.ReadByte(); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0200_0x12 value, IJT808Config config) { writer.WriteByte(value.AttachInfoId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0200_0x13.cs b/src/JT808.Protocol/MessageBody/JT808_0x0200_0x13.cs index e2971ae..fabb5e9 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0200_0x13.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0200_0x13.cs @@ -7,9 +7,18 @@ using System.Text.Json; namespace JT808.Protocol.MessageBody { + /// + /// 路段行驶时间不足/过长报警附加信息 + /// public class JT808_0x0200_0x13 : JT808_0x0200_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// JT808_0x0200_0x13 + /// public override byte AttachInfoId { get; set; } = JT808Constants.JT808_0x0200_0x13; + /// + /// 7 byte + /// public override byte AttachInfoLength { get; set; } = 7; /// @@ -27,7 +36,12 @@ namespace JT808.Protocol.MessageBody /// 结果 0：不足；1：过长 /// public JT808DrivenRouteType DrivenRoute { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0200_0x13 value = new JT808_0x0200_0x13(); @@ -43,7 +57,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{((byte)value.DrivenRoute).ReadNumber()}]结果-{value.DrivenRoute.ToString()}", (byte)value.DrivenRoute); } - + /// + /// + /// + /// + /// + /// public JT808_0x0200_0x13 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0200_0x13 value = new JT808_0x0200_0x13(); @@ -54,7 +73,12 @@ namespace JT808.Protocol.MessageBody value.DrivenRoute = (JT808DrivenRouteType)reader.ReadByte(); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0200_0x13 value, IJT808Config config) { writer.WriteByte(value.AttachInfoId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0200_0x25.cs b/src/JT808.Protocol/MessageBody/JT808_0x0200_0x25.cs index fe6b926..5b37ff2 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0200_0x25.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0200_0x25.cs @@ -6,15 +6,29 @@ using System.Text.Json; namespace JT808.Protocol.MessageBody { + /// + /// 扩展车辆信号状态位 + /// public class JT808_0x0200_0x25 : JT808_0x0200_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { /// /// 扩展车辆信号状态位 /// public int CarSignalStatus { get; set; } + /// + /// JT808_0x0200_0x25 + /// public override byte AttachInfoId { get; set; } = JT808Constants.JT808_0x0200_0x25; + /// + /// 4 byte + /// public override byte AttachInfoLength { get; set; } = 4; - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0200_0x25 value = new JT808_0x0200_0x25(); @@ -25,7 +39,12 @@ namespace JT808.Protocol.MessageBody value.CarSignalStatus = reader.ReadInt32(); writer.WriteNumber($"[{value.CarSignalStatus.ReadNumber()}]扩展车辆信号状态位", value.CarSignalStatus); } - + /// + /// + /// + /// + /// + /// public JT808_0x0200_0x25 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0200_0x25 value = new JT808_0x0200_0x25(); @@ -34,7 +53,12 @@ namespace JT808.Protocol.MessageBody value.CarSignalStatus = reader.ReadInt32(); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0200_0x25 value, IJT808Config config) { writer.WriteByte(value.AttachInfoId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0200_0x2A.cs b/src/JT808.Protocol/MessageBody/JT808_0x0200_0x2A.cs index c10d419..0e8b1f3 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0200_0x2A.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0200_0x2A.cs @@ -6,15 +6,29 @@ using System.Text.Json; namespace JT808.Protocol.MessageBody { + /// + /// IO状态位 + /// public class JT808_0x0200_0x2A : JT808_0x0200_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { /// /// IO状态位 /// public ushort IOStatus { get; set; } + /// + /// JT808_0x0200_0x2A + /// public override byte AttachInfoId { get; set; } = JT808Constants.JT808_0x0200_0x2A; + /// + /// AttachInfoLength + /// public override byte AttachInfoLength { get; set; } = 2; - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0200_0x2A value = new JT808_0x0200_0x2A(); @@ -25,7 +39,12 @@ namespace JT808.Protocol.MessageBody value.IOStatus = reader.ReadUInt16(); writer.WriteNumber($"[{value.IOStatus.ReadNumber()}]IO状态位", value.IOStatus); } - + /// + /// + /// + /// + /// + /// public JT808_0x0200_0x2A Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0200_0x2A value = new JT808_0x0200_0x2A(); @@ -34,7 +53,12 @@ namespace JT808.Protocol.MessageBody value.IOStatus = reader.ReadUInt16(); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0200_0x2A value, IJT808Config config) { writer.WriteByte(value.AttachInfoId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0200_0x2B.cs b/src/JT808.Protocol/MessageBody/JT808_0x0200_0x2B.cs index af63776..785142c 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0200_0x2B.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0200_0x2B.cs @@ -7,15 +7,29 @@ using System.Text.Json; namespace JT808.Protocol.MessageBody { + /// + /// 模拟量 + /// public class JT808_0x0200_0x2B : JT808_0x0200_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { /// /// 模拟量 bit0-15，AD0；bit16-31，AD1 /// public int Analog { get; set; } + /// + /// JT808_0x0200_0x2B + /// public override byte AttachInfoId { get; set; } = JT808Constants.JT808_0x0200_0x2B; + /// + /// 4 byte + /// public override byte AttachInfoLength { get; set; } = 4; - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0200_0x2B value = new JT808_0x0200_0x2B(); @@ -26,7 +40,12 @@ namespace JT808.Protocol.MessageBody value.Analog = reader.ReadInt32(); writer.WriteNumber($"[{value.Analog.ReadNumber()}]模拟量", value.Analog); } - + /// + /// + /// + /// + /// + /// public JT808_0x0200_0x2B Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0200_0x2B value = new JT808_0x0200_0x2B(); @@ -35,7 +54,12 @@ namespace JT808.Protocol.MessageBody value.Analog = reader.ReadInt32(); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0200_0x2B value, IJT808Config config) { writer.WriteByte(value.AttachInfoId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0200_0x30.cs b/src/JT808.Protocol/MessageBody/JT808_0x0200_0x30.cs index bdbbd4a..611cc60 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0200_0x30.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0200_0x30.cs @@ -7,15 +7,29 @@ using System.Text.Json; namespace JT808.Protocol.MessageBody { + /// + /// 无线通信网络信号强度 + /// public class JT808_0x0200_0x30 : JT808_0x0200_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { /// /// 无线通信网络信号强度 /// public byte WiFiSignalStrength { get; set; } + /// + /// JT808_0x0200_0x30 + /// public override byte AttachInfoId { get; set; } = JT808Constants.JT808_0x0200_0x30; + /// + /// AttachInfoLength + /// public override byte AttachInfoLength { get; set; } = 1; - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0200_0x30 value = new JT808_0x0200_0x30(); @@ -26,7 +40,12 @@ namespace JT808.Protocol.MessageBody value.WiFiSignalStrength = reader.ReadByte(); writer.WriteNumber($"[{value.WiFiSignalStrength.ReadNumber()}]无线通信网络信号强度", value.WiFiSignalStrength); } - + /// + /// + /// + /// + /// + /// public JT808_0x0200_0x30 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0200_0x30 value = new JT808_0x0200_0x30(); @@ -35,7 +54,12 @@ namespace JT808.Protocol.MessageBody value.WiFiSignalStrength = reader.ReadByte(); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0200_0x30 value, IJT808Config config) { writer.WriteByte(value.AttachInfoId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0200_0x31.cs b/src/JT808.Protocol/MessageBody/JT808_0x0200_0x31.cs index e047c7c..e5a9f04 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0200_0x31.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0200_0x31.cs @@ -6,15 +6,29 @@ using System.Text.Json; namespace JT808.Protocol.MessageBody { + /// + /// GNSS 定位卫星数 + /// public class JT808_0x0200_0x31 : JT808_0x0200_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { /// /// GNSS 定位卫星数 /// public byte GNSSCount { get; set; } + /// + /// JT808_0x0200_0x31 + /// public override byte AttachInfoId { get; set; } = JT808Constants.JT808_0x0200_0x31; + /// + /// 1 byte + /// public override byte AttachInfoLength { get; set; } = 1; - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0200_0x31 value = new JT808_0x0200_0x31(); @@ -25,7 +39,12 @@ namespace JT808.Protocol.MessageBody value.GNSSCount = reader.ReadByte(); writer.WriteNumber($"[{value.GNSSCount.ReadNumber()}]GNSS定位卫星数", value.GNSSCount); } - + /// + /// + /// + /// + /// + /// public JT808_0x0200_0x31 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0200_0x31 value = new JT808_0x0200_0x31(); @@ -34,6 +53,12 @@ namespace JT808.Protocol.MessageBody value.GNSSCount = reader.ReadByte(); return value; } + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0200_0x31 value, IJT808Config config) { writer.WriteByte(value.AttachInfoId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0201.cs b/src/JT808.Protocol/MessageBody/JT808_0x0201.cs index 59ddc9b..7b2c8c4 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0201.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0201.cs @@ -11,7 +11,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x0201 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0201 + /// public override ushort MsgId { get; } = 0x0201; + /// + /// 位置信息查询应答 + /// public override string Description => "位置信息查询应答"; /// /// 应答流水号 @@ -23,7 +29,12 @@ namespace JT808.Protocol.MessageBody /// 位置信息汇报见 8.12 /// public JT808_0x0200 Position { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0201 value = new JT808_0x0201(); @@ -33,7 +44,12 @@ namespace JT808.Protocol.MessageBody config.GetAnalyze().Analyze(ref reader, writer, config); writer.WriteEndObject(); } - + /// + /// + /// + /// + /// + /// public JT808_0x0201 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0201 jT808_0X0201 = new JT808_0x0201(); @@ -41,7 +57,12 @@ namespace JT808.Protocol.MessageBody jT808_0X0201.Position = config.GetMessagePackFormatter().Deserialize(ref reader, config); return jT808_0X0201; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0201 value, IJT808Config config) { writer.WriteUInt16(value.ReplyMsgNum); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0301.cs b/src/JT808.Protocol/MessageBody/JT808_0x0301.cs index 6369697..a5b8993 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0301.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0301.cs @@ -10,29 +10,51 @@ namespace JT808.Protocol.MessageBody /// /// 事件报告 /// 0x0301 + /// 2019版本已作删除 /// - [Obsolete("2019版本已作删除")] public class JT808_0x0301 : JT808Bodies, IJT808MessagePackFormatter, IJT808_2019_Version, IJT808Analyze { + /// + /// 0x0301 + /// public override ushort MsgId { get; } = 0x0301; + /// + /// 事件报告 + /// public override string Description => "事件报告"; /// /// 事件 ID /// public byte EventId { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { var eventId = reader.ReadByte(); writer.WriteNumber($"[{eventId.ReadNumber()}]事件ID", eventId); } - + /// + /// + /// + /// + /// + /// public JT808_0x0301 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0301 jT808_0X0301 = new JT808_0x0301(); jT808_0X0301.EventId = reader.ReadByte(); return jT808_0X0301; } + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0301 value, IJT808Config config) { writer.WriteByte(value.EventId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0302.cs b/src/JT808.Protocol/MessageBody/JT808_0x0302.cs index afb1985..cd31c04 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0302.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0302.cs @@ -11,11 +11,17 @@ namespace JT808.Protocol.MessageBody /// /// 提问应答 /// 0x0302 + /// 2019版本已作删除 /// - [Obsolete("2019版本已作删除")] public class JT808_0x0302 : JT808Bodies, IJT808MessagePackFormatter,IJT808_2019_Version, IJT808Analyze { + /// + /// 0x0302 + /// public override ushort MsgId { get; } = 0x0302; + /// + /// 提问应答 + /// public override string Description => "提问应答"; /// /// 应答流水号 @@ -27,7 +33,12 @@ namespace JT808.Protocol.MessageBody /// 提问下发中附带的答案 ID /// public byte AnswerId { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0302 jT808_0X0302 = new JT808_0x0302(); @@ -36,7 +47,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0X0302.ReplySNo.ReadNumber()}]应答流水号", jT808_0X0302.ReplySNo); writer.WriteNumber($"[{jT808_0X0302.AnswerId.ReadNumber()}]答案ID", jT808_0X0302.AnswerId); } - + /// + /// + /// + /// + /// + /// public JT808_0x0302 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0302 jT808_0X0302 = new JT808_0x0302(); @@ -44,6 +60,12 @@ namespace JT808.Protocol.MessageBody jT808_0X0302.AnswerId = reader.ReadByte(); return jT808_0X0302; } + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0302 value, IJT808Config config) { writer.WriteUInt16(value.ReplySNo); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0303.cs b/src/JT808.Protocol/MessageBody/JT808_0x0303.cs index fbfb246..c78a314 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0303.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0303.cs @@ -10,11 +10,17 @@ namespace JT808.Protocol.MessageBody /// /// 信息点播/取消 /// 0x0303 + /// 2019版本已作删除 /// - [Obsolete("2019版本已作删除")] public class JT808_0x0303 : JT808Bodies, IJT808MessagePackFormatter, IJT808_2019_Version, IJT808Analyze { + /// + /// 0x0303 + /// public override ushort MsgId { get; } = 0x0303; + /// + /// 信息点播_取消 + /// public override string Description => "信息点播_取消"; /// /// 信息类型 @@ -24,7 +30,12 @@ namespace JT808.Protocol.MessageBody /// 点播/取消标志 /// public byte Flag { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0303 value = new JT808_0x0303(); @@ -33,7 +44,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{value.InformationType.ReadNumber()}]信息类型", value.InformationType); writer.WriteNumber($"[{value.Flag.ReadNumber()}]{(value.Flag==1? "点播" : "取消")}", value.Flag); } - + /// + /// + /// + /// + /// + /// public JT808_0x0303 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0303 value = new JT808_0x0303(); @@ -41,7 +57,12 @@ namespace JT808.Protocol.MessageBody value.Flag = reader.ReadByte(); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0303 value, IJT808Config config) { writer.WriteByte(value.InformationType); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0500.cs b/src/JT808.Protocol/MessageBody/JT808_0x0500.cs index eb8ed63..573c310 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0500.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0500.cs @@ -11,7 +11,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x0500 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0500 + /// public override ushort MsgId { get; } = 0x0500; + /// + /// 车辆控制应答 + /// public override string Description => "车辆控制应答"; /// /// 应答流水号 @@ -22,7 +28,12 @@ namespace JT808.Protocol.MessageBody /// 位置信息汇报消息体 /// public JT808_0x0200 JT808_0x0200 { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0500 value = new JT808_0x0500(); @@ -32,7 +43,12 @@ namespace JT808.Protocol.MessageBody config.GetAnalyze().Analyze(ref reader, writer, config); writer.WriteEndObject(); } - + /// + /// + /// + /// + /// + /// public JT808_0x0500 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0500 value = new JT808_0x0500(); @@ -40,7 +56,12 @@ namespace JT808.Protocol.MessageBody value.JT808_0x0200 = config.GetMessagePackFormatter().Deserialize(ref reader, config); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0500 value, IJT808Config config) { writer.WriteUInt16(value.MsgNum); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0608.cs b/src/JT808.Protocol/MessageBody/JT808_0x0608.cs index cf00f6c..aef02c0 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0608.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0608.cs @@ -12,7 +12,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x0608 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze, IJT808_2019_Version { + /// + /// 0x0608 + /// public override ushort MsgId { get; } = 0x0608; + /// + /// 查询区域或线路数据应答 + /// public override string Description => "查询区域或线路数据应答"; /// /// 查询类型 @@ -46,7 +52,12 @@ namespace JT808.Protocol.MessageBody /// 查询类型为4 /// public List JT808_0x8606s { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0608 value = new JT808_0x0608(); @@ -124,7 +135,12 @@ namespace JT808.Protocol.MessageBody } } } - + /// + /// + /// + /// + /// + /// public JT808_0x0608 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0608 value = new JT808_0x0608(); @@ -189,6 +205,12 @@ namespace JT808.Protocol.MessageBody } return value; } + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0608 value, IJT808Config config) { writer.WriteByte(value.QueryType); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0700.cs b/src/JT808.Protocol/MessageBody/JT808_0x0700.cs index 3b13973..66b5fe6 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0700.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0700.cs @@ -14,7 +14,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x0700 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0700 + /// public override ushort MsgId { get; } = 0x0700; + /// + /// 行驶记录仪数据上传 + /// public override string Description => "行驶记录仪数据上传"; /// /// 应答流水号 @@ -24,9 +30,16 @@ namespace JT808.Protocol.MessageBody /// 命令字 /// public byte CommandId { get; set; } - + /// + /// 行车记录仪上行数据包 + /// public JT808CarDVRUpPackage JT808CarDVRUpPackage { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0700 value = new JT808_0x0700(); @@ -40,7 +53,12 @@ namespace JT808.Protocol.MessageBody writer.WriteEndObject(); writer.WriteEndObject(); } - + /// + /// + /// + /// + /// + /// public JT808_0x0700 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0700 value = new JT808_0x0700(); @@ -49,7 +67,12 @@ namespace JT808.Protocol.MessageBody value.JT808CarDVRUpPackage = JT808CarDVRSerializer.JT808CarDVRUpPackage.Deserialize(ref reader, config); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0700 value, IJT808Config config) { writer.WriteUInt16(value.ReplyMsgNum); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0701.cs b/src/JT808.Protocol/MessageBody/JT808_0x0701.cs index 6378621..9c05dce 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0701.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0701.cs @@ -13,21 +13,33 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x0701 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0701 + /// public override ushort MsgId { get; } = 0x0701; + /// + /// 电子运单上报 + /// public override string Description => "电子运单上报"; /// /// 电子运单长度 /// public uint ElectronicWaybillLength { get; set; } - + /// + /// 电子运单内容 + /// public byte[] ElectronicContent { get; set; } - /// /// 电子运单内容 /// 注意:需要具体的实现 /// public JT808_0x0701_CustomBodyBase ElectronicContentObj { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0701 value = new JT808_0x0701(); @@ -36,7 +48,12 @@ namespace JT808.Protocol.MessageBody value.ElectronicContent = reader.ReadArray((int)value.ElectronicWaybillLength).ToArray(); writer.WriteString($"电子运单", value.ElectronicContent.ToHexString()); } - + /// + /// + /// + /// + /// + /// public JT808_0x0701 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0701 value = new JT808_0x0701(); @@ -44,7 +61,12 @@ namespace JT808.Protocol.MessageBody value.ElectronicContent = reader.ReadArray((int)value.ElectronicWaybillLength).ToArray(); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0701 value, IJT808Config config) { writer.Skip(4, out int skipPosition); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0702.cs b/src/JT808.Protocol/MessageBody/JT808_0x0702.cs index 065fde2..19bf720 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0702.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0702.cs @@ -13,7 +13,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x0702 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze, IJT808_2019_Version { + /// + /// 0x0702 + /// public override ushort MsgId { get; } = 0x0702; + /// + /// Description + /// public override string Description => "驾驶员身份信息采集上报"; /// /// 状态 @@ -67,7 +73,12 @@ namespace JT808.Protocol.MessageBody /// 2019版本 /// public string DriverIdentityCard { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0702 value = new JT808_0x0702(); @@ -105,7 +116,12 @@ namespace JT808.Protocol.MessageBody } } } - + /// + /// + /// + /// + /// + /// public JT808_0x0702 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0702 value = new JT808_0x0702(); @@ -130,7 +146,12 @@ namespace JT808.Protocol.MessageBody } return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0702 value, IJT808Config config) { writer.WriteByte((byte)value.IC_Card_Status); @@ -142,13 +163,13 @@ namespace JT808.Protocol.MessageBody { writer.WriteByte((byte)value.DriverUserName.Length); writer.WriteString(value.DriverUserName); - writer.WriteString(value.QualificationCode.PadRight(20, '0')); + writer.WriteString(value.QualificationCode.PadRight(20, '0').ValiString(nameof(value.QualificationCode),20)); writer.WriteByte((byte)value.LicenseIssuing.Length); writer.WriteString(value.LicenseIssuing); writer.WriteDateTime4(value.CertificateExpiresDate); if (writer.Version == JT808Version.JTT2019) { - writer.WriteString(value.DriverIdentityCard.PadRight(20,'0')); + writer.WriteString(value.DriverIdentityCard.PadRight(20,'0').ValiString(nameof(value.DriverIdentityCard), 20)); } } } diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0704.cs b/src/JT808.Protocol/MessageBody/JT808_0x0704.cs index 2ca3ae9..632888a 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0704.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0704.cs @@ -13,7 +13,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x0704 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0704 + /// public override ushort MsgId { get; } = 0x0704; + /// + /// 定位数据批量上传 + /// public override string Description => "定位数据批量上传"; /// /// 数据项个数 @@ -38,7 +44,12 @@ namespace JT808.Protocol.MessageBody 正常位置批量汇报 = 0x00, 盲区补报 = 0x01 } - + /// + /// + /// + /// + /// + /// public JT808_0x0704 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0704 jT808_0X0704 = new JT808_0x0704(); @@ -62,7 +73,12 @@ namespace JT808.Protocol.MessageBody jT808_0X0704.Positions = jT808_0X0200s; return jT808_0X0704; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0704 value, IJT808Config config) { writer.WriteUInt16(value.Count); @@ -82,7 +98,12 @@ namespace JT808.Protocol.MessageBody } } } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0704 jT808_0X0704 = new JT808_0x0704(); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0705.cs b/src/JT808.Protocol/MessageBody/JT808_0x0705.cs index 2021da9..2b6cfa4 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0705.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0705.cs @@ -16,7 +16,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x0705 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze, IJT808_2019_Version { + /// + /// 0x0705 + /// public override ushort MsgId { get; } = 0x0705; + /// + /// CAN总线数据上传 + /// public override string Description => "CAN总线数据上传"; /// /// 数据项个数 @@ -32,7 +38,12 @@ namespace JT808.Protocol.MessageBody /// CAN 总线数据项 /// public List CanItems { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0705 value = new JT808_0x0705(); @@ -58,7 +69,12 @@ namespace JT808.Protocol.MessageBody } writer.WriteEndArray(); } - + /// + /// + /// + /// + /// + /// public JT808_0x0705 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0705 value = new JT808_0x0705(); @@ -78,7 +94,12 @@ namespace JT808.Protocol.MessageBody } return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0705 value, IJT808Config config) { if (value.CanItems != null && value.CanItems.Count > 0) diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0800.cs b/src/JT808.Protocol/MessageBody/JT808_0x0800.cs index 0df05c3..1a3cbcb 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0800.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0800.cs @@ -13,7 +13,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x0800 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0800 + /// public override ushort MsgId { get; } = 0x0800; + /// + /// 多媒体事件信息上传 + /// public override string Description => "多媒体事件信息上传"; /// /// 多媒体数据 ID @@ -48,7 +54,12 @@ namespace JT808.Protocol.MessageBody /// 通道 ID /// public byte ChannelId { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0800 value = new JT808_0x0800(); @@ -63,7 +74,12 @@ namespace JT808.Protocol.MessageBody value.ChannelId = reader.ReadByte(); writer.WriteNumber($"[{value.ChannelId.ReadNumber()}]通道ID", value.ChannelId); } - + /// + /// + /// + /// + /// + /// public JT808_0x0800 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0800 value = new JT808_0x0800(); @@ -74,7 +90,12 @@ namespace JT808.Protocol.MessageBody value.ChannelId = reader.ReadByte(); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0800 value, IJT808Config config) { writer.WriteUInt32(value.MultimediaId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0801.cs b/src/JT808.Protocol/MessageBody/JT808_0x0801.cs index bddc5fc..0150483 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0801.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0801.cs @@ -13,7 +13,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x0801 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze, IJT808_2019_Version { + /// + /// 0x0801 + /// public override ushort MsgId { get; } = 0x0801; + /// + /// 多媒体数据上传 + /// public override string Description => "多媒体数据上传"; /// /// 多媒体 ID @@ -48,7 +54,12 @@ namespace JT808.Protocol.MessageBody /// 多媒体数据包 /// public byte[] MultimediaDataPackage { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0801 value = new JT808_0x0801(); @@ -69,7 +80,12 @@ namespace JT808.Protocol.MessageBody value.MultimediaDataPackage = reader.ReadContent().ToArray(); writer.WriteString($"多媒体数据包", value.MultimediaDataPackage.ToHexString()); } - + /// + /// + /// + /// + /// + /// public JT808_0x0801 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0801 value = new JT808_0x0801(); @@ -83,7 +99,12 @@ namespace JT808.Protocol.MessageBody value.MultimediaDataPackage = reader.ReadContent().ToArray(); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0801 value, IJT808Config config) { writer.WriteUInt32(value.MultimediaId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0802.cs b/src/JT808.Protocol/MessageBody/JT808_0x0802.cs index 017d148..180b93f 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0802.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0802.cs @@ -15,7 +15,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x0802 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze, IJT808_2019_Version { + /// + /// 0x0802 + /// public override ushort MsgId { get; } = 0x0802; + /// + /// 存储多媒体数据检索应答 + /// public override string Description => "存储多媒体数据检索应答"; /// /// 应答流水号 @@ -31,7 +37,12 @@ namespace JT808.Protocol.MessageBody /// 检索项集合 /// public List MultimediaSearchItems { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0802 value = new JT808_0x0802(); @@ -60,7 +71,12 @@ namespace JT808.Protocol.MessageBody } writer.WriteEndArray(); } - + /// + /// + /// + /// + /// + /// public JT808_0x0802 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0802 value = new JT808_0x0802(); @@ -80,7 +96,12 @@ namespace JT808.Protocol.MessageBody } return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0802 value, IJT808Config config) { writer.WriteUInt16(value.MsgNum); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0805.cs b/src/JT808.Protocol/MessageBody/JT808_0x0805.cs index 96c8969..c92b149 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0805.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0805.cs @@ -13,7 +13,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x0805 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze, IJT808_2019_Version { + /// + /// 0x0805 + /// public override ushort MsgId { get; } = 0x0805; + /// + /// 摄像头立即拍摄命令应答 + /// public override string Description => "摄像头立即拍摄命令应答"; /// /// 应答流水号 @@ -34,7 +40,12 @@ namespace JT808.Protocol.MessageBody /// 多媒体ID列表 /// public List MultimediaIds { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0805 value = new JT808_0x0805(); @@ -67,7 +78,12 @@ namespace JT808.Protocol.MessageBody writer.WriteEndArray(); } } - + /// + /// + /// + /// + /// + /// public JT808_0x0805 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0805 value = new JT808_0x0805(); @@ -85,7 +101,12 @@ namespace JT808.Protocol.MessageBody } return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0805 value, IJT808Config config) { writer.WriteUInt16(value.ReplyMsgNum); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0900.cs b/src/JT808.Protocol/MessageBody/JT808_0x0900.cs index 3b69391..901130c 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0900.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0900.cs @@ -12,7 +12,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x0900 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze, IJT808_2019_Version { + /// + /// 0x0900 + /// public override ushort MsgId { get; } = 0x0900; + /// + /// 数据上行透传 + /// public override string Description => "数据上行透传"; /// /// 透传消息类型 @@ -28,7 +34,12 @@ namespace JT808.Protocol.MessageBody /// 透传消息内容 /// public JT808_0x0900_BodyBase JT808_0x0900_BodyBase { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0900 value = new JT808_0x0900(); @@ -53,7 +64,12 @@ namespace JT808.Protocol.MessageBody writer.WriteString("透传消息内容", value.PassthroughData.ToHexString()); } } - + /// + /// + /// + /// + /// + /// public JT808_0x0900 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0900 value = new JT808_0x0900(); @@ -68,7 +84,12 @@ namespace JT808.Protocol.MessageBody } return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0900 value, IJT808Config config) { writer.WriteByte(value.PassthroughType); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0901.cs b/src/JT808.Protocol/MessageBody/JT808_0x0901.cs index 6138813..90c18d0 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0901.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0901.cs @@ -13,7 +13,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x0901 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0901 + /// public override ushort MsgId { get; } = 0x0901; + /// + /// 数据压缩上报 + /// public override string Description => "数据压缩上报"; /// /// 未压缩消息长度 @@ -25,7 +31,12 @@ namespace JT808.Protocol.MessageBody /// 可实现 refJT808.Protocol.IJT808ICompress 自定义压缩算法 /// public byte[] UnCompressMessage { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0901 value = new JT808_0x0901(); @@ -38,7 +49,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{value.UnCompressMessageLength.ReadNumber()}]未压缩消息长度", value.UnCompressMessageLength); writer.WriteString("未压缩消息体", value.UnCompressMessage.ToHexString()); } - + /// + /// + /// + /// + /// + /// public JT808_0x0901 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0901 value = new JT808_0x0901(); @@ -48,7 +64,12 @@ namespace JT808.Protocol.MessageBody value.UnCompressMessageLength = (uint)value.UnCompressMessage.Length; return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0901 value, IJT808Config config) { var data = config.Compress.Compress(value.UnCompressMessage); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0A00.cs b/src/JT808.Protocol/MessageBody/JT808_0x0A00.cs index e63d337..0e505df 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0A00.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0A00.cs @@ -13,7 +13,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x0A00 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0A00 + /// public override ushort MsgId { get; } = 0x0A00; + /// + /// 终端RSA公钥 + /// public override string Description => "终端RSA公钥"; /// /// e @@ -25,7 +31,12 @@ namespace JT808.Protocol.MessageBody /// RSA 公钥{e,n}中的 n /// public byte[] N { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x0A00 value = new JT808_0x0A00(); @@ -38,7 +49,12 @@ namespace JT808.Protocol.MessageBody throw new JT808Exception(Enums.JT808ErrorCode.NotEnoughLength, $"{nameof(value.N)}->128"); } } - + /// + /// + /// + /// + /// + /// public JT808_0x0A00 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x0A00 value = new JT808_0x0A00 @@ -52,7 +68,12 @@ namespace JT808.Protocol.MessageBody } return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0A00 value, IJT808Config config) { writer.WriteUInt32(value.E); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8001.cs b/src/JT808.Protocol/MessageBody/JT808_0x8001.cs index f8ee148..60e77da 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8001.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8001.cs @@ -12,7 +12,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8001 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x8001 + /// public override ushort MsgId { get; } = 0x8001; + /// + /// 平台通用应答 + /// public override string Description => "平台通用应答"; /// /// 应答消息流水号 @@ -24,10 +30,16 @@ namespace JT808.Protocol.MessageBody /// public ushort AckMsgId { get; set; } /// - /// + /// 返回结果 + /// /// public JT808PlatformResult JT808PlatformResult { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8001 value = new JT808_0x8001(); @@ -38,7 +50,12 @@ namespace JT808.Protocol.MessageBody value.JT808PlatformResult = (JT808PlatformResult)reader.ReadByte(); writer.WriteNumber($"[{((byte)value.JT808PlatformResult).ReadNumber()}]结果-{value.JT808PlatformResult.ToString()}", (byte)value.JT808PlatformResult); } - + /// + /// + /// + /// + /// + /// public JT808_0x8001 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8001 value = new JT808_0x8001(); @@ -47,7 +64,12 @@ namespace JT808.Protocol.MessageBody value.JT808PlatformResult = (JT808PlatformResult)reader.ReadByte(); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8001 value, IJT808Config config) { writer.WriteUInt16(value.MsgNum); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8003.cs b/src/JT808.Protocol/MessageBody/JT808_0x8003.cs index 042681d..a2360b4 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8003.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8003.cs @@ -13,10 +13,16 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8003 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze, IJT808_2019_Version { + /// + /// 0x8003 + /// public override ushort MsgId { get; } = 0x8003; + /// + /// 补传分包请求 + /// public override string Description => "补传分包请求"; /// - /// 原始消息流水号 + /// 原始消息流水号 /// 对应要求补传的原始消息第一包的消息流水号 /// public ushort OriginalMsgNum { get; set; } @@ -32,7 +38,12 @@ namespace JT808.Protocol.MessageBody /// 重传包序号顺序排列，如“包 ID1 包 ID2......包 IDn”。 /// public byte[] AgainPackageData { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8003 value = new JT808_0x8003(); @@ -57,7 +68,12 @@ namespace JT808.Protocol.MessageBody } writer.WriteEndArray(); } - + /// + /// + /// + /// + /// + /// public JT808_0x8003 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8003 value = new JT808_0x8003(); @@ -73,7 +89,12 @@ namespace JT808.Protocol.MessageBody value.AgainPackageData = reader.ReadArray(value.AgainPackageCount * 2).ToArray(); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8003 value, IJT808Config config) { writer.WriteUInt16(value.OriginalMsgNum); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8004.cs b/src/JT808.Protocol/MessageBody/JT808_0x8004.cs index 21b1178..b750ecc 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8004.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8004.cs @@ -12,24 +12,45 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8004 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze, IJT808_2019_Version { + /// + /// 0x8004 + /// public override ushort MsgId { get; } = 0x8004; + /// + /// 查询服务器时间应答 + /// public override string Description => "查询服务器时间应答"; public DateTime Time { get; set; } = DateTime.Now; - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { var datetime= reader.ReadDateTime6(); writer.WriteString($"[{ datetime.ToString("yyMMddHHmmss")}]查询服务器时间应答", datetime.ToString("yyyy-MM-dd HH:mm:ss")); } - + /// + /// + /// + /// + /// + /// public JT808_0x8004 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8004 value = new JT808_0x8004(); value.Time = reader.ReadDateTime6(); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8004 value, IJT808Config config) { writer.WriteDateTime6(value.Time); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8100.cs b/src/JT808.Protocol/MessageBody/JT808_0x8100.cs index d6502f7..39e7739 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8100.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8100.cs @@ -12,7 +12,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8100 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x8100 + /// public override ushort MsgId { get; } = 0x8100; + /// + /// 终端注册应答 + /// public override string Description => "终端注册应答"; /// /// 应答流水号 @@ -30,7 +36,12 @@ namespace JT808.Protocol.MessageBody /// 只有在成功后才有该字段 /// public string Code { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8100 value = new JT808_0x8100(); @@ -46,7 +57,12 @@ namespace JT808.Protocol.MessageBody writer.WriteString($"[{codeBuffer.ToHexString()}]鉴权码", value.Code); } } - + /// + /// + /// + /// + /// + /// public JT808_0x8100 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8100 value = new JT808_0x8100(); @@ -59,7 +75,12 @@ namespace JT808.Protocol.MessageBody } return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8100 value, IJT808Config config) { writer.WriteUInt16(value.AckMsgNum); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103.cs index 891278f..b59e0a3 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103.cs @@ -15,7 +15,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x8103 + /// public override ushort MsgId { get; } = 0x8103; + /// + /// 设置终端参数 + /// public override string Description => "设置终端参数"; /// /// 参数总数 @@ -36,9 +42,16 @@ namespace JT808.Protocol.MessageBody /// 参数列表 /// public List ParamList { get; set; } - + /// + /// 自定义参数列表 + /// public List CustomParamList { get; set; } - + /// + /// + /// + /// + /// + /// public JT808_0x8103 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103 value = new JT808_0x8103 @@ -70,7 +83,12 @@ namespace JT808.Protocol.MessageBody } return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103 value, IJT808Config config) { writer.WriteByte(value.ParamCount); @@ -90,7 +108,12 @@ namespace JT808.Protocol.MessageBody } catch (Exception ex) { } } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { var paramCount = reader.ReadByte();//参数总数 diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0001.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0001.cs index 619d63f..ed85f40 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0001.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0001.cs @@ -13,16 +13,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0001 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0001 + /// public override uint ParamId { get; set; } = 0x0001; /// /// 数据 长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 终端心跳发送间隔，单位为秒（s） /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0001 jT808_0x8103_0x0001 = new JT808_0x8103_0x0001(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0001.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0001.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0001.ParamValue.ReadNumber()}]参数值[终端心跳发送间隔s]", jT808_0x8103_0x0001.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0001 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0001 jT808_0x8103_0x0001 = new JT808_0x8103_0x0001(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0001.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0001; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0001 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0002.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0002.cs index eb77fc5..6a148ca 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0002.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0002.cs @@ -13,16 +13,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0002 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0002 + /// public override uint ParamId { get; set; } = 0x0002; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// TCP 消息应答超时时间，单位为秒（s） /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0002 jT808_0x8103_0x0002 = new JT808_0x8103_0x0002(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0002.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0002.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0002.ParamValue.ReadNumber()}]参数值[TCP消息应答超时时间s]", jT808_0x8103_0x0002.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0002 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0002 jT808_0x8103_0x0002 = new JT808_0x8103_0x0002(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0002.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0002; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0002 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0003.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0003.cs index 87b5bc4..2d44b3b 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0003.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0003.cs @@ -13,16 +13,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0003 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0003 + /// public override uint ParamId { get; set; } = 0x0003; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// TCP 消息重传次数 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0003 jT808_0x8103_0x0003 = new JT808_0x8103_0x0003(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0003.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0003.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0003.ParamValue.ReadNumber()}]参数值[TCP消息重传次数]", jT808_0x8103_0x0003.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0003 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0003 jT808_0x8103_0x0003 = new JT808_0x8103_0x0003(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0003.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0003; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0003 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0004.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0004.cs index 9e4df08..88586aa 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0004.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0004.cs @@ -13,16 +13,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0004 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0004 + /// public override uint ParamId { get; set; } = 0x0004; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// UDP 消息应答超时时间，单位为秒（s） /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0004 jT808_0x8103_0x0004 = new JT808_0x8103_0x0004(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0004.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0004.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0004.ParamValue.ReadNumber()}]参数值[UDP消息应答超时时间s]", jT808_0x8103_0x0004.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0004 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0004 jT808_0x8103_0x0004 = new JT808_0x8103_0x0004(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0004.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0004; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0004 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0005.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0005.cs index 337aae6..710d239 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0005.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0005.cs @@ -13,16 +13,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0005 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0005 + /// public override uint ParamId { get; set; } = 0x0005; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// UDP 消息重传次数 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0005 jT808_0x8103_0x0005 = new JT808_0x8103_0x0005(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0005.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0005.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0005.ParamValue.ReadNumber()}]参数值[UDP消息重传次数]", jT808_0x8103_0x0005.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0005 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0005 jT808_0x8103_0x0005 = new JT808_0x8103_0x0005(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0005.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0005; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0005 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0006.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0006.cs index d2657e8..d19aeaf 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0006.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0006.cs @@ -13,16 +13,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0006 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0006 + /// public override uint ParamId { get; set; } = 0x0006; /// - /// 数据 长度 + /// 数据长度 + /// byte 4 /// public override byte ParamLength { get; set; } = 4; /// /// SMS 消息应答超时时间，单位为秒（s） /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0006 jT808_0x8103_0x0006 = new JT808_0x8103_0x0006(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0006.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0006.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0006.ParamValue.ReadNumber()}]参数值[SMS消息应答超时时间s]", jT808_0x8103_0x0006.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0006 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0006 jT808_0x8103_0x0006 = new JT808_0x8103_0x0006(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0006.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0006; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0006 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0007.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0007.cs index 28afe34..6065490 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0007.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0007.cs @@ -13,16 +13,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0007 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0007 + /// public override uint ParamId { get; set; } = 0x0007; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// SMS 消息重传次数 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0007 jT808_0x8103_0x0007 = new JT808_0x8103_0x0007(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0007.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0007.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0007.ParamValue.ReadNumber()}]参数值[SMS消息重传次数]", jT808_0x8103_0x0007.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0007 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0007 jT808_0x8103_0x0007 = new JT808_0x8103_0x0007(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0007.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0007; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0007 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0010.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0010.cs index 24cdb6a..9c306c2 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0010.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0010.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0010 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0010 + /// public override uint ParamId { get; set; } = 0x0010; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// public override byte ParamLength { get; set; } /// /// 主服务器 APN，无线通信拨号访问点。若网络制式为 CDMA，则该处为PPP 拨号号码 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0010 jT808_0x8103_0x0010 = new JT808_0x8103_0x0010(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0010.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0010.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[主服务器APN]", jT808_0x8103_0x0010.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0010 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0010 jT808_0x8103_0x0010 = new JT808_0x8103_0x0010(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0010.ParamValue = reader.ReadString(jT808_0x8103_0x0010.ParamLength); return jT808_0x8103_0x0010; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0010 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0011.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0011.cs index 58e99b0..14583c0 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0011.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0011.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0011 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0011 + /// public override uint ParamId { get; set; } = 0x0011; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// public override byte ParamLength { get; set; } /// /// 主服务器无线通信拨号用户名 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0011 jT808_0x8103_0x0011 = new JT808_0x8103_0x0011(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0011.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0011.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[主服务器无线通信拨号用户名]", jT808_0x8103_0x0011.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0011 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0011 jT808_0x8103_0x0011 = new JT808_0x8103_0x0011(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0011.ParamValue = reader.ReadString(jT808_0x8103_0x0011.ParamLength); return jT808_0x8103_0x0011; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0011 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0012.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0012.cs index 8dcb9b2..b5d9dc2 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0012.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0012.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0012 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0012 + /// public override uint ParamId { get; set; } = 0x0012; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// public override byte ParamLength { get; set; } /// /// 主服务器无线通信拨号密码 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0012 jT808_0x8103_0x0012 = new JT808_0x8103_0x0012(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0012.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0012.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[主服务器无线通信拨号密码]", jT808_0x8103_0x0012.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0012 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0012 jT808_0x8103_0x0012 = new JT808_0x8103_0x0012(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0012.ParamValue = reader.ReadString(jT808_0x8103_0x0012.ParamLength); return jT808_0x8103_0x0012; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0012 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0013.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0013.cs index 7f1659b..0c11912 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0013.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0013.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0013 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0013 + /// public override uint ParamId { get; set; } = 0x0013; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// public override byte ParamLength { get; set; } /// /// 主服务器地址,IP 或域名 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0013 jT808_0x8103_0x0013 = new JT808_0x8103_0x0013(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0013.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0013.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[主服务器地址IP]", jT808_0x8103_0x0013.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0013 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0013 jT808_0x8103_0x0013 = new JT808_0x8103_0x0013(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0013.ParamValue = reader.ReadString(jT808_0x8103_0x0013.ParamLength); return jT808_0x8103_0x0013; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0013 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0014.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0014.cs index 3f8995c..2969189 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0014.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0014.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0014 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0014 + /// public override uint ParamId { get; set; } = 0x0014; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// public override byte ParamLength { get; set; } /// /// 备份服务器 APN，无线通信拨号访问点 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0014 jT808_0x8103_0x0014 = new JT808_0x8103_0x0014(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0014.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0014.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[备份服务器APN]", jT808_0x8103_0x0014.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0014 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0014 jT808_0x8103_0x0014 = new JT808_0x8103_0x0014(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0014.ParamValue = reader.ReadString(jT808_0x8103_0x0014.ParamLength); return jT808_0x8103_0x0014; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0014 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0015.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0015.cs index 406d3d9..45510bf 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0015.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0015.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0015 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0015 + /// public override uint ParamId { get; set; } = 0x0015; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// public override byte ParamLength { get; set; } /// /// 备份服务器无线通信拨号用户名 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0015 jT808_0x8103_0x0015 = new JT808_0x8103_0x0015(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0015.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0015.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[备份服务器无线通信拨号用户名]", jT808_0x8103_0x0015.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0015 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0015 jT808_0x8103_0x0015 = new JT808_0x8103_0x0015(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0015.ParamValue = reader.ReadString(jT808_0x8103_0x0015.ParamLength); return jT808_0x8103_0x0015; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0015 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0016.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0016.cs index 7180873..96428b1 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0016.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0016.cs @@ -12,6 +12,9 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0016 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0016 + /// public override uint ParamId { get; set; } = 0x0016; /// /// 数据 长度 @@ -21,7 +24,12 @@ namespace JT808.Protocol.MessageBody /// 备份服务器无线通信拨号密码 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0016 jT808_0x8103_0x0016 = new JT808_0x8103_0x0016(); @@ -33,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0016.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0016.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[备份服务器无线通信拨号密码]", jT808_0x8103_0x0016.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0016 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0016 jT808_0x8103_0x0016 = new JT808_0x8103_0x0016(); @@ -42,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0016.ParamValue = reader.ReadString(jT808_0x8103_0x0016.ParamLength); return jT808_0x8103_0x0016; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0016 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0017.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0017.cs index eb4e48c..16fc3af 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0017.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0017.cs @@ -12,6 +12,9 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0017 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0017 + /// public override uint ParamId { get; set; } = 0x0017; /// /// 数据 长度 @@ -21,7 +24,12 @@ namespace JT808.Protocol.MessageBody /// 备份服务器地址,IP 或域名 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0017 jT808_0x8103_0x0017 = new JT808_0x8103_0x0017(); @@ -33,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0017.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0017.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[备份服务器地址IP]", jT808_0x8103_0x0017.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0017 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0017 jT808_0x8103_0x0017 = new JT808_0x8103_0x0017(); @@ -42,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0017.ParamValue = reader.ReadString(jT808_0x8103_0x0017.ParamLength); return jT808_0x8103_0x0017; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0017 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0018.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0018.cs index 14994e8..a10a7be 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0018.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0018.cs @@ -14,16 +14,25 @@ namespace JT808.Protocol.MessageBody [Obsolete("2019版本已作为保留")] public class JT808_0x8103_0x0018 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808_2019_Version, IJT808Analyze { + /// + /// 0x0018 + /// public override uint ParamId { get; set; } = 0x0018; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// ///服务器 TCP 端口 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0018 value = new JT808_0x8103_0x0018(); @@ -34,7 +43,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{value.ParamLength.ReadNumber()}]参数长度", value.ParamLength); writer.WriteNumber($"[{ value.ParamValue.ReadNumber()}]参数值[服务器TCP端口]", value.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0018 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0018 value = new JT808_0x8103_0x0018(); @@ -43,7 +57,12 @@ namespace JT808.Protocol.MessageBody value.ParamValue = reader.ReadUInt32(); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0018 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0019.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0019.cs index bd4cd73..858239e 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0019.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0019.cs @@ -1,5 +1,4 @@ - -using JT808.Protocol.Extensions; +using JT808.Protocol.Extensions; using JT808.Protocol.Formatters; using JT808.Protocol.Interfaces; using JT808.Protocol.MessagePack; @@ -11,19 +10,27 @@ namespace JT808.Protocol.MessageBody /// /// 服务器 UDP 端口 /// - [Obsolete("2019版本已作为保留")] public class JT808_0x8103_0x0019 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808_2019_Version, IJT808Analyze { + /// + /// 0x0019 + /// public override uint ParamId { get; set; } = 0x0019; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// public override byte ParamLength { get; set; } = 4; /// ///服务器 UDP 端口 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0019 value = new JT808_0x8103_0x0019(); @@ -34,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{value.ParamLength.ReadNumber()}]参数长度", value.ParamLength); writer.WriteNumber($"[{ value.ParamValue.ReadNumber()}]参数值[服务器UDP端口]", value.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0019 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0019 value = new JT808_0x8103_0x0019(); @@ -43,7 +55,12 @@ namespace JT808.Protocol.MessageBody value.ParamValue = reader.ReadUInt32(); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0019 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001A.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001A.cs index 57d11b4..f0767da 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001A.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001A.cs @@ -12,16 +12,24 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x001A : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x001A + /// public override uint ParamId { get; set; } = 0x001A; /// - /// 数据 长度 + /// 数据长度 /// public override byte ParamLength { get; set; } /// /// 道路运输证 IC 卡认证主服务器 IP 地址或域名 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x001A jT808_0x8103_0x001A = new JT808_0x8103_0x001A(); @@ -33,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x001A.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x001A.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[道路运输证IC卡认证主服务器 IP]", jT808_0x8103_0x001A.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x001A Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x001A jT808_0x8103_0x001A = new JT808_0x8103_0x001A(); @@ -42,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x001A.ParamValue = reader.ReadString(jT808_0x8103_0x001A.ParamLength); return jT808_0x8103_0x001A; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x001A value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001B.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001B.cs index 7d236da..bdcf2be 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001B.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001B.cs @@ -1,5 +1,4 @@ using System.Text.Json; - using JT808.Protocol.Extensions; using JT808.Protocol.Formatters; using JT808.Protocol.Interfaces; @@ -12,16 +11,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x001B : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x001B + /// public override uint ParamId { get; set; } = 0x001B; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// ///道路运输证 IC 卡认证主服务器 TCP 端口 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x001B jT808_0x8103_0x001B = new JT808_0x8103_0x001B(); @@ -32,7 +40,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x001B.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x001B.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x001B.ParamValue.ReadNumber()}]参数值[道路运输证IC卡认证主服务器TCP端口]", jT808_0x8103_0x001B.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x001B Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x001B jT808_0x8103_0x001B = new JT808_0x8103_0x001B(); @@ -41,7 +54,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x001B.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x001B; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x001B value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001C.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001C.cs index 6620a24..00c6fb9 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001C.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001C.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x001C : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x001C + /// public override uint ParamId { get; set; } = 0x001C; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// ///道路运输证 IC 卡认证主服务器 UDP 端口 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x001C jT808_0x8103_0x001C = new JT808_0x8103_0x001C(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x001C.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x001C.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x001C.ParamValue.ReadNumber()}]参数值[道路运输证IC卡认证主服务器UDP端口]", jT808_0x8103_0x001C.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x001C Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x001C jT808_0x8103_0x001C = new JT808_0x8103_0x001C(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x001C.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x001C; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x001C value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001D.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001D.cs index dfebc6c..af92439 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001D.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001D.cs @@ -12,16 +12,24 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x001D : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x001D + /// public override uint ParamId { get; set; } = 0x001D; /// - /// 数据 长度 + /// 数据长度 /// public override byte ParamLength { get; set; } /// /// 道路运输证 IC 卡认证备份服务器 IP 地址或域名，端口同主服务器 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x001D jT808_0x8103_0x001D = new JT808_0x8103_0x001D(); @@ -33,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x001D.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x001D.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[道路运输证IC卡认证备份服务器IP]", jT808_0x8103_0x001D.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x001D Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x001D jT808_0x8103_0x001D = new JT808_0x8103_0x001D(); @@ -42,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x001D.ParamValue = reader.ReadString(jT808_0x8103_0x001D.ParamLength); return jT808_0x8103_0x001D; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x001D value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0020.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0020.cs index 04ca6ce..9b4b20c 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0020.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0020.cs @@ -12,16 +12,28 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0020 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0020 + /// public override uint ParamId { get; set; } = 0x0020; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// - /// 位置汇报策略，0：定时汇报；1：定距汇报；2：定时和定距汇报 + /// 位置汇报策略， + /// 0：定时汇报； + /// 1：定距汇报； + /// 2：定时和定距汇报 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0020 jT808_0x8103_0x0020 = new JT808_0x8103_0x0020(); @@ -32,7 +44,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0020.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0020.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0020.ParamValue.ReadNumber()}]参数值[位置汇报策略，0：定时汇报；1：定距汇报；2：定时和定距汇报]", jT808_0x8103_0x0020.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0020 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0020 jT808_0x8103_0x0020 = new JT808_0x8103_0x0020(); @@ -41,7 +58,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0020.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0020; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0020 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0021.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0021.cs index b35837e..112d8ab 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0021.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0021.cs @@ -12,16 +12,27 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0021 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0021 + /// public override uint ParamId { get; set; } = 0x0021; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// - /// 位置汇报方案，0：根据 ACC 状态； 1：根据登录状态和 ACC 状态，先判断登录状态，若登录再根据 ACC 状态 + /// 位置汇报方案， + /// 0：根据 ACC 状态； + /// 1：根据登录状态和 ACC 状态，先判断登录状态，若登录再根据 ACC 状态 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0021 jT808_0x8103_0x0021 = new JT808_0x8103_0x0021(); @@ -32,7 +43,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0021.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0021.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0021.ParamValue.ReadNumber()}]参数值[位置汇报方案，0：根据 ACC 状态； 1：根据登录状态和 ACC 状态]", jT808_0x8103_0x0021.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0021 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0021 jT808_0x8103_0x0021 = new JT808_0x8103_0x0021(); @@ -41,7 +57,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0021.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0021; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0021 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0022.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0022.cs index ec5e0eb..37d3fae 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0022.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0022.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0022 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0022 + /// public override uint ParamId { get; set; } = 0x0022; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 驾驶员未登录汇报时间间隔，单位为秒（s），>0 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0022 jT808_0x8103_0x0022 = new JT808_0x8103_0x0022(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0022.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0022.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0022.ParamValue.ReadNumber()}]参数值[驾驶员未登录汇报时间间隔s]", jT808_0x8103_0x0022.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0022 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0022 jT808_0x8103_0x0022 = new JT808_0x8103_0x0022(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0022.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0022; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0022 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0023.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0023.cs index ab178b0..38d3b39 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0023.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0023.cs @@ -13,16 +13,26 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0023 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808_2019_Version, IJT808Analyze { + /// + /// 0x0023 + /// public override uint ParamId { get; set; } = 0x0023; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// public override byte ParamLength { get; set; } /// - /// + /// 参数值 + /// 从服务器APN /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0023 value = new JT808_0x8103_0x0023(); @@ -34,7 +44,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{value.ParamLength.ReadNumber()}]参数长度", value.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[从服务器APN]", value.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0023 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0023 value = new JT808_0x8103_0x0023(); @@ -43,7 +58,12 @@ namespace JT808.Protocol.MessageBody value.ParamValue = reader.ReadString(value.ParamLength); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0023 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0024.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0024.cs index 25bedfd..aba6f24 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0024.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0024.cs @@ -13,16 +13,26 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0024 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808_2019_Version, IJT808Analyze { + /// + /// 0x0024 + /// public override uint ParamId { get; set; } = 0x0024; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// public override byte ParamLength { get; set; } /// - /// + /// 参数值 + /// 从服务器无线通信拨号用户名 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0024 jT808_0x8103_0x0024 = new JT808_0x8103_0x0024(); @@ -34,7 +44,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0024.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0024.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[从服务器无线通信拨号用户名]", jT808_0x8103_0x0024.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0024 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0024 jT808_0x8103_0x0024 = new JT808_0x8103_0x0024(); @@ -43,7 +58,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0024.ParamValue = reader.ReadString(jT808_0x8103_0x0024.ParamLength); return jT808_0x8103_0x0024; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0024 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0025.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0025.cs index bffbb1a..84c1ab5 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0025.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0025.cs @@ -13,16 +13,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0025 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808_2019_Version, IJT808Analyze { + /// + /// 0x0025 + /// public override uint ParamId { get; set; } = 0x0025; /// /// 数据 长度 /// public override byte ParamLength { get; set; } /// - /// + /// 参数值 + /// 从服务器无线通信拨号密码 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0025 jT808_0x8103_0x0025 = new JT808_0x8103_0x0025(); @@ -34,7 +43,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0025.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0025.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[从服务器无线通信拨号密码]", jT808_0x8103_0x0025.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0025 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0025 jT808_0x8103_0x0025 = new JT808_0x8103_0x0025(); @@ -43,7 +57,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0025.ParamValue = reader.ReadString(jT808_0x8103_0x0025.ParamLength); return jT808_0x8103_0x0025; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0025 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0026.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0026.cs index 08ce8d3..0bf38d7 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0026.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0026.cs @@ -13,16 +13,26 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0026 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808_2019_Version, IJT808Analyze { + /// + /// 0x0026 + /// public override uint ParamId { get; set; } = 0x0026; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// public override byte ParamLength { get; set; } /// - /// + /// 参数值 + /// 从服务器备份地址IP /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0026 value = new JT808_0x8103_0x0026(); @@ -34,7 +44,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{value.ParamLength.ReadNumber()}]参数长度", value.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[从服务器备份地址IP]", value.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0026 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0026 value = new JT808_0x8103_0x0026(); @@ -43,7 +58,12 @@ namespace JT808.Protocol.MessageBody value.ParamValue = reader.ReadString(value.ParamLength); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0026 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0027.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0027.cs index a1148a8..21cc2ce 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0027.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0027.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0027 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0027 + /// public override uint ParamId { get; set; } = 0x0027; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 休眠时汇报时间间隔，单位为秒（s），>0 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0027 jT808_0x8103_0x0027 = new JT808_0x8103_0x0027(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0027.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0027.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0027.ParamValue.ReadNumber()}]参数值[休眠时汇报时间间隔s]", jT808_0x8103_0x0027.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0027 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0027 jT808_0x8103_0x0027 = new JT808_0x8103_0x0027(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0027.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0027; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0027 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0028.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0028.cs index 565aceb..5e8600a 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0028.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0028.cs @@ -12,16 +12,26 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0028 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0028 + /// public override uint ParamId { get; set; } = 0x0028; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// + /// 参数值 /// 紧急报警时汇报时间间隔，单位为秒（s），>0 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0028 jT808_0x8103_0x0028 = new JT808_0x8103_0x0028(); @@ -32,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0028.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0028.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0028.ParamValue.ReadNumber()}]参数值[紧急报警时汇报时间间隔s]", jT808_0x8103_0x0028.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0028 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0028 jT808_0x8103_0x0028 = new JT808_0x8103_0x0028(); @@ -41,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0028.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0028; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0028 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0029.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0029.cs index 15c290b..baf54fb 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0029.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0029.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0029 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0029 + /// public override uint ParamId { get; set; } = 0x0029; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 缺省时间汇报间隔，单位为秒（s），>0 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0029 jT808_0x8103_0x0029 = new JT808_0x8103_0x0029(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0029.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0029.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0029.ParamValue.ReadNumber()}]参数值[缺省时间汇报间隔s]", jT808_0x8103_0x0029.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0029 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0029 jT808_0x8103_0x0029 = new JT808_0x8103_0x0029(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0029.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0029; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0029 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002C.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002C.cs index ebad832..a03d0fc 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002C.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002C.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x002C : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x002C + /// public override uint ParamId { get; set; } = 0x002C; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 缺省距离汇报间隔，单位为米（m），>0 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x002C jT808_0x8103_0x002C = new JT808_0x8103_0x002C(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x002C.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x002C.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x002C.ParamValue.ReadNumber()}]参数值[缺省距离汇报间隔m]", jT808_0x8103_0x002C.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x002C Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x002C jT808_0x8103_0x002C = new JT808_0x8103_0x002C(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x002C.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x002C; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x002C value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002D.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002D.cs index bb44f92..e356fdf 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002D.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002D.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x002D : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x002D + /// public override uint ParamId { get; set; } = 0x002D; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 驾驶员未登录汇报距离间隔，单位为米（m），>0 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x002D jT808_0x8103_0x002D = new JT808_0x8103_0x002D(); @@ -32,6 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x002D.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x002D.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x002D.ParamValue.ReadNumber()}]参数值[驾驶员未登录汇报距离间隔m]", jT808_0x8103_0x002D.ParamValue); } + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x002D Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x002D jT808_0x8103_0x002D = new JT808_0x8103_0x002D(); @@ -40,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x002D.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x002D; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x002D value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002E.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002E.cs index 4325467..fda59ed 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002E.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002E.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x002E : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x002E + /// public override uint ParamId { get; set; } = 0x002E; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 休眠时汇报距离间隔，单位为米（m），>0 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x002E jT808_0x8103_0x002E = new JT808_0x8103_0x002E(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x002E.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x002E.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x002E.ParamValue.ReadNumber()}]参数值[休眠时汇报距离间隔m]", jT808_0x8103_0x002E.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x002E Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x002E jT808_0x8103_0x002E = new JT808_0x8103_0x002E(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x002E.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x002E; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x002E value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002F.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002F.cs index 0484188..4117f60 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002F.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002F.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x002F : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x002F + /// public override uint ParamId { get; set; } = 0x002F; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 紧急报警时汇报距离间隔，单位为米（m），>0 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x002F jT808_0x8103_0x002F = new JT808_0x8103_0x002F(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x002F.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x002F.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x002F.ParamValue.ReadNumber()}]参数值[紧急报警时汇报距离间隔m]", jT808_0x8103_0x002F.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x002F Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x002F jT808_0x8103_0x002F = new JT808_0x8103_0x002F(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x002F.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x002F; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x002F value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0030.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0030.cs index 790c9fe..33c8466 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0030.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0030.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0030 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0030 + /// public override uint ParamId { get; set; } = 0x0030; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 拐点补传角度，小于180 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0030 jT808_0x8103_0x0030 = new JT808_0x8103_0x0030(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0030.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0030.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0030.ParamValue.ReadNumber()}]参数值[拐点补传角度,<180]", jT808_0x8103_0x0030.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0030 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0030 jT808_0x8103_0x0030 = new JT808_0x8103_0x0030(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0030.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0030; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0030 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0031.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0031.cs index c4f8ed0..8abe3f1 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0031.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0031.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0031 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0031 + /// public override uint ParamId { get; set; } = 0x0031; /// - /// 数据 长度 + /// 数据长度 + /// 2 byte /// public override byte ParamLength { get; set; } = 2; /// /// 电子围栏半径（非法位移阈值），单位为米 /// public ushort ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0031 jT808_0x8103_0x0031 = new JT808_0x8103_0x0031(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0031.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0031.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0031.ParamValue.ReadNumber()}]参数值[电子围栏半径m]", jT808_0x8103_0x0031.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0031 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0031 jT808_0x8103_0x0031 = new JT808_0x8103_0x0031(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0031.ParamValue = reader.ReadUInt16(); return jT808_0x8103_0x0031; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0031 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0032.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0032.cs index 4003513..db7f23e 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0032.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0032.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0032 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808_2019_Version, IJT808Analyze { + /// + /// 0x0032 + /// public override uint ParamId { get; set; } = 0x0032; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 违规行驶时段范围（非法位移阈值），单位为米 /// public byte[] ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0032 value = new JT808_0x8103_0x0032(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{value.ParamLength.ReadNumber()}]参数长度", value.ParamLength); writer.WriteString($"[{ value.ParamValue.ToHexString()}]参数值[违规行驶时段范围]", $"开始时间{value.ParamValue[0]}时{value.ParamValue[1]}分，结束时间{value.ParamValue[2]}时{value.ParamValue[3]}分"); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0032 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0032 value = new JT808_0x8103_0x0032(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody value.ParamValue = reader.ReadArray(4).ToArray(); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0032 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0040.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0040.cs index a57a7ff..bfa5716 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0040.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0040.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0040 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0040 + /// public override uint ParamId { get; set; } = 0x0040; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// public override byte ParamLength { get; set; } /// /// 监控平台电话号码 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0040 jT808_0x8103_0x0040 = new JT808_0x8103_0x0040(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0040.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0040.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[监控平台电话号码]", jT808_0x8103_0x0040.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0040 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0040 jT808_0x8103_0x0040 = new JT808_0x8103_0x0040(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0040.ParamValue = reader.ReadString(jT808_0x8103_0x0040.ParamLength); return jT808_0x8103_0x0040; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0040 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0041.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0041.cs index ea82ce5..9a17573 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0041.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0041.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0041 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0041 + /// public override uint ParamId { get; set; } = 0x0041; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// public override byte ParamLength { get; set; } /// /// 复位电话号码，可采用此电话号码拨打终端电话让终端复位 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0041 jT808_0x8103_0x0041 = new JT808_0x8103_0x0041(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0041.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0041.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[复位电话号码]", jT808_0x8103_0x0041.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0041 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0041 jT808_0x8103_0x0041 = new JT808_0x8103_0x0041(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0041.ParamValue = reader.ReadString(jT808_0x8103_0x0041.ParamLength); return jT808_0x8103_0x0041; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0041 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0042.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0042.cs index cd82f19..dbe51c0 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0042.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0042.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0042 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0042 + /// public override uint ParamId { get; set; } = 0x0042; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// public override byte ParamLength { get; set; } /// /// 恢复出厂设置电话号码，可采用此电话号码拨打终端电话让终端恢复出厂设置 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0042 jT808_0x8103_0x0042 = new JT808_0x8103_0x0042(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0042.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0042.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[恢复出厂设置电话号码]", jT808_0x8103_0x0042.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0042 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0042 jT808_0x8103_0x0042 = new JT808_0x8103_0x0042(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0042.ParamValue = reader.ReadString(jT808_0x8103_0x0042.ParamLength); return jT808_0x8103_0x0042; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0042 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0043.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0043.cs index dc54b09..eb44c81 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0043.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0043.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0043 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0043 + /// public override uint ParamId { get; set; } = 0x0043; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// public override byte ParamLength { get; set; } /// /// 监控平台 SMS 电话号码 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0043 jT808_0x8103_0x0043 = new JT808_0x8103_0x0043(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0043.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0043.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[监控平台SMS电话号码]", jT808_0x8103_0x0043.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0043 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0043 jT808_0x8103_0x0043 = new JT808_0x8103_0x0043(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0043.ParamValue = reader.ReadString(jT808_0x8103_0x0043.ParamLength); return jT808_0x8103_0x0043; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0043 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0044.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0044.cs index 77a1d40..cbde209 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0044.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0044.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0044 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0044 + /// public override uint ParamId { get; set; } = 0x0044; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// public override byte ParamLength { get; set; } /// /// 接收终端 SMS 文本报警号码 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0044 jT808_0x8103_0x0044 = new JT808_0x8103_0x0044(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0044.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0044.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[接收终端SMS文本报警号码]", jT808_0x8103_0x0044.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0044 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0044 jT808_0x8103_0x0044 = new JT808_0x8103_0x0044(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0044.ParamValue = reader.ReadString(jT808_0x8103_0x0044.ParamLength); return jT808_0x8103_0x0044; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0044 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0045.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0045.cs index 613a3fc..5747ca8 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0045.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0045.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0045 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0045 + /// public override uint ParamId { get; set; } = 0x0045; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 终端电话接听策略，0：自动接听；1：ACC ON 时自动接听，OFF 时手动接听 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0045 jT808_0x8103_0x0045 = new JT808_0x8103_0x0045(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0045.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0045.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0045.ParamValue.ReadNumber()}]参数值[终端电话接听策略，0：自动接听；1：ACC ON 时自动接听，OFF 时手动接听]", jT808_0x8103_0x0045.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0045 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0045 jT808_0x8103_0x0045 = new JT808_0x8103_0x0045(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0045.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0045; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0045 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0046.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0046.cs index a9c931a..0d8dd34 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0046.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0046.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0046 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0046 + /// public override uint ParamId { get; set; } = 0x0046; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 每次最长通话时间，单位为秒（s），0 为不允许通话，0xFFFFFFFF 为不限制 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0046 jT808_0x8103_0x0046 = new JT808_0x8103_0x0046(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0046.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0046.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0046.ParamValue.ReadNumber()}]参数值[每次最长通话时间s]", jT808_0x8103_0x0046.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0046 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0046 jT808_0x8103_0x0046 = new JT808_0x8103_0x0046(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0046.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0046; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0046 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0047.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0047.cs index d87b81f..c74a4cb 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0047.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0047.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0047 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0047 + /// public override uint ParamId { get; set; } = 0x0047; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 当月最长通话时间，单位为秒（s），0 为不允许通话，0xFFFFFFFF 为不限制 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0047 jT808_0x8103_0x0047 = new JT808_0x8103_0x0047(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0047.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0047.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0047.ParamValue.ReadNumber()}]参数值[当月最长通话时间s]", jT808_0x8103_0x0047.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0047 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0047 jT808_0x8103_0x0047 = new JT808_0x8103_0x0047(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0047.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0047; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0047 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0048.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0048.cs index 3f4968e..e689470 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0048.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0048.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0048 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0048 + /// public override uint ParamId { get; set; } = 0x0048; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// public override byte ParamLength { get; set; } /// /// 监听电话号码 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0048 jT808_0x8103_0x0048 = new JT808_0x8103_0x0048(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0048.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0048.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[监听电话号码]", jT808_0x8103_0x0048.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0048 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0048 jT808_0x8103_0x0048 = new JT808_0x8103_0x0048(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0048.ParamValue = reader.ReadString(jT808_0x8103_0x0048.ParamLength); return jT808_0x8103_0x0048; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0048 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0049.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0049.cs index 915bf74..a0c7e0b 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0049.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0049.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0049 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0049 + /// public override uint ParamId { get; set; } = 0x0049; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// public override byte ParamLength { get; set; } /// /// 监管平台特权短信号码 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0049 jT808_0x8103_0x0049 = new JT808_0x8103_0x0049(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0049.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0049.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[监管平台特权短信号码]", jT808_0x8103_0x0049.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0049 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0049 jT808_0x8103_0x0049 = new JT808_0x8103_0x0049(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0049.ParamValue = reader.ReadString(jT808_0x8103_0x0049.ParamLength); return jT808_0x8103_0x0049; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0049 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0050.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0050.cs index 7f5a20f..0a9d01d 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0050.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0050.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0050 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0050 + /// public override uint ParamId { get; set; } = 0x0050; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 报警屏蔽字，与位置信息汇报消息中的报警标志相对应，相应位为 1则相应报警被屏蔽 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0050 jT808_0x8103_0x0050 = new JT808_0x8103_0x0050(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0050.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0050.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0050.ParamValue.ReadNumber()}]参数值[报警屏蔽字,与位置信息汇报消息中的报警标志相对应]", jT808_0x8103_0x0050.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0050 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0050 jT808_0x8103_0x0050 = new JT808_0x8103_0x0050(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0050.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0050; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0050 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0051.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0051.cs index 24e1864..3c22d60 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0051.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0051.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0051 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0051 + /// public override uint ParamId { get; set; } = 0x0051; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 报警发送文本 SMS 开关，与位置信息汇报消息中的报警标志相对应，相应位为 1 则相应报警时发送文本 SMS /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0051 jT808_0x8103_0x0051 = new JT808_0x8103_0x0051(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0051.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0051.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0051.ParamValue.ReadNumber()}]参数值[报警发送文本SMS开关]", jT808_0x8103_0x0051.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0051 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0051 jT808_0x8103_0x0051 = new JT808_0x8103_0x0051(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0051.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0051; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0051 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0052.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0052.cs index 6e7a18c..e5c72ca 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0052.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0052.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0052 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0052 + /// public override uint ParamId { get; set; } = 0x0052; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 报警拍摄开关，与位置信息汇报消息中的报警标志相对应，相应位为1 则相应报警时摄像头拍摄 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0052 jT808_0x8103_0x0052 = new JT808_0x8103_0x0052(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0052.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0052.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0052.ParamValue.ReadNumber()}]参数值[报警拍摄开关]", jT808_0x8103_0x0052.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0052 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0052 jT808_0x8103_0x0052 = new JT808_0x8103_0x0052(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0052.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0052; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0052 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0053.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0053.cs index 0f37e77..2be0354 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0053.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0053.cs @@ -1,5 +1,4 @@ using System.Text.Json; - using JT808.Protocol.Extensions; using JT808.Protocol.Formatters; using JT808.Protocol.Interfaces; @@ -12,16 +11,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0053 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0053 + /// public override uint ParamId { get; set; } = 0x0053; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 报警拍摄存储标志，与位置信息汇报消息中的报警标志相对应，相应位为 1 则对相应报警时拍的照片进行存储，否则实时上传 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0053 jT808_0x8103_0x0053 = new JT808_0x8103_0x0053(); @@ -32,7 +40,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0053.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0053.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0053.ParamValue.ReadNumber()}]参数值[报警拍摄存储标志]", jT808_0x8103_0x0053.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0053 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0053 jT808_0x8103_0x0053 = new JT808_0x8103_0x0053(); @@ -41,7 +54,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0053.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0053; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0053 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0054.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0054.cs index d841843..f688dd9 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0054.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0054.cs @@ -1,5 +1,4 @@ using System.Text.Json; - using JT808.Protocol.Extensions; using JT808.Protocol.Formatters; using JT808.Protocol.Interfaces; @@ -12,16 +11,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0054 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0054 + /// public override uint ParamId { get; set; } = 0x0054; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 关键标志，与位置信息汇报消息中的报警标志相对应，相应位为 1 则对相应报警为关键报警 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0054 jT808_0x8103_0x0054 = new JT808_0x8103_0x0054(); @@ -32,7 +40,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0054.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0054.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0054.ParamValue.ReadNumber()}]参数值[关键标志]", jT808_0x8103_0x0054.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0054 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0054 jT808_0x8103_0x0054 = new JT808_0x8103_0x0054(); @@ -41,7 +54,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0054.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0054; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0054 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0055.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0055.cs index 3caa430..fdade43 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0055.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0055.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0055 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0055 + /// public override uint ParamId { get; set; } = 0x0055; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 最高速度，单位为公里每小时（km/h） /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0055 jT808_0x8103_0x0055 = new JT808_0x8103_0x0055(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0055.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0055.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0055.ParamValue.ReadNumber()}]参数值[最高速度km/h]", jT808_0x8103_0x0055.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0055 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0055 jT808_0x8103_0x0055 = new JT808_0x8103_0x0055(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0055.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0055; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0055 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0056.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0056.cs index e18117a..286194f 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0056.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0056.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0056 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0056 + /// public override uint ParamId { get; set; } = 0x0056; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 超速持续时间，单位为秒（s） /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0056 jT808_0x8103_0x0056 = new JT808_0x8103_0x0056(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0056.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0056.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0056.ParamValue.ReadNumber()}]参数值[超速持续时间s]", jT808_0x8103_0x0056.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0056 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0056 jT808_0x8103_0x0056 = new JT808_0x8103_0x0056(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0056.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0056; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0056 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0057.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0057.cs index 75cb623..15f3535 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0057.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0057.cs @@ -12,16 +12,24 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0057 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0057 + /// public override uint ParamId { get; set; } = 0x0057; /// - /// 数据 长度 + /// 数据长度 /// public override byte ParamLength { get; set; } = 4; /// /// 连续驾驶时间门限，单位为秒（s） /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0057 jT808_0x8103_0x0057 = new JT808_0x8103_0x0057(); @@ -32,7 +40,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0057.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0057.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0057.ParamValue.ReadNumber()}]参数值[连续驾驶时间门限s]", jT808_0x8103_0x0057.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0057 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0057 jT808_0x8103_0x0057 = new JT808_0x8103_0x0057(); @@ -41,7 +54,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0057.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0057; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0057 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0058.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0058.cs index 38627fa..c2b3184 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0058.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0058.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0058 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0058 + /// public override uint ParamId { get; set; } = 0x0058; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 当天累计驾驶时间门限，单位为秒（s） /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0058 jT808_0x8103_0x0058 = new JT808_0x8103_0x0058(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0058.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0058.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0058.ParamValue.ReadNumber()}]参数值[当天累计驾驶时间门限s]", jT808_0x8103_0x0058.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0058 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0058 jT808_0x8103_0x0058 = new JT808_0x8103_0x0058(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0058.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0058; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0058 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0059.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0059.cs index 914bd92..7175ede 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0059.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0059.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0059 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0059 + /// public override uint ParamId { get; set; } = 0x0059; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 最小休息时间，单位为秒（s） /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0059 jT808_0x8103_0x0059 = new JT808_0x8103_0x0059(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0059.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0059.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0059.ParamValue.ReadNumber()}]参数值[最小休息时间s]", jT808_0x8103_0x0059.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0059 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0059 jT808_0x8103_0x0059 = new JT808_0x8103_0x0059(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0059.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0059; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0059 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005A.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005A.cs index 12b03d0..f2a0700 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005A.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005A.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x005A : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x005A + /// public override uint ParamId { get; set; } = 0x005A; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 最长停车时间，单位为秒（s） /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x005A jT808_0x8103_0x005A = new JT808_0x8103_0x005A(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x005A.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x005A.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x005A.ParamValue.ReadNumber()}]参数值[最长停车时间s]", jT808_0x8103_0x005A.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x005A Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x005A jT808_0x8103_0x005A = new JT808_0x8103_0x005A(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x005A.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x005A; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x005A value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005B.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005B.cs index 20e050a..e5cec3b 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005B.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005B.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x005B : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x005B + /// public override uint ParamId { get; set; } = 0x005B; /// - /// 数据 长度 + /// 数据长度 + /// 2 byte /// public override byte ParamLength { get; set; } = 2; /// /// 超速报警预警差值，单位为 1/10Km/h /// public ushort ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x005B jT808_0x8103_0x005B = new JT808_0x8103_0x005B(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x005B.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x005B.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x005B.ParamValue.ReadNumber()}]参数值[超速报警预警差值1/10Km/h]", jT808_0x8103_0x005B.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x005B Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x005B jT808_0x8103_0x005B = new JT808_0x8103_0x005B(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x005B.ParamValue = reader.ReadUInt16(); return jT808_0x8103_0x005B; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x005B value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005C.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005C.cs index d407452..4dbc203 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005C.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005C.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x005C : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x005C + /// public override uint ParamId { get; set; } = 0x005C; /// - /// 数据 长度 + /// 数据长度 + /// 2 byte /// public override byte ParamLength { get; set; } = 2; /// /// 疲劳驾驶预警差值，单位为秒（s），>0 /// public ushort ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x005C jT808_0x8103_0x005C = new JT808_0x8103_0x005C(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x005C.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x005C.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x005C.ParamValue.ReadNumber()}]参数值[疲劳驾驶预警差值s]", jT808_0x8103_0x005C.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x005C Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x005C jT808_0x8103_0x005C = new JT808_0x8103_0x005C(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x005C.ParamValue = reader.ReadUInt16(); return jT808_0x8103_0x005C; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x005C value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005D.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005D.cs index 97dcba2..83e6aa5 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005D.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005D.cs @@ -14,9 +14,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x005D : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x005D + /// public override uint ParamId { get; set; } = 0x005D; /// - /// 数据 长度 + /// 数据长度 + /// 2 byte /// public override byte ParamLength { get; set; } = 2; /// @@ -25,7 +29,12 @@ namespace JT808.Protocol.MessageBody /// b15-b8：碰撞加速度，单位 0.1g，设置范围在：0-79 之间，默认为10。 /// public ushort ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x005D jT808_0x8103_0x005D = new JT808_0x8103_0x005D(); @@ -36,7 +45,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x005D.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x005D.ParamLength); writer.WriteString($"[{ jT808_0x8103_0x005D.ParamValue.ReadNumber()}]参数值[碰撞报警参数设置]",$"碰撞时间:{(byte)jT808_0x8103_0x005D.ParamValue}(ms),碰撞加速度:{(byte)(jT808_0x8103_0x005D.ParamValue>>8)}(0.1g)"); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x005D Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x005D jT808_0x8103_0x005D = new JT808_0x8103_0x005D(); @@ -45,7 +59,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x005D.ParamValue = reader.ReadUInt16(); return jT808_0x8103_0x005D; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x005D value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005E.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005E.cs index f6bfc95..9a41aed 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005E.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005E.cs @@ -13,9 +13,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x005E : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x005E + /// public override uint ParamId { get; set; } = 0x005E; /// - /// 数据 长度 + /// 数据长度 + /// 2 byte /// public override byte ParamLength { get; set; } = 2; /// @@ -23,7 +27,12 @@ namespace JT808.Protocol.MessageBody /// 侧翻角度，单位 1 度，默认为 30 度 /// public ushort ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x005E jT808_0x8103_0x005E = new JT808_0x8103_0x005E(); @@ -34,7 +43,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x005E.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x005E.ParamLength); writer.WriteString($"[{ jT808_0x8103_0x005E.ParamValue.ReadNumber()}]参数值[侧翻报警参数设置]",$"侧翻角度:{jT808_0x8103_0x005E.ParamValue}(度)" ); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x005E Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x005E jT808_0x8103_0x005E = new JT808_0x8103_0x005E(); @@ -43,7 +57,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x005E.ParamValue = reader.ReadUInt16(); return jT808_0x8103_0x005E; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x005E value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0064.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0064.cs index dbcaeef..67ce539 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0064.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0064.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0064 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0064 + /// public override uint ParamId { get; set; } = 0x0064; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// - /// 定时拍照控制，见 表 14 + /// 定时拍照控制，见808表 14 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0064 jT808_0x8103_0x0064 = new JT808_0x8103_0x0064(); @@ -30,9 +39,14 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0064.ParamValue = reader.ReadUInt32(); writer.WriteNumber($"[{ jT808_0x8103_0x0064.ParamId.ReadNumber()}]参数ID", jT808_0x8103_0x0064.ParamId); writer.WriteNumber($"[{jT808_0x8103_0x0064.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0064.ParamLength); - writer.WriteNumber($"[{ jT808_0x8103_0x0064.ParamValue.ReadNumber()}]参数值[定时拍照控制,见表14]", jT808_0x8103_0x0064.ParamValue); + writer.WriteNumber($"[{ jT808_0x8103_0x0064.ParamValue.ReadNumber()}]参数值[定时拍照控制,见808表14]", jT808_0x8103_0x0064.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0064 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0064 jT808_0x8103_0x0064 = new JT808_0x8103_0x0064(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0064.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0064; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0064 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0065.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0065.cs index c6e5f65..e6b4c91 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0065.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0065.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0065 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0065 + /// public override uint ParamId { get; set; } = 0x0065; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// - /// 定距拍照控制，见 表 15 + /// 定距拍照控制，见808表15 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0065 jT808_0x8103_0x0065 = new JT808_0x8103_0x0065(); @@ -30,9 +39,14 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0065.ParamValue = reader.ReadUInt32(); writer.WriteNumber($"[{ jT808_0x8103_0x0065.ParamId.ReadNumber()}]参数ID", jT808_0x8103_0x0065.ParamId); writer.WriteNumber($"[{jT808_0x8103_0x0065.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0065.ParamLength); - writer.WriteNumber($"[{ jT808_0x8103_0x0065.ParamValue.ReadNumber()}]参数值[定距拍照控制,见表15]", jT808_0x8103_0x0065.ParamValue); + writer.WriteNumber($"[{ jT808_0x8103_0x0065.ParamValue.ReadNumber()}]参数值[定距拍照控制,见808表15]", jT808_0x8103_0x0065.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0065 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0065 jT808_0x8103_0x0065 = new JT808_0x8103_0x0065(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0065.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0065; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0065 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0070.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0070.cs index e56bcd2..bcba48d 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0070.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0070.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0070 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0070 + /// public override uint ParamId { get; set; } = 0x0070; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 图像/视频质量，1-10，1 最好 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0070 jT808_0x8103_0x0070 = new JT808_0x8103_0x0070(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0070.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0070.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0070.ParamValue.ReadNumber()}]参数值[图像/视频质量,越小越好]", jT808_0x8103_0x0070.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0070 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0070 jT808_0x8103_0x0070 = new JT808_0x8103_0x0070(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0070.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0070; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0070 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0071.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0071.cs index 569e549..2e4d874 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0071.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0071.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0071 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0071 + /// public override uint ParamId { get; set; } = 0x0071; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 亮度，0-255 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0071 jT808_0x8103_0x0071 = new JT808_0x8103_0x0071(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0071.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0071.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0071.ParamValue.ReadNumber()}]参数值[亮度]", jT808_0x8103_0x0071.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0071 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0071 jT808_0x8103_0x0071 = new JT808_0x8103_0x0071(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0071.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0071; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0071 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0072.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0072.cs index 27f3ae3..4f4cd94 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0072.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0072.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0072 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0072 + /// public override uint ParamId { get; set; } = 0x0072; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 对比度，0-127 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0072 jT808_0x8103_0x0072 = new JT808_0x8103_0x0072(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0072.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0072.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0072.ParamValue.ReadNumber()}]参数值[对比度]", jT808_0x8103_0x0072.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0072 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0072 jT808_0x8103_0x0072 = new JT808_0x8103_0x0072(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0072.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0072; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0072 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0073.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0073.cs index b266b75..b43218d 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0073.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0073.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0073 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0073 + /// public override uint ParamId { get; set; } = 0x0073; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 饱和度，0-127 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0073 jT808_0x8103_0x0073 = new JT808_0x8103_0x0073(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0073.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0073.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0073.ParamValue.ReadNumber()}]参数值[饱和度]", jT808_0x8103_0x0073.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0073 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0073 jT808_0x8103_0x0073 = new JT808_0x8103_0x0073(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0073.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0073; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0073 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0074.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0074.cs index c165f2b..0caa7e8 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0074.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0074.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0074 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0074 + /// public override uint ParamId { get; set; } = 0x0074; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 色度，0-255 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0074 jT808_0x8103_0x0074 = new JT808_0x8103_0x0074(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0074.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0074.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0074.ParamValue.ReadNumber()}]参数值[色度]", jT808_0x8103_0x0074.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0074 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0074 jT808_0x8103_0x0074 = new JT808_0x8103_0x0074(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0074.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0074; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0074 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0080.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0080.cs index 82a77d3..35a3dc0 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0080.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0080.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0080 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0080 + /// public override uint ParamId { get; set; } = 0x0080; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// public override byte ParamLength { get; set; } = 4; /// /// 车辆里程表读数，1/10km /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0080 jT808_0x8103_0x0080 = new JT808_0x8103_0x0080(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0080.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0080.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0080.ParamValue.ReadNumber()}]参数值[车辆里程表读数1/10km]", jT808_0x8103_0x0080.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0080 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0080 jT808_0x8103_0x0080 = new JT808_0x8103_0x0080(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0080.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0080; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0080 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0081.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0081.cs index 1a7f94e..0b5dbc8 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0081.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0081.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0081 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0081 + /// public override uint ParamId { get; set; } = 0x0081; /// - /// 数据 长度 + /// 数据长度 + /// 2 byte /// public override byte ParamLength { get; set; } = 2; /// /// 车辆所在的省域 ID /// public ushort ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0081 jT808_0x8103_0x0081 = new JT808_0x8103_0x0081(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0081.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0081.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0081.ParamValue.ReadNumber()}]参数值[车辆所在的省域ID]", jT808_0x8103_0x0081.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0081 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0081 jT808_0x8103_0x0081 = new JT808_0x8103_0x0081(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0081.ParamValue = reader.ReadUInt16(); return jT808_0x8103_0x0081; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0081 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0082.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0082.cs index 32811d2..60d533b 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0082.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0082.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0082 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0082 + /// public override uint ParamId { get; set; } = 0x0082; /// - /// 数据 长度 + /// 数据长度 + /// 2 byte /// public override byte ParamLength { get; set; } = 2; /// /// 车辆所在的市域 ID /// public ushort ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0082 jT808_0x8103_0x0082 = new JT808_0x8103_0x0082(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0082.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0082.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0082.ParamValue.ReadNumber()}]参数值[车辆所在的市域ID]", jT808_0x8103_0x0082.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0082 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0082 jT808_0x8103_0x0082 = new JT808_0x8103_0x0082(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0082.ParamValue = reader.ReadUInt16(); return jT808_0x8103_0x0082; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0082 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0083.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0083.cs index 35256a6..0a8ae5b 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0083.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0083.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0083 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0083 + /// public override uint ParamId { get; set; } = 0x0083; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// public override byte ParamLength { get; set; } /// /// 公安交通管理部门颁发的机动车号牌 /// public string ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0083 jT808_0x8103_0x0083 = new JT808_0x8103_0x0083(); @@ -33,7 +42,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0083.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0083.ParamLength); writer.WriteString($"[{paramValue.ToArray().ToHexString()}]参数值[公安交通管理部门颁发的机动车号牌]", jT808_0x8103_0x0083.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0083 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0083 jT808_0x8103_0x0083 = new JT808_0x8103_0x0083(); @@ -42,7 +56,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0083.ParamValue = reader.ReadString(jT808_0x8103_0x0083.ParamLength); return jT808_0x8103_0x0083; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0083 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0084.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0084.cs index 5d0310d..7d09c6e 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0084.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0084.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0084 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808_2019_Version, IJT808Analyze { + /// + /// 0x0084 + /// public override uint ParamId { get; set; } = 0x0084; /// - /// 数据 长度 + /// 数据长度 + /// n byte /// - public override byte ParamLength { get; set; } + public override byte ParamLength { get; set; } = 1; /// /// 车牌颜色，按照 JT/T415-2006 的 5.4.12 /// public byte ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0084 jT808_0x8103_0x0084 = new JT808_0x8103_0x0084(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0084.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0084.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0084.ParamValue.ReadNumber()}]参数值[车牌颜色,按照 JT/T415-2006 的 5.4.12]", jT808_0x8103_0x0084.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0084 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0084 jT808_0x8103_0x0084 = new JT808_0x8103_0x0084(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0084.ParamValue = reader.ReadByte(); return jT808_0x8103_0x0084; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0084 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0090.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0090.cs index 09c4162..56c0011 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0090.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0090.cs @@ -16,11 +16,15 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0090 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0090 + /// public override uint ParamId { get; set; } = 0x0090; /// - /// 数据 长度 + /// 数据长度 + /// 1 byte /// - public override byte ParamLength { get; set; } + public override byte ParamLength { get; set; } = 1; /// /// GNSS 定位模式，定义如下： /// bit0，0：禁用 GPS 定位， 1：启用 GPS 定位； @@ -29,7 +33,12 @@ namespace JT808.Protocol.MessageBody /// bit3，0：禁用 Galileo 定位， 1：启用 Galileo 定位。 /// public byte ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0090 jT808_0x8103_0x0090 = new JT808_0x8103_0x0090(); @@ -45,7 +54,12 @@ namespace JT808.Protocol.MessageBody writer.WriteStringValue((jT808_0x8103_0x0090.ParamValue & 08) > 0 ? "启用Galileo定位" : "禁用Galileo定位"); writer.WriteEndArray(); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0090 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0090 jT808_0x8103_0x0090 = new JT808_0x8103_0x0090(); @@ -54,7 +68,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0090.ParamValue = reader.ReadByte(); return jT808_0x8103_0x0090; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0090 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0091.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0091.cs index 4e6fe84..cad0e41 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0091.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0091.cs @@ -16,11 +16,15 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0091 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0091 + /// public override uint ParamId { get; set; } = 0x0091; /// - /// 数据 长度 + /// 数据长度 + /// 1 byte /// - public override byte ParamLength { get; set; } + public override byte ParamLength { get; set; } = 1; /// /// GNSS 波特率，定义如下： /// 0x00：4800；0x01：9600； @@ -28,7 +32,12 @@ namespace JT808.Protocol.MessageBody /// 0x04：57600；0x05：115200。 /// public byte ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0091 jT808_0x8103_0x0091 = new JT808_0x8103_0x0091(); @@ -39,7 +48,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0091.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0091.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0091.ParamValue.ReadNumber()}]参数值[GNSS波特率]",Math.Pow(4800, jT808_0x8103_0x0091.ParamValue)); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0091 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0091 jT808_0x8103_0x0091 = new JT808_0x8103_0x0091(); @@ -48,7 +62,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0091.ParamValue = reader.ReadByte(); return jT808_0x8103_0x0091; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0091 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0092.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0092.cs index 9f1d6d5..1f60892 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0092.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0092.cs @@ -15,11 +15,15 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0092 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0092 + /// public override uint ParamId { get; set; } = 0x0092; /// - /// 数据 长度 + /// 数据长度 + /// 1 byte /// - public override byte ParamLength { get; set; } + public override byte ParamLength { get; set; } = 1; /// /// GNSS 模块详细定位数据输出频率，定义如下： /// 0x00：500ms；0x01：1000ms（默认值）； @@ -27,7 +31,12 @@ namespace JT808.Protocol.MessageBody /// 0x04：4000ms。 /// public byte ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0092 jT808_0x8103_0x0092 = new JT808_0x8103_0x0092(); @@ -38,7 +47,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0092.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0092.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0092.ParamValue.ReadNumber()}]GNSS模块详细定位数据输出频率ms", jT808_0x8103_0x0092.ParamValue==0?500: jT808_0x8103_0x0092.ParamValue*1000); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0092 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0092 jT808_0x8103_0x0092 = new JT808_0x8103_0x0092(); @@ -47,7 +61,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0092.ParamValue = reader.ReadByte(); return jT808_0x8103_0x0092; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0092 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0093.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0093.cs index 8ff35f5..c3ac16e 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0093.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0093.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0093 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0093 + /// public override uint ParamId { get; set; } = 0x0093; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// - public override byte ParamLength { get; set; } + public override byte ParamLength { get; set; } = 4; /// /// GNSS 模块详细定位数据采集频率，单位为秒，默认为 1。 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0093 jT808_0x8103_0x0093 = new JT808_0x8103_0x0093(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0093.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0093.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0093.ParamValue.ReadNumber()}]参数值[GNSS模块详细定位数据采集频率s]", jT808_0x8103_0x0093.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0093 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0093 jT808_0x8103_0x0093 = new JT808_0x8103_0x0093(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0093.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0093; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0093 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0094.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0094.cs index 6b594f6..465e09b 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0094.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0094.cs @@ -18,11 +18,15 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0094 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0094 + /// public override uint ParamId { get; set; } = 0x0094; /// - /// 数据 长度 + /// 数据长度 + /// 1 byte /// - public override byte ParamLength { get; set; } + public override byte ParamLength { get; set; } = 1; /// /// GNSS 模块详细定位数据上传方式 /// 0x00，本地存储，不上传（默认值）； @@ -33,7 +37,12 @@ namespace JT808.Protocol.MessageBody /// 0x0D，按累计条数上传，达到上传条数后自动停止上传。 /// public byte ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0094 jT808_0x8103_0x0094 = new JT808_0x8103_0x0094(); @@ -63,7 +72,12 @@ namespace JT808.Protocol.MessageBody } } } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0094 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0094 jT808_0x8103_0x0094 = new JT808_0x8103_0x0094(); @@ -72,7 +86,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0094.ParamValue = reader.ReadByte(); return jT808_0x8103_0x0094; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0094 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0095.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0095.cs index 32242ee..e0d23f9 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0095.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0095.cs @@ -17,11 +17,15 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0095 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0095 + /// public override uint ParamId { get; set; } = 0x0095; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// - public override byte ParamLength { get; set; } + public override byte ParamLength { get; set; } = 4; /// /// GNSS 模块详细定位数据上传设置： /// 上传方式为 0x01 时，单位为秒； diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0100.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0100.cs index e428e75..3ef265f 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0100.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0100.cs @@ -12,16 +12,24 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0100 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0100 + /// public override uint ParamId { get; set; } = 0x0100; /// /// 数据 长度 /// - public override byte ParamLength { get; set; } + public override byte ParamLength { get; set; } = 4; /// /// CAN 总线通道 1 采集时间间隔(ms)，0 表示不采集 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0100 jT808_0x8103_0x0100 = new JT808_0x8103_0x0100(); @@ -32,7 +40,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0100.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0100.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0100.ParamValue.ReadNumber()}]参数值[CAN总线通道1 ,采集时间间隔(ms)，0 表示不采集]", jT808_0x8103_0x0100.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0100 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0100 jT808_0x8103_0x0100 = new JT808_0x8103_0x0100(); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0101.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0101.cs index 7ddbca7..e7dc463 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0101.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0101.cs @@ -16,12 +16,17 @@ namespace JT808.Protocol.MessageBody /// /// 数据 长度 /// - public override byte ParamLength { get; set; } + public override byte ParamLength { get; set; } = 2; /// /// CAN 总线通道 1 上传时间间隔(s)，0 表示不上传 /// public ushort ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0101 jT808_0x8103_0x0101 = new JT808_0x8103_0x0101(); @@ -32,7 +37,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0101.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0101.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0101.ParamValue.ReadNumber()}]参数值[CAN总线通道1, 上传时间间隔(s)，0 表示不上传]", jT808_0x8103_0x0101.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0101 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0101 jT808_0x8103_0x0101 = new JT808_0x8103_0x0101(); @@ -41,7 +51,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0101.ParamValue = reader.ReadUInt16(); return jT808_0x8103_0x0101; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0101 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0102.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0102.cs index 49f090d..1e56ec7 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0102.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0102.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0102 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0102 + /// public override uint ParamId { get; set; } = 0x0102; /// - /// 数据 长度 + /// 数据长度 + /// 4 byte /// - public override byte ParamLength { get; set; } + public override byte ParamLength { get; set; } = 4; /// /// CAN 总线通道 2 采集时间间隔(ms)，0 表示不采集 /// public uint ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0102 jT808_0x8103_0x0102 = new JT808_0x8103_0x0102(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0102.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0102.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0102.ParamValue.ReadNumber()}]参数值[CAN 总线通道2, 采集时间间隔(ms)，0 表示不采集]", jT808_0x8103_0x0102.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0102 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0102 jT808_0x8103_0x0102 = new JT808_0x8103_0x0102(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0102.ParamValue = reader.ReadUInt32(); return jT808_0x8103_0x0102; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0102 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0103.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0103.cs index 1aec752..d1d2429 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0103.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0103.cs @@ -12,16 +12,25 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0103 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0103 + /// public override uint ParamId { get; set; } = 0x0103; /// - /// 数据 长度 + /// 数据长度 + /// 2 byte /// - public override byte ParamLength { get; set; } + public override byte ParamLength { get; set; } = 2; /// /// CAN 总线通道 2 上传时间间隔(s)，0 表示不上传 /// public ushort ParamValue { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8103_0x0103 jT808_0x8103_0x0103 = new JT808_0x8103_0x0103(); @@ -32,7 +41,12 @@ namespace JT808.Protocol.MessageBody writer.WriteNumber($"[{jT808_0x8103_0x0103.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0103.ParamLength); writer.WriteNumber($"[{ jT808_0x8103_0x0103.ParamValue.ReadNumber()}]参数值[CAN 总线通道2,上传时间间隔(s)，0 表示不上传]", jT808_0x8103_0x0103.ParamValue); } - + /// + /// + /// + /// + /// + /// public JT808_0x8103_0x0103 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8103_0x0103 jT808_0x8103_0x0103 = new JT808_0x8103_0x0103(); @@ -41,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0x8103_0x0103.ParamValue = reader.ReadUInt16(); return jT808_0x8103_0x0103; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0103 value, IJT808Config config) { writer.WriteUInt32(value.ParamId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0110.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0110.cs index 04fa4d5..b35be6f 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0110.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0110.cs @@ -19,9 +19,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8103_0x0110 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0110 + /// public override uint ParamId { get; set; } = 0x0110; /// - /// 数据 长度 + /// 数据长度 + /// 8 byte /// public override byte ParamLength { get; set; } = 8; /// diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_BodyBase.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_BodyBase.cs index 471a570..b8fb3de 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_BodyBase.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_BodyBase.cs @@ -6,6 +6,9 @@ using System.Text.Json; namespace JT808.Protocol.MessageBody { + /// + /// 终端参数设置 + /// public abstract class JT808_0x8103_BodyBase { /// diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_CustomBodyBase.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_CustomBodyBase.cs index 3617b12..57c86bf 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8103_CustomBodyBase.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_CustomBodyBase.cs @@ -3,6 +3,9 @@ using System.Collections.Generic; namespace JT808.Protocol.MessageBody { + /// + /// 自定义终端参数设置 + /// public abstract class JT808_0x8103_CustomBodyBase { /// diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8104.cs b/src/JT808.Protocol/MessageBody/JT808_0x8104.cs index c09ad90..84d7828 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8104.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8104.cs @@ -5,7 +5,13 @@ /// public class JT808_0x8104 : JT808Bodies { + /// + /// 0x8104 + /// public override ushort MsgId { get; } = 0x8104; + /// + /// 查询终端参数 + /// public override string Description => "查询终端参数"; /// /// 跳过数据体序列化 diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8105.cs b/src/JT808.Protocol/MessageBody/JT808_0x8105.cs index f348987..57dbd44 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8105.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8105.cs @@ -12,7 +12,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8105 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze, IJT808_2019_Version { + /// + /// 0x8105 + /// public override ushort MsgId { get; } = 0x8105; + /// + /// 终端控制 + /// public override string Description => "终端控制"; /// /// 命令字 @@ -22,7 +28,12 @@ namespace JT808.Protocol.MessageBody /// 命令参数 /// public CommandParams CommandValue { get; set; } - + /// + /// + /// + /// + /// + /// public JT808_0x8105 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8105 jT808_0x8105 = new JT808_0x8105 @@ -36,7 +47,12 @@ namespace JT808.Protocol.MessageBody } return jT808_0x8105; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8105 value, IJT808Config config) { writer.WriteByte(value.CommandWord); @@ -45,7 +61,12 @@ namespace JT808.Protocol.MessageBody writer.WriteString(value.CommandValue.ToString()); } } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8105 value = new JT808_0x8105 @@ -252,10 +273,18 @@ namespace JT808.Protocol.MessageBody /// 若值为 0，则表示一直连接指 定服务器 /// public ushort? ConnectTimeLimit { get; set; } + /// + /// + /// + /// public override string ToString() { return $"{ConnectionControl};{DialPointName};{DialUserName};{DialPwd};{ServerUrl};{TCPPort};{UDPPort};{MakerId};{MonitoringPlatformAuthenticationCode};{HardwareVersion};{FirmwareVersion};{URL};{ConnectTimeLimit}"; } + /// + /// + /// + /// public void SetCommandParams(string commandValue) { var values = commandValue.Split(';'); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8106.cs b/src/JT808.Protocol/MessageBody/JT808_0x8106.cs index 307415f..355b0f2 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8106.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8106.cs @@ -13,7 +13,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8106 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x8106 + /// public override ushort MsgId { get; } = 0x8106; + /// + /// 查询指定终端参数 + /// public override string Description => "查询指定终端参数"; /// /// 参数总数 @@ -25,7 +31,12 @@ namespace JT808.Protocol.MessageBody /// 参数顺序排列，如“参数 ID1 参数 ID2......参数IDn”。 /// public uint[] Parameters { get; set; } - + /// + /// + /// + /// + /// + /// public JT808_0x8106 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8106 jT808_0X8106 = new JT808_0x8106(); @@ -37,7 +48,12 @@ namespace JT808.Protocol.MessageBody } return jT808_0X8106; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8106 value, IJT808Config config) { writer.WriteByte(value.ParameterCount); @@ -46,6 +62,12 @@ namespace JT808.Protocol.MessageBody writer.WriteUInt32(value.Parameters[i]); } } + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8106 value = new JT808_0x8106(); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8107.cs b/src/JT808.Protocol/MessageBody/JT808_0x8107.cs index 8673626..a1f1f44 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8107.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8107.cs @@ -5,12 +5,17 @@ /// public class JT808_0x8107 : JT808Bodies { + /// + /// 0x8107 + /// public override ushort MsgId { get; } = 0x8107; /// /// 跳过数据体序列化 /// public override bool SkipSerialization { get; set; } = true; - + /// + /// 查询终端属性 + /// public override string Description => "查询终端属性"; } } diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8108.cs b/src/JT808.Protocol/MessageBody/JT808_0x8108.cs index 3115e34..c810fab 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8108.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8108.cs @@ -12,8 +12,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8108 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze, IJT808_2019_Version { + /// + /// 0x8108 + /// public override ushort MsgId { get; } = 0x8108; - + /// + /// 下发终端升级包 + /// public override string Description => "下发终端升级包"; /// /// 升级类型 @@ -41,7 +46,12 @@ namespace JT808.Protocol.MessageBody /// 升级数据包 /// public byte[] UpgradePackage { get; set; } - + /// + /// + /// + /// + /// + /// public JT808_0x8108 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8108 jT808_0X8108 = new JT808_0x8108(); @@ -60,7 +70,12 @@ namespace JT808.Protocol.MessageBody jT808_0X8108.UpgradePackage = reader.ReadArray(jT808_0X8108.UpgradePackageLength).ToArray(); return jT808_0X8108; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8108 value, IJT808Config config) { writer.WriteByte((byte)value.UpgradeType); @@ -77,7 +92,12 @@ namespace JT808.Protocol.MessageBody writer.WriteInt32(value.UpgradePackage.Length); writer.WriteArray(value.UpgradePackage); } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8108 value = new JT808_0x8108(); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8201.cs b/src/JT808.Protocol/MessageBody/JT808_0x8201.cs index b59ee85..cbed0b7 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8201.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8201.cs @@ -5,12 +5,17 @@ /// public class JT808_0x8201: JT808Bodies { + /// + /// 0x8201 + /// public override ushort MsgId { get; } = 0x8201; /// /// 跳过数据体序列化 /// public override bool SkipSerialization { get; set; } = true; - + /// + /// 位置信息查询 + /// public override string Description => "位置信息查询"; } } diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8202.cs b/src/JT808.Protocol/MessageBody/JT808_0x8202.cs index aea8ae3..d9549a9 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8202.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8202.cs @@ -11,21 +11,30 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8202 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x8202 + /// public override ushort MsgId { get; } = 0x8202; - + /// + /// 临时位置跟踪控制 + /// public override string Description => "临时位置跟踪控制"; /// /// 时间间隔 /// 单位为秒（s），0 则停止跟踪。停止跟踪无需带后继字段 /// public ushort Interval { get; set; } - /// /// 位置跟踪有效期 /// 单位为秒（s），终端在接收到位置跟踪控制消息后，在有效期截止时间之前，依据消息中的时间间隔发送位置汇报 /// public int LocationTrackingValidity { get; set; } - + /// + /// + /// + /// + /// + /// public JT808_0x8202 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8202 jT808_0X8202 = new JT808_0x8202(); @@ -33,13 +42,23 @@ namespace JT808.Protocol.MessageBody jT808_0X8202.LocationTrackingValidity = reader.ReadInt32(); return jT808_0X8202; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8202 value, IJT808Config config) { writer.WriteUInt16(value.Interval); writer.WriteInt32(value.LocationTrackingValidity); } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8202 value = new JT808_0x8202(); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8203.cs b/src/JT808.Protocol/MessageBody/JT808_0x8203.cs index 6faa6d2..ed0ca84 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8203.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8203.cs @@ -14,7 +14,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8203 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x8203 + /// public override ushort MsgId { get; } = 0x8203; + /// + /// 人工确认报警消息 + /// public override string Description => "人工确认报警消息"; /// /// 报警消息流水号 @@ -25,7 +31,12 @@ namespace JT808.Protocol.MessageBody /// 人工确认报警类型 /// public uint ManualConfirmAlarmType { get; set; } - + /// + /// + /// + /// + /// + /// public JT808_0x8203 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8203 jT808_0X8203 = new JT808_0x8203(); @@ -33,13 +44,23 @@ namespace JT808.Protocol.MessageBody jT808_0X8203.ManualConfirmAlarmType = reader.ReadUInt32(); return jT808_0X8203; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8203 value, IJT808Config config) { writer.WriteUInt16(value.AlarmMsgNum); writer.WriteUInt32(value.ManualConfirmAlarmType); } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8203 value = new JT808_0x8203(); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8204.cs b/src/JT808.Protocol/MessageBody/JT808_0x8204.cs index c4679fd..7611960 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8204.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8204.cs @@ -10,10 +10,17 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8204 : JT808Bodies, IJT808_2019_Version { + /// + /// 0x8204 + /// public override ushort MsgId { get; } = 0x8204; - + /// + /// 跳过序列化器 + /// public override bool SkipSerialization { get; set; } = true; - + /// + /// 链路检测 + /// public override string Description => "链路检测"; } } diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8300.cs b/src/JT808.Protocol/MessageBody/JT808_0x8300.cs index e1a9ed4..b8b6072 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8300.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8300.cs @@ -15,7 +15,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8300 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze, IJT808_2019_Version { + /// + /// 0x8300 + /// public override ushort MsgId { get; } = 0x8300; + /// + /// 文本信息下发 + /// public override string Description => "文本信息下发"; /// /// 文本信息标志位含义见 表 38 @@ -32,7 +38,12 @@ namespace JT808.Protocol.MessageBody /// 最长为 1024 字节，经GBK编码 /// public string TextInfo { get; set; } - + /// + /// + /// + /// + /// + /// public JT808_0x8300 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8300 jT808_0X8300 = new JT808_0x8300(); @@ -44,7 +55,12 @@ namespace JT808.Protocol.MessageBody jT808_0X8300.TextInfo = reader.ReadRemainStringContent(); return jT808_0X8300; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8300 value, IJT808Config config) { writer.WriteByte(value.TextFlag); @@ -54,7 +70,12 @@ namespace JT808.Protocol.MessageBody } writer.WriteString(value.TextInfo); } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8300 value = new JT808_0x8300(); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8301.cs b/src/JT808.Protocol/MessageBody/JT808_0x8301.cs index cce7848..abca724 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8301.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8301.cs @@ -12,11 +12,17 @@ namespace JT808.Protocol.MessageBody /// /// 事件设置 /// 0x8301 + /// 2019版本已作删除 /// - [Obsolete("2019版本已作删除")] public class JT808_0x8301 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze, IJT808_2019_Version { + /// + /// 0x8301 + /// public override ushort MsgId { get; } = 0x8301; + /// + /// 事件设置 + /// public override string Description => "事件设置"; /// /// 设置类型 @@ -31,7 +37,12 @@ namespace JT808.Protocol.MessageBody /// 事件项 /// public List EventItems { get; set; } - + /// + /// + /// + /// + /// + /// public JT808_0x8301 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8301 jT808_0X8301 = new JT808_0x8301(); @@ -48,7 +59,12 @@ namespace JT808.Protocol.MessageBody } return jT808_0X8301; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8301 value, IJT808Config config) { writer.WriteByte(value.SettingType); @@ -66,7 +82,12 @@ namespace JT808.Protocol.MessageBody } } } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8301 value = new JT808_0x8301(); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8302.cs b/src/JT808.Protocol/MessageBody/JT808_0x8302.cs index 1487a6c..f8130ff 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8302.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8302.cs @@ -11,11 +11,17 @@ namespace JT808.Protocol.MessageBody /// /// 提问下发 /// 0x8302 + /// 2019版本已作删除 /// - [Obsolete("2019版本已作删除")] public class JT808_0x8302 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze, IJT808_2019_Version { + /// + /// 0x8302 + /// public override ushort MsgId { get; } = 0x8302; + /// + /// 提问下发 + /// public override string Description => "提问下发"; /// /// 标志 @@ -35,7 +41,9 @@ namespace JT808.Protocol.MessageBody /// 候选答案列表 /// public List Answers { get; set; } - + /// + /// 候选答案信息 + /// public class Answer { /// @@ -53,7 +61,12 @@ namespace JT808.Protocol.MessageBody /// public string Content { get; set; } } - + /// + /// + /// + /// + /// + /// public JT808_0x8302 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8302 jT808_0X8302 = new JT808_0x8302(); @@ -78,7 +91,12 @@ namespace JT808.Protocol.MessageBody } return jT808_0X8302; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8302 value, IJT808Config config) { writer.WriteByte(value.Flag); @@ -99,7 +117,12 @@ namespace JT808.Protocol.MessageBody } } } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8302 value = new JT808_0x8302(); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8303.cs b/src/JT808.Protocol/MessageBody/JT808_0x8303.cs index ce2e9d0..cce04d2 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8303.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8303.cs @@ -13,10 +13,15 @@ namespace JT808.Protocol.MessageBody /// 信息点播菜单设置 /// 0x8303 /// - [Obsolete("2019版本已作删除")] public class JT808_0x8303 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze, IJT808_2019_Version { + /// + /// 0x8303 + /// public override ushort MsgId { get; } = 0x8303; + /// + /// 信息点播菜单设置 + /// public override string Description => "信息点播菜单设置"; /// /// 设置类型 @@ -32,7 +37,12 @@ namespace JT808.Protocol.MessageBody /// 信息项列表 /// public List InformationItems { get; set; } - + /// + /// + /// + /// + /// + /// public JT808_0x8303 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8303 jT808_0X8303 = new JT808_0x8303(); @@ -49,7 +59,12 @@ namespace JT808.Protocol.MessageBody } return jT808_0X8303; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8303 value, IJT808Config config) { writer.WriteByte(value.SettingType); @@ -64,7 +79,12 @@ namespace JT808.Protocol.MessageBody writer.WriteUInt16Return(length, position); } } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8303 value = new JT808_0x8303(); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8304.cs b/src/JT808.Protocol/MessageBody/JT808_0x8304.cs index 4d584b6..29d79ac 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8304.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8304.cs @@ -10,11 +10,17 @@ namespace JT808.Protocol.MessageBody /// /// 信息服务 /// 0x8304 + /// 2019版本已作删除 /// - [Obsolete("2019版本已作删除")] public class JT808_0x8304 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze, IJT808_2019_Version { + /// + /// 0x8304 + /// public override ushort MsgId { get; } = 0x8304; + /// + /// 信息服务 + /// public override string Description => "信息服务"; /// /// 信息类型 @@ -29,6 +35,12 @@ namespace JT808.Protocol.MessageBody /// 经 GBK 编码 /// public string InformationContent { get; set; } + /// + /// + /// + /// + /// + /// public JT808_0x8304 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8304 jT808_0X8304 = new JT808_0x8304(); @@ -37,7 +49,12 @@ namespace JT808.Protocol.MessageBody jT808_0X8304.InformationContent = reader.ReadString(jT808_0X8304.InformationLength); return jT808_0X8304; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8304 value, IJT808Config config) { writer.WriteByte(value.InformationType); @@ -47,6 +64,12 @@ namespace JT808.Protocol.MessageBody ushort length = (ushort)(writer.GetCurrentPosition() - position - 2); writer.WriteUInt16Return(length, position); } + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8304 value = new JT808_0x8304(); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8400.cs b/src/JT808.Protocol/MessageBody/JT808_0x8400.cs index fb23448..4aba3b7 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8400.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8400.cs @@ -12,7 +12,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8400 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x8400 + /// public override ushort MsgId { get; } = 0x8400; + /// + /// 电话回拨 + /// public override string Description => "电话回拨"; /// /// 0:普通通话；1:监听 @@ -23,7 +29,12 @@ namespace JT808.Protocol.MessageBody /// 最长为 20 字节 /// public string PhoneNumber { get; set; } - + /// + /// + /// + /// + /// + /// public JT808_0x8400 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8400 jT808_0X8400 = new JT808_0x8400(); @@ -32,13 +43,23 @@ namespace JT808.Protocol.MessageBody jT808_0X8400.PhoneNumber = reader.ReadRemainStringContent(); return jT808_0X8400; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8400 value, IJT808Config config) { writer.WriteByte((byte)value.CallBack); - writer.WriteString(value.PhoneNumber); + writer.WriteString(value.PhoneNumber.ValiMaxString(nameof(value.PhoneNumber),20)); } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8400 value = new JT808_0x8400(); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8401.cs b/src/JT808.Protocol/MessageBody/JT808_0x8401.cs index e7a799a..15cd26a 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8401.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8401.cs @@ -14,7 +14,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8401 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x8401 + /// public override ushort MsgId { get; } = 0x8401; + /// + /// 设置电话本 + /// public override string Description => "设置电话本"; /// /// 设置类型 @@ -28,7 +34,12 @@ namespace JT808.Protocol.MessageBody /// 联系人项 /// public IList JT808ContactProperties { get; set; } - + /// + /// + /// + /// + /// + /// public JT808_0x8401 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8401 jT808_0X8401 = new JT808_0x8401(); @@ -48,7 +59,12 @@ namespace JT808.Protocol.MessageBody jT808_0X8401.JT808ContactProperties = jT808_0X8401s; return jT808_0X8401; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8401 value, IJT808Config config) { writer.WriteByte((byte)value.SettingTelephoneBook); @@ -62,7 +78,12 @@ namespace JT808.Protocol.MessageBody writer.WriteString(item.Contact); } } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8401 value = new JT808_0x8401(); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8500.cs b/src/JT808.Protocol/MessageBody/JT808_0x8500.cs index a0cd666..38aa9a1 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8500.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8500.cs @@ -15,7 +15,13 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8500 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze, IJT808_2019_Version { + /// + /// 0x8500 + /// public override ushort MsgId { get; } = 0x8500; + /// + /// 车辆控制 + /// public override string Description => "车辆控制"; /// /// 控制标志 @@ -36,7 +42,12 @@ namespace JT808.Protocol.MessageBody /// 用于序列化的时候,由于厂家自定义类型比较多，所以直接用JT808_0x8500_ControlType /// public List ControlTypes { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8500 value = new JT808_0x8500(); @@ -73,7 +84,12 @@ namespace JT808.Protocol.MessageBody writer.WriteEndObject(); } } - + /// + /// + /// + /// + /// + /// public JT808_0x8500 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8500 value = new JT808_0x8500(); @@ -100,6 +116,12 @@ namespace JT808.Protocol.MessageBody } return value; } + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8500 value, IJT808Config config) { if (writer.Version == JT808Version.JTT2019) diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8500_0x0001.cs b/src/JT808.Protocol/MessageBody/JT808_0x8500_0x0001.cs index 5b316b9..b25f3c5 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8500_0x0001.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8500_0x0001.cs @@ -14,10 +14,21 @@ namespace JT808.Protocol.MessageBody /// public class JT808_0x8500_0x0001 : JT808_0x8500_ControlType, IJT808MessagePackFormatter, IJT808Analyze { + /// + /// 0x0001 + /// public override ushort ControlTypeId { get; set; } = 0x0001; + /// + /// 控制类型参数 + /// public byte ControlTypeParameter { get; set; } - + /// + /// + /// + /// + /// + /// public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) { JT808_0x8500_0x0001 value = new JT808_0x8500_0x0001(); @@ -26,7 +37,12 @@ namespace JT808.Protocol.MessageBody value.ControlTypeParameter = reader.ReadByte(); writer.WriteNumber($"[{ value.ControlTypeParameter.ReadNumber()}]控制类型参数", value.ControlTypeParameter); } - + /// + /// + /// + /// + /// + /// public JT808_0x8500_0x0001 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x8500_0x0001 value = new JT808_0x8500_0x0001(); @@ -34,7 +50,12 @@ namespace JT808.Protocol.MessageBody value.ControlTypeParameter = reader.ReadByte(); return value; } - + /// + /// + /// + /// + /// + /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8500_0x0001 value, IJT808Config config) { writer.WriteUInt16(value.ControlTypeId); diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8500_ControlType.cs b/src/JT808.Protocol/MessageBody/JT808_0x8500_ControlType.cs index 9876416..7d8e870 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x8500_ControlType.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x8500_ControlType.cs @@ -10,6 +10,9 @@ namespace JT808.Protocol.MessageBody /// public abstract class JT808_0x8500_ControlType : IJT808_2019_Version { + /// + /// 控制类型Id + /// public abstract ushort ControlTypeId { get; set; } } }