完善指令消息注释

src/.editorconfig

@@ -0,0 +1,10 @@
+[*.{cs,vb}]
+
+# IDE0017: 简化对象初始化
+dotnet_diagnostic.IDE0017.severity = none
+
+# IDE0028: 简化集合初始化
+dotnet_diagnostic.IDE0028.severity = none
+
+# IDE0059: 不需要赋值
+dotnet_diagnostic.IDE0059.severity = none

src/JT808.Protocol.Test/MessageBody/JT808_0x0608Test.cs

@@ -10,7 +10,7 @@ namespace JT808.Protocol.Test.MessageBody
 {
     public class JT808_0x0608Test
     {
-        JT808Serializer JT808Serializer = new JT808Serializer();
+        readonly JT808Serializer JT808Serializer = new JT808Serializer();
 
         [Fact]
         public void Test1()

src/JT808.Protocol.Test/Simples/Demo4.cs

@@ -22,7 +22,7 @@ namespace JT808.Protocol.Test.Simples
         {
 
         }
-        private Dictionary<string, DeviceType> cache = new Dictionary<string, DeviceType>
+        private readonly Dictionary<string, DeviceType> cache = new Dictionary<string, DeviceType>
         {
             { "123456789012",DeviceType.DT1 },
             { "123456789013",DeviceType.DT2 }
@@ -84,7 +84,7 @@ namespace JT808.Protocol.Test.Simples
 
     public class JT808_0x0200_DT1_0x81_ExtDataProcessor : IExtDataProcessor
     {
-        private JT808_0x0200_DT1_0x81 jT808_0X0200_DT1_0X81;
+        private readonly JT808_0x0200_DT1_0x81 jT808_0X0200_DT1_0X81;
         public JT808_0x0200_DT1_0x81_ExtDataProcessor(JT808_0x0200_DT1_0x81 jT808_0X0200_DT1_0X81)
         {
             this.jT808_0X0200_DT1_0X81 = jT808_0X0200_DT1_0X81;
@@ -99,7 +99,7 @@ namespace JT808.Protocol.Test.Simples
 
     public class JT808_0x0200_DT1_0x82_ExtDataProcessor : IExtDataProcessor
     {
-        private JT808_0x0200_DT1_0x82 jT808_0X0200_DT1_0X82;
+        private readonly JT808_0x0200_DT1_0x82 jT808_0X0200_DT1_0X82;
         public JT808_0x0200_DT1_0x82_ExtDataProcessor(JT808_0x0200_DT1_0x82 jT808_0X0200_DT1_0X82)
         {
             this.jT808_0X0200_DT1_0X82 = jT808_0X0200_DT1_0X82;
@@ -112,7 +112,7 @@ namespace JT808.Protocol.Test.Simples
 
     public class JT808_0x0200_DT2_0x81_ExtDataProcessor : IExtDataProcessor
     {
-        private JT808_0x0200_DT2_0x81 jT808_0X0200_DT2_0X81;
+        private readonly JT808_0x0200_DT2_0x81 jT808_0X0200_DT2_0X81;
         public JT808_0x0200_DT2_0x81_ExtDataProcessor(JT808_0x0200_DT2_0x81 jT808_0X0200_DT2_0X81)
         {
             this.jT808_0X0200_DT2_0X81 = jT808_0X0200_DT2_0X81;
@@ -128,15 +128,12 @@ namespace JT808.Protocol.Test.Simples
     {
         public static DeviceTypeBase Create(DeviceType deviceType, Dictionary<byte, JT808_0x0200_CustomBodyBase> jT808CustomLocationAttachData)
         {
-            switch (deviceType)
+            return deviceType switch
             {
-                case DeviceType.DT1:
-                    return new DeviceType1(jT808CustomLocationAttachData);
-                case DeviceType.DT2:
-                    return new DeviceType2(jT808CustomLocationAttachData);
-                default:
-                    return default;
-            }
+                DeviceType.DT1 => new DeviceType1(jT808CustomLocationAttachData),
+                DeviceType.DT2 => new DeviceType2(jT808CustomLocationAttachData),
+                _ => default,
+            };
         }
     }
 

src/JT808.Protocol.sln

@@ -9,6 +9,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "JT808.Protocol.Test", "JT80
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{E6296ADE-B239-4A4B-ACDA-B80C0A61399B}"
 	ProjectSection(SolutionItems) = preProject
+		.editorconfig = .editorconfig
 		..\README.md = ..\README.md
 	EndProjectSection
 EndProject

src/JT808.Protocol/Enums/JT808CameraResolutionType.cs

@@ -40,6 +40,6 @@ namespace JT808.Protocol.Enums
         /// <summary>
         /// x704_576_D1
         /// </summary>
-        x704_576_D1 = 0x07,
+        x704_576_D1 = 0x08,
     }
 }

src/JT808.Protocol/Enums/JT808CarDVRCommandID.cs

@@ -9,34 +9,113 @@ namespace JT808.Protocol.Enums
     /// </summary>
     public enum JT808CarDVRCommandID:byte
     {
-        采集记录仪执行标准版本=0x00,
+        /// <summary>
+        /// 采集记录仪执行标准版本
+        /// </summary>
+        采集记录仪执行标准版本 = 0x00,
+        /// <summary>
+        /// 采集当前驾驶人信息
+        /// </summary>
         采集当前驾驶人信息 = 0x01,
+        /// <summary>
+        /// 采集记录仪实时时间
+        /// </summary>
         采集记录仪实时时间 = 0x02,
+        /// <summary>
+        /// 采集累计行驶里程
+        /// </summary>
         采集累计行驶里程 = 0x03,
+        /// <summary>
+        /// 采集记录仪脉冲系数
+        /// </summary>
         采集记录仪脉冲系数 = 0x04,
+        /// <summary>
+        /// 采集车辆信息
+        /// </summary>
         采集车辆信息 = 0x05,
+        /// <summary>
+        /// 采集记录仪状态信号配置信息
+        /// </summary>
         采集记录仪状态信号配置信息 = 0x06,
+        /// <summary>
+        /// 采集记录仪唯一性编号
+        /// </summary>
         采集记录仪唯一性编号 = 0x07,
+        /// <summary>
+        /// 采集指定的行驶速度记录
+        /// </summary>
         采集指定的行驶速度记录 = 0x08,
+        /// <summary>
+        /// 采集指定的位置信息记录
+        /// </summary>
         采集指定的位置信息记录 = 0x09,
+        /// <summary>
+        /// 采集指定的事故疑点记录
+        /// </summary>
         采集指定的事故疑点记录 = 0x10,
+        /// <summary>
+        /// 采集指定的超时驾驶记录
+        /// </summary>
         采集指定的超时驾驶记录 = 0x11,
+        /// <summary>
+        /// 采集指定的驾驶人身份记录
+        /// </summary>
         采集指定的驾驶人身份记录 = 0x12,
+        /// <summary>
+        /// 采集指定的外部供电记录
+        /// </summary>
         采集指定的外部供电记录 = 0x13,
+        /// <summary>
+        /// 采集指定的参数修改记录
+        /// </summary>
         采集指定的参数修改记录 = 0x14,
+        /// <summary>
+        /// 采集指定的速度状态日志
+        /// </summary>
         采集指定的速度状态日志 = 0x15,
-
-        设置车辆信息= 0x82,
+        /// <summary>
+        /// 设置车辆信息
+        /// </summary>
+        设置车辆信息 = 0x82,
+        /// <summary>
+        /// 设置记录仪初次安装日期
+        /// </summary>
         设置记录仪初次安装日期 = 0x83,
+        /// <summary>
+        /// 设置状态量配置信息
+        /// </summary>
         设置状态量配置信息 = 0x84,
+        /// <summary>
+        /// 设置记录仪时间
+        /// </summary>
         设置记录仪时间 = 0xC2,
+        /// <summary>
+        /// 设置记录仪脉冲系数
+        /// </summary>
         设置记录仪脉冲系数 = 0xC3,
+        /// <summary>
+        /// 设置初始里程
+        /// </summary>
         设置初始里程 = 0xC4,
-
+        /// <summary>
+        /// 进入或保持检定状态
+        /// </summary>
         进入或保持检定状态 = 0xE0,
+        /// <summary>
+        /// 进入里程误差测量
+        /// </summary>
         进入里程误差测量 = 0xE1,
+        /// <summary>
+        /// 进入脉冲系数误差测量
+        /// </summary>
         进入脉冲系数误差测量 = 0xE2,
+        /// <summary>
+        /// 进入实时时间误差测量
+        /// </summary>
         进入实时时间误差测量 = 0xE3,
+        /// <summary>
+        /// 返回正常工作状态
+        /// </summary>
         返回正常工作状态 = 0xE4,
     }
 }

src/JT808.Protocol/Enums/JT808DrivenRouteType.cs

@@ -5,7 +5,13 @@
     /// </summary>
     public enum JT808DrivenRouteType
     {
+        /// <summary>
+        /// 不足
+        /// </summary>
         不足 = 0,
+        /// <summary>
+        /// 过长
+        /// </summary>
         过长 = 1
     }
 }

src/JT808.Protocol/Enums/JT808EncryptMethod.cs

@@ -1,8 +1,17 @@
 namespace JT808.Protocol.Enums
 {
+    /// <summary>
+    /// JT808加密选项
+    /// </summary>
     public enum JT808EncryptMethod
     {
+        /// <summary>
+        /// 未加密
+        /// </summary>
         None,
+        /// <summary>
+        /// RSA加密
+        /// </summary>
         RSA
     }
 }

src/JT808.Protocol/Enums/JT808EventItemCoding.cs

@@ -5,9 +5,21 @@
     /// </summary>
     public enum JT808EventItemCoding : byte
     {
+        /// <summary>
+        /// 平台下发指令
+        /// </summary>
         平台下发指令 = 0x00,
+        /// <summary>
+        /// 定时动作
+        /// </summary>
         定时动作 = 0x01,
+        /// <summary>
+        /// 抢劫报警触发
+        /// </summary>
         抢劫报警触发 = 0x02,
+        /// <summary>
+        /// 碰撞侧翻报警触发
+        /// </summary>
         碰撞侧翻报警触发 = 0x03
     }
 }

src/JT808.Protocol/Enums/JT808ICCardReadResult.cs

@@ -5,10 +5,25 @@
     /// </summary>
     public enum JT808ICCardReadResult : byte
     {
+        /// <summary>
+        /// IC卡读卡成功
+        /// </summary>
         IC卡读卡成功 = 0x00,
+        /// <summary>
+        /// 读卡失败_原因为卡片密钥认证未通过
+        /// </summary>
         读卡失败_原因为卡片密钥认证未通过 = 0x01,
+        /// <summary>
+        /// 读卡失败_原因为卡片已被锁定
+        /// </summary>
         读卡失败_原因为卡片已被锁定 = 0x02,
+        /// <summary>
+        /// 读卡失败_原因为卡片被拔出
+        /// </summary>
         读卡失败_原因为卡片被拔出 = 0x03,
+        /// <summary>
+        /// 读卡失败_原因为数据校验错误
+        /// </summary>
         读卡失败_原因为数据校验错误 = 0x04,
     }
 }

src/JT808.Protocol/Enums/JT808ICCardStatus.cs

@@ -5,7 +5,13 @@
     /// </summary>
     public enum JT808ICCardStatus : byte
     {
+        /// <summary>
+        /// 从业资格证IC卡插入_驾驶员上班
+        /// </summary>
         从业资格证IC卡插入_驾驶员上班 = 0x01,
+        /// <summary>
+        /// 从业资格证IC卡拔出_驾驶员下班
+        /// </summary>
         从业资格证IC卡拔出_驾驶员下班 = 0x02
     }
 }

src/JT808.Protocol/Enums/JT808MultimediaCodingFormat.cs

@@ -5,10 +5,25 @@
     /// </summary>
     public enum JT808MultimediaCodingFormat : byte
     {
+        /// <summary>
+        /// JPEG
+        /// </summary>
         JPEG = 0x00,
+        /// <summary>
+        /// TIF
+        /// </summary>
         TIF = 0x01,
+        /// <summary>
+        /// MP3
+        /// </summary>
         MP3 = 0x02,
+        /// <summary>
+        /// WAV
+        /// </summary>
         WAV = 0x03,
+        /// <summary>
+        /// WMV
+        /// </summary>
         WMV = 0x04
     }
 }

src/JT808.Protocol/Enums/JT808MultimediaDeleted.cs

@@ -6,7 +6,13 @@
     /// </summary>
     public enum JT808MultimediaDeleted : byte
     {
+        /// <summary>
+        /// 保留
+        /// </summary>
         保留 = 0,
+        /// <summary>
+        /// 删除
+        /// </summary>
         删除 = 1
     }
 }

src/JT808.Protocol/Enums/JT808MultimediaType.cs

@@ -5,8 +5,17 @@
     /// </summary>
     public enum JT808MultimediaType : byte
     {
+        /// <summary>
+        /// 图像
+        /// </summary>
         图像 = 0x00,
+        /// <summary>
+        /// 音频
+        /// </summary>
         音频 = 0x01,
+        /// <summary>
+        /// 视频
+        /// </summary>
         视频 = 0x02
     }
 }

src/JT808.Protocol/Enums/JT808PhoneNumberType.cs

@@ -10,9 +10,17 @@
     /// </summary>
     public enum JT808PhoneNumberType
     {
+        /// <summary>
+        /// 大陆
+        /// </summary>
         大陆 = 11,
-        香港 = 8,
-        澳门 = 8,
+        /// <summary>
+        /// 香港|澳门
+        /// </summary>
+        香港_澳门 = 8,
+        /// <summary>
+        /// 台湾
+        /// </summary>
         台湾 = 10
     }
 }

src/JT808.Protocol/Enums/JT808RecordCmd.cs

@@ -5,7 +5,13 @@
     /// </summary>
     public enum JT808RecordCmd : byte
     {
+        /// <summary>
+        /// 停止录音
+        /// </summary>
         停止录音 = 0x00,
+        /// <summary>
+        /// 停止录音
+        /// </summary>
         开始录音 = 0x01
     }
 }

src/JT808.Protocol/Enums/JT808RecordSave.cs

@@ -5,7 +5,13 @@
     /// </summary>
     public enum JT808RecordSave : byte
     {
+        /// <summary>
+        /// 实时上传
+        /// </summary>
         实时上传 = 0,
+        /// <summary>
+        /// 保存
+        /// </summary>
         保存 = 1
     }
 }

src/JT808.Protocol/Enums/JT808SettingProperty.cs

@@ -5,8 +5,17 @@
     /// </summary>
     public enum JT808SettingProperty : byte
     {
+        /// <summary>
+        /// 更新区域
+        /// </summary>
         更新区域 = 0x00,
+        /// <summary>
+        /// 追加区域
+        /// </summary>
         追加区域 = 0x01,
+        /// <summary>
+        /// 修改区域
+        /// </summary>
         修改区域 = 0x02
     }
 }

src/JT808.Protocol/Enums/JT808SettingTelephoneBook.cs

@@ -5,9 +5,21 @@
     /// </summary>
     public enum JT808SettingTelephoneBook : byte
     {
+        /// <summary>
+        /// 删除终端上所有存储的联系人
+        /// </summary>
         删除终端上所有存储的联系人 = 0,
+        /// <summary>
+        /// 更新电话本_删除终端中已有全部联系人并追加消息中的联系人
+        /// </summary>
         更新电话本_删除终端中已有全部联系人并追加消息中的联系人 = 1,
+        /// <summary>
+        /// 追加电话本
+        /// </summary>
         追加电话本 = 2,
+        /// <summary>
+        /// 修改电话本_以联系人为索引
+        /// </summary>
         修改电话本_以联系人为索引 = 3
     }
 }

src/JT808.Protocol/Enums/JT808Status.cs

@@ -2,31 +2,94 @@
 
 namespace JT808.Protocol.Enums
 {
+    /// <summary>
+    /// JT808车辆状态位
+    /// </summary>
     [Flags]
     public enum JT808Status : uint
     {
+        /// <summary>
+        /// ACC开
+        /// </summary>
         ACC开 = 1,
+        /// <summary>
+        /// 定位
+        /// </summary>
         定位 = 2,
+        /// <summary>
+        /// 南纬
+        /// </summary>
         南纬 = 4,
+        /// <summary>
+        /// 西经
+        /// </summary>
         西经 = 8,
+        /// <summary>
+        /// 停运状态
+        /// </summary>
         停运状态 = 16,
+        /// <summary>
+        /// 经纬度已经保密插件加密
+        /// </summary>
         经纬度已经保密插件加密 = 32,
         //保留 = 64,
         //保留 = 128,
+        /// <summary>
+        /// 半载
+        /// </summary>
         半载 = 256,
         //保留 = 512,
+        /// <summary>
+        /// 满载
+        /// </summary>
         满载 = 768,
+        /// <summary>
+        /// 车辆油路断开
+        /// </summary>
         车辆油路断开 = 1024,
+        /// <summary>
+        /// 车辆电路断开
+        /// </summary>
         车辆电路断开 = 2048,
+        /// <summary>
+        /// 车门加锁
+        /// </summary>
         车门加锁 = 4096,
+        /// <summary>
+        /// 前门开
+        /// </summary>
         前门开 = 8192,
+        /// <summary>
+        /// 中门开
+        /// </summary>
         中门开 = 16384,
+        /// <summary>
+        /// 后门开
+        /// </summary>
         后门开 = 32768,
+        /// <summary>
+        /// 驾驶席门开
+        /// </summary>
         驾驶席门开 = 65536,
+        /// <summary>
+        /// 自定义
+        /// </summary>
         自定义 = 131072,
+        /// <summary>
+        /// 使用GPS卫星进行定位
+        /// </summary>
         使用GPS卫星进行定位 = 262144,
+        /// <summary>
+        /// 使用北斗卫星进行定位
+        /// </summary>
         使用北斗卫星进行定位 = 524288,
+        /// <summary>
+        /// 使用GLONASS卫星进行定位
+        /// </summary>
         使用GLONASS卫星进行定位 = 1048576,
+        /// <summary>
+        /// 使用Galileo卫星进行定位
+        /// </summary>
         使用Galileo卫星进行定位 = 2097152
     }
 }

src/JT808.Protocol/Extensions/JT808PackageExtensions.cs

@@ -2,8 +2,19 @@
 
 namespace JT808.Protocol.Extensions
 {
+    /// <summary>
+    /// JT808创建包扩展
+    /// </summary>
     public static partial class JT808PackageExtensions
     {
+        /// <summary>
+        /// 根据消息Id创建包
+        /// </summary>
+        /// <typeparam name="TJT808Bodies"></typeparam>
+        /// <param name="msgId"></param>
+        /// <param name="terminalPhoneNo"></param>
+        /// <param name="bodies"></param>
+        /// <returns></returns>
         public static JT808Package Create<TJT808Bodies>(this JT808MsgId msgId, string terminalPhoneNo, TJT808Bodies bodies)
             where TJT808Bodies : JT808Bodies
         {
@@ -18,7 +29,12 @@ namespace JT808.Protocol.Extensions
             };
             return jT808Package;
         }
-
+        /// <summary>
+        /// 根据消息Id创建包
+        /// </summary>
+        /// <param name="msgId"></param>
+        /// <param name="terminalPhoneNo"></param>
+        /// <returns></returns>
         public static JT808Package Create(this JT808MsgId msgId, string terminalPhoneNo)
         {
             JT808Package jT808Package = new JT808Package
@@ -31,7 +47,14 @@ namespace JT808.Protocol.Extensions
             };
             return jT808Package;
         }
-
+        /// <summary>
+        /// 根据自定义消息Id创建包
+        /// </summary>
+        /// <typeparam name="TJT808Bodies"></typeparam>
+        /// <param name="msgId"></param>
+        /// <param name="terminalPhoneNo"></param>
+        /// <param name="bodies"></param>
+        /// <returns></returns>
         public static JT808Package CreateCustomMsgId<TJT808Bodies>(this ushort msgId, string terminalPhoneNo, TJT808Bodies bodies)
             where TJT808Bodies : JT808Bodies
         {
@@ -46,7 +69,12 @@ namespace JT808.Protocol.Extensions
             };
             return jT808Package;
         }
-
+        /// <summary>
+        /// 根据自定义消息Id创建包
+        /// </summary>
+        /// <param name="msgId"></param>
+        /// <param name="terminalPhoneNo"></param>
+        /// <returns></returns>
         public static JT808Package CreateCustomMsgId(this ushort msgId, string terminalPhoneNo)
         {
             JT808Package jT808Package = new JT808Package
@@ -59,7 +87,14 @@ namespace JT808.Protocol.Extensions
             };
             return jT808Package;
         }
-
+        /// <summary>
+        /// 根据消息Id创建2019版本包
+        /// </summary>
+        /// <typeparam name="TJT808Bodies"></typeparam>
+        /// <param name="msgId"></param>
+        /// <param name="terminalPhoneNo"></param>
+        /// <param name="bodies"></param>
+        /// <returns></returns>
         public static JT808Package Create2019<TJT808Bodies>(this JT808MsgId msgId, string terminalPhoneNo, TJT808Bodies bodies)
             where TJT808Bodies : JT808Bodies
         {
@@ -75,7 +110,12 @@ namespace JT808.Protocol.Extensions
             jT808Package.Header.MessageBodyProperty.VersionFlag = true;
             return jT808Package;
         }
-
+        /// <summary>
+        /// 根据消息Id创建2019版本包
+        /// </summary>
+        /// <param name="msgId"></param>
+        /// <param name="terminalPhoneNo"></param>
+        /// <returns></returns>
         public static JT808Package Create2019(this JT808MsgId msgId, string terminalPhoneNo)
         {
             JT808Package jT808Package = new JT808Package
@@ -89,7 +129,14 @@ namespace JT808.Protocol.Extensions
             jT808Package.Header.MessageBodyProperty.VersionFlag = true;
             return jT808Package;
         }
-
+        /// <summary>
+        /// 根据自定义消息Id创建2019版本包
+        /// </summary>
+        /// <typeparam name="TJT808Bodies"></typeparam>
+        /// <param name="msgId"></param>
+        /// <param name="terminalPhoneNo"></param>
+        /// <param name="bodies"></param>
+        /// <returns></returns>
         public static JT808Package CreateCustomMsgId2019<TJT808Bodies>(this ushort msgId, string terminalPhoneNo, TJT808Bodies bodies)
             where TJT808Bodies : JT808Bodies
         {
@@ -105,7 +152,12 @@ namespace JT808.Protocol.Extensions
             jT808Package.Header.MessageBodyProperty.VersionFlag = true;
             return jT808Package;
         }
-
+        /// <summary>
+        /// 根据自定义消息Id创建2019版本包
+        /// </summary>
+        /// <param name="msgId"></param>
+        /// <param name="terminalPhoneNo"></param>
+        /// <returns></returns>
         public static JT808Package CreateCustomMsgId2019(this ushort msgId, string terminalPhoneNo)
         {
             JT808Package jT808Package = new JT808Package

src/JT808.Protocol/Interfaces/IJT808_CarDVR_Down_Factory.cs

@@ -9,7 +9,15 @@ namespace JT808.Protocol.Interfaces
     /// </summary>
    public  interface IJT808_CarDVR_Down_Factory : IJT808ExternalRegister
     {
+        /// <summary>
+        /// 
+        /// </summary>
         IDictionary<byte, object> Map { get; }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="TJT808CarDVRDownBodies"></typeparam>
+        /// <returns></returns>
         IJT808_CarDVR_Down_Factory SetMap<TJT808CarDVRDownBodies>() where TJT808CarDVRDownBodies : JT808CarDVRDownBodies; 
     }
 }

src/JT808.Protocol/Interfaces/IJT808_CarDVR_Down_Package.cs

@@ -4,6 +4,9 @@ using System.Text;
 
 namespace JT808.Protocol.Interfaces
 {
+    /// <summary>
+    /// 
+    /// </summary>
     public interface IJT808_CarDVR_Down_Package
     {
     }

src/JT808.Protocol/Interfaces/IJT808_CarDVR_Up_Factory.cs

@@ -9,7 +9,15 @@ namespace JT808.Protocol.Interfaces
     /// </summary>
    public  interface IJT808_CarDVR_Up_Factory : IJT808ExternalRegister
     {
+        /// <summary>
+        /// 
+        /// </summary>
         IDictionary<byte, object> Map { get; }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="TJT808CarDVRUpBodies"></typeparam>
+        /// <returns></returns>
         IJT808_CarDVR_Up_Factory SetMap<TJT808CarDVRUpBodies>() where TJT808CarDVRUpBodies : JT808CarDVRUpBodies;
     }
 }

src/JT808.Protocol/Interfaces/IJT808_CarDVR_Up_Package.cs

@@ -4,6 +4,9 @@ using System.Text;
 
 namespace JT808.Protocol.Interfaces
 {
+    /// <summary>
+    /// 
+    /// </summary>
     public interface IJT808_CarDVR_Up_Package
     {
     }

src/JT808.Protocol/Internal/JT808_0x8103_Factory.cs

@@ -110,7 +110,7 @@ namespace JT808.Protocol.Interfaces
                 {
                     paramId = (uint)type.GetProperty(nameof(JT808_0x8103_BodyBase.ParamId)).GetValue(instance);
                 }
-                catch (Exception ex)
+                catch
                 {
                     continue;
                 }

src/JT808.Protocol/Internal/JT808_CarDVR_Down_Factory.cs

@@ -11,13 +11,22 @@ namespace JT808.Protocol.Interfaces
     /// </summary>
    public  class JT808_CarDVR_Down_Factory:IJT808_CarDVR_Down_Factory
     {
+        /// <summary>
+        /// 
+        /// </summary>
         public IDictionary<byte, object> Map { get; }
-
+        /// <summary>
+        /// 
+        /// </summary>
         public JT808_CarDVR_Down_Factory()
         {
             Map = new Dictionary<byte, object>();
             Register(Assembly.GetExecutingAssembly());
         }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="externalAssembly"></param>
         public void Register(Assembly externalAssembly)
         {
             var types = externalAssembly.GetTypes().Where(w => w.BaseType == typeof(JT808CarDVRDownBodies)).ToList();
@@ -35,7 +44,11 @@ namespace JT808.Protocol.Interfaces
                 }
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="TJT808CarDVRDownBodies"></typeparam>
+        /// <returns></returns>
         public IJT808_CarDVR_Down_Factory SetMap<TJT808CarDVRDownBodies>() where TJT808CarDVRDownBodies : JT808CarDVRDownBodies
         {
             Type type = typeof(TJT808CarDVRDownBodies);

src/JT808.Protocol/JT808.Protocol.csproj

@@ -37,6 +37,7 @@
       <Pack>True</Pack>
       <PackagePath></PackagePath>
     </None>
+    <None Include="..\.editorconfig" Link=".editorconfig" />
   </ItemGroup>
 
   <ItemGroup>

src/JT808.Protocol/JT808CarDVRUpPackage.cs

@@ -73,9 +73,9 @@ namespace JT808.Protocol
                     writer.WriteEndObject();
                 }
             }
-            var carDVRCheckCode = reader.ReadCarDVRCheckCode(currentPosition);
+            var (CalculateXorCheckCode, RealXorCheckCode) = reader.ReadCarDVRCheckCode(currentPosition);
             value.CheckCode = reader.ReadByte();
-            if (carDVRCheckCode.RealXorCheckCode != carDVRCheckCode.CalculateXorCheckCode)
+            if (RealXorCheckCode != CalculateXorCheckCode)
             {
                 writer.WriteString($"[{value.CheckCode.ReadNumber()}]校验位错误", $"{reader.RealCheckXorCode}!={reader.CalculateCheckXorCode}");
             }
@@ -108,10 +108,10 @@ namespace JT808.Protocol
                     value.Bodies = attachImpl;
                 }
             }
-            var carDVRCheckCode = reader.ReadCarDVRCheckCode(currentPosition);
+            var (CalculateXorCheckCode, RealXorCheckCode) = reader.ReadCarDVRCheckCode(currentPosition);
             if (!config.SkipCarDVRCRCCode)
             {
-                if (carDVRCheckCode.RealXorCheckCode != carDVRCheckCode.CalculateXorCheckCode)
+                if (RealXorCheckCode != CalculateXorCheckCode)
                     throw new JT808Exception(JT808ErrorCode.CarDVRCheckCodeNotEqual, $"{reader.RealCheckXorCode}!={reader.CalculateCheckXorCode}");
             }
             value.CheckCode = reader.ReadByte();

src/JT808.Protocol/JT808Serializer.cs

@@ -244,14 +244,12 @@ namespace JT808.Protocol
             {
                 JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
                 jT808MessagePackReader.Decode(buffer);
-                using(MemoryStream memoryStream = new MemoryStream())
-                using (Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options))
-                {
-                    jT808Package.Analyze(ref jT808MessagePackReader, utf8JsonWriter, jT808Config);
-                    utf8JsonWriter.Flush();
-                    string value = Encoding.UTF8.GetString(memoryStream.ToArray());
-                    return value; 
-                }
+                using MemoryStream memoryStream = new MemoryStream();
+                using Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options);
+                jT808Package.Analyze(ref jT808MessagePackReader, utf8JsonWriter, jT808Config);
+                utf8JsonWriter.Flush();
+                string value = Encoding.UTF8.GetString(memoryStream.ToArray());
+                return value;
             }
             finally
             {
@@ -276,16 +274,14 @@ namespace JT808.Protocol
                 if (CheckPackageType(typeof(T)))
                     jT808MessagePackReader.Decode(buffer);
                 var analyze = jT808Config.GetAnalyze<T>();
-                using (MemoryStream memoryStream = new MemoryStream())
-                using (Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options))
-                {
-                    if (!CheckPackageType(typeof(T))) utf8JsonWriter.WriteStartObject();
-                    analyze.Analyze(ref jT808MessagePackReader, utf8JsonWriter, jT808Config);
-                    if (!CheckPackageType(typeof(T))) utf8JsonWriter.WriteEndObject();
-                    utf8JsonWriter.Flush();
-                    string value = Encoding.UTF8.GetString(memoryStream.ToArray());
-                    return value;
-                }
+                using MemoryStream memoryStream = new MemoryStream();
+                using Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options);
+                if (!CheckPackageType(typeof(T))) utf8JsonWriter.WriteStartObject();
+                analyze.Analyze(ref jT808MessagePackReader, utf8JsonWriter, jT808Config);
+                if (!CheckPackageType(typeof(T))) utf8JsonWriter.WriteEndObject();
+                utf8JsonWriter.Flush();
+                string value = Encoding.UTF8.GetString(memoryStream.ToArray());
+                return value;
             }
             finally
             {
@@ -311,21 +307,19 @@ namespace JT808.Protocol
                 {
                     if (jT808Config.FormatterFactory.FormatterDict.TryGetValue(msgHandle.GetType().GUID, out object instance))
                     {
-                        using (MemoryStream memoryStream = new MemoryStream())
-                        using (Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options))
-                        {
-                            JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
-                            utf8JsonWriter.WriteStartObject();
-                            instance.Analyze(ref jT808MessagePackReader, utf8JsonWriter, jT808Config);
-                            utf8JsonWriter.WriteEndObject();
-                            utf8JsonWriter.Flush();
-                            string value = Encoding.UTF8.GetString(memoryStream.ToArray());
-                            return value;
-                        }
+                        using MemoryStream memoryStream = new MemoryStream();
+                        using Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options);
+                        JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
+                        utf8JsonWriter.WriteStartObject();
+                        instance.Analyze(ref jT808MessagePackReader, utf8JsonWriter, jT808Config);
+                        utf8JsonWriter.WriteEndObject();
+                        utf8JsonWriter.Flush();
+                        string value = Encoding.UTF8.GetString(memoryStream.ToArray());
+                        return value;
                     }
-                    return $"未找到对应的0x{msgid.ToString("X2")}消息数据体类型";
+                    return $"未找到对应的0x{msgid:X2}消息数据体类型";
                 }
-                return $"未找到对应的0x{msgid.ToString("X2")}消息数据体类型";
+                return $"未找到对应的0x{msgid:X2}消息数据体类型";
             }
             finally
             {
@@ -351,20 +345,18 @@ namespace JT808.Protocol
                 {
                     if (jT808Config.FormatterFactory.FormatterDict.TryGetValue(msgHandle.GetType().GUID, out object instance))
                     {
-                        using (MemoryStream memoryStream = new MemoryStream())
-                        using (Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options))
-                        {
-                            JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
-                            utf8JsonWriter.WriteStartObject();
-                            instance.Analyze(ref jT808MessagePackReader, utf8JsonWriter, jT808Config);
-                            utf8JsonWriter.WriteEndObject();
-                            utf8JsonWriter.Flush();
-                            return memoryStream.ToArray();
-                        }
+                        using MemoryStream memoryStream = new MemoryStream();
+                        using Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options);
+                        JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
+                        utf8JsonWriter.WriteStartObject();
+                        instance.Analyze(ref jT808MessagePackReader, utf8JsonWriter, jT808Config);
+                        utf8JsonWriter.WriteEndObject();
+                        utf8JsonWriter.Flush();
+                        return memoryStream.ToArray();
                     }
-                    return Encoding.UTF8.GetBytes($"未找到对应的0x{msgid.ToString("X2")}消息数据体类型");
+                    return Encoding.UTF8.GetBytes($"未找到对应的0x{msgid:X2}消息数据体类型");
                 }
-                return Encoding.UTF8.GetBytes($"未找到对应的0x{msgid.ToString("X2")}消息数据体类型");
+                return Encoding.UTF8.GetBytes($"未找到对应的0x{msgid:X2}消息数据体类型");
             }
             finally
             {
@@ -386,13 +378,11 @@ namespace JT808.Protocol
             {
                 JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
                 jT808MessagePackReader.Decode(buffer);
-                using (MemoryStream memoryStream = new MemoryStream())
-                using (Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options))
-                {
-                    jT808Package.Analyze(ref jT808MessagePackReader, utf8JsonWriter, jT808Config);
-                    utf8JsonWriter.Flush();
-                    return memoryStream.ToArray();
-                }
+                using MemoryStream memoryStream = new MemoryStream();
+                using Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options);
+                jT808Package.Analyze(ref jT808MessagePackReader, utf8JsonWriter, jT808Config);
+                utf8JsonWriter.Flush();
+                return memoryStream.ToArray();
             }
             finally
             {
@@ -417,15 +407,13 @@ namespace JT808.Protocol
                 if (CheckPackageType(typeof(T)))
                     jT808MessagePackReader.Decode(buffer);
                 var analyze = jT808Config.GetAnalyze<T>();
-                using (MemoryStream memoryStream = new MemoryStream())
-                using (Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options))
-                {
-                    if (!CheckPackageType(typeof(T))) utf8JsonWriter.WriteStartObject();
-                    analyze.Analyze(ref jT808MessagePackReader, utf8JsonWriter, jT808Config);
-                    if (!CheckPackageType(typeof(T))) utf8JsonWriter.WriteEndObject();
-                    utf8JsonWriter.Flush();
-                    return memoryStream.ToArray();
-                }
+                using MemoryStream memoryStream = new MemoryStream();
+                using Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options);
+                if (!CheckPackageType(typeof(T))) utf8JsonWriter.WriteStartObject();
+                analyze.Analyze(ref jT808MessagePackReader, utf8JsonWriter, jT808Config);
+                if (!CheckPackageType(typeof(T))) utf8JsonWriter.WriteEndObject();
+                utf8JsonWriter.Flush();
+                return memoryStream.ToArray();
             }
             finally
             {

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x00.cs

@@ -16,10 +16,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x00 : JT808CarDVRDownBodies
     {
+        /// <summary>
+        /// 0x00
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集记录仪执行标准版本.ToByteValue();
-         
+        /// <summary>
+        /// 采集记录仪执行标准版本
+        /// </summary>
         public override string Description => "采集记录仪执行标准版本";
-
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x01.cs

@@ -16,10 +16,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x01 : JT808CarDVRDownBodies
     {
+        /// <summary>
+        /// 0x01
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集当前驾驶人信息.ToByteValue();
-
+        /// <summary>
+        /// 采集机动车驾驶证号码
+        /// </summary>
         public override string Description => "采集机动车驾驶证号码";
-
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x02.cs

@@ -16,10 +16,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x02 : JT808CarDVRDownBodies
     {
+        /// <summary>
+        /// 0x02
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.采集记录仪实时时间.ToByteValue();
-         
+        /// <summary>
+        /// 实时时间
+        /// </summary>
         public override string Description => "实时时间";
-
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x03.cs

@@ -16,10 +16,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x03 : JT808CarDVRDownBodies
     {
+        /// <summary>
+        /// 0x03
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.采集累计行驶里程.ToByteValue();
-         
+        /// <summary>
+        /// 实时时间、安装时的初始里程及安装后的累计行驶里程
+        /// </summary>
         public override string Description => "实时时间、安装时的初始里程及安装后的累计行驶里程";
-
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x04.cs

@@ -16,10 +16,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x04 : JT808CarDVRDownBodies
     {
+        /// <summary>
+        /// 0x04
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.采集记录仪脉冲系数.ToByteValue();
-         
+        /// <summary>
+        /// 实时时间及设定的脉冲系数
+        /// </summary>
         public override string Description => "实时时间及设定的脉冲系数";
-
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x05.cs

@@ -16,10 +16,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x05 : JT808CarDVRDownBodies
     {
+        /// <summary>
+        /// 0x05
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集车辆信息.ToByteValue();
-
+        /// <summary>
+        /// 车辆识别代号、机动车号牌号码和机动车号牌分类
+        /// </summary>
         public override string Description => "车辆识别代号、机动车号牌号码和机动车号牌分类";
-
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x06.cs

@@ -16,10 +16,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x06 : JT808CarDVRDownBodies
     {
+        /// <summary>
+        /// 0x06
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集记录仪状态信号配置信息.ToByteValue();
-         
+        /// <summary>
+        /// 状态信号配置信息
+        /// </summary>
         public override string Description => "状态信号配置信息";
-
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x07.cs

@@ -16,10 +16,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x07 : JT808CarDVRDownBodies
     {
+        /// <summary>
+        /// 0x07
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集记录仪唯一性编号.ToByteValue();
-         
+        /// <summary>
+        /// 唯一性编号及初次安装日期
+        /// </summary>
         public override string Description => "唯一性编号及初次安装日期";
-
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x08.cs

@@ -17,6 +17,9 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x08 : JT808CarDVRDownBodies, IJT808MessagePackFormatter<JT808_CarDVR_Down_0x08>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x08
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集指定的行驶速度记录.ToByteValue();
         /// <summary>
         /// 开始时间
@@ -30,15 +33,28 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 最大单位数据块个数
         /// </summary>
         public ushort Count { get; set; }
+        /// <summary>
+        /// 符合条件的行驶速度记录
+        /// </summary>
         public override string Description => "符合条件的行驶速度记录";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Down_0x08 value, IJT808Config config)
         {
             writer.WriteDateTime6(value.StartTime);
             writer.WriteDateTime6(value.EndTime);
             writer.WriteUInt16(value.Count);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Down_0x08  Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Down_0x08 value = new JT808_CarDVR_Down_0x08();
@@ -47,14 +63,19 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.Count = reader.ReadUInt16();
             return value;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Down_0x08 value = new JT808_CarDVR_Down_0x08();
             value.StartTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.StartTime.ToString("yyMMddHHmmss")}]开始时间", value.StartTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.StartTime:yyMMddHHmmss}]开始时间", value.StartTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.EndTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.EndTime.ToString("yyMMddHHmmss")}]结束时间", value.EndTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.EndTime:yyMMddHHmmss}]结束时间", value.EndTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.Count = reader.ReadUInt16();
             writer.WriteNumber($"[{value.Count.ReadNumber()}]最大单位数据块个数", value.Count);
         }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x09.cs

@@ -17,8 +17,13 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x09 : JT808CarDVRDownBodies, IJT808MessagePackFormatter<JT808_CarDVR_Down_0x09>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x09
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集指定的位置信息记录.ToByteValue();
-
+        /// <summary>
+        /// 符合条件的位置信息记录
+        /// </summary>
         public override string Description => "符合条件的位置信息记录";
         /// <summary>
         /// 开始时间
@@ -32,14 +37,24 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 最大单位数据块个数
         /// </summary>
         public ushort Count { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Down_0x09 value, IJT808Config config)
         {
             writer.WriteDateTime6(value.StartTime);
             writer.WriteDateTime6(value.EndTime);
             writer.WriteUInt16(value.Count);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Down_0x09 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Down_0x09 value = new JT808_CarDVR_Down_0x09();
@@ -48,14 +63,19 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.Count = reader.ReadUInt16();
             return value;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Down_0x09 value = new JT808_CarDVR_Down_0x09();
             value.StartTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.StartTime.ToString("yyMMddHHmmss")}]开始时间", value.StartTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.StartTime:yyMMddHHmmss}]开始时间", value.StartTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.EndTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.EndTime.ToString("yyMMddHHmmss")}]结束时间", value.EndTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.EndTime:yyMMddHHmmss}]结束时间", value.EndTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.Count = reader.ReadUInt16();
             writer.WriteNumber($"[{value.Count.ReadNumber()}]最大单位数据块个数", value.Count);
         }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x10.cs

@@ -17,8 +17,13 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x10 : JT808CarDVRDownBodies, IJT808MessagePackFormatter<JT808_CarDVR_Down_0x10>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x10
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集指定的事故疑点记录.ToByteValue();
-
+        /// <summary>
+        /// 符合条件的事故疑点记录
+        /// </summary>
         public override string Description => "符合条件的事故疑点记录";
         /// <summary>
         /// 开始时间
@@ -32,14 +37,24 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 最大单位数据块个数
         /// </summary>
         public ushort Count { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Down_0x10 value, IJT808Config config)
         {
             writer.WriteDateTime6(value.StartTime);
             writer.WriteDateTime6(value.EndTime);
             writer.WriteUInt16(value.Count);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Down_0x10 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Down_0x10 value = new JT808_CarDVR_Down_0x10();
@@ -48,14 +63,19 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.Count = reader.ReadUInt16();
             return value;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Down_0x10 value = new JT808_CarDVR_Down_0x10();
             value.StartTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.StartTime.ToString("yyMMddHHmmss")}]开始时间", value.StartTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.StartTime:yyMMddHHmmss}]开始时间", value.StartTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.EndTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.EndTime.ToString("yyMMddHHmmss")}]结束时间", value.EndTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.EndTime:yyMMddHHmmss}]结束时间", value.EndTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.Count = reader.ReadUInt16();
             writer.WriteNumber($"[{value.Count.ReadNumber()}]最大单位数据块个数", value.Count);
         }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x11.cs

@@ -16,8 +16,13 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x11 : JT808CarDVRDownBodies, IJT808MessagePackFormatter<JT808_CarDVR_Down_0x11>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x11
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集指定的超时驾驶记录.ToByteValue();
-
+        /// <summary>
+        /// 符合条件的超时驾驶记录
+        /// </summary>
         public override string Description => "符合条件的超时驾驶记录";
         /// <summary>
         /// 开始时间
@@ -31,14 +36,24 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 最大单位数据块个数
         /// </summary>
         public ushort Count { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Down_0x11 value, IJT808Config config)
         {
             writer.WriteDateTime6(value.StartTime);
             writer.WriteDateTime6(value.EndTime);
             writer.WriteUInt16(value.Count);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Down_0x11 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Down_0x11 value = new JT808_CarDVR_Down_0x11();
@@ -47,14 +62,19 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.Count = reader.ReadUInt16();
             return value;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Down_0x11 value = new JT808_CarDVR_Down_0x11();
             value.StartTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.StartTime.ToString("yyMMddHHmmss")}]开始时间", value.StartTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.StartTime:yyMMddHHmmss}]开始时间", value.StartTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.EndTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.EndTime.ToString("yyMMddHHmmss")}]结束时间", value.EndTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.EndTime:yyMMddHHmmss}]结束时间", value.EndTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.Count = reader.ReadUInt16();
             writer.WriteNumber($"[{value.Count.ReadNumber()}]最大单位数据块个数", value.Count);
         }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x12.cs

@@ -16,8 +16,13 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x12 : JT808CarDVRDownBodies, IJT808MessagePackFormatter<JT808_CarDVR_Down_0x12>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x12
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集指定的驾驶人身份记录.ToByteValue();
-
+        /// <summary>
+        /// 符合条件的驾驶人登录退出记录
+        /// </summary>
         public override string Description => "符合条件的驾驶人登录退出记录";
         /// <summary>
         /// 开始时间
@@ -31,14 +36,24 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 最大单位数据块个数
         /// </summary>
         public ushort Count { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Down_0x12 value, IJT808Config config)
         {
             writer.WriteDateTime6(value.StartTime);
             writer.WriteDateTime6(value.EndTime);
             writer.WriteUInt16(value.Count);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Down_0x12 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Down_0x12 value = new JT808_CarDVR_Down_0x12();
@@ -47,14 +62,19 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.Count = reader.ReadUInt16();
             return value;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Down_0x12 value = new JT808_CarDVR_Down_0x12();
             value.StartTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.StartTime.ToString("yyMMddHHmmss")}]开始时间", value.StartTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.StartTime:yyMMddHHmmss}]开始时间", value.StartTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.EndTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.EndTime.ToString("yyMMddHHmmss")}]结束时间", value.EndTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.EndTime:yyMMddHHmmss}]结束时间", value.EndTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.Count = reader.ReadUInt16();
             writer.WriteNumber($"[{value.Count.ReadNumber()}]最大单位数据块个数", value.Count);
         }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x13.cs

@@ -16,8 +16,13 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x13 : JT808CarDVRDownBodies, IJT808MessagePackFormatter<JT808_CarDVR_Down_0x13>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x13
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集指定的外部供电记录.ToByteValue();
-
+        /// <summary>
+        /// 符合条件的供电记录
+        /// </summary>
         public override string Description => "符合条件的供电记录";
         /// <summary>
         /// 开始时间
@@ -31,14 +36,24 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 最大单位数据块个数
         /// </summary>
         public ushort Count { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Down_0x13 value, IJT808Config config)
         {
             writer.WriteDateTime6(value.StartTime);
             writer.WriteDateTime6(value.EndTime);
             writer.WriteUInt16(value.Count);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Down_0x13 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Down_0x13 value = new JT808_CarDVR_Down_0x13();
@@ -47,14 +62,19 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.Count = reader.ReadUInt16();
             return value;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Down_0x13 value = new JT808_CarDVR_Down_0x13();
             value.StartTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.StartTime.ToString("yyMMddHHmmss")}]开始时间", value.StartTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.StartTime:yyMMddHHmmss}]开始时间", value.StartTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.EndTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.EndTime.ToString("yyMMddHHmmss")}]结束时间", value.EndTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.EndTime:yyMMddHHmmss}]结束时间", value.EndTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.Count = reader.ReadUInt16();
             writer.WriteNumber($"[{value.Count.ReadNumber()}]最大单位数据块个数", value.Count);
         }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x14.cs

@@ -16,8 +16,13 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x14 : JT808CarDVRDownBodies, IJT808MessagePackFormatter<JT808_CarDVR_Down_0x14>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x14
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集指定的参数修改记录.ToByteValue();
-
+        /// <summary>
+        /// 符合条件的参数修改记录
+        /// </summary>
         public override string Description => "符合条件的参数修改记录";
         /// <summary>
         /// 开始时间
@@ -31,14 +36,24 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 最大单位数据块个数
         /// </summary>
         public ushort Count { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Down_0x14 value, IJT808Config config)
         {
             writer.WriteDateTime6(value.StartTime);
             writer.WriteDateTime6(value.EndTime);
             writer.WriteUInt16(value.Count);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Down_0x14 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Down_0x14 value = new JT808_CarDVR_Down_0x14();
@@ -47,14 +62,19 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.Count = reader.ReadUInt16();
             return value;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Down_0x14 value = new JT808_CarDVR_Down_0x14();
             value.StartTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.StartTime.ToString("yyMMddHHmmss")}]开始时间", value.StartTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.StartTime:yyMMddHHmmss}]开始时间", value.StartTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.EndTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.EndTime.ToString("yyMMddHHmmss")}]结束时间", value.EndTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.EndTime:yyMMddHHmmss}]结束时间", value.EndTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.Count = reader.ReadUInt16();
             writer.WriteNumber($"[{value.Count.ReadNumber()}]最大单位数据块个数", value.Count);
         }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x15.cs

@@ -16,8 +16,13 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x15 : JT808CarDVRDownBodies, IJT808MessagePackFormatter<JT808_CarDVR_Down_0x15>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x15
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集指定的速度状态日志.ToByteValue();
-
+        /// <summary>
+        /// 符合条件的速度状态日志
+        /// </summary>
         public override string Description => "符合条件的速度状态日志";
         /// <summary>
         /// 开始时间
@@ -31,14 +36,24 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 最大单位数据块个数
         /// </summary>
         public ushort Count { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Down_0x15 value, IJT808Config config)
         {
             writer.WriteDateTime6(value.StartTime);
             writer.WriteDateTime6(value.EndTime);
             writer.WriteUInt16(value.Count);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Down_0x15 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Down_0x15 value = new JT808_CarDVR_Down_0x15();
@@ -47,14 +62,19 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.Count = reader.ReadUInt16();
             return value;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Down_0x15 value = new JT808_CarDVR_Down_0x15();
             value.StartTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.StartTime.ToString("yyMMddHHmmss")}]开始时间", value.StartTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.StartTime:yyMMddHHmmss}]开始时间", value.StartTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.EndTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.EndTime.ToString("yyMMddHHmmss")}]结束时间", value.EndTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.EndTime:yyMMddHHmmss}]结束时间", value.EndTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.Count = reader.ReadUInt16();
             writer.WriteNumber($"[{value.Count.ReadNumber()}]最大单位数据块个数", value.Count);
         }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x82.cs

@@ -17,6 +17,9 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x82 : JT808CarDVRDownBodies, IJT808MessagePackFormatter<JT808_CarDVR_Down_0x82>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x82
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.设置车辆信息.ToByteValue();
         /// <summary>
         /// 车辆识别代号
@@ -32,8 +35,16 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 后 4 个字节为备用字
         /// </summary>
         public string VehicleType { get; set; }
+        /// <summary>
+        /// 车辆信息
+        /// </summary>
         public override string Description => "车辆信息";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Down_0x82 value = new JT808_CarDVR_Down_0x82();
@@ -47,7 +58,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.VehicleType = reader.ReadString(10);
             writer.WriteString($"[{vehicleTypeHex.ToArray().ToHexString()}]机动车号牌分类", value.VehicleType);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Down_0x82 value, IJT808Config config)
         {
             var currentPosition = writer.GetCurrentPosition();
@@ -60,7 +76,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             writer.WriteString(value.VehicleType);
             writer.Skip(10 - (writer.GetCurrentPosition() - currentPosition), out var _);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Down_0x82 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Down_0x82 value = new JT808_CarDVR_Down_0x82();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x83.cs

@@ -17,25 +17,46 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x83 : JT808CarDVRDownBodies, IJT808MessagePackFormatter<JT808_CarDVR_Down_0x83>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x83
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.设置记录仪初次安装日期.ToByteValue();
         /// <summary>
         /// 实时时间
         /// </summary>
         public DateTime RealTime { get; set; }
+        /// <summary>
+        /// 初次安装日期
+        /// </summary>
         public override string Description => "初次安装日期";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Down_0x83 value = new JT808_CarDVR_Down_0x83();
             value.RealTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.RealTime.ToString("yyMMddHHmmss")}]初次安装日期", value.RealTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.RealTime:yyMMddHHmmss}]初次安装日期", value.RealTime.ToString("yyyy-MM-dd HH:mm:ss"));
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Down_0x83 value, IJT808Config config)
         {
             writer.WriteDateTime6(value.RealTime);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Down_0x83 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Down_0x83 value = new JT808_CarDVR_Down_0x83();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0x84.cs

@@ -17,6 +17,9 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0x84 : JT808CarDVRDownBodies, IJT808MessagePackFormatter<JT808_CarDVR_Down_0x84>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x84
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.设置状态量配置信息.ToByteValue();
         /// <summary>
         /// 实时时间
@@ -28,12 +31,16 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// </summary>
         public byte SignalOperate { get; set; }
         /// <summary>
-        /// 
+        /// D0
         /// </summary>
         public string D0 { get; set; }
-
+        /// <summary>
+        /// D1
+        /// </summary>
         public string D1 { get; set; }
-
+        /// <summary>
+        /// D2
+        /// </summary>
         public string D2 { get; set; }
         /// <summary>
         /// 近光 D3
@@ -60,13 +67,21 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 10个字节，未使用或不足时，补0
         /// </summary>
         public string Brake { get; set; }
+        /// <summary>
+        /// 状态量配置信息
+        /// </summary>
         public override string Description => "状态量配置信息";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Down_0x84 value = new JT808_CarDVR_Down_0x84();
             value.RealTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.RealTime.ToString("yyMMddHHmmss")}]实时时间", value.RealTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.RealTime:yyMMddHHmmss}]实时时间", value.RealTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.SignalOperate = reader.ReadByte();
             writer.WriteNumber($"[{value.SignalOperate.ReadNumber()}]信号个数", value.SignalOperate);
             var display = reader.ReadVirtualArray(10);
@@ -94,7 +109,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.Brake = reader.ReadString(10);
             writer.WriteString($"[{display.ToArray().ToHexString()}]制动", value.Brake);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Down_0x84 value, IJT808Config config)
         {
             writer.WriteDateTime6(value.RealTime);
@@ -124,7 +144,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             writer.WriteString(value.Brake);
             writer.Skip(10 - (writer.GetCurrentPosition() - currentPosition), out var _);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Down_0x84 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Down_0x84 value = new JT808_CarDVR_Down_0x84();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0xC2.cs

@@ -17,26 +17,47 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0xC2 : JT808CarDVRDownBodies, IJT808MessagePackFormatter<JT808_CarDVR_Down_0xC2>, IJT808Analyze
     {
+        /// <summary>
+        /// 0xC2
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.设置记录仪时间.ToByteValue();
         /// <summary>
         /// 实时时间
         /// </summary>
         public DateTime RealTime { get; set; }
+        /// <summary>
+        /// 北京时间的日期、时钟
+        /// </summary>
         public override string Description => "北京时间的日期、时钟";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Down_0xC2 value = new JT808_CarDVR_Down_0xC2();
             value.RealTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.RealTime.ToString("yyMMddHHmmss")}]实时时间", value.RealTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.RealTime:yyMMddHHmmss}]实时时间", value.RealTime.ToString("yyyy-MM-dd HH:mm:ss"));
         }
 
-
+        /// <summary>
+        /// 北京时间的日期、时钟
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Down_0xC2 value, IJT808Config config)
         {
             writer.WriteDateTime6(value.RealTime);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Down_0xC2 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Down_0xC2 value = new JT808_CarDVR_Down_0xC2();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0xC3.cs

@@ -17,6 +17,9 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0xC3 : JT808CarDVRDownBodies, IJT808MessagePackFormatter<JT808_CarDVR_Down_0xC3>, IJT808Analyze
     {
+        /// <summary>
+        /// 0xC3
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.设置记录仪脉冲系数.ToByteValue();
         /// <summary>
         /// 当前时间
@@ -26,25 +29,44 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 脉冲系数
         /// </summary>
         public ushort PulseCoefficient { get; set; }
+        /// <summary>
+        /// 记录仪脉冲系数
+        /// </summary>
         public override string Description => "记录仪脉冲系数";
 
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Down_0xC3 value = new JT808_CarDVR_Down_0xC3();
             value.RealTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.RealTime.ToString("yyMMddHHmmss")}]当前时间", value.RealTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.RealTime:yyMMddHHmmss}]当前时间", value.RealTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.PulseCoefficient = reader.ReadUInt16();
             writer.WriteNumber($"[{value.PulseCoefficient.ReadNumber()}]脉冲系数", value.PulseCoefficient);
 
         }
 
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Down_0xC3 value, IJT808Config config)
         {
             writer.WriteDateTime6(value.RealTime);
             writer.WriteUInt16(value.PulseCoefficient);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Down_0xC3 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Down_0xC3 value = new JT808_CarDVR_Down_0xC3();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0xC4.cs

@@ -17,6 +17,9 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0xC4 : JT808CarDVRDownBodies, IJT808MessagePackFormatter<JT808_CarDVR_Down_0xC4>, IJT808Analyze
     {
+        /// <summary>
+        /// 0xC4
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.设置初始里程.ToByteValue();
         /// <summary>
         /// 实时时间
@@ -34,21 +37,34 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 累计里程
         /// </summary>
         public string TotalMilage { get; set; }
+        /// <summary>
+        /// 车辆识别代号、机动车号牌号码和机动车号牌分类
+        /// </summary>
         public override string Description => "车辆识别代号、机动车号牌号码和机动车号牌分类";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Down_0xC4 value = new JT808_CarDVR_Down_0xC4();
             value.RealTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.RealTime.ToString("yyMMddHHmmss")}]当前时间", value.RealTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.RealTime:yyMMddHHmmss}]当前时间", value.RealTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.FirstInstallTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.FirstInstallTime.ToString("yyMMddHHmmss")}]初次安装时间", value.FirstInstallTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.FirstInstallTime:yyMMddHHmmss}]初次安装时间", value.FirstInstallTime.ToString("yyyy-MM-dd HH:mm:ss"));
             value.FirstMileage = reader.ReadBCD(8);
             writer.WriteString($"[{value.FirstMileage}]初始里程", value.FirstMileage);
             value.TotalMilage = reader.ReadBCD(8);
             writer.WriteString($"[{value.TotalMilage}]累计里程", value.TotalMilage);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Down_0xC4 value, IJT808Config config)
         {
             writer.WriteDateTime6(value.RealTime);
@@ -56,7 +72,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             writer.WriteBCD(value.FirstMileage, 8);
             writer.WriteBCD(value.TotalMilage, 8);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Down_0xC4 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Down_0xC4 value = new JT808_CarDVR_Down_0xC4();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0xE0.cs

@@ -17,9 +17,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0xE0 : JT808CarDVRDownBodies
     {
+        /// <summary>
+        /// 0xE0
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.进入或保持检定状态.ToByteValue();
-
+        /// <summary>
+        /// 进入或保持检定状态
+        /// </summary>
         public override string Description => "进入或保持检定状态";
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
 
     }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0xE1.cs

@@ -17,6 +17,9 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0xE1 : JT808CarDVRDownBodies, IJT808MessagePackFormatter<JT808_CarDVR_Down_0xE1>, IJT808Analyze
     {
+        /// <summary>
+        /// 0xE1
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.进入里程误差测量.ToByteValue();
         /// <summary>
         /// 记录仪唯一性编号
@@ -39,8 +42,16 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 状态信号
         /// </summary>
         public byte StatusSignal { get; set; }
-        public override string Description => "通过 DB9 的 7 脚接收标准速度脉冲测量信号（TTL 电平）";
-
+        /// <summary>
+        /// 通过DB9的7脚接收标准速度脉冲测量信号（TTL 电平）
+        /// </summary>
+        public override string Description => "通过DB9的7脚接收标准速度脉冲测量信号（TTL 电平）";
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Down_0xE1 value = new JT808_CarDVR_Down_0xE1();
@@ -56,7 +67,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.StatusSignal = reader.ReadByte();
             writer.WriteNumber($"[{value.StatusSignal.ReadNumber()}]状态信号", value.StatusSignal);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Down_0xE1 value, IJT808Config config)
         {
             var currentPosition = writer.GetCurrentPosition();
@@ -67,7 +83,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             writer.WriteUInt32(value.TotalMileage);
             writer.WriteByte(value.StatusSignal);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Down_0xE1 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Down_0xE1 value = new JT808_CarDVR_Down_0xE1();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0xE2.cs

@@ -17,10 +17,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0xE2 : JT808CarDVRDownBodies
     {
+        /// <summary>
+        /// 0xE2
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.进入脉冲系数误差测量.ToByteValue();
-
-        public override string Description => "通过 DB9 的 7 脚输出车速传感器信号（TTL 电平）";
-
+        /// <summary>
+        /// 通过DB9的7脚输出车速传感器信号（TTL 电平）
+        /// </summary>
+        public override string Description => "通过DB9的7脚输出车速传感器信号（TTL 电平）";
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0xE3.cs

@@ -17,9 +17,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0xE3 : JT808CarDVRDownBodies
     {
+        /// <summary>
+        /// 0xE3
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.进入实时时间误差测量.ToByteValue();
-
-        public override string Description => "通过 DB9 的 7 脚输出实时时钟的秒脉冲信号（TTL 电平）";
+        /// <summary>
+        /// 通过 DB9 的 7 脚输出实时时钟的秒脉冲信号（TTL 电平）
+        /// </summary>
+        public override string Description => "通过DB9的7脚输出实时时钟的秒脉冲信号（TTL 电平）";
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Down_0xE4.cs

@@ -17,9 +17,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Down_0xE4 : JT808CarDVRDownBodies
     {
+        /// <summary>
+        /// 0xE4
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.返回正常工作状态.ToByteValue();
+        /// <summary>
+        /// 返回正常工作状态
+        /// </summary>
         public override string Description => "返回正常工作状态";
-
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x00.cs

@@ -17,6 +17,9 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x00 : JT808CarDVRUpBodies, IJT808MessagePackFormatter<JT808_CarDVR_Up_0x00>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x00
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集记录仪执行标准版本.ToByteValue();
         /// <summary>
         /// 记录仪执行标准年号后 2 位  BCD 码
@@ -28,8 +31,16 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 无修改单或无应答则默认为 00H
         /// </summary>
         public byte ModifyNumber { get; set; }
+        /// <summary>
+        /// 记录仪执行标准的年号及修改单号
+        /// </summary>
         public override string Description => "记录仪执行标准的年号及修改单号";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Up_0x00 value = new JT808_CarDVR_Up_0x00();
@@ -38,13 +49,23 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.ModifyNumber = reader.ReadByte();
             writer.WriteNumber($"[{value.ModifyNumber.ReadNumber()}]修改单号", value.ModifyNumber);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Up_0x00 value, IJT808Config config)
         {
             writer.WriteBCD(value.StandardYear, 2);
             writer.WriteByte(value.ModifyNumber);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Up_0x00 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Up_0x00 value = new JT808_CarDVR_Up_0x00();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x01.cs

@@ -17,14 +17,25 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x01 : JT808CarDVRUpBodies, IJT808MessagePackFormatter<JT808_CarDVR_Up_0x01>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x01
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.采集当前驾驶人信息.ToByteValue();
         /// <summary>
         /// 机动车驾驶证号码
         /// 机动车驾驶证号码为 15 位时，后 3 位以 00H 补齐。驾驶人身份未知时以 00H 表示
         /// </summary>
         public string DriverLicenseNo { get; set; }
+        /// <summary>
+        /// 当前驾驶人的机动车驾驶证号码
+        /// </summary>
         public override string Description => "当前驾驶人的机动车驾驶证号码";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Up_0x01 value = new JT808_CarDVR_Up_0x01();
@@ -32,14 +43,24 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.DriverLicenseNo = reader.ReadASCII(18);
             writer.WriteString($"[{hex.ToArray().ToHexString()}]当前驾驶人的机动车驾驶证号码", value.DriverLicenseNo);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Up_0x01 value, IJT808Config config)
         {
             var currentPosition = writer.GetCurrentPosition();
             writer.WriteASCII(value.DriverLicenseNo);
             writer.Skip(18 - (writer.GetCurrentPosition() - currentPosition), out var _);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Up_0x01 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Up_0x01 value = new JT808_CarDVR_Up_0x01();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x02.cs

@@ -17,13 +17,24 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x02 : JT808CarDVRUpBodies, IJT808MessagePackFormatter<JT808_CarDVR_Up_0x02>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x02
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.采集记录仪实时时间.ToByteValue();
         /// <summary>
         /// 实时时间
         /// </summary>
         public DateTime RealTime { get; set; }
+        /// <summary>
+        /// 实时时间
+        /// </summary>
         public override string Description => "实时时间";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Up_0x02 value = new JT808_CarDVR_Up_0x02();
@@ -31,12 +42,22 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.RealTime = reader.ReadDateTime6();
             writer.WriteString($"[{hex.ToArray().ToHexString()}]实时时间", value.RealTime);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Up_0x02 value, IJT808Config config)
         {
             writer.WriteDateTime6(value.RealTime);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Up_0x02 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Up_0x02 value = new JT808_CarDVR_Up_0x02();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x03.cs

@@ -4,9 +4,6 @@ using JT808.Protocol.Formatters;
 using JT808.Protocol.Interfaces;
 using JT808.Protocol.MessagePack;
 using System;
-using System.Buffers.Binary;
-using System.Collections.Generic;
-using System.Text;
 using System.Text.Json;
 
 namespace JT808.Protocol.MessageBody.CarDVR
@@ -17,6 +14,9 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x03 : JT808CarDVRUpBodies, IJT808MessagePackFormatter<JT808_CarDVR_Up_0x03>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x03
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集累计行驶里程.ToByteValue();
         /// <summary>
         /// 实时时间
@@ -34,8 +34,16 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 累计里程
         /// </summary>
         public string TotalMilage { get; set; }
+        /// <summary>
+        /// 实时时间、安装时的初始里程及安装后的累计行驶里程
+        /// </summary>
         public override string Description => "实时时间、安装时的初始里程及安装后的累计行驶里程";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Up_0x03 value = new JT808_CarDVR_Up_0x03();
@@ -52,7 +60,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.TotalMilage = reader.ReadBCD(8);
             writer.WriteString($"[{hex.ToArray().ToHexString()}]累计里程", value.TotalMilage);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Up_0x03 value, IJT808Config config)
         {
             writer.WriteDateTime6(value.RealTime);
@@ -60,7 +73,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             writer.WriteBCD(value.FirstMileage, 8);
             writer.WriteBCD(value.TotalMilage, 8);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Up_0x03 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Up_0x03 value = new JT808_CarDVR_Up_0x03();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x04.cs

@@ -17,6 +17,9 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x04 : JT808CarDVRUpBodies, IJT808MessagePackFormatter<JT808_CarDVR_Up_0x04>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x04
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.采集记录仪脉冲系数.ToByteValue();
         /// <summary>
         /// 当前时间
@@ -26,9 +29,16 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 脉冲系数
         /// </summary>
         public ushort PulseCoefficient { get; set; }
-
+        /// <summary>
+        /// 实时时间及设定的脉冲系数
+        /// </summary>
         public override string Description => "实时时间及设定的脉冲系数";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Up_0x04 value = new JT808_CarDVR_Up_0x04();
@@ -38,13 +48,23 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.PulseCoefficient = reader.ReadUInt16();
             writer.WriteNumber($"[{value.PulseCoefficient.ReadNumber()}]脉冲系数",value.PulseCoefficient);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Up_0x04 value, IJT808Config config)
         {
             writer.WriteDateTime6(value.RealTime);
             writer.WriteUInt16(value.PulseCoefficient);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Up_0x04 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Up_0x04 value = new JT808_CarDVR_Up_0x04();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x05.cs

@@ -17,6 +17,9 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x05 : JT808CarDVRUpBodies, IJT808MessagePackFormatter<JT808_CarDVR_Up_0x05>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x05
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.采集车辆信息.ToByteValue();
         /// <summary>
         /// 车辆识别代号
@@ -32,8 +35,16 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 后 4 个字节为备用字
         /// </summary>
         public string VehicleType { get; set; }
+        /// <summary>
+        /// 车辆识别代号、机动车号牌号码和机动车号牌分类
+        /// </summary>
         public override string Description => "车辆识别代号、机动车号牌号码和机动车号牌分类";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Up_0x05 value = new JT808_CarDVR_Up_0x05();
@@ -47,7 +58,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.VehicleType = reader.ReadString(10);
             writer.WriteString($"[{hex.ToArray().ToHexString()}]机动车号牌分类", value.VehicleType);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Up_0x05 value, IJT808Config config)
         {
             var currentPosition = writer.GetCurrentPosition();
@@ -60,7 +76,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             writer.WriteString(value.VehicleType);
             writer.Skip(10 - (writer.GetCurrentPosition() - currentPosition), out var _);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Up_0x05 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Up_0x05 value = new JT808_CarDVR_Up_0x05();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x06.cs

@@ -17,6 +17,9 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x06 : JT808CarDVRUpBodies, IJT808MessagePackFormatter<JT808_CarDVR_Up_0x06>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x06
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集记录仪状态信号配置信息.ToByteValue();
         /// <summary>
         /// 实时时间
@@ -28,12 +31,16 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// </summary>
         public byte SignalOperate { get; set; }
         /// <summary>
-        /// 
+        /// D0
         /// </summary>
         public string D0 { get; set; }
-
+        /// <summary>
+        /// D1
+        /// </summary>
         public string D1 { get; set; }
-
+        /// <summary>
+        /// D2
+        /// </summary>
         public string D2 { get; set; }
         /// <summary>
         /// 近光 D3
@@ -60,9 +67,16 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 10个字节，未使用或不足时，补0
         /// </summary>
         public string Brake { get; set; }
-        
+        /// <summary>
+        /// 状态信号配置信息
+        /// </summary>
         public override string Description => "状态信号配置信息";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Up_0x06 value = new JT808_CarDVR_Up_0x06();
@@ -96,7 +110,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.Brake = reader.ReadString(10);
             writer.WriteString($"[{hex.ToArray().ToHexString()}]制动", value.Brake);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Up_0x06 value, IJT808Config config)
         {
             writer.WriteDateTime6(value.RealTime);
@@ -126,7 +145,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             writer.WriteString(value.Brake);
             writer.Skip(10 - (writer.GetCurrentPosition() - currentPosition), out var _);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Up_0x06 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Up_0x06 value = new JT808_CarDVR_Up_0x06();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x07.cs

@@ -17,6 +17,9 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x07 : JT808CarDVRUpBodies, IJT808MessagePackFormatter<JT808_CarDVR_Up_0x07>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x07
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集记录仪唯一性编号.ToByteValue();
         /// <summary>
         /// 生产厂 CCC 认证代码  7字节
@@ -38,8 +41,16 @@ namespace JT808.Protocol.MessageBody.CarDVR
         /// 备用  5字节
         /// </summary>
         public string Reversed { get; set; }
+        /// <summary>
+        /// 唯一性编号及初次安装日期
+        /// </summary>
         public override string Description => "唯一性编号及初次安装日期";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_CarDVR_Up_0x07 value = new JT808_CarDVR_Up_0x07();
@@ -59,7 +70,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             value.Reversed = reader.ReadString(5);
             writer.WriteString($"[{hex.ToArray().ToHexString()}]备用", value.Reversed);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Up_0x07 value, IJT808Config config)
         {
             var currentPosition = writer.GetCurrentPosition();
@@ -76,7 +92,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             writer.WriteString(value.Reversed);
             writer.Skip(5 - (writer.GetCurrentPosition() - currentPosition), out var _);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Up_0x07 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Up_0x07 value = new JT808_CarDVR_Up_0x07();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x08.cs

@@ -18,16 +18,26 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x08 : JT808CarDVRUpBodies, IJT808MessagePackFormatter<JT808_CarDVR_Up_0x08>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x08
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.采集指定的行驶速度记录.ToByteValue();
         /// <summary>
         /// 请求发送指定的时间范围内 N 个单位数据块的数据（N≥1）
         /// </summary>
         public List<JT808_CarDVR_Up_0x08_SpeedPerMinute> JT808_CarDVR_Up_0x08_SpeedPerMinutes { get; set; }
+        /// <summary>
+        /// 符合条件的行驶速度记录
+        /// </summary>
         public override string Description => "符合条件的行驶速度记录";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
-            JT808_CarDVR_Up_0x08 value = new JT808_CarDVR_Up_0x08();
             writer.WriteStartArray("请求发送指定的时间范围内 N 个单位数据块的数据");
             var count = (reader.ReadCurrentRemainContentLength() - 1) / 126;//记录块个数, -1 去掉校验位
             for (int i = 0; i < count; i++)
@@ -54,7 +64,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             }
             writer.WriteEndArray();
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Up_0x08 value, IJT808Config config)
         {
             foreach (var speedPerMinute in value.JT808_CarDVR_Up_0x08_SpeedPerMinutes)
@@ -74,7 +89,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
                 }
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Up_0x08 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Up_0x08 value = new JT808_CarDVR_Up_0x08();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x09.cs

@@ -18,16 +18,26 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x09 : JT808CarDVRUpBodies, IJT808MessagePackFormatter<JT808_CarDVR_Up_0x09>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x09
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集指定的位置信息记录.ToByteValue();
         /// <summary>
         /// 请求发送指定的时间范围内 N 个单位数据块的数据（N≥1）
         /// </summary>
         public List<JT808_CarDVR_Up_0x09_PositionPerHour> JT808_CarDVR_Up_0x09_PositionPerHours { get; set; }
+        /// <summary>
+        /// 符合条件的位置信息记录
+        /// </summary>
         public override string Description => "符合条件的位置信息记录";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
-            JT808_CarDVR_Up_0x09 value = new JT808_CarDVR_Up_0x09();
             writer.WriteStartArray("请求发送指定的时间范围内 N 个单位数据块的数据");
             var count = (reader.ReadCurrentRemainContentLength() - 1) / 666;//记录块个数, -1 去掉校验位
             for (int i = 0; i < count; i++)
@@ -57,6 +67,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             }
             writer.WriteEndArray();
         }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Up_0x09 value, IJT808Config config)
         {
             foreach (var positionPerHour in value.JT808_CarDVR_Up_0x09_PositionPerHours)
@@ -80,7 +96,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
                 }
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Up_0x09 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Up_0x09 value = new JT808_CarDVR_Up_0x09();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x10.cs

@@ -19,16 +19,26 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x10 : JT808CarDVRUpBodies, IJT808MessagePackFormatter<JT808_CarDVR_Up_0x10>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x10
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.采集指定的事故疑点记录.ToByteValue();
         /// <summary>
         /// 请求发送指定的时间范围内 N 个单位数据块的数据（N≥1）
         /// </summary>
         public List<JT808_CarDVR_Up_0x10_AccidentSuspectin> JT808_CarDVR_Up_0x10_AccidentSuspectins { get; set; }
+        /// <summary>
+        /// 符合条件的事故疑点记录
+        /// </summary>
         public override string Description => "符合条件的事故疑点记录";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
-            JT808_CarDVR_Up_0x10 value = new JT808_CarDVR_Up_0x10();
             writer.WriteStartArray("请求发送指定的时间范围内 N 个单位数据块的数据");
             var count = (reader.ReadCurrentRemainContentLength() - 1) / 234;//记录块个数, -1 去掉校验位
             for (int i = 0; i < count; i++)
@@ -50,7 +60,7 @@ namespace JT808.Protocol.MessageBody.CarDVR
                         writer.WriteStartObject("行驶结束时的速度");
                     }
                     else {
-                        writer.WriteStartObject($"行驶结束时间前 { (j * 0.2).ToString("F1")} 秒时的速度");
+                        writer.WriteStartObject($"行驶结束时间前 { j * 0.2:F1} 秒时的速度");
                     }
                     jT808_CarDVR_Up_0X10_DrivingStatus.Speed = reader.ReadByte();
                     writer.WriteNumber($"[{ jT808_CarDVR_Up_0X10_DrivingStatus.Speed.ReadNumber()}]速度", jT808_CarDVR_Up_0X10_DrivingStatus.Speed);
@@ -69,7 +79,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             }
             writer.WriteEndArray();
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Up_0x10 value, IJT808Config config)
         {
             foreach (var accidentSuspectin in value.JT808_CarDVR_Up_0x10_AccidentSuspectins)
@@ -96,7 +111,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
                 writer.WriteInt16(accidentSuspectin.Height);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Up_0x10 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Up_0x10 value = new JT808_CarDVR_Up_0x10();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x11.cs

@@ -17,16 +17,26 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x11 : JT808CarDVRUpBodies, IJT808MessagePackFormatter<JT808_CarDVR_Up_0x11>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x11
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.采集指定的超时驾驶记录.ToByteValue();
         /// <summary>
         /// 请求发送指定的时间范围内 N 个单位数据块的数据（N≥1）
         /// </summary>
         public List<JT808_CarDVR_Up_0x11_DriveOverTime> JT808_CarDVR_Up_0x11_DriveOverTimes{ get; set; }
+        /// <summary>
+        /// 符合条件的超时驾驶记录
+        /// </summary>
         public override string Description => "符合条件的超时驾驶记录";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
-            JT808_CarDVR_Up_0x11 value = new JT808_CarDVR_Up_0x11();
             writer.WriteStartArray("请求发送指定的时间范围内 N 个单位数据块的数据");
             var count = (reader.ReadCurrentRemainContentLength() - 1) / 50;//记录块个数, -1 去掉校验位
             for (int i = 0; i < count; i++)
@@ -64,7 +74,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             }
             writer.WriteEndArray();
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Up_0x11 value, IJT808Config config)
         {
             foreach (var driveOverTime in value.JT808_CarDVR_Up_0x11_DriveOverTimes)
@@ -82,7 +97,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
                 writer.WriteInt16(driveOverTime.EndHeight);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Up_0x11 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Up_0x11 value = new JT808_CarDVR_Up_0x11();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x12.cs

@@ -17,16 +17,26 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x12 : JT808CarDVRUpBodies, IJT808MessagePackFormatter<JT808_CarDVR_Up_0x12>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x12
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.采集指定的驾驶人身份记录.ToByteValue();
         /// <summary>
         /// 请求发送指定的时间范围内 N 个单位数据块的数据（N≥1）
         /// </summary>
         public List<JT808_CarDVR_Up_0x12_DriveLogin> JT808_CarDVR_Up_0x12_DriveLogins { get; set; }
+        /// <summary>
+        /// 符合条件的驾驶人登录退出记录
+        /// </summary>
         public override string Description => "符合条件的驾驶人登录退出记录";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
-            JT808_CarDVR_Up_0x12 value = new JT808_CarDVR_Up_0x12();
             writer.WriteStartArray("请求发送指定的时间范围内 N 个单位数据块的数据");
             var count = (reader.ReadCurrentRemainContentLength() - 1) / 25;//记录块个数, -1 去掉校验位
             for (int i = 0; i < count; i++)
@@ -46,7 +56,8 @@ namespace JT808.Protocol.MessageBody.CarDVR
                 writer.WriteEndObject();
             }
             writer.WriteEndArray();
-            string LoginTypeDisplay(byte loginType){
+
+            static string LoginTypeDisplay(byte loginType){
                 if (loginType == 1)
                 {
                     return "登录";
@@ -60,7 +71,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
                 }
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Up_0x12 value, IJT808Config config)
         {
             foreach (var driveLogin in value.JT808_CarDVR_Up_0x12_DriveLogins)
@@ -72,7 +88,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
                 writer.WriteByte(driveLogin.LoginType);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Up_0x12 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Up_0x12 value = new JT808_CarDVR_Up_0x12();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x13.cs

@@ -17,16 +17,26 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x13 : JT808CarDVRUpBodies, IJT808MessagePackFormatter<JT808_CarDVR_Up_0x13>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x13
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.采集指定的外部供电记录.ToByteValue();
         /// <summary>
         /// 请求发送指定的时间范围内 N 个单位数据块的数据（N≥1）
         /// </summary>
         public List<JT808_CarDVR_Up_0x13_ExternalPowerSupply> JT808_CarDVR_Up_0x13_ExternalPowerSupplys { get; set; }
+        /// <summary>
+        /// 符合条件的供电记录
+        /// </summary>
         public override string Description => "符合条件的供电记录";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
-            JT808_CarDVR_Up_0x13 value = new JT808_CarDVR_Up_0x13();
             writer.WriteStartArray("请求发送指定的时间范围内 N 个单位数据块的数据");
             var count = (reader.ReadCurrentRemainContentLength() - 1) / 7;//记录块个数, -1 去掉校验位
             for (int i = 0; i < count; i++)
@@ -43,7 +53,8 @@ namespace JT808.Protocol.MessageBody.CarDVR
                 writer.WriteEndObject();
             }
             writer.WriteEndArray();
-            string EventTypeDisplay(byte eventType) {
+
+            static string EventTypeDisplay(byte eventType) {
                 if (eventType == 1)
                 {
                     return "供电";
@@ -53,6 +64,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
                 }
             }
         }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Up_0x13 value, IJT808Config config)
         {
             foreach (var externalPowerSupply in value.JT808_CarDVR_Up_0x13_ExternalPowerSupplys)
@@ -61,7 +78,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
                 writer.WriteByte(externalPowerSupply.EventType);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Up_0x13 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Up_0x13 value = new JT808_CarDVR_Up_0x13();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x14.cs

@@ -17,16 +17,26 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x14 : JT808CarDVRUpBodies, IJT808MessagePackFormatter<JT808_CarDVR_Up_0x14>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x14
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.采集指定的参数修改记录.ToByteValue();
         /// <summary>
         /// 请求发送指定的时间范围内 N 个单位数据块的数据（N≥1）
         /// </summary>
         public List<JT808_CarDVR_Up_0x14_ParameterModify> JT808_CarDVR_Up_0x14_ParameterModifys { get; set; }
+        /// <summary>
+        /// 符合条件的参数修改记录
+        /// </summary>
         public override string Description => "符合条件的参数修改记录";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
-            JT808_CarDVR_Up_0x14 value = new JT808_CarDVR_Up_0x14();
             writer.WriteStartArray("请求发送指定的时间范围内 N 个单位数据块的数据");
             var count = (reader.ReadCurrentRemainContentLength() - 1) / 7;//记录块个数, -1 去掉校验位
             for (int i = 0; i < count; i++)
@@ -44,7 +54,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
             }
             writer.WriteEndArray();
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Up_0x14 value, IJT808Config config)
         {
             foreach (var parameterModify in value.JT808_CarDVR_Up_0x14_ParameterModifys)
@@ -53,7 +68,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
                 writer.WriteByte(parameterModify.EventType);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Up_0x14 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Up_0x14 value = new JT808_CarDVR_Up_0x14();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x15.cs

@@ -17,16 +17,26 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x15 : JT808CarDVRUpBodies, IJT808MessagePackFormatter<JT808_CarDVR_Up_0x15>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x15
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.采集指定的速度状态日志.ToByteValue();
         /// <summary>
         /// 请求发送指定的时间范围内 N 个单位数据块的数据（N≥1）
         /// </summary>
         public List<JT808_CarDVR_Up_0x15_SpeedStatusLog> JT808_CarDVR_Up_0x15_SpeedStatusLogs { get; set; }
+        /// <summary>
+        /// 符合条件的速度状态日志
+        /// </summary>
         public override string Description => "符合条件的速度状态日志";
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
-            JT808_CarDVR_Up_0x15 value = new JT808_CarDVR_Up_0x15();
             writer.WriteStartArray("请求发送指定的时间范围内 N 个单位数据块的数据");
             var count = (reader.ReadCurrentRemainContentLength() - 1) / 133;//记录块个数, -1 去掉校验位
             for (int i = 0; i < count; i++)
@@ -68,7 +78,8 @@ namespace JT808.Protocol.MessageBody.CarDVR
                 writer.WriteEndObject();
             }
             writer.WriteEndArray();
-            string SpeedStatusDisplay(byte speedStatus) {
+
+            static string SpeedStatusDisplay(byte speedStatus) {
                 if (speedStatus == 0x01)
                 {
                     return "正常";
@@ -82,7 +93,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
                 }
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_CarDVR_Up_0x15 value, IJT808Config config)
         {
             foreach (var speedStatusLog in value.JT808_CarDVR_Up_0x15_SpeedStatusLogs)
@@ -104,7 +120,12 @@ namespace JT808.Protocol.MessageBody.CarDVR
                 }
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_CarDVR_Up_0x15 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_CarDVR_Up_0x15 value = new JT808_CarDVR_Up_0x15();

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x82.cs

@@ -17,9 +17,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x82 : JT808CarDVRUpBodies
     {
+        /// <summary>
+        /// 0x82
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.设置车辆信息.ToByteValue();
-
+        /// <summary>
+        /// 车辆信息
+        /// </summary>
         public override string Description => "车辆信息";
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x83.cs

@@ -17,10 +17,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x83 : JT808CarDVRUpBodies
     {
+        /// <summary>
+        /// 0x83
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.设置记录仪初次安装日期.ToByteValue();
-
+        /// <summary>
+        /// 初次安装日期
+        /// </summary>
         public override string Description => "初次安装日期";
-
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0x84.cs

@@ -17,9 +17,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0x84 : JT808CarDVRUpBodies
     {
+        /// <summary>
+        /// 0x84
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.设置状态量配置信息.ToByteValue();
-
+        /// <summary>
+        /// 状态量配置信息
+        /// </summary>
         public override string Description => "状态量配置信息";
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0xC2.cs

@@ -17,9 +17,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0xC2 : JT808CarDVRUpBodies
     {
+        /// <summary>
+        /// 0xC2
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.设置记录仪时间.ToByteValue();
-
+        /// <summary>
+        /// 北京时间的日期、时钟
+        /// </summary>
         public override string Description => "北京时间的日期、时钟";
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0xC3.cs

@@ -17,9 +17,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0xC3 : JT808CarDVRUpBodies
     {
+        /// <summary>
+        /// 0xC3
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.设置记录仪脉冲系数.ToByteValue();
-
+        /// <summary>
+        /// 记录仪脉冲系数
+        /// </summary>
         public override string Description => "记录仪脉冲系数";
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0xC4.cs

@@ -17,8 +17,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0xC4 : JT808CarDVRUpBodies
     {
+        /// <summary>
+        /// 0xC4
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.设置初始里程.ToByteValue();
+        /// <summary>
+        /// 车辆识别代号、机动车号牌号码和机动车号牌分类
+        /// </summary>
         public override string Description => "车辆识别代号、机动车号牌号码和机动车号牌分类";
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0xE0.cs

@@ -18,8 +18,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0xE0 : JT808CarDVRUpBodies
     {
+        /// <summary>
+        /// 0xE0
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.进入或保持检定状态.ToByteValue();
+        /// <summary>
+        /// 进入或保持检定状态
+        /// </summary>
         public override string Description => "进入或保持检定状态";
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0xE1.cs

@@ -17,9 +17,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0xE1 : JT808CarDVRUpBodies
     {
+        /// <summary>
+        /// 0xE1
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.进入里程误差测量.ToByteValue();
-
-        public override string Description => "通过 DB9 的 7 脚接收标准速度脉冲测量信号（TTL 电平）";
+        /// <summary>
+        /// 通过DB9的7脚接收标准速度脉冲测量信号（TTL 电平）
+        /// </summary>
+        public override string Description => "通过 DB9的7脚接收标准速度脉冲测量信号（TTL 电平）";
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0xE2.cs

@@ -17,9 +17,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0xE2 : JT808CarDVRUpBodies
     {
+        /// <summary>
+        /// 0xE2
+        /// </summary>
         public override byte CommandId => JT808CarDVRCommandID.进入脉冲系数误差测量.ToByteValue();
-
+        /// <summary>
+        /// 通过DB9的7脚输出车速传感器信号（TTL 电平）
+        /// </summary>
         public override string Description => "通过 DB9 的 7 脚输出车速传感器信号（TTL 电平）";
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0xE3.cs

@@ -17,9 +17,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0xE3 : JT808CarDVRUpBodies
     {
+        /// <summary>
+        /// 0xE3
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.进入实时时间误差测量.ToByteValue();
-
-        public override string Description => "通过 DB9 的 7 脚输出实时时钟的秒脉冲信号（TTL 电平）";
+        /// <summary>
+        /// 通过DB9的7脚输出实时时钟的秒脉冲信号（TTL 电平）
+        /// </summary>
+        public override string Description => "通过DB9的7脚输出实时时钟的秒脉冲信号（TTL 电平）";
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/CarDVR/JT808_CarDVR_Up_0xE4.cs

@@ -17,8 +17,17 @@ namespace JT808.Protocol.MessageBody.CarDVR
     /// </summary>
     public class JT808_CarDVR_Up_0xE4 : JT808CarDVRUpBodies
     {
+        /// <summary>
+        /// 0xE4
+        /// </summary>
         public override byte CommandId =>  JT808CarDVRCommandID.返回正常工作状态.ToByteValue();
+        /// <summary>
+        /// 返回正常工作状态
+        /// </summary>
         public override string Description => "返回正常工作状态";
+        /// <summary>
+        /// 
+        /// </summary>
         public override bool SkipSerialization { get; set; } = true;
     }
 }

src/JT808.Protocol/MessageBody/JT808_0x0200.cs

@@ -207,7 +207,7 @@ namespace JT808.Protocol.MessageBody
                     {
                         JT808MessagePackFormatterResolverExtensions.JT808DynamicSerialize(item.Value, ref writer, item.Value, config);
                     }
-                    catch(Exception ex)
+                    catch
                     {
 
                     }
@@ -357,7 +357,7 @@ namespace JT808.Protocol.MessageBody
             value.Direction = reader.ReadUInt16();
             writer.WriteNumber($"[{value.Direction.ReadNumber()}]方向", value.Direction);
             value.GPSTime = reader.ReadDateTime6();
-            writer.WriteString($"[{value.GPSTime.ToString("yyMMddHHmmss")}]定位时间", value.GPSTime.ToString("yyyy-MM-dd HH:mm:ss"));
+            writer.WriteString($"[{value.GPSTime:yyMMddHHmmss}]定位时间", value.GPSTime.ToString("yyyy-MM-dd HH:mm:ss"));
             // 位置附加信息
             writer.WriteStartArray("附加信息列表");
             while (reader.ReadCurrentRemainContentLength() > 0)
@@ -402,7 +402,7 @@ namespace JT808.Protocol.MessageBody
                         writer.WriteString($"未知附加信息", reader.ReadArray(reader.ReaderCount - 2, attachLen + 2).ToArray().ToHexString());   
                         reader.Skip(attachLen);
                     }
-                    catch (Exception ex)
+                    catch
                     {
                         throw;
                     }

src/JT808.Protocol/MessageBody/JT808_0x0704.cs

@@ -116,7 +116,7 @@ namespace JT808.Protocol.MessageBody
             jT808_0X0704.Count = reader.ReadUInt16();
             writer.WriteNumber($"[{jT808_0X0704.Count.ReadNumber()}]数据项个数", jT808_0X0704.Count);
             jT808_0X0704.LocationType = (JT808_0x0704.BatchLocationType)reader.ReadByte();
-            writer.WriteNumber($"[{((byte)jT808_0X0704.LocationType).ReadNumber()}]位置数据类型-{jT808_0X0704.LocationType.ToString()}", (byte)jT808_0X0704.LocationType);
+            writer.WriteNumber($"[{((byte)jT808_0X0704.LocationType).ReadNumber()}]位置数据类型-{jT808_0X0704.LocationType}", (byte)jT808_0X0704.LocationType);
             writer.WriteStartArray("位置汇报数据集合");
             for (int i = 0; i < jT808_0X0704.Count; i++)
             {

src/JT808.Protocol/MessageBody/JT808_0x8103.cs

@@ -77,7 +77,7 @@ namespace JT808.Protocol.MessageBody
                     }
                 }
             }
-            catch (Exception ex)
+            catch
             {
 
             }
@@ -106,7 +106,7 @@ namespace JT808.Protocol.MessageBody
                     }
                 }
             }
-            catch (Exception ex) { }
+            catch { }
         }
         /// <summary>
         /// 

src/JT808.Protocol/MessageBody/JT808_0x8103_0x0095.cs

@@ -35,7 +35,12 @@ namespace JT808.Protocol.MessageBody
         /// 上传方式为 0x0D 时，单位为条。
         /// </summary>
         public uint ParamValue { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8103_0x0095 jT808_0x8103_0x0095 = new JT808_0x8103_0x0095();
@@ -46,7 +51,12 @@ namespace JT808.Protocol.MessageBody
             writer.WriteNumber($"[{jT808_0x8103_0x0095.ParamLength.ReadNumber()}]参数长度", jT808_0x8103_0x0095.ParamLength);
             writer.WriteNumber($"[{ jT808_0x8103_0x0095.ParamValue.ReadNumber()}]参数值[GNSS模块详细定位数据上传设置]", jT808_0x8103_0x0095.ParamValue);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8103_0x0095 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8103_0x0095 jT808_0x8103_0x0095 = new JT808_0x8103_0x0095();
@@ -55,7 +65,12 @@ namespace JT808.Protocol.MessageBody
             jT808_0x8103_0x0095.ParamValue = reader.ReadUInt32();
             return jT808_0x8103_0x0095;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0095 value, IJT808Config config)
         {
             writer.WriteUInt32(value.ParamId);

src/JT808.Protocol/MessageBody/JT808_0x8103_0x0100.cs

@@ -54,7 +54,12 @@ namespace JT808.Protocol.MessageBody
             jT808_0x8103_0x0100.ParamValue = reader.ReadUInt32();
             return jT808_0x8103_0x0100;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0100 value, IJT808Config config)
         {
             writer.WriteUInt32(value.ParamId);

src/JT808.Protocol/MessageBody/JT808_0x8302.cs

@@ -84,7 +84,7 @@ namespace JT808.Protocol.MessageBody
                     answer.Content = reader.ReadString(answer.ContentLength);
                     jT808_0X8302.Answers.Add(answer);
                 }
-                catch (Exception ex)
+                catch
                 {
                     break;
                 }