diff --git a/src/JT808.Protocol/Enums/JT808MsgId.cs b/src/JT808.Protocol/Enums/JT808MsgId.cs
index e5e226e..ed62b0a 100644
--- a/src/JT808.Protocol/Enums/JT808MsgId.cs
+++ b/src/JT808.Protocol/Enums/JT808MsgId.cs
@@ -69,21 +69,21 @@ namespace JT808.Protocol.Enums
/// 设置终端参数
/// 0x8103
///
- //[JT808BodiesType(typeof(JT808_0x8103))]
+ [JT808BodiesType(typeof(JT808_0x8103))]
[JT808MsgIdDescription("0x8103", "设置终端参数")]
设置终端参数 = 0x8103,
///
/// 查询终端参数
/// 0x8104
///
- //[JT808BodiesType(typeof(JT808_0x8104))]
+ [JT808BodiesType(typeof(JT808_0x8104))]
[JT808MsgIdDescription("0x8104", "查询终端参数")]
查询终端参数 = 0x8104,
///
/// 查询终端参数应答
/// 0x0104
///
- //[JT808BodiesType(typeof(JT808_0x0104))]
+ [JT808BodiesType(typeof(JT808_0x0104))]
[JT808MsgIdDescription("0x0104", "查询终端参数应答")]
查询终端参数应答 = 0x0104,
///
diff --git a/src/JT808.Protocol/Extensions/JT808EnumExtensions.cs b/src/JT808.Protocol/Extensions/JT808EnumExtensions.cs
index f2492d8..4667129 100644
--- a/src/JT808.Protocol/Extensions/JT808EnumExtensions.cs
+++ b/src/JT808.Protocol/Extensions/JT808EnumExtensions.cs
@@ -99,7 +99,7 @@ namespace JT808.Protocol.Extensions
///
/// 获取DescriptionAttribute特性枚举及描述
///
- ///
+ ///
///
public static Dictionary GetDescriptionAttributeDictionary(this Enum value)
{
diff --git a/src/JT808.Protocol/JT808.Protocol.csproj b/src/JT808.Protocol/JT808.Protocol.csproj
index 713c008..710d85a 100644
--- a/src/JT808.Protocol/JT808.Protocol.csproj
+++ b/src/JT808.Protocol/JT808.Protocol.csproj
@@ -53,92 +53,6 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/src/JT808.Protocol/JT808.Protocol.xml b/src/JT808.Protocol/JT808.Protocol.xml
index 86be106..233ace5 100644
--- a/src/JT808.Protocol/JT808.Protocol.xml
+++ b/src/JT808.Protocol/JT808.Protocol.xml
@@ -867,7 +867,7 @@
获取DescriptionAttribute特性枚举及描述
-
+
@@ -2399,6 +2399,27 @@
鉴权码
+
+
+ 查询终端参数应答
+
+
+
+
+ 应答流水号
+ 查询指定终端参数的流水号
+
+
+
+
+ 应答参数个数
+
+
+
+
+ 参数列表
+
+
查询终端属性应答
@@ -3186,6 +3207,1323 @@
只有在成功后才有该字段
+
+
+ 设置终端参数
+
+
+
+
+ 参数总数
+
+
+
+
+ 参数列表
+
+
+
+
+ 终端心跳发送间隔，单位为秒（s）
+ 0x8103_0x0001
+
+
+
+
+ 数据 长度
+
+
+
+
+ 终端心跳发送间隔，单位为秒（s）
+
+
+
+
+ TCP 消息应答超时时间，单位为秒（s）
+ 0x8103_0x0002
+
+
+
+
+ 数据 长度
+
+
+
+
+ TCP 消息应答超时时间，单位为秒（s）
+
+
+
+
+ TCP 消息重传次数
+ 0x8103_0x0003
+
+
+
+
+ 数据 长度
+
+
+
+
+ TCP 消息重传次数
+
+
+
+
+ UDP 消息应答超时时间，单位为秒（s）
+ 0x8103_0x0004
+
+
+
+
+ 数据 长度
+
+
+
+
+ UDP 消息应答超时时间，单位为秒（s）
+
+
+
+
+ UDP 消息重传次数
+ 0x8103_0x0005
+
+
+
+
+ 数据 长度
+
+
+
+
+ UDP 消息重传次数
+
+
+
+
+ SMS 消息应答超时时间，单位为秒（s）
+ 0x8103_0x0006
+
+
+
+
+ 数据 长度
+
+
+
+
+ SMS 消息应答超时时间，单位为秒（s）
+
+
+
+
+ SMS 消息重传次数
+ 0x8103_0x0007
+
+
+
+
+ 数据 长度
+
+
+
+
+ SMS 消息重传次数
+
+
+
+
+ 主服务器 APN，无线通信拨号访问点。若网络制式为 CDMA，则该处为PPP 拨号号码
+
+
+
+
+ 数据 长度
+
+
+
+
+ 主服务器 APN，无线通信拨号访问点。若网络制式为 CDMA，则该处为PPP 拨号号码
+
+
+
+
+ 主服务器无线通信拨号用户名
+
+
+
+
+ 数据 长度
+
+
+
+
+ 主服务器无线通信拨号用户名
+
+
+
+
+ 主服务器无线通信拨号密码
+
+
+
+
+ 数据 长度
+
+
+
+
+ 主服务器无线通信拨号密码
+
+
+
+
+ 主服务器地址,IP 或域名
+
+
+
+
+ 数据 长度
+
+
+
+
+ 主服务器地址,IP 或域名
+
+
+
+
+ 备份服务器 APN，无线通信拨号访问点
+
+
+
+
+ 数据 长度
+
+
+
+
+ 备份服务器 APN，无线通信拨号访问点
+
+
+
+
+ 备份服务器无线通信拨号用户名
+
+
+
+
+ 数据 长度
+
+
+
+
+ 备份服务器无线通信拨号用户名
+
+
+
+
+ 备份服务器无线通信拨号密码
+
+
+
+
+ 数据 长度
+
+
+
+
+ 备份服务器无线通信拨号密码
+
+
+
+
+ 备份服务器地址,IP 或域名
+
+
+
+
+ 数据 长度
+
+
+
+
+ 备份服务器地址,IP 或域名
+
+
+
+
+ 服务器 TCP 端口
+
+
+
+
+ 数据 长度
+
+
+
+
+ 服务器 TCP 端口
+
+
+
+
+ 服务器 UDP 端口
+
+
+
+
+ 数据 长度
+
+
+
+
+ 服务器 TCP 端口
+
+
+
+
+ 道路运输证 IC 卡认证主服务器 IP 地址或域名
+
+
+
+
+ 数据 长度
+
+
+
+
+ 道路运输证 IC 卡认证主服务器 IP 地址或域名
+
+
+
+
+ 道路运输证 IC 卡认证主服务器 TCP 端口
+
+
+
+
+ 数据 长度
+
+
+
+
+ 道路运输证 IC 卡认证主服务器 TCP 端口
+
+
+
+
+ 道路运输证 IC 卡认证主服务器 UDP 端口
+
+
+
+
+ 数据 长度
+
+
+
+
+ 道路运输证 IC 卡认证主服务器 UDP 端口
+
+
+
+
+ 道路运输证 IC 卡认证备份服务器 IP 地址或域名，端口同主服务器
+
+
+
+
+ 数据 长度
+
+
+
+
+ 道路运输证 IC 卡认证备份服务器 IP 地址或域名，端口同主服务器
+
+
+
+
+ 位置汇报策略，0：定时汇报；1：定距汇报；2：定时和定距汇报
+
+
+
+
+ 数据 长度
+
+
+
+
+ 位置汇报策略，0：定时汇报；1：定距汇报；2：定时和定距汇报
+
+
+
+
+ 位置汇报方案，0：根据 ACC 状态； 1：根据登录状态和 ACC 状态，先判断登录状态，若登录再根据 ACC 状态
+
+
+
+
+ 数据 长度
+
+
+
+
+ 位置汇报方案，0：根据 ACC 状态； 1：根据登录状态和 ACC 状态，先判断登录状态，若登录再根据 ACC 状态
+
+
+
+
+ 驾驶员未登录汇报时间间隔，单位为秒（s），>0
+
+
+
+
+ 数据 长度
+
+
+
+
+ 驾驶员未登录汇报时间间隔，单位为秒（s），>0
+
+
+
+
+ 休眠时汇报时间间隔，单位为秒（s），>0
+
+
+
+
+ 数据 长度
+
+
+
+
+ 休眠时汇报时间间隔，单位为秒（s），>0
+
+
+
+
+ 紧急报警时汇报时间间隔，单位为秒（s），>0
+
+
+
+
+ 数据 长度
+
+
+
+
+ 紧急报警时汇报时间间隔，单位为秒（s），>0
+
+
+
+
+ 缺省时间汇报间隔，单位为秒（s），>0
+
+
+
+
+ 数据 长度
+
+
+
+
+ 缺省时间汇报间隔，单位为秒（s），>0
+
+
+
+
+ 缺省距离汇报间隔，单位为米（m），>0
+
+
+
+
+ 数据 长度
+
+
+
+
+ 缺省距离汇报间隔，单位为米（m），>0
+
+
+
+
+ 驾驶员未登录汇报距离间隔，单位为米（m），>0
+
+
+
+
+ 数据 长度
+
+
+
+
+ 驾驶员未登录汇报距离间隔，单位为米（m），>0
+
+
+
+
+ 休眠时汇报距离间隔，单位为米（m），>0
+
+
+
+
+ 数据 长度
+
+
+
+
+ 休眠时汇报距离间隔，单位为米（m），>0
+
+
+
+
+ 紧急报警时汇报距离间隔，单位为米（m），>0
+
+
+
+
+ 数据 长度
+
+
+
+
+ 紧急报警时汇报距离间隔，单位为米（m），>0
+
+
+
+
+
+ 数据 长度
+
+
+
+
+
+ 电子围栏半径（非法位移阈值），单位为米
+
+
+
+
+ 数据 长度
+
+
+
+
+ 电子围栏半径（非法位移阈值），单位为米
+
+
+
+
+ 监控平台电话号码
+
+
+
+
+ 数据 长度
+
+
+
+
+ 监控平台电话号码
+
+
+
+
+ 复位电话号码，可采用此电话号码拨打终端电话让终端复位
+
+
+
+
+ 数据 长度
+
+
+
+
+ 复位电话号码，可采用此电话号码拨打终端电话让终端复位
+
+
+
+
+ 恢复出厂设置电话号码，可采用此电话号码拨打终端电话让终端恢复出厂设置
+
+
+
+
+ 数据 长度
+
+
+
+
+ 恢复出厂设置电话号码，可采用此电话号码拨打终端电话让终端恢复出厂设置
+
+
+
+
+ 监控平台 SMS 电话号码
+
+
+
+
+ 数据 长度
+
+
+
+
+ 监控平台 SMS 电话号码
+
+
+
+
+ 接收终端 SMS 文本报警号码
+
+
+
+
+ 数据 长度
+
+
+
+
+ 接收终端 SMS 文本报警号码
+
+
+
+
+ 终端电话接听策略，0：自动接听；1：ACC ON 时自动接听，OFF 时手动接听
+
+
+
+
+ 数据 长度
+
+
+
+
+ 终端电话接听策略，0：自动接听；1：ACC ON 时自动接听，OFF 时手动接听
+
+
+
+
+ 每次最长通话时间，单位为秒（s），0 为不允许通话，0xFFFFFFFF 为不限制
+
+
+
+
+ 数据 长度
+
+
+
+
+ 每次最长通话时间，单位为秒（s），0 为不允许通话，0xFFFFFFFF 为不限制
+
+
+
+
+ 当月最长通话时间，单位为秒（s），0 为不允许通话，0xFFFFFFFF 为不限制
+
+
+
+
+ 数据 长度
+
+
+
+
+ 当月最长通话时间，单位为秒（s），0 为不允许通话，0xFFFFFFFF 为不限制
+
+
+
+
+ 监听电话号码
+
+
+
+
+ 数据 长度
+
+
+
+
+ 监听电话号码
+
+
+
+
+ 监管平台特权短信号码
+
+
+
+
+ 数据 长度
+
+
+
+
+ 监管平台特权短信号码
+
+
+
+
+ 报警屏蔽字，与位置信息汇报消息中的报警标志相对应，相应位为 1则相应报警被屏蔽
+
+
+
+
+ 数据 长度
+
+
+
+
+ 报警屏蔽字，与位置信息汇报消息中的报警标志相对应，相应位为 1则相应报警被屏蔽
+
+
+
+
+ 报警发送文本 SMS 开关，与位置信息汇报消息中的报警标志相对应，相应位为 1 则相应报警时发送文本 SMS
+
+
+
+
+ 数据 长度
+
+
+
+
+ 报警发送文本 SMS 开关，与位置信息汇报消息中的报警标志相对应，相应位为 1 则相应报警时发送文本 SMS
+
+
+
+
+ 报警拍摄开关，与位置信息汇报消息中的报警标志相对应，相应位为1 则相应报警时摄像头拍摄
+
+
+
+
+ 数据 长度
+
+
+
+
+ 报警拍摄开关，与位置信息汇报消息中的报警标志相对应，相应位为1 则相应报警时摄像头拍摄
+
+
+
+
+ 报警拍摄存储标志，与位置信息汇报消息中的报警标志相对应，相应位为 1 则对相应报警时拍的照片进行存储，否则实时上传
+
+
+
+
+ 数据 长度
+
+
+
+
+ 报警拍摄存储标志，与位置信息汇报消息中的报警标志相对应，相应位为 1 则对相应报警时拍的照片进行存储，否则实时上传
+
+
+
+
+ 关键标志，与位置信息汇报消息中的报警标志相对应，相应位为 1 则对相应报警为关键报警
+
+
+
+
+ 数据 长度
+
+
+
+
+ 关键标志，与位置信息汇报消息中的报警标志相对应，相应位为 1 则对相应报警为关键报警
+
+
+
+
+ 最高速度，单位为公里每小时（km/h）
+
+
+
+
+ 数据 长度
+
+
+
+
+ 最高速度，单位为公里每小时（km/h）
+
+
+
+
+ 超速持续时间，单位为秒（s）
+
+
+
+
+ 数据 长度
+
+
+
+
+ 超速持续时间，单位为秒（s）
+
+
+
+
+ 连续驾驶时间门限，单位为秒（s）
+
+
+
+
+ 数据 长度
+
+
+
+
+ 连续驾驶时间门限，单位为秒（s）
+
+
+
+
+ 当天累计驾驶时间门限，单位为秒（s）
+
+
+
+
+ 数据 长度
+
+
+
+
+ 当天累计驾驶时间门限，单位为秒（s）
+
+
+
+
+ 最小休息时间，单位为秒（s）
+
+
+
+
+ 数据 长度
+
+
+
+
+ 最小休息时间，单位为秒（s）
+
+
+
+
+ 最长停车时间，单位为秒（s）
+
+
+
+
+ 数据 长度
+
+
+
+
+ 最长停车时间，单位为秒（s）
+
+
+
+
+ 超速报警预警差值，单位为 1/10Km/h
+
+
+
+
+ 数据 长度
+
+
+
+
+ 超速报警预警差值，单位为 1/10Km/h
+
+
+
+
+ 疲劳驾驶预警差值，单位为秒（s），>0
+
+
+
+
+ 数据 长度
+
+
+
+
+ 疲劳驾驶预警差值，单位为秒（s），>0
+
+
+
+
+ 碰撞报警参数设置
+ b7-b0： 碰撞时间，单位 4ms；
+ b15-b8：碰撞加速度，单位 0.1g，设置范围在：0-79 之间，默认为10。
+
+
+
+
+ 数据 长度
+
+
+
+
+ 碰撞报警参数设置
+ b7-b0： 碰撞时间，单位 4ms；
+ b15-b8：碰撞加速度，单位 0.1g，设置范围在：0-79 之间，默认为10。
+
+
+
+
+ 侧翻报警参数设置：
+ 侧翻角度，单位 1 度，默认为 30 度
+
+
+
+
+ 数据 长度
+
+
+
+
+ 侧翻报警参数设置：
+ 侧翻角度，单位 1 度，默认为 30 度
+
+
+
+
+ 定时拍照控制，见 表 13
+
+
+
+
+ 数据 长度
+
+
+
+
+ 定时拍照控制，见 表 13
+
+
+
+
+ 定距拍照控制，见 表 14
+
+
+
+
+ 数据 长度
+
+
+
+
+ 定距拍照控制，见 表 14
+
+
+
+
+ 图像/视频质量，1-10，1 最好
+
+
+
+
+ 数据 长度
+
+
+
+
+ 图像/视频质量，1-10，1 最好
+
+
+
+
+ 亮度，0-255
+
+
+
+
+ 数据 长度
+
+
+
+
+ 亮度，0-255
+
+
+
+
+ 对比度，0-127
+
+
+
+
+ 数据 长度
+
+
+
+
+ 对比度，0-127
+
+
+
+
+ 饱和度，0-127
+
+
+
+
+ 数据 长度
+
+
+
+
+ 饱和度，0-127
+
+
+
+
+ 色度，0-255
+
+
+
+
+ 数据 长度
+
+
+
+
+ 饱和度，0-127
+
+
+
+
+ 车辆里程表读数，1/10km
+
+
+
+
+ 数据 长度
+
+
+
+
+ 车辆里程表读数，1/10km
+
+
+
+
+ 车辆所在的省域 ID
+
+
+
+
+ 数据 长度
+
+
+
+
+ 车辆所在的省域 ID
+
+
+
+
+ 车辆所在的市域 ID
+
+
+
+
+ 数据 长度
+
+
+
+
+ 车辆所在的市域 ID
+
+
+
+
+ 公安交通管理部门颁发的机动车号牌
+
+
+
+
+ 数据 长度
+
+
+
+
+ 公安交通管理部门颁发的机动车号牌
+
+
+
+
+ 车牌颜色，按照 JT/T415-2006 的 5.4.12
+
+
+
+
+ 数据 长度
+
+
+
+
+ 车牌颜色，按照 JT/T415-2006 的 5.4.12
+
+
+
+
+ GNSS 定位模式，定义如下：
+ bit0，0：禁用 GPS 定位， 1：启用 GPS 定位；
+ bit1，0：禁用北斗定位， 1：启用北斗定位；
+ bit2，0：禁用 GLONASS 定位， 1：启用 GLONASS 定位；
+ bit3，0：禁用 Galileo 定位， 1：启用 Galileo 定位。
+
+
+
+
+ 数据 长度
+
+
+
+
+ GNSS 定位模式，定义如下：
+ bit0，0：禁用 GPS 定位， 1：启用 GPS 定位；
+ bit1，0：禁用北斗定位， 1：启用北斗定位；
+ bit2，0：禁用 GLONASS 定位， 1：启用 GLONASS 定位；
+ bit3，0：禁用 Galileo 定位， 1：启用 Galileo 定位。
+
+
+
+
+ GNSS 波特率，定义如下：
+ 0x00：4800；0x01：9600；
+ 0x02：19200；0x03：38400；
+ 0x04：57600；0x05：115200。
+
+
+
+
+ 数据 长度
+
+
+
+
+ GNSS 波特率，定义如下：
+ 0x00：4800；0x01：9600；
+ 0x02：19200；0x03：38400；
+ 0x04：57600；0x05：115200。
+
+
+
+
+ GNSS 模块详细定位数据输出频率，定义如下：
+ 0x00：500ms；0x01：1000ms（默认值）；
+ 0x02：2000ms；0x03：3000ms；
+ 0x04：4000ms。
+
+
+
+
+ 数据 长度
+
+
+
+
+ GNSS 模块详细定位数据输出频率，定义如下：
+ 0x00：500ms；0x01：1000ms（默认值）；
+ 0x02：2000ms；0x03：3000ms；
+ 0x04：4000ms。
+
+
+
+
+ GNSS 模块详细定位数据采集频率，单位为秒，默认为 1。
+
+
+
+
+ 数据 长度
+
+
+
+
+ GNSS 模块详细定位数据采集频率，单位为秒，默认为 1。
+
+
+
+
+ GNSS 模块详细定位数据上传方式
+ 0x00，本地存储，不上传（默认值）；
+ 0x01，按时间间隔上传；
+ 0x02，按距离间隔上传；
+ 0x0B，按累计时间上传，达到传输时间后自动停止上传；
+ 0x0C，按累计距离上传，达到距离后自动停止上传；
+ 0x0D，按累计条数上传，达到上传条数后自动停止上传。
+
+
+
+
+ 数据 长度
+
+
+
+
+ GNSS 模块详细定位数据上传方式
+ 0x00，本地存储，不上传（默认值）；
+ 0x01，按时间间隔上传；
+ 0x02，按距离间隔上传；
+ 0x0B，按累计时间上传，达到传输时间后自动停止上传；
+ 0x0C，按累计距离上传，达到距离后自动停止上传；
+ 0x0D，按累计条数上传，达到上传条数后自动停止上传。
+
+
+
+
+ GNSS 模块详细定位数据上传设置：
+ 上传方式为 0x01 时，单位为秒；
+ 上传方式为 0x02 时，单位为米；
+ 上传方式为 0x0B 时，单位为秒；
+ 上传方式为 0x0C 时，单位为米；
+ 上传方式为 0x0D 时，单位为条。
+
+
+
+
+ 数据 长度
+
+
+
+
+ GNSS 模块详细定位数据上传设置：
+ 上传方式为 0x01 时，单位为秒；
+ 上传方式为 0x02 时，单位为米；
+ 上传方式为 0x0B 时，单位为秒；
+ 上传方式为 0x0C 时，单位为米；
+ 上传方式为 0x0D 时，单位为条。
+
+
+
+
+ CAN 总线通道 1 采集时间间隔(ms)，0 表示不采集
+
+
+
+
+ 数据 长度
+
+
+
+
+ CAN 总线通道 1 采集时间间隔(ms)，0 表示不采集
+
+
+
+
+ CAN 总线通道 1 上传时间间隔(s)，0 表示不上传
+
+
+
+
+ 数据 长度
+
+
+
+
+ CAN 总线通道 1 上传时间间隔(s)，0 表示不上传
+
+
+
+
+ CAN 总线通道 2 采集时间间隔(ms)，0 表示不采集
+
+
+
+
+ 数据 长度
+
+
+
+
+ CAN 总线通道 2 采集时间间隔(ms)，0 表示不采集
+
+
+
+
+ CAN 总线通道 2 上传时间间隔(s)，0 表示不上传
+
+
+
+
+ 数据 长度
+
+
+
+
+ CAN 总线通道 2 上传时间间隔(s)，0 表示不上传
+
+
+
+
+ CAN 总线 ID 单独采集设置：
+ bit63-bit32 表示此 ID 采集时间间隔(ms)，0 表示不采集；
+ bit31 表示 CAN 通道号，0：CAN1，1：CAN2；
+ bit30 表示帧类型，0：标准帧，1：扩展帧；
+ bit29 表示数据采集方式，0：原始数据，1：采集区间的计算值；
+ bit28-bit0 表示 CAN 总线 ID。
+
+
+
+
+ 数据 长度
+
+
+
+
+ CAN 总线 ID 单独采集设置：
+ bit63-bit32 表示此 ID 采集时间间隔(ms)，0 表示不采集；
+ bit31 表示 CAN 通道号，0：CAN1，1：CAN2；
+ bit30 表示帧类型，0：标准帧，1：扩展帧；
+ bit29 表示数据采集方式，0：原始数据，1：采集区间的计算值；
+ bit28-bit0 表示 CAN 总线 ID。
+
+
+
+
+ 参数 ID
+
+
+
+
+ 参数长度
+
+
+
+
+ 参数 ID
+
+
+
+
+ 参数长度
+
+
+
+
+ 查询终端参数
+
+
+
+
+ 跳过数据体序列化
+
+
终端控制
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103.cs
index c0816c5..8a371a7 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103.cs
@@ -1,5 +1,8 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Extensions;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
+using System;
using System.Collections.Generic;
using System.Linq;
@@ -8,8 +11,7 @@ namespace JT808.Protocol.MessageBody
///
/// 设置终端参数
///
- [JT808Formatter(typeof(JT808_0x8103_Formatter))]
- public class JT808_0x8103 : JT808Bodies
+ public class JT808_0x8103 : JT808Bodies, IJT808MessagePackFormatter
{
///
/// 参数总数
@@ -32,5 +34,61 @@ 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 jT808_0x8103 = new JT808_0x8103
+ {
+ ParamList = new List(),
+ CustomParamList = new List()
+ };
+ var paramCount = reader.ReadByte();//参数总数
+ try
+ {
+ for (int i = 0; i < paramCount; i++)
+ {
+ var paramId = reader.ReadVirtualUInt32();//参数ID
+ if (config.JT808_0X8103_Factory.ParamMethods.TryGetValue(paramId, out Type type))
+ {
+ object attachImplObj = config.GetMessagePackFormatterByType(type);
+ dynamic attachImpl = JT808MessagePackFormatterResolverExtensions.JT808DynamicDeserialize(attachImplObj, ref reader, config);
+ jT808_0x8103.ParamList.Add(attachImpl);
+ }
+ else if (config.JT808_0X8103_Custom_Factory.ParamMethods.TryGetValue(paramId, out Type customType))
+ {
+ object attachImplObj = config.GetMessagePackFormatterByType(customType);
+ dynamic attachImpl = JT808MessagePackFormatterResolverExtensions.JT808DynamicDeserialize(attachImplObj, ref reader, config);
+ jT808_0x8103.CustomParamList.Add(attachImpl);
+ }
+ }
+ }
+ catch (Exception ex)
+ {
+
+ }
+ return jT808_0x8103;
+ }
+
+ public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103 value, IJT808Config config)
+ {
+ writer.WriteByte(value.ParamCount);
+ try
+ {
+ foreach (var item in value.ParamList)
+ {
+ object attachImplObj = config.GetMessagePackFormatterByType(item.GetType());
+ JT808MessagePackFormatterResolverExtensions.JT808DynamicSerialize(attachImplObj, ref writer, item, config);
+ }
+ if (value.CustomParamList != null)
+ {
+ foreach (var item in value.CustomParamList)
+ {
+ object attachImplObj = config.GetMessagePackFormatterByType(item.GetType());
+ JT808MessagePackFormatterResolverExtensions.JT808DynamicSerialize(attachImplObj, ref writer, item, config);
+ }
+ }
+ }
+ catch (Exception ex) { }
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0001.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0001.cs
index 803f672..1a1bc1e 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0001.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0001.cs
@@ -1,5 +1,6 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
@@ -7,8 +8,7 @@ namespace JT808.Protocol.MessageBody
/// 终端心跳发送间隔，单位为秒（s）
/// 0x8103_0x0001
///
- [JT808Formatter(typeof(JT808_0x8103_0x0001_Formatter))]
- public class JT808_0x8103_0x0001 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0001 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0001;
///
@@ -19,5 +19,21 @@ namespace JT808.Protocol.MessageBody
/// 终端心跳发送间隔，单位为秒（s）
///
public uint ParamValue { get; set; }
+
+ public JT808_0x8103_0x0001 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0001 jT808_0x8103_0x0001 = new JT808_0x8103_0x0001();
+ jT808_0x8103_0x0001.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0001.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0002.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0002.cs
index d5329b7..67d62e8 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0002.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0002.cs
@@ -1,5 +1,6 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
@@ -7,8 +8,7 @@ namespace JT808.Protocol.MessageBody
/// TCP 消息应答超时时间，单位为秒（s）
/// 0x8103_0x0002
///
- [JT808Formatter(typeof(JT808_0x8103_0x0002_Formatter))]
- public class JT808_0x8103_0x0002 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0002 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0002;
///
@@ -19,5 +19,20 @@ namespace JT808.Protocol.MessageBody
/// TCP 消息应答超时时间，单位为秒（s）
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0002 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0002 jT808_0x8103_0x0002 = new JT808_0x8103_0x0002();
+ jT808_0x8103_0x0002.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0002.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0003.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0003.cs
index bf91318..7ef249a 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0003.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0003.cs
@@ -1,5 +1,6 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
@@ -7,8 +8,7 @@ namespace JT808.Protocol.MessageBody
/// TCP 消息重传次数
/// 0x8103_0x0003
///
- [JT808Formatter(typeof(JT808_0x8103_0x0003_Formatter))]
- public class JT808_0x8103_0x0003 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0003 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0003;
///
@@ -19,5 +19,21 @@ namespace JT808.Protocol.MessageBody
/// TCP 消息重传次数
///
public uint ParamValue { get; set; }
+
+ public JT808_0x8103_0x0003 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0003 jT808_0x8103_0x0003 = new JT808_0x8103_0x0003();
+ jT808_0x8103_0x0003.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0003.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0004.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0004.cs
index e3e5501..ddce8fa 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0004.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0004.cs
@@ -1,5 +1,6 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
@@ -7,8 +8,7 @@ namespace JT808.Protocol.MessageBody
/// UDP 消息应答超时时间，单位为秒（s）
/// 0x8103_0x0004
///
- [JT808Formatter(typeof(JT808_0x8103_0x0004_Formatter))]
- public class JT808_0x8103_0x0004 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0004 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0004;
///
@@ -19,5 +19,20 @@ namespace JT808.Protocol.MessageBody
/// UDP 消息应答超时时间，单位为秒（s）
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0004 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0004 jT808_0x8103_0x0004 = new JT808_0x8103_0x0004();
+ jT808_0x8103_0x0004.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0004.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0005.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0005.cs
index 4833c36..4a61ae8 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0005.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0005.cs
@@ -1,5 +1,6 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
@@ -7,8 +8,7 @@ namespace JT808.Protocol.MessageBody
/// UDP 消息重传次数
/// 0x8103_0x0005
///
- [JT808Formatter(typeof(JT808_0x8103_0x0005_Formatter))]
- public class JT808_0x8103_0x0005 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0005 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0005;
///
@@ -19,5 +19,20 @@ namespace JT808.Protocol.MessageBody
/// UDP 消息重传次数
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0005 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0005 jT808_0x8103_0x0005 = new JT808_0x8103_0x0005();
+ jT808_0x8103_0x0005.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0005.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0006.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0006.cs
index 1718568..4e1b506 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0006.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0006.cs
@@ -1,5 +1,6 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
@@ -7,8 +8,7 @@ namespace JT808.Protocol.MessageBody
/// SMS 消息应答超时时间，单位为秒（s）
/// 0x8103_0x0006
///
- [JT808Formatter(typeof(JT808_0x8103_0x0006_Formatter))]
- public class JT808_0x8103_0x0006 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0006 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0006;
///
@@ -19,5 +19,20 @@ namespace JT808.Protocol.MessageBody
/// SMS 消息应答超时时间，单位为秒（s）
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0006 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0006 jT808_0x8103_0x0006 = new JT808_0x8103_0x0006();
+ jT808_0x8103_0x0006.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0006.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0007.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0007.cs
index 4e71207..e04bbb2 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0007.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0007.cs
@@ -1,5 +1,6 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
@@ -7,8 +8,7 @@ namespace JT808.Protocol.MessageBody
/// SMS 消息重传次数
/// 0x8103_0x0007
///
- [JT808Formatter(typeof(JT808_0x8103_0x0007_Formatter))]
- public class JT808_0x8103_0x0007 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0007 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0007;
///
@@ -19,5 +19,20 @@ namespace JT808.Protocol.MessageBody
/// SMS 消息重传次数
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0007 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0007 jT808_0x8103_0x0007 = new JT808_0x8103_0x0007();
+ jT808_0x8103_0x0007.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0007.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0010.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0010.cs
index 0dd35de..ede685b 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0010.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0010.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 主服务器 APN，无线通信拨号访问点。若网络制式为 CDMA，则该处为PPP 拨号号码
///
- [JT808Formatter(typeof(JT808_0x8103_0x0010_Formatter))]
- public class JT808_0x8103_0x0010 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0010 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0010;
///
@@ -18,5 +18,22 @@ namespace JT808.Protocol.MessageBody
/// 主服务器 APN，无线通信拨号访问点。若网络制式为 CDMA，则该处为PPP 拨号号码
///
public string ParamValue { get; set; }
+ public JT808_0x8103_0x0010 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0010 jT808_0x8103_0x0010 = new JT808_0x8103_0x0010();
+ jT808_0x8103_0x0010.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0010.ParamLength = reader.ReadByte();
+ 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);
+ writer.Skip(1, out int skipPosition);
+ writer.WriteString(value.ParamValue);
+ int length = writer.GetCurrentPosition() - skipPosition - 1;
+ writer.WriteByteReturn((byte)length, skipPosition);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0011.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0011.cs
index 396c8b0..7584bc4 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0011.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0011.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 主服务器无线通信拨号用户名
///
- [JT808Formatter(typeof(JT808_0x8103_0x0011_Formatter))]
- public class JT808_0x8103_0x0011 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0011 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0011;
///
@@ -18,5 +18,22 @@ namespace JT808.Protocol.MessageBody
/// 主服务器无线通信拨号用户名
///
public string ParamValue { get; set; }
+ public JT808_0x8103_0x0011 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0011 jT808_0x8103_0x0011 = new JT808_0x8103_0x0011();
+ jT808_0x8103_0x0011.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0011.ParamLength = reader.ReadByte();
+ 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);
+ writer.Skip(1, out int skipPosition);
+ writer.WriteString(value.ParamValue);
+ int length = writer.GetCurrentPosition() - skipPosition - 1;
+ writer.WriteByteReturn((byte)length, skipPosition);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0012.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0012.cs
index 0a7ddc9..0e9bf6c 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0012.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0012.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 主服务器无线通信拨号密码
///
- [JT808Formatter(typeof(JT808_0x8103_0x0012_Formatter))]
- public class JT808_0x8103_0x0012 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0012 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0012;
///
@@ -18,5 +18,22 @@ namespace JT808.Protocol.MessageBody
/// 主服务器无线通信拨号密码
///
public string ParamValue { get; set; }
+ public JT808_0x8103_0x0012 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0012 jT808_0x8103_0x0012 = new JT808_0x8103_0x0012();
+ jT808_0x8103_0x0012.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0012.ParamLength = reader.ReadByte();
+ 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);
+ writer.Skip(1, out int skipPosition);
+ writer.WriteString(value.ParamValue);
+ int length = writer.GetCurrentPosition() - skipPosition - 1;
+ writer.WriteByteReturn((byte)length, skipPosition);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0013.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0013.cs
index c953c93..b88c841 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0013.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0013.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 主服务器地址,IP 或域名
///
- [JT808Formatter(typeof(JT808_0x8103_0x0013_Formatter))]
- public class JT808_0x8103_0x0013 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0013 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0013;
///
@@ -18,5 +18,22 @@ namespace JT808.Protocol.MessageBody
/// 主服务器地址,IP 或域名
///
public string ParamValue { get; set; }
+ public JT808_0x8103_0x0013 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0013 jT808_0x8103_0x0013 = new JT808_0x8103_0x0013();
+ jT808_0x8103_0x0013.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0013.ParamLength = reader.ReadByte();
+ 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);
+ writer.Skip(1, out int skipPosition);
+ writer.WriteString(value.ParamValue);
+ int length = writer.GetCurrentPosition() - skipPosition - 1;
+ writer.WriteByteReturn((byte)length, skipPosition);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0014.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0014.cs
index 7432614..79c6661 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0014.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0014.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 备份服务器 APN，无线通信拨号访问点
///
- [JT808Formatter(typeof(JT808_0x8103_0x0014_Formatter))]
- public class JT808_0x8103_0x0014 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0014 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0014;
///
@@ -18,5 +18,22 @@ namespace JT808.Protocol.MessageBody
/// 备份服务器 APN，无线通信拨号访问点
///
public string ParamValue { get; set; }
+ public JT808_0x8103_0x0014 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0014 jT808_0x8103_0x0014 = new JT808_0x8103_0x0014();
+ jT808_0x8103_0x0014.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0014.ParamLength = reader.ReadByte();
+ 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);
+ writer.Skip(1, out int skipPosition);
+ writer.WriteString(value.ParamValue);
+ int length = writer.GetCurrentPosition() - skipPosition - 1;
+ writer.WriteByteReturn((byte)length, skipPosition);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0015.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0015.cs
index 7aa2217..19a6664 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0015.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0015.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 备份服务器无线通信拨号用户名
///
- [JT808Formatter(typeof(JT808_0x8103_0x0015_Formatter))]
- public class JT808_0x8103_0x0015 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0015 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0015;
///
@@ -18,5 +18,22 @@ namespace JT808.Protocol.MessageBody
/// 备份服务器无线通信拨号用户名
///
public string ParamValue { get; set; }
+ public JT808_0x8103_0x0015 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0015 jT808_0x8103_0x0015 = new JT808_0x8103_0x0015();
+ jT808_0x8103_0x0015.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0015.ParamLength = reader.ReadByte();
+ 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);
+ writer.Skip(1, out int skipPosition);
+ writer.WriteString(value.ParamValue);
+ int length = writer.GetCurrentPosition() - skipPosition - 1;
+ writer.WriteByteReturn((byte)length, skipPosition);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0016.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0016.cs
index a64e979..e3dd443 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0016.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0016.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 备份服务器无线通信拨号密码
///
- [JT808Formatter(typeof(JT808_0x8103_0x0016_Formatter))]
- public class JT808_0x8103_0x0016 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0016 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0016;
///
@@ -18,5 +18,22 @@ namespace JT808.Protocol.MessageBody
/// 备份服务器无线通信拨号密码
///
public string ParamValue { get; set; }
+ public JT808_0x8103_0x0016 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0016 jT808_0x8103_0x0016 = new JT808_0x8103_0x0016();
+ jT808_0x8103_0x0016.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0016.ParamLength = reader.ReadByte();
+ 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);
+ writer.Skip(1, out int skipPosition);
+ writer.WriteString(value.ParamValue);
+ int length = writer.GetCurrentPosition() - skipPosition - 1;
+ writer.WriteByteReturn((byte)length, skipPosition);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0017.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0017.cs
index f0c34f1..1cfc3eb 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0017.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0017.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 备份服务器地址,IP 或域名
///
- [JT808Formatter(typeof(JT808_0x8103_0x0017_Formatter))]
- public class JT808_0x8103_0x0017 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0017 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0017;
///
@@ -18,5 +18,22 @@ namespace JT808.Protocol.MessageBody
/// 备份服务器地址,IP 或域名
///
public string ParamValue { get; set; }
+ public JT808_0x8103_0x0017 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0017 jT808_0x8103_0x0017 = new JT808_0x8103_0x0017();
+ jT808_0x8103_0x0017.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0017.ParamLength = reader.ReadByte();
+ 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);
+ writer.Skip(1, out int skipPosition);
+ writer.WriteString(value.ParamValue);
+ int length = writer.GetCurrentPosition() - skipPosition - 1;
+ writer.WriteByteReturn((byte)length, skipPosition);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0018.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0018.cs
index 89fa14c..2ac12b5 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0018.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0018.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 服务器 TCP 端口
///
- [JT808Formatter(typeof(JT808_0x8103_0x0018_Formatter))]
- public class JT808_0x8103_0x0018 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0018 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0018;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
///服务器 TCP 端口
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0018 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0018 jT808_0x8103_0x0018 = new JT808_0x8103_0x0018();
+ jT808_0x8103_0x0018.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0018.ParamLength = reader.ReadByte();
+ jT808_0x8103_0x0018.ParamValue = reader.ReadUInt32();
+ return jT808_0x8103_0x0018;
+ }
+
+ public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0018 value, IJT808Config config)
+ {
+ writer.WriteUInt32(value.ParamId);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0019.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0019.cs
index 5676162..e030a7f 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0019.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0019.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 服务器 UDP 端口
///
- [JT808Formatter(typeof(JT808_0x8103_0x0019_Formatter))]
- public class JT808_0x8103_0x0019 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0019 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0019;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
///服务器 TCP 端口
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0019 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0019 jT808_0x8103_0x0019 = new JT808_0x8103_0x0019();
+ jT808_0x8103_0x0019.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0019.ParamLength = reader.ReadByte();
+ jT808_0x8103_0x0019.ParamValue = reader.ReadUInt32();
+ return jT808_0x8103_0x0019;
+ }
+
+ public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0019 value, IJT808Config config)
+ {
+ writer.WriteUInt32(value.ParamId);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001A.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001A.cs
index b518f29..d4e115d 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001A.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001A.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 道路运输证 IC 卡认证主服务器 IP 地址或域名
///
- [JT808Formatter(typeof(JT808_0x8103_0x001A_Formatter))]
- public class JT808_0x8103_0x001A : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x001A : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x001A;
///
@@ -18,5 +18,22 @@ namespace JT808.Protocol.MessageBody
/// 道路运输证 IC 卡认证主服务器 IP 地址或域名
///
public string ParamValue { get; set; }
+ public JT808_0x8103_0x001A Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x001A jT808_0x8103_0x001A = new JT808_0x8103_0x001A();
+ jT808_0x8103_0x001A.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x001A.ParamLength = reader.ReadByte();
+ 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);
+ writer.Skip(1, out int skipPosition);
+ writer.WriteString(value.ParamValue);
+ int length = writer.GetCurrentPosition() - skipPosition - 1;
+ writer.WriteByteReturn((byte)length, skipPosition);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001B.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001B.cs
index 65b2a5c..900fd9f 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001B.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001B.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 道路运输证 IC 卡认证主服务器 TCP 端口
///
- [JT808Formatter(typeof(JT808_0x8103_0x001B_Formatter))]
- public class JT808_0x8103_0x001B : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x001B : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x001B;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
///道路运输证 IC 卡认证主服务器 TCP 端口
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x001B Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x001B jT808_0x8103_0x001B = new JT808_0x8103_0x001B();
+ jT808_0x8103_0x001B.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x001B.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001C.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001C.cs
index 34b7bed..4693e59 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001C.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001C.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 道路运输证 IC 卡认证主服务器 UDP 端口
///
- [JT808Formatter(typeof(JT808_0x8103_0x001C_Formatter))]
- public class JT808_0x8103_0x001C : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x001C : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x001C;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
///道路运输证 IC 卡认证主服务器 UDP 端口
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x001C Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x001C jT808_0x8103_0x001C = new JT808_0x8103_0x001C();
+ jT808_0x8103_0x001C.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x001C.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001D.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001D.cs
index 158442b..5ff09c1 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001D.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x001D.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 道路运输证 IC 卡认证备份服务器 IP 地址或域名，端口同主服务器
///
- [JT808Formatter(typeof(JT808_0x8103_0x001D_Formatter))]
- public class JT808_0x8103_0x001D : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x001D : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x001D;
///
@@ -18,5 +18,22 @@ namespace JT808.Protocol.MessageBody
/// 道路运输证 IC 卡认证备份服务器 IP 地址或域名，端口同主服务器
///
public string ParamValue { get; set; }
+ public JT808_0x8103_0x001D Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x001D jT808_0x8103_0x001D = new JT808_0x8103_0x001D();
+ jT808_0x8103_0x001D.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x001D.ParamLength = reader.ReadByte();
+ 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);
+ writer.Skip(1, out int skipPosition);
+ writer.WriteString(value.ParamValue);
+ int length = writer.GetCurrentPosition() - skipPosition - 1;
+ writer.WriteByteReturn((byte)length, skipPosition);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0020.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0020.cs
index 191479d..6d6919a 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0020.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0020.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 位置汇报策略，0：定时汇报；1：定距汇报；2：定时和定距汇报
///
- [JT808Formatter(typeof(JT808_0x8103_0x0020_Formatter))]
- public class JT808_0x8103_0x0020 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0020 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0020;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 位置汇报策略，0：定时汇报；1：定距汇报；2：定时和定距汇报
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0020 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0020 jT808_0x8103_0x0020 = new JT808_0x8103_0x0020();
+ jT808_0x8103_0x0020.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0020.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0021.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0021.cs
index ccf9e6b..bf3d87d 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0021.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0021.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 位置汇报方案，0：根据 ACC 状态； 1：根据登录状态和 ACC 状态，先判断登录状态，若登录再根据 ACC 状态
///
- [JT808Formatter(typeof(JT808_0x8103_0x0021_Formatter))]
- public class JT808_0x8103_0x0021 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0021 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0021;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 位置汇报方案，0：根据 ACC 状态； 1：根据登录状态和 ACC 状态，先判断登录状态，若登录再根据 ACC 状态
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0021 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0021 jT808_0x8103_0x0021 = new JT808_0x8103_0x0021();
+ jT808_0x8103_0x0021.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0021.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0022.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0022.cs
index 9727f66..ca5ba4e 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0022.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0022.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 驾驶员未登录汇报时间间隔，单位为秒（s），>0
///
- [JT808Formatter(typeof(JT808_0x8103_0x0022_Formatter))]
- public class JT808_0x8103_0x0022 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0022 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0022;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 驾驶员未登录汇报时间间隔，单位为秒（s），>0
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0022 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0022 jT808_0x8103_0x0022 = new JT808_0x8103_0x0022();
+ jT808_0x8103_0x0022.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0022.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0027.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0027.cs
index c7af276..8a4d441 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0027.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0027.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 休眠时汇报时间间隔，单位为秒（s），>0
///
- [JT808Formatter(typeof(JT808_0x8103_0x0027_Formatter))]
- public class JT808_0x8103_0x0027 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0027 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0027;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 休眠时汇报时间间隔，单位为秒（s），>0
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0027 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0027 jT808_0x8103_0x0027 = new JT808_0x8103_0x0027();
+ jT808_0x8103_0x0027.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0027.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0028.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0028.cs
index 355ae3e..79cf7cc 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0028.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0028.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 紧急报警时汇报时间间隔，单位为秒（s），>0
///
- [JT808Formatter(typeof(JT808_0x8103_0x0028_Formatter))]
- public class JT808_0x8103_0x0028 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0028 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0028;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 紧急报警时汇报时间间隔，单位为秒（s），>0
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0028 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0028 jT808_0x8103_0x0028 = new JT808_0x8103_0x0028();
+ jT808_0x8103_0x0028.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0028.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0029.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0029.cs
index c8ee297..06e7de2 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0029.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0029.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 缺省时间汇报间隔，单位为秒（s），>0
///
- [JT808Formatter(typeof(JT808_0x8103_0x0029_Formatter))]
- public class JT808_0x8103_0x0029 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0029 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0029;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 缺省时间汇报间隔，单位为秒（s），>0
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0029 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0029 jT808_0x8103_0x0029 = new JT808_0x8103_0x0029();
+ jT808_0x8103_0x0029.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0029.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002C.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002C.cs
index 2a7af06..dfba47c 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002C.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002C.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 缺省距离汇报间隔，单位为米（m），>0
///
- [JT808Formatter(typeof(JT808_0x8103_0x002C_Formatter))]
- public class JT808_0x8103_0x002C : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x002C : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x002C;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 缺省距离汇报间隔，单位为米（m），>0
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x002C Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x002C jT808_0x8103_0x002C = new JT808_0x8103_0x002C();
+ jT808_0x8103_0x002C.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x002C.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002D.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002D.cs
index a9b79c4..58c533d 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002D.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002D.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 驾驶员未登录汇报距离间隔，单位为米（m），>0
///
- [JT808Formatter(typeof(JT808_0x8103_0x002D_Formatter))]
- public class JT808_0x8103_0x002D : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x002D : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x002D;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 驾驶员未登录汇报距离间隔，单位为米（m），>0
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x002D Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x002D jT808_0x8103_0x002D = new JT808_0x8103_0x002D();
+ jT808_0x8103_0x002D.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x002D.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002E.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002E.cs
index c061742..b6cd597 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002E.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002E.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 休眠时汇报距离间隔，单位为米（m），>0
///
- [JT808Formatter(typeof(JT808_0x8103_0x002E_Formatter))]
- public class JT808_0x8103_0x002E : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x002E : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x002E;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 休眠时汇报距离间隔，单位为米（m），>0
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x002E Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x002E jT808_0x8103_0x002E = new JT808_0x8103_0x002E();
+ jT808_0x8103_0x002E.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x002E.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002F.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002F.cs
index 6543d10..65e8d92 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002F.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x002F.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 紧急报警时汇报距离间隔，单位为米（m），>0
///
- [JT808Formatter(typeof(JT808_0x8103_0x002F_Formatter))]
- public class JT808_0x8103_0x002F : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x002F : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x002F;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 紧急报警时汇报距离间隔，单位为米（m），>0
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x002F Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x002F jT808_0x8103_0x002F = new JT808_0x8103_0x002F();
+ jT808_0x8103_0x002F.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x002F.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0030.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0030.cs
index b089441..252376b 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0030.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0030.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 拐点补传角度，<180
///
- [JT808Formatter(typeof(JT808_0x8103_0x0030_Formatter))]
- public class JT808_0x8103_0x0030 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0030 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0030;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 拐点补传角度，<180
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0030 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0030 jT808_0x8103_0x0030 = new JT808_0x8103_0x0030();
+ jT808_0x8103_0x0030.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0030.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0031.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0031.cs
index ce64476..94dfeac 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0031.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0031.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 电子围栏半径（非法位移阈值），单位为米
///
- [JT808Formatter(typeof(JT808_0x8103_0x0031_Formatter))]
- public class JT808_0x8103_0x0031 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0031 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0031;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 电子围栏半径（非法位移阈值），单位为米
///
public ushort ParamValue { get; set; }
+ public JT808_0x8103_0x0031 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0031 jT808_0x8103_0x0031 = new JT808_0x8103_0x0031();
+ jT808_0x8103_0x0031.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0031.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt16(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0040.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0040.cs
index 024d821..2318606 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0040.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0040.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 监控平台电话号码
///
- [JT808Formatter(typeof(JT808_0x8103_0x0040_Formatter))]
- public class JT808_0x8103_0x0040 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0040 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0040;
///
@@ -18,5 +18,22 @@ namespace JT808.Protocol.MessageBody
/// 监控平台电话号码
///
public string ParamValue { get; set; }
+ public JT808_0x8103_0x0040 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0040 jT808_0x8103_0x0040 = new JT808_0x8103_0x0040();
+ jT808_0x8103_0x0040.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0040.ParamLength = reader.ReadByte();
+ 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);
+ writer.Skip(1, out int skipPosition);
+ writer.WriteString(value.ParamValue);
+ int length = writer.GetCurrentPosition() - skipPosition - 1;
+ writer.WriteByteReturn((byte)length, skipPosition);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0041.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0041.cs
index 825df95..20bac5f 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0041.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0041.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 复位电话号码，可采用此电话号码拨打终端电话让终端复位
///
- [JT808Formatter(typeof(JT808_0x8103_0x0041_Formatter))]
- public class JT808_0x8103_0x0041 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0041 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0041;
///
@@ -18,5 +18,22 @@ namespace JT808.Protocol.MessageBody
/// 复位电话号码，可采用此电话号码拨打终端电话让终端复位
///
public string ParamValue { get; set; }
+ public JT808_0x8103_0x0041 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0041 jT808_0x8103_0x0041 = new JT808_0x8103_0x0041();
+ jT808_0x8103_0x0041.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0041.ParamLength = reader.ReadByte();
+ 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);
+ writer.Skip(1, out int skipPosition);
+ writer.WriteString(value.ParamValue);
+ int length = writer.GetCurrentPosition() - skipPosition - 1;
+ writer.WriteByteReturn((byte)length, skipPosition);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0042.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0042.cs
index c27cca7..7c76702 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0042.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0042.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 恢复出厂设置电话号码，可采用此电话号码拨打终端电话让终端恢复出厂设置
///
- [JT808Formatter(typeof(JT808_0x8103_0x0042_Formatter))]
- public class JT808_0x8103_0x0042 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0042 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0042;
///
@@ -18,5 +18,22 @@ namespace JT808.Protocol.MessageBody
/// 恢复出厂设置电话号码，可采用此电话号码拨打终端电话让终端恢复出厂设置
///
public string ParamValue { get; set; }
+ public JT808_0x8103_0x0042 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0042 jT808_0x8103_0x0042 = new JT808_0x8103_0x0042();
+ jT808_0x8103_0x0042.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0042.ParamLength = reader.ReadByte();
+ 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);
+ writer.Skip(1, out int skipPosition);
+ writer.WriteString(value.ParamValue);
+ int length = writer.GetCurrentPosition() - skipPosition - 1;
+ writer.WriteByteReturn((byte)length, skipPosition);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0043.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0043.cs
index 593aeac..9414b6a 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0043.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0043.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 监控平台 SMS 电话号码
///
- [JT808Formatter(typeof(JT808_0x8103_0x0043_Formatter))]
- public class JT808_0x8103_0x0043 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0043 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0043;
///
@@ -18,5 +18,22 @@ namespace JT808.Protocol.MessageBody
/// 监控平台 SMS 电话号码
///
public string ParamValue { get; set; }
+ public JT808_0x8103_0x0043 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0043 jT808_0x8103_0x0043 = new JT808_0x8103_0x0043();
+ jT808_0x8103_0x0043.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0043.ParamLength = reader.ReadByte();
+ 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);
+ writer.Skip(1, out int skipPosition);
+ writer.WriteString(value.ParamValue);
+ int length = writer.GetCurrentPosition() - skipPosition - 1;
+ writer.WriteByteReturn((byte)length, skipPosition);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0044.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0044.cs
index 3e87dde..67764f3 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0044.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0044.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 接收终端 SMS 文本报警号码
///
- [JT808Formatter(typeof(JT808_0x8103_0x0044_Formatter))]
- public class JT808_0x8103_0x0044 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0044 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0044;
///
@@ -18,5 +18,22 @@ namespace JT808.Protocol.MessageBody
/// 接收终端 SMS 文本报警号码
///
public string ParamValue { get; set; }
+ public JT808_0x8103_0x0044 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0044 jT808_0x8103_0x0044 = new JT808_0x8103_0x0044();
+ jT808_0x8103_0x0044.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0044.ParamLength = reader.ReadByte();
+ 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);
+ writer.Skip(1, out int skipPosition);
+ writer.WriteString(value.ParamValue);
+ int length = writer.GetCurrentPosition() - skipPosition - 1;
+ writer.WriteByteReturn((byte)length, skipPosition);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0045.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0045.cs
index 42dd696..6694162 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0045.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0045.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 终端电话接听策略，0：自动接听；1：ACC ON 时自动接听，OFF 时手动接听
///
- [JT808Formatter(typeof(JT808_0x8103_0x0045_Formatter))]
- public class JT808_0x8103_0x0045 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0045 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0045;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 终端电话接听策略，0：自动接听；1：ACC ON 时自动接听，OFF 时手动接听
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0045 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0045 jT808_0x8103_0x0045 = new JT808_0x8103_0x0045();
+ jT808_0x8103_0x0045.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0045.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0046.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0046.cs
index fed5456..8241e92 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0046.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0046.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 每次最长通话时间，单位为秒（s），0 为不允许通话，0xFFFFFFFF 为不限制
///
- [JT808Formatter(typeof(JT808_0x8103_0x0046_Formatter))]
- public class JT808_0x8103_0x0046 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0046 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0046;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 每次最长通话时间，单位为秒（s），0 为不允许通话，0xFFFFFFFF 为不限制
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0046 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0046 jT808_0x8103_0x0046 = new JT808_0x8103_0x0046();
+ jT808_0x8103_0x0046.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0046.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0047.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0047.cs
index e7b1d9d..e71756b 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0047.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0047.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 当月最长通话时间，单位为秒（s），0 为不允许通话，0xFFFFFFFF 为不限制
///
- [JT808Formatter(typeof(JT808_0x8103_0x0047_Formatter))]
- public class JT808_0x8103_0x0047 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0047 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0047;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 当月最长通话时间，单位为秒（s），0 为不允许通话，0xFFFFFFFF 为不限制
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0047 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0047 jT808_0x8103_0x0047 = new JT808_0x8103_0x0047();
+ jT808_0x8103_0x0047.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0047.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0048.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0048.cs
index 0c87e80..8b71ec0 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0048.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0048.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 监听电话号码
///
- [JT808Formatter(typeof(JT808_0x8103_0x0048_Formatter))]
- public class JT808_0x8103_0x0048 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0048 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0048;
///
@@ -18,5 +18,22 @@ namespace JT808.Protocol.MessageBody
/// 监听电话号码
///
public string ParamValue { get; set; }
+ public JT808_0x8103_0x0048 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0048 jT808_0x8103_0x0048 = new JT808_0x8103_0x0048();
+ jT808_0x8103_0x0048.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0048.ParamLength = reader.ReadByte();
+ 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);
+ writer.Skip(1, out int skipPosition);
+ writer.WriteString(value.ParamValue);
+ int length = writer.GetCurrentPosition() - skipPosition - 1;
+ writer.WriteByteReturn((byte)length, skipPosition);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0049.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0049.cs
index d084851..239f426 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0049.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0049.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 监管平台特权短信号码
///
- [JT808Formatter(typeof(JT808_0x8103_0x0049_Formatter))]
- public class JT808_0x8103_0x0049 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0049 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0049;
///
@@ -18,5 +18,22 @@ namespace JT808.Protocol.MessageBody
/// 监管平台特权短信号码
///
public string ParamValue { get; set; }
+ public JT808_0x8103_0x0049 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0049 jT808_0x8103_0x0049 = new JT808_0x8103_0x0049();
+ jT808_0x8103_0x0049.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0049.ParamLength = reader.ReadByte();
+ 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);
+ writer.Skip(1, out int skipPosition);
+ writer.WriteString(value.ParamValue);
+ int length = writer.GetCurrentPosition() - skipPosition - 1;
+ writer.WriteByteReturn((byte)length, skipPosition);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0050.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0050.cs
index 0ca5b95..b302357 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0050.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0050.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 报警屏蔽字，与位置信息汇报消息中的报警标志相对应，相应位为 1则相应报警被屏蔽
///
- [JT808Formatter(typeof(JT808_0x8103_0x0050_Formatter))]
- public class JT808_0x8103_0x0050 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0050 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0050;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 报警屏蔽字，与位置信息汇报消息中的报警标志相对应，相应位为 1则相应报警被屏蔽
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0050 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0050 jT808_0x8103_0x0050 = new JT808_0x8103_0x0050();
+ jT808_0x8103_0x0050.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0050.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0051.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0051.cs
index 8c7feb1..aad8038 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0051.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0051.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 报警发送文本 SMS 开关，与位置信息汇报消息中的报警标志相对应，相应位为 1 则相应报警时发送文本 SMS
///
- [JT808Formatter(typeof(JT808_0x8103_0x0051_Formatter))]
- public class JT808_0x8103_0x0051 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0051 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0051;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 报警发送文本 SMS 开关，与位置信息汇报消息中的报警标志相对应，相应位为 1 则相应报警时发送文本 SMS
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0051 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0051 jT808_0x8103_0x0051 = new JT808_0x8103_0x0051();
+ jT808_0x8103_0x0051.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0051.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0052.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0052.cs
index fda4251..cb75ea2 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0052.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0052.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 报警拍摄开关，与位置信息汇报消息中的报警标志相对应，相应位为1 则相应报警时摄像头拍摄
///
- [JT808Formatter(typeof(JT808_0x8103_0x0052_Formatter))]
- public class JT808_0x8103_0x0052 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0052 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0052;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 报警拍摄开关，与位置信息汇报消息中的报警标志相对应，相应位为1 则相应报警时摄像头拍摄
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0052 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0052 jT808_0x8103_0x0052 = new JT808_0x8103_0x0052();
+ jT808_0x8103_0x0052.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0052.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0053.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0053.cs
index d87d6f7..bc8642a 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0053.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0053.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 报警拍摄存储标志，与位置信息汇报消息中的报警标志相对应，相应位为 1 则对相应报警时拍的照片进行存储，否则实时上传
///
- [JT808Formatter(typeof(JT808_0x8103_0x0053_Formatter))]
- public class JT808_0x8103_0x0053 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0053 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0053;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 报警拍摄存储标志，与位置信息汇报消息中的报警标志相对应，相应位为 1 则对相应报警时拍的照片进行存储，否则实时上传
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0053 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0053 jT808_0x8103_0x0053 = new JT808_0x8103_0x0053();
+ jT808_0x8103_0x0053.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0053.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0054.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0054.cs
index 2dd0135..dce64ea 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0054.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0054.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 关键标志，与位置信息汇报消息中的报警标志相对应，相应位为 1 则对相应报警为关键报警
///
- [JT808Formatter(typeof(JT808_0x8103_0x0054_Formatter))]
- public class JT808_0x8103_0x0054 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0054 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0054;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 关键标志，与位置信息汇报消息中的报警标志相对应，相应位为 1 则对相应报警为关键报警
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0054 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0054 jT808_0x8103_0x0054 = new JT808_0x8103_0x0054();
+ jT808_0x8103_0x0054.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0054.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0055.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0055.cs
index 717e739..ee937d7 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0055.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0055.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 最高速度，单位为公里每小时（km/h）
///
- [JT808Formatter(typeof(JT808_0x8103_0x0055_Formatter))]
- public class JT808_0x8103_0x0055 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0055 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0055;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 最高速度，单位为公里每小时（km/h）
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0055 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0055 jT808_0x8103_0x0055 = new JT808_0x8103_0x0055();
+ jT808_0x8103_0x0055.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0055.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0056.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0056.cs
index 4090ef3..3d4efcc 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0056.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0056.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 超速持续时间，单位为秒（s）
///
- [JT808Formatter(typeof(JT808_0x8103_0x0056_Formatter))]
- public class JT808_0x8103_0x0056 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0056 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0056;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 超速持续时间，单位为秒（s）
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0056 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0056 jT808_0x8103_0x0056 = new JT808_0x8103_0x0056();
+ jT808_0x8103_0x0056.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0056.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0057.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0057.cs
index 1854bfe..a5ae369 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0057.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0057.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 连续驾驶时间门限，单位为秒（s）
///
- [JT808Formatter(typeof(JT808_0x8103_0x0057_Formatter))]
- public class JT808_0x8103_0x0057 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0057 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0057;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 连续驾驶时间门限，单位为秒（s）
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0057 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0057 jT808_0x8103_0x0057 = new JT808_0x8103_0x0057();
+ jT808_0x8103_0x0057.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0057.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0058.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0058.cs
index 3139f77..812bcb4 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0058.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0058.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 当天累计驾驶时间门限，单位为秒（s）
///
- [JT808Formatter(typeof(JT808_0x8103_0x0058_Formatter))]
- public class JT808_0x8103_0x0058 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0058 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0058;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 当天累计驾驶时间门限，单位为秒（s）
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0058 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0058 jT808_0x8103_0x0058 = new JT808_0x8103_0x0058();
+ jT808_0x8103_0x0058.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0058.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0059.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0059.cs
index b90b684..83ce52b 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0059.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0059.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 最小休息时间，单位为秒（s）
///
- [JT808Formatter(typeof(JT808_0x8103_0x0059_Formatter))]
- public class JT808_0x8103_0x0059 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0059 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0059;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 最小休息时间，单位为秒（s）
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0059 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0059 jT808_0x8103_0x0059 = new JT808_0x8103_0x0059();
+ jT808_0x8103_0x0059.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0059.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005A.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005A.cs
index baa46b6..54c581a 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005A.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005A.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 最长停车时间，单位为秒（s）
///
- [JT808Formatter(typeof(JT808_0x8103_0x005A_Formatter))]
- public class JT808_0x8103_0x005A : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x005A : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x005A;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 最长停车时间，单位为秒（s）
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x005A Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x005A jT808_0x8103_0x005A = new JT808_0x8103_0x005A();
+ jT808_0x8103_0x005A.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x005A.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005B.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005B.cs
index 18d7d7d..412e235 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005B.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005B.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 超速报警预警差值，单位为 1/10Km/h
///
- [JT808Formatter(typeof(JT808_0x8103_0x005B_Formatter))]
- public class JT808_0x8103_0x005B : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x005B : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x005B;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 超速报警预警差值，单位为 1/10Km/h
///
public ushort ParamValue { get; set; }
+ public JT808_0x8103_0x005B Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x005B jT808_0x8103_0x005B = new JT808_0x8103_0x005B();
+ jT808_0x8103_0x005B.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x005B.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt16(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005C.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005C.cs
index 350a58f..3238fd5 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005C.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005C.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 疲劳驾驶预警差值，单位为秒（s），>0
///
- [JT808Formatter(typeof(JT808_0x8103_0x005C_Formatter))]
- public class JT808_0x8103_0x005C : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x005C : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x005C;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 疲劳驾驶预警差值，单位为秒（s），>0
///
public ushort ParamValue { get; set; }
+ public JT808_0x8103_0x005C Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x005C jT808_0x8103_0x005C = new JT808_0x8103_0x005C();
+ jT808_0x8103_0x005C.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x005C.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt16(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005D.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005D.cs
index 13f562d..83695e2 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005D.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005D.cs
@@ -1,5 +1,6 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
@@ -8,8 +9,7 @@ namespace JT808.Protocol.MessageBody
/// b7-b0： 碰撞时间，单位 4ms；
/// b15-b8：碰撞加速度，单位 0.1g，设置范围在：0-79 之间，默认为10。
///
- [JT808Formatter(typeof(JT808_0x8103_0x005D_Formatter))]
- public class JT808_0x8103_0x005D : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x005D : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x005D;
///
@@ -22,5 +22,20 @@ namespace JT808.Protocol.MessageBody
/// b15-b8：碰撞加速度，单位 0.1g，设置范围在：0-79 之间，默认为10。
///
public ushort ParamValue { get; set; }
+ public JT808_0x8103_0x005D Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x005D jT808_0x8103_0x005D = new JT808_0x8103_0x005D();
+ jT808_0x8103_0x005D.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x005D.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt16(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005E.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005E.cs
index 6fdd507..268230b 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005E.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x005E.cs
@@ -1,5 +1,6 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
@@ -7,8 +8,7 @@ namespace JT808.Protocol.MessageBody
/// 侧翻报警参数设置：
/// 侧翻角度，单位 1 度，默认为 30 度
///
- [JT808Formatter(typeof(JT808_0x8103_0x005E_Formatter))]
- public class JT808_0x8103_0x005E : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x005E : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x005E;
///
@@ -20,5 +20,20 @@ namespace JT808.Protocol.MessageBody
/// 侧翻角度，单位 1 度，默认为 30 度
///
public ushort ParamValue { get; set; }
+ public JT808_0x8103_0x005E Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x005E jT808_0x8103_0x005E = new JT808_0x8103_0x005E();
+ jT808_0x8103_0x005E.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x005E.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt16(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0064.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0064.cs
index 5ba7a87..78e829e 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0064.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0064.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 定时拍照控制，见 表 13
///
- [JT808Formatter(typeof(JT808_0x8103_0x0064_Formatter))]
- public class JT808_0x8103_0x0064 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0064 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0064;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 定时拍照控制，见 表 13
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0064 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0064 jT808_0x8103_0x0064 = new JT808_0x8103_0x0064();
+ jT808_0x8103_0x0064.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0064.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0065.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0065.cs
index d8c2742..e20d683 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0065.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0065.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 定距拍照控制，见 表 14
///
- [JT808Formatter(typeof(JT808_0x8103_0x0065_Formatter))]
- public class JT808_0x8103_0x0065 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0065 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0065;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 定距拍照控制，见 表 14
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0065 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0065 jT808_0x8103_0x0065 = new JT808_0x8103_0x0065();
+ jT808_0x8103_0x0065.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0065.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0070.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0070.cs
index 82034b8..32a1806 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0070.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0070.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 图像/视频质量，1-10，1 最好
///
- [JT808Formatter(typeof(JT808_0x8103_0x0070_Formatter))]
- public class JT808_0x8103_0x0070 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0070 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0070;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 图像/视频质量，1-10，1 最好
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0070 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0070 jT808_0x8103_0x0070 = new JT808_0x8103_0x0070();
+ jT808_0x8103_0x0070.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0070.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0071.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0071.cs
index b47746c..22daffc 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0071.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0071.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 亮度，0-255
///
- [JT808Formatter(typeof(JT808_0x8103_0x0071_Formatter))]
- public class JT808_0x8103_0x0071 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0071 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0071;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 亮度，0-255
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0071 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0071 jT808_0x8103_0x0071 = new JT808_0x8103_0x0071();
+ jT808_0x8103_0x0071.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0071.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0072.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0072.cs
index fa9ac9d..6d89b54 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0072.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0072.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 对比度，0-127
///
- [JT808Formatter(typeof(JT808_0x8103_0x0072_Formatter))]
- public class JT808_0x8103_0x0072 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0072 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0072;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 对比度，0-127
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0072 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0072 jT808_0x8103_0x0072 = new JT808_0x8103_0x0072();
+ jT808_0x8103_0x0072.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0072.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0073.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0073.cs
index b6b9601..f8e9208 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0073.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0073.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 饱和度，0-127
///
- [JT808Formatter(typeof(JT808_0x8103_0x0073_Formatter))]
- public class JT808_0x8103_0x0073 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0073 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0073;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 饱和度，0-127
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0073 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0073 jT808_0x8103_0x0073 = new JT808_0x8103_0x0073();
+ jT808_0x8103_0x0073.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0073.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0074.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0074.cs
index 3a7abe0..279f78b 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0074.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0074.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 色度，0-255
///
- [JT808Formatter(typeof(JT808_0x8103_0x0074_Formatter))]
- public class JT808_0x8103_0x0074 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0074 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0074;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 饱和度，0-127
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0074 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0074 jT808_0x8103_0x0074 = new JT808_0x8103_0x0074();
+ jT808_0x8103_0x0074.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0074.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0080.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0080.cs
index 1fd7f65..fc10ba4 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0080.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0080.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 车辆里程表读数，1/10km
///
- [JT808Formatter(typeof(JT808_0x8103_0x0080_Formatter))]
- public class JT808_0x8103_0x0080 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0080 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0080;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 车辆里程表读数，1/10km
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0080 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0080 jT808_0x8103_0x0080 = new JT808_0x8103_0x0080();
+ jT808_0x8103_0x0080.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0080.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0081.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0081.cs
index 36e2b24..dd1ebb3 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0081.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0081.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 车辆所在的省域 ID
///
- [JT808Formatter(typeof(JT808_0x8103_0x0081_Formatter))]
- public class JT808_0x8103_0x0081 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0081 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0081;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 车辆所在的省域 ID
///
public ushort ParamValue { get; set; }
+ public JT808_0x8103_0x0081 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0081 jT808_0x8103_0x0081 = new JT808_0x8103_0x0081();
+ jT808_0x8103_0x0081.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0081.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt16(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0082.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0082.cs
index e6dd69f..5a12098 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0082.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0082.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 车辆所在的市域 ID
///
- [JT808Formatter(typeof(JT808_0x8103_0x0082_Formatter))]
- public class JT808_0x8103_0x0082 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0082 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0082;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 车辆所在的市域 ID
///
public ushort ParamValue { get; set; }
+ public JT808_0x8103_0x0082 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0082 jT808_0x8103_0x0082 = new JT808_0x8103_0x0082();
+ jT808_0x8103_0x0082.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0082.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt16(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0083.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0083.cs
index 87914c1..3bda09d 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0083.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0083.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 公安交通管理部门颁发的机动车号牌
///
- [JT808Formatter(typeof(JT808_0x8103_0x0083_Formatter))]
- public class JT808_0x8103_0x0083 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0083 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0083;
///
@@ -18,5 +18,22 @@ namespace JT808.Protocol.MessageBody
/// 公安交通管理部门颁发的机动车号牌
///
public string ParamValue { get; set; }
+ public JT808_0x8103_0x0083 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0083 jT808_0x8103_0x0083 = new JT808_0x8103_0x0083();
+ jT808_0x8103_0x0083.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0083.ParamLength = reader.ReadByte();
+ 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);
+ writer.Skip(1, out int skipPosition);
+ writer.WriteString(value.ParamValue);
+ int length = writer.GetCurrentPosition() - skipPosition - 1;
+ writer.WriteByteReturn((byte)length, skipPosition);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0084.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0084.cs
index 0048e3f..95ab737 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0084.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0084.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// 车牌颜色，按照 JT/T415-2006 的 5.4.12
///
- [JT808Formatter(typeof(JT808_0x8103_0x0084_Formatter))]
- public class JT808_0x8103_0x0084 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0084 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0084;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// 车牌颜色，按照 JT/T415-2006 的 5.4.12
///
public byte ParamValue { get; set; }
+ public JT808_0x8103_0x0084 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0084 jT808_0x8103_0x0084 = new JT808_0x8103_0x0084();
+ jT808_0x8103_0x0084.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0084.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteByte(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0090.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0090.cs
index e9420e9..09d1789 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0090.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0090.cs
@@ -1,5 +1,6 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
@@ -10,8 +11,7 @@ namespace JT808.Protocol.MessageBody
/// bit2，0：禁用 GLONASS 定位， 1：启用 GLONASS 定位；
/// bit3，0：禁用 Galileo 定位， 1：启用 Galileo 定位。
///
- [JT808Formatter(typeof(JT808_0x8103_0x0090_Formatter))]
- public class JT808_0x8103_0x0090 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0090 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0090;
///
@@ -26,5 +26,20 @@ namespace JT808.Protocol.MessageBody
/// bit3，0：禁用 Galileo 定位， 1：启用 Galileo 定位。
///
public byte ParamValue { get; set; }
+ public JT808_0x8103_0x0090 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0090 jT808_0x8103_0x0090 = new JT808_0x8103_0x0090();
+ jT808_0x8103_0x0090.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0090.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteByte(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0091.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0091.cs
index 26df052..cbe094f 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0091.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0091.cs
@@ -1,5 +1,6 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
@@ -9,8 +10,7 @@ namespace JT808.Protocol.MessageBody
/// 0x02：19200；0x03：38400；
/// 0x04：57600；0x05：115200。
///
- [JT808Formatter(typeof(JT808_0x8103_0x0091_Formatter))]
- public class JT808_0x8103_0x0091 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0091 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0091;
///
@@ -24,5 +24,20 @@ namespace JT808.Protocol.MessageBody
/// 0x04：57600；0x05：115200。
///
public byte ParamValue { get; set; }
+ public JT808_0x8103_0x0091 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0091 jT808_0x8103_0x0091 = new JT808_0x8103_0x0091();
+ jT808_0x8103_0x0091.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0091.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteByte(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0092.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0092.cs
index bef54ee..e747a8c 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0092.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0092.cs
@@ -1,5 +1,6 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
@@ -9,8 +10,7 @@ namespace JT808.Protocol.MessageBody
/// 0x02：2000ms；0x03：3000ms；
/// 0x04：4000ms。
///
- [JT808Formatter(typeof(JT808_0x8103_0x0092_Formatter))]
- public class JT808_0x8103_0x0092 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0092 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0092;
///
@@ -24,5 +24,20 @@ namespace JT808.Protocol.MessageBody
/// 0x04：4000ms。
///
public byte ParamValue { get; set; }
+ public JT808_0x8103_0x0092 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0092 jT808_0x8103_0x0092 = new JT808_0x8103_0x0092();
+ jT808_0x8103_0x0092.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0092.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteByte(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0093.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0093.cs
index 1b77ad7..223f8a9 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0093.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0093.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// GNSS 模块详细定位数据采集频率，单位为秒，默认为 1。
///
- [JT808Formatter(typeof(JT808_0x8103_0x0093_Formatter))]
- public class JT808_0x8103_0x0093 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0093 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0093;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// GNSS 模块详细定位数据采集频率，单位为秒，默认为 1。
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0093 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0093 jT808_0x8103_0x0093 = new JT808_0x8103_0x0093();
+ jT808_0x8103_0x0093.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0093.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0094.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0094.cs
index 6f6f446..015db18 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0094.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0094.cs
@@ -1,5 +1,6 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
@@ -12,8 +13,7 @@ namespace JT808.Protocol.MessageBody
/// 0x0C，按累计距离上传，达到距离后自动停止上传；
/// 0x0D，按累计条数上传，达到上传条数后自动停止上传。
///
- [JT808Formatter(typeof(JT808_0x8103_0x0094_Formatter))]
- public class JT808_0x8103_0x0094 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0094 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0094;
///
@@ -30,5 +30,20 @@ namespace JT808.Protocol.MessageBody
/// 0x0D，按累计条数上传，达到上传条数后自动停止上传。
///
public byte ParamValue { get; set; }
+ public JT808_0x8103_0x0094 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0094 jT808_0x8103_0x0094 = new JT808_0x8103_0x0094();
+ jT808_0x8103_0x0094.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0094.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteByte(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0095.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0095.cs
index b9fd2aa..4afca31 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0095.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0095.cs
@@ -1,5 +1,6 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
@@ -11,8 +12,7 @@ namespace JT808.Protocol.MessageBody
/// 上传方式为 0x0C 时，单位为米；
/// 上传方式为 0x0D 时，单位为条。
///
- [JT808Formatter(typeof(JT808_0x8103_0x0095_Formatter))]
- public class JT808_0x8103_0x0095 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0095 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0095;
///
@@ -28,5 +28,20 @@ namespace JT808.Protocol.MessageBody
/// 上传方式为 0x0D 时，单位为条。
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0095 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0095 jT808_0x8103_0x0095 = new JT808_0x8103_0x0095();
+ jT808_0x8103_0x0095.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0095.ParamLength = reader.ReadByte();
+ jT808_0x8103_0x0095.ParamValue = reader.ReadUInt32();
+ return jT808_0x8103_0x0095;
+ }
+
+ public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0095 value, IJT808Config config)
+ {
+ writer.WriteUInt32(value.ParamId);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0100.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0100.cs
index a77c4e7..b55d432 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0100.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0100.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// CAN 总线通道 1 采集时间间隔(ms)，0 表示不采集
///
- [JT808Formatter(typeof(JT808_0x8103_0x0100_Formatter))]
- public class JT808_0x8103_0x0100 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0100 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0100;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// CAN 总线通道 1 采集时间间隔(ms)，0 表示不采集
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0100 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0100 jT808_0x8103_0x0100 = new JT808_0x8103_0x0100();
+ jT808_0x8103_0x0100.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0100.ParamLength = reader.ReadByte();
+ jT808_0x8103_0x0100.ParamValue = reader.ReadUInt32();
+ return jT808_0x8103_0x0100;
+ }
+
+ public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0100 value, IJT808Config config)
+ {
+ writer.WriteUInt32(value.ParamId);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0101.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0101.cs
index ed84494..0ba8322 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0101.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0101.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// CAN 总线通道 1 上传时间间隔(s)，0 表示不上传
///
- [JT808Formatter(typeof(JT808_0x8103_0x0101_Formatter))]
- public class JT808_0x8103_0x0101 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0101 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0101;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// CAN 总线通道 1 上传时间间隔(s)，0 表示不上传
///
public ushort ParamValue { get; set; }
+ public JT808_0x8103_0x0101 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0101 jT808_0x8103_0x0101 = new JT808_0x8103_0x0101();
+ jT808_0x8103_0x0101.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0101.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt16(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0102.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0102.cs
index 9136275..7037e35 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0102.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0102.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// CAN 总线通道 2 采集时间间隔(ms)，0 表示不采集
///
- [JT808Formatter(typeof(JT808_0x8103_0x0102_Formatter))]
- public class JT808_0x8103_0x0102 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0102 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0102;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// CAN 总线通道 2 采集时间间隔(ms)，0 表示不采集
///
public uint ParamValue { get; set; }
+ public JT808_0x8103_0x0102 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0102 jT808_0x8103_0x0102 = new JT808_0x8103_0x0102();
+ jT808_0x8103_0x0102.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0102.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt32(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0103.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0103.cs
index a23c489..4a2388e 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0103.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0103.cs
@@ -1,13 +1,13 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
///
/// CAN 总线通道 2 上传时间间隔(s)，0 表示不上传
///
- [JT808Formatter(typeof(JT808_0x8103_0x0103_Formatter))]
- public class JT808_0x8103_0x0103 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0103 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0103;
///
@@ -18,5 +18,20 @@ namespace JT808.Protocol.MessageBody
/// CAN 总线通道 2 上传时间间隔(s)，0 表示不上传
///
public ushort ParamValue { get; set; }
+ public JT808_0x8103_0x0103 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0103 jT808_0x8103_0x0103 = new JT808_0x8103_0x0103();
+ jT808_0x8103_0x0103.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0103.ParamLength = reader.ReadByte();
+ 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);
+ writer.WriteByte(value.ParamLength);
+ writer.WriteUInt16(value.ParamValue);
+ }
}
}
diff --git a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0110.cs b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0110.cs
index fde4b13..dbd46f0 100644
--- a/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0110.cs
+++ b/src/JT808.Protocol/MessageBody/JT808_0x8103_0x0110.cs
@@ -1,5 +1,6 @@
using JT808.Protocol.Attributes;
-using JT808.Protocol.Formatters.MessageBodyFormatters;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
namespace JT808.Protocol.MessageBody
{
@@ -11,8 +12,7 @@ namespace JT808.Protocol.MessageBody
/// bit29 表示数据采集方式，0：原始数据，1：采集区间的计算值；
/// bit28-bit0 表示 CAN 总线 ID。
///
- [JT808Formatter(typeof(JT808_0x8103_0x0110_Formatter))]
- public class JT808_0x8103_0x0110 : JT808_0x8103_BodyBase
+ public class JT808_0x8103_0x0110 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter
{
public override uint ParamId { get; set; } = 0x0110;
///
@@ -28,5 +28,20 @@ namespace JT808.Protocol.MessageBody
/// bit28-bit0 表示 CAN 总线 ID。
///
public byte[] ParamValue { get; set; }
+ public JT808_0x8103_0x0110 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
+ {
+ JT808_0x8103_0x0110 jT808_0x8103_0x0110 = new JT808_0x8103_0x0110();
+ jT808_0x8103_0x0110.ParamId = reader.ReadUInt32();
+ jT808_0x8103_0x0110.ParamLength = reader.ReadByte();
+ jT808_0x8103_0x0110.ParamValue = reader.ReadArray(jT808_0x8103_0x0110.ParamLength).ToArray();
+ return jT808_0x8103_0x0110;
+ }
+
+ public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0110 value, IJT808Config config)
+ {
+ writer.WriteUInt32(value.ParamId);
+ writer.WriteByte((byte)value.ParamValue.Length);
+ writer.WriteArray(value.ParamValue);
+ }
}
}