diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808.Protocol.Extensions.JTActiveSafety.Test.csproj b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808.Protocol.Extensions.JTActiveSafety.Test.csproj index c7ce9d9..43ff6eb 100644 --- a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808.Protocol.Extensions.JTActiveSafety.Test.csproj +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808.Protocol.Extensions.JTActiveSafety.Test.csproj @@ -6,13 +6,6 @@ false - - - - True - - - diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_0x1210_Test.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_0x1210_Test.cs index f250bf5..3558cd4 100644 --- a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_0x1210_Test.cs +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.JTActiveSafety.Test/JT808_0x1210_Test.cs @@ -43,7 +43,7 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.Test FileSize=10 } }, - MakerID = "4444444", + TerminalId = "4444444", InfoType = 0 }; var hex = JT808Serializer.Serialize(jT808UploadLocationRequest).ToHexString(); @@ -68,7 +68,7 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.Test Assert.Equal(9, jT808UploadLocationRequest.AttachInfos[1].FileNameLength); Assert.Equal(10u, jT808UploadLocationRequest.AttachInfos[1].FileSize); - Assert.Equal("4444444", jT808UploadLocationRequest.MakerID); + Assert.Equal("4444444", jT808UploadLocationRequest.TerminalId); Assert.Equal(0, jT808UploadLocationRequest.InfoType); } diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.JTActiveSafety/JT808.Protocol.Extensions.JTActiveSafety.xml b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.JTActiveSafety/JT808.Protocol.Extensions.JTActiveSafety.xml index 8986e83..9e3a4b0 100644 --- a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.JTActiveSafety/JT808.Protocol.Extensions.JTActiveSafety.xml +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.JTActiveSafety/JT808.Protocol.Extensions.JTActiveSafety.xml @@ -783,9 +783,9 @@ 报警附件信息消息 - + - 制造商Id + 终端ID 7 个字节，由大写字母和数字组成，此终端ID 由制造商自行定义，位数不足时，后补“0x00” diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_0x1210.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_0x1210.cs index 4a6d105..6de33f1 100644 --- a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_0x1210.cs +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.JTActiveSafety/MessageBody/JT808_0x1210.cs @@ -15,10 +15,10 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody public class JT808_0x1210: JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze { /// - /// 制造商Id + /// 终端ID /// 7 个字节，由大写字母和数字组成，此终端ID 由制造商自行定义，位数不足时，后补“0x00” /// - public string MakerID { get; set; } + public string TerminalId { get; set; } /// /// 报警标识号 /// @@ -60,8 +60,8 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody { JT808_0x1210 value = new JT808_0x1210(); string makerIdHex=reader.ReadVirtualArray(7).ToArray().ToHexString(); - value.MakerID = reader.ReadString(7); - writer.WriteString($"[{makerIdHex}]制造商Id", value.MakerID); + value.TerminalId = reader.ReadString(7); + writer.WriteString($"[{makerIdHex}]终端ID", value.TerminalId); value.AlarmIdentification = new AlarmIdentificationProperty(); string terminalIDHex = reader.ReadVirtualArray(7).ToArray().ToHexString(); value.AlarmIdentification.TerminalID = reader.ReadString(7); @@ -109,7 +109,7 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody public JT808_0x1210 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) { JT808_0x1210 value = new JT808_0x1210(); - value.MakerID = reader.ReadString(7); + value.TerminalId = reader.ReadString(7); value.AlarmIdentification = new AlarmIdentificationProperty { TerminalID = reader.ReadString(7), @@ -143,7 +143,7 @@ namespace JT808.Protocol.Extensions.JTActiveSafety.MessageBody /// public void Serialize(ref JT808MessagePackWriter writer, JT808_0x1210 value, IJT808Config config) { - writer.WriteString(value.MakerID.PadRight(7, '\0')); + writer.WriteString(value.TerminalId.PadRight(7, '\0')); if (value.AlarmIdentification == null) { throw new NullReferenceException($"{nameof(AlarmIdentificationProperty)}不为空"); diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Enums/ActivePhotographyStrategyType.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Enums/ActivePhotographyStrategyType.cs new file mode 100644 index 0000000..09a3eef --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Enums/ActivePhotographyStrategyType.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace JT808.Protocol.Extensions.YueBiao.Enums +{ + /// + /// 主动拍照策略 + /// + public enum ActivePhotographyStrategyType:byte + { + /// + /// 不开启 + /// + 不开启 = 0x00, + /// + /// 定时拍照 + /// + 定时拍照 = 0x01, + /// + /// 定距拍照 + /// + 定距拍照 = 0x02, + /// + /// 保留 + /// + 保留 = 0x03, + /// + /// 不修改参数 + /// + 不修改参数 = 0xFF + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Enums/JT808_YueBiao_MsgId.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Enums/JT808_YueBiao_MsgId.cs new file mode 100644 index 0000000..aa2d916 --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Enums/JT808_YueBiao_MsgId.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace JT808.Protocol.Extensions.YueBiao.Enums +{ + /// + /// 主动安全消息Id + /// + public enum JT808_YueBiao_MsgId : ushort + { + /// + /// 报警附件信息消息 + /// + 报警附件信息消息 = 0x1210, + /// + /// 文件信息上传 + /// + 文件信息上传 = 0x1211, + /// + /// 文件上传完成消息 + /// + 文件上传完成消息 = 0x1212, + /// + /// 报警附件上传指令 + /// + 报警附件上传指令 = 0x9208, + /// + /// 文件上传完成消息应答 + /// + 文件上传完成消息应答 = 0x9212, + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Enums/PhotoResolutionType.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Enums/PhotoResolutionType.cs new file mode 100644 index 0000000..92bca3c --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Enums/PhotoResolutionType.cs @@ -0,0 +1,41 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace JT808.Protocol.Extensions.YueBiao.Enums +{ + /// + /// 拍照分辨率 + /// + public enum PhotoResolutionType:byte + { + /// + /// 352x288 + /// + x352_288 = 0x01, + /// + /// 704x288 + /// + x704_288 = 0x02, + /// + /// 704x576 + /// + x704_576 = 0x03, + /// + /// 640x480 + /// + x640_480 = 0x04, + /// + /// 1280x720 + /// + x1280_720 = 0x05, + /// + /// 1920x1080 + /// + x1920_1080 = 0x06, + /// + /// 不修改参数 + /// + 不修改参数 = 0xFF + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Enums/USBIDType.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Enums/USBIDType.cs new file mode 100644 index 0000000..6761dd6 --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Enums/USBIDType.cs @@ -0,0 +1,29 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace JT808.Protocol.Extensions.YueBiao.Enums +{ + /// + /// USB编号类型 + /// + public enum USBIDType:byte + { + /// + /// 高级驾驶辅助系统 + /// + ADAS = 0x64, + /// + /// 驾驶员状态监控系统 + /// + DSM = 0x65, + /// + /// 轮胎气压监测系统 + /// + TPMS = 0x66, + /// + /// 盲点监测系统 + /// + BSD = 0x67 + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Enums/VideoRecordingResolutionType.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Enums/VideoRecordingResolutionType.cs new file mode 100644 index 0000000..6d1f9f5 --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Enums/VideoRecordingResolutionType.cs @@ -0,0 +1,45 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace JT808.Protocol.Extensions.YueBiao.Enums +{ + /// + /// 视频录制分辨率 + /// + public enum VideoRecordingResolutionType:byte + { + /// + /// CIF + /// + CIF = 0x01, + /// + /// HD1 + /// + HD1 = 0x02, + /// + /// D1 + /// + D1 = 0x03, + /// + /// WD1 + /// + WD1 = 0x04, + /// + /// VGA + /// + VGA = 0x05, + /// + /// 720P + /// + _720P = 0x06, + /// + /// 1080P + /// + _1080P = 0x07, + /// + /// 不修改参数 + /// + 不修改参数 = 0xFF + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Enums/WorkingConditionType.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Enums/WorkingConditionType.cs new file mode 100644 index 0000000..f292fea --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Enums/WorkingConditionType.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace JT808.Protocol.Extensions.YueBiao.Enums +{ + /// + /// 工作状态 + /// + public enum WorkingConditionType:byte + { + /// + /// 正常工作 + /// + 正常工作 = 0x01, + /// + /// 待机状态 + /// + 待机状态 = 0x02, + /// + /// 升级维护 + /// + 升级维护 = 0x03, + /// + /// 设备异常 + /// + 设备异常 = 0x04, + /// + /// 断开连接 + /// + 断开连接 = 0x10, + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/JT808.Protocol.Extensions.YueBiao.csproj b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/JT808.Protocol.Extensions.YueBiao.csproj index 03b8429..1467982 100644 --- a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/JT808.Protocol.Extensions.YueBiao.csproj +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/JT808.Protocol.Extensions.YueBiao.csproj @@ -13,7 +13,7 @@ True - + diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/JT808.Protocol.Extensions.YueBiao.xml b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/JT808.Protocol.Extensions.YueBiao.xml index 0ec9c30..7ccb3a4 100644 --- a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/JT808.Protocol.Extensions.YueBiao.xml +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/JT808.Protocol.Extensions.YueBiao.xml @@ -16,5 +16,2022 @@ + + + 主动拍照策略 + + + + + 不开启 + + + + + 定时拍照 + + + + + 定距拍照 + + + + + 保留 + + + + + 不修改参数 + + + + + 主动安全消息Id + + + + + 报警附件信息消息 + + + + + 文件信息上传 + + + + + 文件上传完成消息 + + + + + 报警附件上传指令 + + + + + 文件上传完成消息应答 + + + + + 拍照分辨率 + + + + + 352x288 + + + + + 704x288 + + + + + 704x576 + + + + + 640x480 + + + + + 1280x720 + + + + + 1920x1080 + + + + + 不修改参数 + + + + + USB编号类型 + + + + + 高级驾驶辅助系统 + + + + + 驾驶员状态监控系统 + + + + + 轮胎气压监测系统 + + + + + 盲点监测系统 + + + + + 视频录制分辨率 + + + + + CIF + + + + + HD1 + + + + + D1 + + + + + WD1 + + + + + VGA + + + + + 720P + + + + + 1080P + + + + + 不修改参数 + + + + + 工作状态 + + + + + 正常工作 + + + + + 待机状态 + + + + + 升级维护 + + + + + 设备异常 + + + + + 断开连接 + + + + + 主动安全常量 + + + + + 附加信息ID 高级驾驶辅助系统报警信息 + + + + + 附加信息ID 驾驶员状态监测系统报警信息 + + + + + 附加信息ID 胎压监测系统报警信息 + + + + + 附加信息ID 盲区监测系统报警信息 + + + + + 高级驾驶辅助系统参数设置 + + + + + 驾驶员状态监测系统参数设置 + + + + + 胎压监测系统参数设置 + + + + + 盲区监测系统参数设置 + + + + + 状态查询 + + + + + 信息查询 + + + + + 高级驾驶辅助系统报警信息 + + + + + 高级驾驶辅助系统报警信息Id + + + + + 高级驾驶辅助系统报警信息附加长度 + + + + + 报警ID + + + + + 标志状态 + + + + + 报警/事件类型 + + + + + 报警/事件类型 + + + + + 前车车速 + + + + + 前车/行人距离 + + + + + 偏离类型 + + + + + 道路标志识别类型 + + + + + 道路标志识别类型 + + + + + 车速 + + + + + 高程 + + + + + 纬度 + + + + + 经度 + + + + + 日期时间 + YYMMDDhhmmss + BCD[6] + + + + + 车辆状态 + + + + + 报警标识号 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 驾驶员状态监测系统报警信息 + + + + + 驾驶员状态监测系统报警信息Id + + + + + 驾驶员状态监测系统报警信息长度 + + + + + 报警ID + + + + + 标志状态 + + + + + 报警/事件类型 + + + + + 报警级别 + + + + + 疲劳程度 + + + + + 预留 + + + + + 车速 + + + + + 高程 + + + + + 纬度 + + + + + 经度 + + + + + 日期时间 + YYMMDDhhmmss + BCD[6] + + + + + 车辆状态 + + + + + 报警标识号 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 胎压监测系统报警信息 + + + + + 胎压监测系统报警信息Id + + + + + 胎压监测系统报警信息长度 + + + + + 报警ID + + + + + 标志状态 + + + + + 车速 + + + + + 高程 + + + + + 纬度 + + + + + 经度 + + + + + 日期时间 + YYMMDDhhmmss + BCD[6] + + + + + 车辆状态 + + + + + 报警标识号 + + + + + 报警/事件列表总数 + + + + + 报警/事件信息列表 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 盲区监测系统报警信息 + + + + + 盲区监测系统报警信息Id + + + + + 盲区监测系统报警信息长度 + + + + + 报警ID + + + + + 标志状态 + + + + + 报警/事件类型 + + + + + 报警/事件类型 + + + + + 车速 + + + + + 高程 + + + + + 纬度 + + + + + 经度 + + + + + 日期时间 + YYMMDDhhmmss + BCD[6] + + + + + 车辆状态 + + + + + 报警标识号 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 透传数据 + + + + + 透传类型 + + + + + 消息列表总数 + + + + + 消息列表数据 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 透传数据 + + + + + 透传类型 + + + + + 消息列表总数 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 报警附件信息消息 + + + + + 终端 ID + 30 个字节，由大写字母和数字组成，此终端ID 由制造商自行定义，位数不足时，后补“0x00” + + + + + 报警标识号 + + + + + 平台给报警分配的唯一编号 + 32 + + + + + 信息类型 + 0x00：正常报警文件信息 + 0x01：补传报警文件信息 + + + + + 附件数量 + + + + + 附件信息列表 + + + + + 报警附件信息消息Id + + + + + 报警附件信息消息 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 文件信息上传 + + + + + 文件信息上传 + + + + + 文件名称长度 + + + + + 文件名称 + 形如：文件类型_通道号_报警类型_序号_报警编号.后缀名 + + + + + 文件类型 + + + + + 文件大小 + + + + + 文件信息上传Id + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 文件上传完成消息 + + + + + 文件上传完成消息 + + + + + 文件名称长度 + + + + + 文件名称 + 形如：文件类型_通道号_报警类型_序号_报警编号.后缀名 + + + + + 文件类型 + + + + + 文件大小 + + + + + 文件上传完成消息 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 高级驾驶辅助系统参数 + + + + + 高级驾驶辅助系统参数 + + + + + 高级驾驶辅助系统参数长度 + + + + + 报警判断速度阈值 + + + + + 报警提示音量 + + + + + 主动拍照策略 + + + + + + 主动定时拍照时间间隔 + + + + + 主动定距拍照距离间隔 + + + + + 单次主动拍照张数 + + + + + 单次主动拍照时间间隔 + + + + + 拍照分辨率 + + + + + + 视频录制分辨率 + + + + + 报警使能 + + + + + 事件使能 + + + + + 预留字段 + + + + + 障碍物报警距离阈值 + + + + + 障碍物报警分级速度阈值 + + + + + 障碍物报警前后视频录制时间 + + + + + 障碍物报警拍照张数 + + + + + 障碍物报警拍照间隔 + + + + + 频繁变道报警判断时间段 + + + + + 频繁变道报警判断次数 + + + + + 频繁变道报警分级速度阈值 + + + + + 频繁变道报警前后视频录制时间 + + + + + 频繁变道报警拍照张数 + + + + + 频繁变道报警拍照间隔 + + + + + 车道偏离报警分级速度阈值 + + + + + 车道偏离报警前后视频录制时间 + + + + + 车道偏离报警拍照张数 + + + + + 车道偏离报警拍照间隔 + + + + + 前向碰撞报警时间阈值 + + + + + 前向碰撞报警分级速度阈值 + + + + + 前向碰撞报警前后视频录制时间 + + + + + 前向碰撞报警拍照张数 + + + + + 前向碰撞报警拍照间隔 + + + + + 行人碰撞报警时间阈值 + + + + + 行人碰撞报警使能速度阈值 + + + + + 行人碰撞报警前后视频录制时间 + + + + + 行人碰撞报警拍照张数 + + + + + 行人碰撞报警拍照间隔 + + + + + 车距监控报警距离阈值 + + + + + 车距监控报警分级速度阈值 + + + + + 车距过近报警前后视频录制时间 + + + + + 车距过近报警拍照张数 + + + + + 车距过近报警拍照间隔 + + + + + 道路标志识别拍照张数 + + + + + 道路标志识别拍照间隔 + + + + + 保留字段 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 驾驶员状态监测系统参数 + + + + + 驾驶员状态监测系统参数 + + + + + 驾驶员状态监测系统参数长度 + + + + + 报警判断速度阈值 + + + + + 报警提示音量 + + + + + 主动拍照策略 + + + + + 主动定时拍照时间间隔 + + + + + 主动定距拍照距离间隔 + + + + + 单次主动拍照张数 + + + + + 单次主动拍照时间间隔 + + + + + 拍照分辨率 + + + + + 视频录制分辨率 + + + + + 报警使能 + + + + + 事件使能 + + + + + 吸烟报警判断时间间隔 + + + + + 接打电话报警判断时间间隔 + + + + + 预留字段 + + + + + 疲劳驾驶报警分级速度阈值 + + + + + 疲劳驾驶报警前后视频录制时间 + + + + + 疲劳驾驶报警拍照张数 + + + + + 疲劳驾驶报警拍照间隔时间 + + + + + 接打电话报警分级速度阈值 + + + + + 接打电话报警前后视频录制时间 + + + + + 接打电话报警拍驾驶员面部特征照片张数 + + + + + 接打电话报警拍驾驶员面部特征照片间隔时间 + + + + + 抽烟报警分级车速阈值 + + + + + 抽烟报警前后视频录制时间 + + + + + 抽烟报警拍驾驶员面部特征照片张数 + + + + + 抽烟报警拍驾驶员面部特征照片间隔时间 + + + + + 分神驾驶报警分级车速阈值 + + + + + 分神驾驶报警拍照张数 + + + + + 分神驾驶报警拍照间隔时间 + + + + + 驾驶行为异常视频录制时间 + + + + + 驾驶行为异常抓拍照片张数 + + + + + 驾驶行为异常拍照间隔 + + + + + 驾驶员身份识别触发 + + + + + 保留字段 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 胎压监测系统参数 + + + + + 胎压监测系统参数Id + + + + + 胎压监测系统参数长度 + + + + + 轮胎规格型号 12位 + + + + + 胎压单位 + + + + + 正常胎压值 + + + + + 胎压不平衡门限 + + + + + 慢漏气门限 + + + + + 低压阈值 + + + + + 高压阈值 + + + + + 高温阈值 + + + + + 电压阈值 + + + + + 定时上报时间间隔 + + + + + 保留项 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 盲区监测系统参数 + + + + + 盲区监测系统参数Id + + + + + 盲区监测系统参数长度 + + + + + 后方接近报警时间阈值 + + + + + 侧后方接近报警时间阈值 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 状态查询 + + + + + 查询基本信息类型 + 外设状态信息：外设工作状态、设备报警信息 + + + + + 外设ID列表总数 + + + + + 外设ID + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 信息查询 + + + + + 查询基本信息透传类型 + 外设传感器的基本信息：公司信息、 产品代码、 版本号、 外设 ID、 客户代码。对应的消息内容见表 + + + + + 外设ID列表总数 + + + + + 外设ID + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 报警附件上传指令 + + + + + Description + + + + + 服务IP地址长度 + + + + + 服务IP地址 + + + + + TCP端口 + + + + + UDP端口 + + + + + 报警标识号 + + + + + 平台给报警分配的唯一编号 + 32 + + + + + 预留 + + + + + 报警附件上传指令Id + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 文件上传完成消息应答 + + + + + 文件上传完成消息应答 + + + + + 文件名称长度 + + + + + 文件名称 + + + + + 文件类型 + + + + + 上传结果 + + + + + 补传数据包数量 + 需要补传的数据包数量，无补传时该值为0 + + + + + 补传数据包列表 + + + + + 文件上传完成消息应答Id + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 报警标识号 + 报警附件信息消息数据格式 + + + + + 终端ID + 30 + + + + + YY-MM-DD-hh-mm-ss + BCD[6] + + + + + 序号 + + + + + 附件数量 + + + + + 预留1 + + + + + 预留2 + + + + + 胎压监测系统报警/事件信息 + + + + + 胎压报警位置 + + + + + 报警/事件类型 + + + + + 胎压 + + + + + 胎温 + + + + + 电池电量 + + + + + 附件信息 + + + + + 文件名称长度 + + + + + 文件名称 + 形如：文件类型_通道号_报警类型_序号_报警编号.后缀名 + + + + + 文件大小 + + + + + 补传数据包信息 + + + + + 数据偏移量 + + + + + 数据长度 + + + + + + + + + + 外设ID + + + + + + 消息长度 + + + + + 工作状态 + + + + + + 报警状态 + + + + + + + + + + 外设ID + + + + + + 消息长度 + + + + + 公司名称长度 + + + + + 公司名称 + + + + + 产品型号长度 + + + + + 产品型号 + + + + + 硬件版本号长度 + + + + + 硬件版本号 + ASCII + + + + + 软件版本号长度 + + + + + 软件版本号 + ASCII + + + + + 设备ID长度 + + + + + 设备ID + + + + + 客户代码长度 + + + + + 客户代码 + + diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/JT808_YueBiao_Constants.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/JT808_YueBiao_Constants.cs new file mode 100644 index 0000000..95dfe1f --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/JT808_YueBiao_Constants.cs @@ -0,0 +1,53 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace JT808.Protocol.Extensions.YueBiao +{ + /// + /// 主动安全常量 + /// + public static class JT808_YueBiao_Constants + { + /// + /// 附加信息ID 高级驾驶辅助系统报警信息 + /// + public const byte JT808_0X0200_0x64 = 0x64; + /// + /// 附加信息ID 驾驶员状态监测系统报警信息 + /// + public const byte JT808_0X0200_0x65 = 0x65; + /// + /// 附加信息ID 胎压监测系统报警信息 + /// + public const byte JT808_0X0200_0x66 = 0x66; + /// + /// 附加信息ID 盲区监测系统报警信息 + /// + public const byte JT808_0X0200_0x67 = 0x67; + /// + /// 高级驾驶辅助系统参数设置 + /// + public const uint JT808_0X8103_0xF364 = 0xF364; + /// + /// 驾驶员状态监测系统参数设置 + /// + public const uint JT808_0X8103_0xF365 = 0xF365; + /// + /// 胎压监测系统参数设置 + /// + public const uint JT808_0X8103_0xF366 = 0xF366; + /// + /// 盲区监测系统参数设置 + /// + public const uint JT808_0X8103_0xF367 = 0xF367; + /// + /// 状态查询 + /// + public const byte JT808_0X0900_0xF7 = 0xF7; + /// + /// 信息查询 + /// + public const byte JT808_0X0900_0xF8 = 0xF8; + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x0200_0x64.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x0200_0x64.cs new file mode 100644 index 0000000..8f92a51 --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x0200_0x64.cs @@ -0,0 +1,352 @@ +using JT808.Protocol.Extensions.YueBiao.Metadata; +using JT808.Protocol.Formatters; +using JT808.Protocol.Interfaces; +using JT808.Protocol.MessageBody; +using JT808.Protocol.MessagePack; +using System; +using System.Collections.Generic; +using System.Text; +using System.Text.Json; + +namespace JT808.Protocol.Extensions.YueBiao.MessageBody +{ + /// + /// 高级驾驶辅助系统报警信息 + /// + public class JT808_0x0200_0x64 : JT808_0x0200_BodyBase, IJT808MessagePackFormatter, IJT808Analyze + { + /// + /// 高级驾驶辅助系统报警信息Id + /// + public override byte AttachInfoId { get; set; } = JT808_YueBiao_Constants.JT808_0X0200_0x64; + /// + /// 高级驾驶辅助系统报警信息附加长度 + /// + public override byte AttachInfoLength { get; set; } = 32; + /// + /// 报警ID + /// + public uint AlarmId { get; set; } + /// + /// 标志状态 + /// + public byte FlagState { get; set; } + /// + /// 报警/事件类型 + /// + public byte AlarmOrEventType{ get; set; } + /// + /// 报警/事件类型 + /// + public byte AlarmLevel { get; set; } + /// + /// 前车车速 + /// + public byte VehicleSpeed { get; set; } + /// + /// 前车/行人距离 + /// + public byte CarOrPedestrianDistanceAhead { get; set; } + /// + /// 偏离类型 + /// + public byte DeviateType { get; set; } + /// + /// 道路标志识别类型 + /// + public byte RoadSignIdentificationType { get; set; } + /// + /// 道路标志识别类型 + /// + public byte RoadSignIdentificationData { get; set; } + /// + /// 车速 + /// + public byte Speed { get; set; } + /// + /// 高程 + /// + public ushort Altitude { get; set; } + /// + /// 纬度 + /// + public int Latitude { get; set; } + /// + /// 经度 + /// + public int Longitude { get; set; } + /// + /// 日期时间 + /// YYMMDDhhmmss + /// BCD[6] + /// + public DateTime AlarmTime { get; set; } + /// + /// 车辆状态 + /// + public ushort VehicleState { get; set; } + /// + /// 报警标识号 + /// + public AlarmIdentificationProperty AlarmIdentification { get; set; } + /// + /// + /// + /// + /// + /// + public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) + { + JT808_0x0200_0x64 value = new JT808_0x0200_0x64(); + value.AttachInfoId = reader.ReadByte(); + writer.WriteNumber($"[{value.AttachInfoId.ReadNumber()}]附加信息Id", value.AttachInfoId); + value.AttachInfoLength = reader.ReadByte(); + writer.WriteNumber($"[{value.AttachInfoLength.ReadNumber()}]附加信息长度", value.AttachInfoLength); + value.AlarmId = reader.ReadUInt32(); + writer.WriteNumber($"[{value.AlarmId.ReadNumber()}]报警ID", value.AlarmId); + value.FlagState = reader.ReadByte(); + string flagStateString = "未知"; + switch (value.FlagState) + { + case 0: + flagStateString = "不可用"; + break; + case 1: + flagStateString = "开始标志"; + break; + case 2: + flagStateString = "结束标志"; + break; + } + writer.WriteNumber($"[{value.FlagState.ReadNumber()}]标志状态-{flagStateString}", value.FlagState); + value.AlarmOrEventType = reader.ReadByte(); + string alarmOrEventTypeString = ""; + string vehicleSpeedString = "无效"; + string carOrPedestrianDistanceAheadString = "无效"; + string deviateTypeString = "无效"; + string roadSignIdentificationTypeString = "无效"; + switch (value.AlarmOrEventType) + { + case 0x01: + alarmOrEventTypeString = "前向碰撞报警"; + vehicleSpeedString = "有效"; + carOrPedestrianDistanceAheadString = "有效"; + break; + case 0x02: + alarmOrEventTypeString = "车道偏离报警"; + vehicleSpeedString = "有效"; + carOrPedestrianDistanceAheadString = "有效"; + deviateTypeString = "有效"; + break; + case 0x03: + alarmOrEventTypeString = "车距过近报警"; + break; + case 0x04: + alarmOrEventTypeString = "行人碰撞报警"; + vehicleSpeedString = "有效"; + break; + case 0x05: + alarmOrEventTypeString = "频繁变道报警"; + break; + case 0x06: + alarmOrEventTypeString = "道路标识超限报警"; + roadSignIdentificationTypeString = "有效"; + break; + case 0x07: + alarmOrEventTypeString = "障碍物报警"; + break; + case 0x08: + case 0x09: + case 0x0A: + case 0x0B: + case 0x0C: + case 0x0D: + case 0x0E: + case 0x0F: + alarmOrEventTypeString = "用户自定义"; + break; + case 0x10: + roadSignIdentificationTypeString = "有效"; + alarmOrEventTypeString = "道路标志识别事件"; + break; + case 0x11: + alarmOrEventTypeString = "主动抓拍事件"; + break; + case 0x12: + alarmOrEventTypeString = "实现变道报警"; + break; + case 0x13: + alarmOrEventTypeString = "车厢过道行人检测报警"; + break; + case 0x14: + case 0x15: + case 0x16: + case 0x17: + case 0x18: + case 0x19: + case 0x1A: + case 0x1B: + case 0x1C: + case 0x1D: + case 0x1E: + case 0x1F: + alarmOrEventTypeString = "用户自定义"; + break; + } + writer.WriteNumber($"[{value.AlarmOrEventType.ReadNumber()}]报警_事件类型-{alarmOrEventTypeString}", value.AlarmOrEventType); + value.AlarmLevel = reader.ReadByte(); + string alarmLevelString = "未知"; + switch (value.AlarmLevel) + { + case 0x01: + alarmLevelString = "一级报警"; + break; + case 0x02: + alarmLevelString = "二级报警"; + break; + } + writer.WriteNumber($"[{value.AlarmLevel.ReadNumber()}]报警级别-{alarmLevelString}", value.AlarmLevel); + value.VehicleSpeed = reader.ReadByte(); + writer.WriteNumber($"[{value.VehicleSpeed.ReadNumber()}]前车车速-{vehicleSpeedString}", value.VehicleSpeed); + value.CarOrPedestrianDistanceAhead = reader.ReadByte(); + writer.WriteNumber($"[{value.CarOrPedestrianDistanceAhead.ReadNumber()}]前车_行人距离-{carOrPedestrianDistanceAheadString}", value.CarOrPedestrianDistanceAhead); + value.DeviateType = reader.ReadByte(); + string deviateType = value.DeviateType == 0x01 ? "左侧偏离" : "右侧偏离"; + writer.WriteNumber($"[{value.DeviateType.ReadNumber()}]偏离类型-{deviateType}-{deviateTypeString}", value.DeviateType); + value.RoadSignIdentificationType = reader.ReadByte(); + string roadSignIdentificationType = "未知标志"; + if (value.RoadSignIdentificationType == 0x01) + { + roadSignIdentificationType = "限速标志"; + } + else if (value.RoadSignIdentificationType == 0x02) + { + roadSignIdentificationType = "限高标志"; + } + else if (value.RoadSignIdentificationType == 0x03) + { + roadSignIdentificationType = "限重标志"; + } + writer.WriteNumber($"[{value.RoadSignIdentificationType.ReadNumber()}]道路标志识别类型-{roadSignIdentificationType}-{roadSignIdentificationTypeString}", value.RoadSignIdentificationType); + value.RoadSignIdentificationData = reader.ReadByte(); + writer.WriteNumber($"[{value.RoadSignIdentificationData.ReadNumber()}]道路标志识别数据", value.RoadSignIdentificationData); + value.Speed = reader.ReadByte(); + writer.WriteNumber($"[{value.Speed.ReadNumber()}]车速", value.Speed); + value.Altitude = reader.ReadUInt16(); + writer.WriteNumber($"[{value.Altitude.ReadNumber()}]高程", value.Altitude); + value.Latitude = (int)reader.ReadUInt32(); + writer.WriteNumber($"[{value.Latitude.ReadNumber()}]纬度", value.Latitude); + value.Longitude = (int)reader.ReadUInt32(); + writer.WriteNumber($"[{value.Longitude.ReadNumber()}]经度", value.Longitude); + value.AlarmTime = reader.ReadDateTime6(); + writer.WriteString($"[{value.AlarmTime.ToString("yyMMddHHmmss")}]日期时间", value.AlarmTime.ToString("yyyy-MM-dd HH:mm:ss")); + value.VehicleState = reader.ReadUInt16(); + writer.WriteNumber($"[{value.VehicleState.ReadNumber()}]车辆状态", value.VehicleState); + var vehicleStateBits = Convert.ToString(value.VehicleState, 2).PadLeft(16, '0'); + writer.WriteStartObject($"车辆状态对象[{vehicleStateBits}]"); + writer.WriteString($"[{vehicleStateBits[15]}]Bit0ACC状态", vehicleStateBits[15] == '0' ? "关闭" : "打开"); + writer.WriteString($"[{vehicleStateBits[14]}]Bit1左转向状态", vehicleStateBits[14] == '0' ? "关闭" : "打开"); + writer.WriteString($"[{vehicleStateBits[13]}]Bit2右转向状态", vehicleStateBits[13] == '0' ? "关闭" : "打开"); + writer.WriteString($"[{vehicleStateBits[12]}]Bit3雨刮器状态", vehicleStateBits[12] == '0' ? "关闭" : "打开"); + writer.WriteString($"[{vehicleStateBits[11]}]Bit4制动状态", vehicleStateBits[11] == '0' ? "未制动" : "制动"); + writer.WriteString($"[{vehicleStateBits[10]}]Bit5插卡状态", vehicleStateBits[10] == '0' ? "未插卡" : "已插卡"); + writer.WriteString($"[{vehicleStateBits[9]}]Bit6自定义", vehicleStateBits[9].ToString()); + writer.WriteString($"[{vehicleStateBits[8]}]Bit7自定义", vehicleStateBits[8].ToString()); + writer.WriteString($"[{vehicleStateBits[7]}]Bit8自定义", vehicleStateBits[7].ToString()); + writer.WriteString($"[{vehicleStateBits[6]}]Bit9自定义", vehicleStateBits[6].ToString()); + writer.WriteString($"[{vehicleStateBits[5]}]Bit10定位状态", vehicleStateBits[5] == '0' ? "未定位" : "已定位"); + writer.WriteString($"[{vehicleStateBits[4]}]Bit11自定义", vehicleStateBits[4].ToString()); + writer.WriteString($"[{vehicleStateBits[3]}]Bit12自定义", vehicleStateBits[3].ToString()); + writer.WriteString($"[{vehicleStateBits[2]}]Bit13自定义", vehicleStateBits[2].ToString()); + writer.WriteString($"[{vehicleStateBits[1]}]Bit14自定义", vehicleStateBits[1].ToString()); + writer.WriteString($"[{vehicleStateBits[0]}]Bit15自定义", vehicleStateBits[0].ToString()); + writer.WriteEndObject(); + value.AlarmIdentification = new AlarmIdentificationProperty(); + string terminalIDHex = reader.ReadVirtualArray(30).ToArray().ToHexString(); + value.AlarmIdentification.TerminalId = reader.ReadString(30); + value.AlarmIdentification.Time = reader.ReadDateTime6(); + value.AlarmIdentification.SN = reader.ReadByte(); + value.AlarmIdentification.AttachCount = reader.ReadByte(); + value.AlarmIdentification.Retain1 = reader.ReadByte(); + value.AlarmIdentification.Retain2 = reader.ReadByte(); + writer.WriteString($"[{terminalIDHex}]终端ID", value.AlarmIdentification.TerminalId); + writer.WriteString($"[{value.AlarmIdentification.Time.ToString("yyMMddHHmmss")}]日期时间", value.AlarmIdentification.Time.ToString("yyyy-MM-dd HH:mm:ss")); + writer.WriteNumber($"[{value.AlarmIdentification.SN.ReadNumber()}]序号", value.AlarmIdentification.SN); + writer.WriteNumber($"[{value.AlarmIdentification.AttachCount.ReadNumber()}]附件数量", value.AlarmIdentification.AttachCount); + writer.WriteNumber($"[{value.AlarmIdentification.Retain1.ReadNumber()}]预留1", value.AlarmIdentification.Retain1); + writer.WriteNumber($"[{value.AlarmIdentification.Retain2.ReadNumber()}]预留2", value.AlarmIdentification.Retain2); + } + /// + /// + /// + /// + /// + /// + public JT808_0x0200_0x64 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) + { + JT808_0x0200_0x64 value = new JT808_0x0200_0x64(); + value.AttachInfoId = reader.ReadByte(); + value.AttachInfoLength = reader.ReadByte(); + value.AlarmId = reader.ReadUInt32(); + value.FlagState = reader.ReadByte(); + value.AlarmOrEventType = reader.ReadByte(); + value.AlarmLevel = reader.ReadByte(); + value.VehicleSpeed = reader.ReadByte(); + value.CarOrPedestrianDistanceAhead = reader.ReadByte(); + value.DeviateType = reader.ReadByte(); + value.RoadSignIdentificationType = reader.ReadByte(); + value.RoadSignIdentificationData = reader.ReadByte(); + value.Speed = reader.ReadByte(); + value.Altitude = reader.ReadUInt16(); + value.Latitude = (int)reader.ReadUInt32(); + value.Longitude = (int)reader.ReadUInt32(); + value.AlarmTime = reader.ReadDateTime6(); + value.VehicleState = reader.ReadUInt16(); + value.AlarmIdentification = new AlarmIdentificationProperty + { + TerminalId = reader.ReadString(30), + Time = reader.ReadDateTime6(), + SN = reader.ReadByte(), + AttachCount = reader.ReadByte(), + Retain1 = reader.ReadByte(), + Retain2 = reader.ReadByte() + }; + return value; + } + /// + /// + /// + /// + /// + /// + public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0200_0x64 value, IJT808Config config) + { + writer.WriteByte(value.AttachInfoId); + writer.WriteByte(value.AttachInfoLength); + writer.WriteUInt32(value.AlarmId); + writer.WriteByte(value.FlagState); + writer.WriteByte(value.AlarmOrEventType); + writer.WriteByte(value.AlarmLevel); + writer.WriteByte(value.VehicleSpeed); + writer.WriteByte(value.CarOrPedestrianDistanceAhead); + writer.WriteByte(value.DeviateType); + writer.WriteByte(value.RoadSignIdentificationType); + writer.WriteByte(value.RoadSignIdentificationData); + writer.WriteByte(value.Speed); + writer.WriteUInt16(value.Altitude); + writer.WriteUInt32((uint)value.Latitude); + writer.WriteUInt32((uint)value.Longitude); + writer.WriteDateTime6(value.AlarmTime); + writer.WriteUInt16(value.VehicleState); + if (value.AlarmIdentification == null) { + throw new NullReferenceException($"{nameof(AlarmIdentificationProperty)}不为空"); + } + writer.WriteString(value.AlarmIdentification.TerminalId.PadRight(30, '\0')); + writer.WriteDateTime6(value.AlarmIdentification.Time); + writer.WriteByte(value.AlarmIdentification.SN); + writer.WriteByte(value.AlarmIdentification.AttachCount); + writer.WriteByte(value.AlarmIdentification.Retain1); + writer.WriteByte(value.AlarmIdentification.Retain2); + } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x0200_0x65.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x0200_0x65.cs new file mode 100644 index 0000000..6f18db6 --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x0200_0x65.cs @@ -0,0 +1,315 @@ +using JT808.Protocol.Extensions.YueBiao.Metadata; +using JT808.Protocol.Formatters; +using JT808.Protocol.Interfaces; +using JT808.Protocol.MessageBody; +using JT808.Protocol.MessagePack; +using System; +using System.Collections.Generic; +using System.Text; +using System.Text.Json; + +namespace JT808.Protocol.Extensions.YueBiao.MessageBody +{ + /// + /// 驾驶员状态监测系统报警信息 + /// + public class JT808_0x0200_0x65 : JT808_0x0200_BodyBase, IJT808MessagePackFormatter, IJT808Analyze + { + /// + /// 驾驶员状态监测系统报警信息Id + /// + public override byte AttachInfoId { get; set; } = JT808_YueBiao_Constants.JT808_0X0200_0x65; + /// + /// 驾驶员状态监测系统报警信息长度 + /// + public override byte AttachInfoLength { get; set; } = 47; + /// + /// 报警ID + /// + public uint AlarmId { get; set; } + /// + /// 标志状态 + /// + public byte FlagState { get; set; } + /// + /// 报警/事件类型 + /// + public byte AlarmOrEventType{ get; set; } + /// + /// 报警级别 + /// + public byte AlarmLevel { get; set; } + /// + /// 疲劳程度 + /// + public byte Fatigue { get; set; } + /// + /// 预留 + /// + public byte[] Retain { get; set; } = new byte[4]; + /// + /// 车速 + /// + public byte Speed { get; set; } + /// + /// 高程 + /// + public ushort Altitude { get; set; } + /// + /// 纬度 + /// + public int Latitude { get; set; } + /// + /// 经度 + /// + public int Longitude { get; set; } + /// + /// 日期时间 + /// YYMMDDhhmmss + /// BCD[6] + /// + public DateTime AlarmTime { get; set; } + /// + /// 车辆状态 + /// + public ushort VehicleState { get; set; } + /// + /// 报警标识号 + /// + public AlarmIdentificationProperty AlarmIdentification { get; set; } + /// + /// + /// + /// + /// + /// + public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) + { + JT808_0x0200_0x65 value = new JT808_0x0200_0x65(); + value.AttachInfoId = reader.ReadByte(); + writer.WriteNumber($"[{value.AttachInfoId.ReadNumber()}]附加信息Id", value.AttachInfoId); + value.AttachInfoLength = reader.ReadByte(); + writer.WriteNumber($"[{value.AttachInfoLength.ReadNumber()}]附加信息长度", value.AttachInfoLength); + value.AlarmId = reader.ReadUInt32(); + writer.WriteNumber($"[{value.AlarmId.ReadNumber()}]报警ID", value.AlarmId); + value.FlagState = reader.ReadByte(); + string flagStateString = "未知"; + switch (value.FlagState) + { + case 0: + flagStateString = "不可用"; + break; + case 1: + flagStateString = "开始标志"; + break; + case 2: + flagStateString = "结束标志"; + break; + } + writer.WriteNumber($"[{value.FlagState.ReadNumber()}]标志状态-{flagStateString}", value.FlagState); + value.AlarmOrEventType = reader.ReadByte(); + string alarmOrEventTypeString = ""; + switch (value.AlarmOrEventType) + { + case 0x01: + alarmOrEventTypeString = "疲劳驾驶报警"; + break; + case 0x02: + alarmOrEventTypeString = "接打手持电话报警"; + break; + case 0x03: + alarmOrEventTypeString = "抽烟报警"; + break; + case 0x04: + alarmOrEventTypeString = "不目视前方报警"; + break; + case 0x05: + alarmOrEventTypeString = "驾驶员异常报警"; + break; + case 0x06: + alarmOrEventTypeString = "探头遮挡报警"; + break; + case 0x07: + alarmOrEventTypeString = "用户自定义"; + break; + case 0x08: + alarmOrEventTypeString = "超时驾驶报警"; + break; + case 0x09: + alarmOrEventTypeString = "用户自定义"; + break; + case 0x0A: + alarmOrEventTypeString = "未系安全带报警"; + break; + case 0x0B: + alarmOrEventTypeString = "红外阻断型墨镜失效报警"; + break; + case 0x0C: + alarmOrEventTypeString = "双脱把报警（双手同时脱离方向盘）"; + break; + case 0x0D: + alarmOrEventTypeString = "玩手机报警"; + break; + case 0x0E: + case 0x0F: + alarmOrEventTypeString = "用户自定义"; + break; + case 0x10: + alarmOrEventTypeString = "自动抓拍事件"; + break; + case 0x11: + alarmOrEventTypeString = "驾驶员变更事件"; + break; + case 0x12: + case 0x13: + case 0x14: + case 0x15: + case 0x16: + case 0x17: + case 0x18: + case 0x19: + case 0x1A: + case 0x1B: + case 0x1C: + case 0x1D: + case 0x1E: + case 0x1F: + alarmOrEventTypeString = "用户自定义"; + break; + } + writer.WriteNumber($"[{value.AlarmOrEventType.ReadNumber()}]报警_事件类型-{alarmOrEventTypeString}", value.AlarmOrEventType); + value.AlarmLevel = reader.ReadByte(); + string alarmLevelString = "未知"; + switch (value.AlarmLevel) + { + case 0x01: + alarmLevelString = "一级报警"; + break; + case 0x02: + alarmLevelString = "二级报警"; + break; + } + writer.WriteNumber($"[{value.AlarmLevel.ReadNumber()}]报警级别-{alarmLevelString}", value.AlarmLevel); + value.Fatigue = reader.ReadByte(); + writer.WriteNumber($"[{value.Fatigue.ReadNumber()}]疲劳程度", value.Fatigue); + value.Retain = reader.ReadArray(4).ToArray(); + writer.WriteString("预留", value.Retain.ToHexString()); + value.Speed = reader.ReadByte(); + writer.WriteNumber($"[{value.Speed.ReadNumber()}]车速", value.Speed); + value.Altitude = reader.ReadUInt16(); + writer.WriteNumber($"[{value.Altitude.ReadNumber()}]高程", value.Altitude); + value.Latitude = (int)reader.ReadUInt32(); + writer.WriteNumber($"[{value.Latitude.ReadNumber()}]纬度", value.Latitude); + value.Longitude = (int)reader.ReadUInt32(); + writer.WriteNumber($"[{value.Longitude.ReadNumber()}]经度", value.Longitude); + value.AlarmTime = reader.ReadDateTime6(); + writer.WriteString($"[{value.AlarmTime.ToString("yyMMddHHmmss")}]日期时间", value.AlarmTime.ToString("yyyy-MM-dd HH:mm:ss")); + value.VehicleState = reader.ReadUInt16(); + writer.WriteNumber($"[{value.VehicleState.ReadNumber()}]车辆状态", value.VehicleState); + var vehicleStateBits = Convert.ToString(value.VehicleState, 2).PadLeft(16, '0'); + writer.WriteStartObject($"车辆状态对象[{vehicleStateBits}]"); + writer.WriteString($"[{vehicleStateBits[15]}]Bit0ACC状态", vehicleStateBits[15] == '0' ? "关闭" : "打开"); + writer.WriteString($"[{vehicleStateBits[14]}]Bit1左转向状态", vehicleStateBits[14] == '0' ? "关闭" : "打开"); + writer.WriteString($"[{vehicleStateBits[13]}]Bit2右转向状态", vehicleStateBits[13] == '0' ? "关闭" : "打开"); + writer.WriteString($"[{vehicleStateBits[12]}]Bit3雨刮器状态", vehicleStateBits[12] == '0' ? "关闭" : "打开"); + writer.WriteString($"[{vehicleStateBits[11]}]Bit4制动状态", vehicleStateBits[11] == '0' ? "未制动" : "制动"); + writer.WriteString($"[{vehicleStateBits[10]}]Bit5插卡状态", vehicleStateBits[10] == '0' ? "未插卡" : "已插卡"); + writer.WriteString($"[{vehicleStateBits[9]}]Bit6自定义", vehicleStateBits[9].ToString()); + writer.WriteString($"[{vehicleStateBits[8]}]Bit7自定义", vehicleStateBits[8].ToString()); + writer.WriteString($"[{vehicleStateBits[7]}]Bit8自定义", vehicleStateBits[7].ToString()); + writer.WriteString($"[{vehicleStateBits[6]}]Bit9自定义", vehicleStateBits[6].ToString()); + writer.WriteString($"[{vehicleStateBits[5]}]Bit10定位状态", vehicleStateBits[5] == '0' ? "未定位" : "已定位"); + writer.WriteString($"[{vehicleStateBits[4]}]Bit11自定义", vehicleStateBits[4].ToString()); + writer.WriteString($"[{vehicleStateBits[3]}]Bit12自定义", vehicleStateBits[3].ToString()); + writer.WriteString($"[{vehicleStateBits[2]}]Bit13自定义", vehicleStateBits[2].ToString()); + writer.WriteString($"[{vehicleStateBits[1]}]Bit14自定义", vehicleStateBits[1].ToString()); + writer.WriteString($"[{vehicleStateBits[0]}]Bit15自定义", vehicleStateBits[0].ToString()); + writer.WriteEndObject(); + value.AlarmIdentification = new AlarmIdentificationProperty(); + string terminalIDHex = reader.ReadVirtualArray(30).ToArray().ToHexString(); + value.AlarmIdentification.TerminalId = reader.ReadString(30); + value.AlarmIdentification.Time = reader.ReadDateTime6(); + value.AlarmIdentification.SN = reader.ReadByte(); + value.AlarmIdentification.AttachCount = reader.ReadByte(); + value.AlarmIdentification.Retain1 = reader.ReadByte(); + value.AlarmIdentification.Retain2 = reader.ReadByte(); + writer.WriteString($"[{terminalIDHex}]终端ID", value.AlarmIdentification.TerminalId); + writer.WriteString($"[{value.AlarmIdentification.Time.ToString("yyMMddHHmmss")}]日期时间", value.AlarmIdentification.Time.ToString("yyyy-MM-dd HH:mm:ss")); + writer.WriteNumber($"[{value.AlarmIdentification.SN.ReadNumber()}]序号", value.AlarmIdentification.SN); + writer.WriteNumber($"[{value.AlarmIdentification.AttachCount.ReadNumber()}]附件数量", value.AlarmIdentification.AttachCount); + writer.WriteNumber($"[{value.AlarmIdentification.Retain1.ReadNumber()}]预留1", value.AlarmIdentification.Retain1); + writer.WriteNumber($"[{value.AlarmIdentification.Retain2.ReadNumber()}]预留2", value.AlarmIdentification.Retain2); + } + /// + /// + /// + /// + /// + /// + public JT808_0x0200_0x65 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) + { + JT808_0x0200_0x65 value = new JT808_0x0200_0x65(); + value.AttachInfoId = reader.ReadByte(); + value.AttachInfoLength = reader.ReadByte(); + value.AlarmId = reader.ReadUInt32(); + value.FlagState = reader.ReadByte(); + value.AlarmOrEventType = reader.ReadByte(); + value.AlarmLevel = reader.ReadByte(); + value.Fatigue = reader.ReadByte(); + value.Retain = reader.ReadArray(4).ToArray(); + value.Speed = reader.ReadByte(); + value.Altitude = reader.ReadUInt16(); + value.Latitude = (int)reader.ReadUInt32(); + value.Longitude = (int)reader.ReadUInt32(); + value.AlarmTime = reader.ReadDateTime6(); + value.VehicleState = reader.ReadUInt16(); + value.AlarmIdentification = new AlarmIdentificationProperty + { + TerminalId = reader.ReadString(30), + Time = reader.ReadDateTime6(), + SN = reader.ReadByte(), + AttachCount = reader.ReadByte(), + Retain1 = reader.ReadByte(), + Retain2 = reader.ReadByte() + }; + return value; + } + /// + /// + /// + /// + /// + /// + public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0200_0x65 value, IJT808Config config) + { + writer.WriteByte(value.AttachInfoId); + writer.WriteByte(value.AttachInfoLength); + writer.WriteUInt32(value.AlarmId); + writer.WriteByte(value.FlagState); + writer.WriteByte(value.AlarmOrEventType); + writer.WriteByte(value.AlarmLevel); + writer.WriteByte(value.Fatigue); + if (value.Retain.Length != 4) + { + throw new ArgumentOutOfRangeException($"{nameof(JT808_0x0200_0x65.Retain)} length==4"); + } + writer.WriteArray(value.Retain); + writer.WriteByte(value.Speed); + writer.WriteUInt16(value.Altitude); + writer.WriteUInt32((uint)value.Latitude); + writer.WriteUInt32((uint)value.Longitude); + writer.WriteDateTime6(value.AlarmTime); + writer.WriteUInt16(value.VehicleState); + if (value.AlarmIdentification == null) + { + throw new NullReferenceException($"{nameof(AlarmIdentificationProperty)}不为空"); + } + writer.WriteString(value.AlarmIdentification.TerminalId.PadRight(30, '\0')); + writer.WriteDateTime6(value.AlarmIdentification.Time); + writer.WriteByte(value.AlarmIdentification.SN); + writer.WriteByte(value.AlarmIdentification.AttachCount); + writer.WriteByte(value.AlarmIdentification.Retain1); + writer.WriteByte(value.AlarmIdentification.Retain2); + } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x0200_0x66.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x0200_0x66.cs new file mode 100644 index 0000000..163c6e5 --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x0200_0x66.cs @@ -0,0 +1,316 @@ +using JT808.Protocol.Extensions.YueBiao.Metadata; +using JT808.Protocol.Formatters; +using JT808.Protocol.Interfaces; +using JT808.Protocol.MessageBody; +using JT808.Protocol.MessagePack; +using System; +using System.Collections.Generic; +using System.Text; +using System.Text.Json; + +namespace JT808.Protocol.Extensions.YueBiao.MessageBody +{ + /// + /// 胎压监测系统报警信息 + /// + public class JT808_0x0200_0x66 : JT808_0x0200_BodyBase, IJT808MessagePackFormatter, IJT808Analyze + { + /// + /// 胎压监测系统报警信息Id + /// + public override byte AttachInfoId { get; set; } = JT808_YueBiao_Constants.JT808_0X0200_0x66; + /// + /// 胎压监测系统报警信息长度 + /// + public override byte AttachInfoLength { get; set; } + /// + /// 报警ID + /// + public uint AlarmId { get; set; } + /// + /// 标志状态 + /// + public byte FlagState { get; set; } + /// + /// 车速 + /// + public byte Speed { get; set; } + /// + /// 高程 + /// + public ushort Altitude { get; set; } + /// + /// 纬度 + /// + public int Latitude { get; set; } + /// + /// 经度 + /// + public int Longitude { get; set; } + /// + /// 日期时间 + /// YYMMDDhhmmss + /// BCD[6] + /// + public DateTime AlarmTime { get; set; } + /// + /// 车辆状态 + /// + public ushort VehicleState { get; set; } + /// + /// 报警标识号 + /// + public AlarmIdentificationProperty AlarmIdentification { get; set; } + /// + /// 报警/事件列表总数 + /// + public byte AlarmOrEventCount { get; set; } + /// + /// 报警/事件信息列表 + /// + public List AlarmOrEvents { get; set; } + /// + /// + /// + /// + /// + /// + public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) + { + JT808_0x0200_0x66 value = new JT808_0x0200_0x66(); + value.AttachInfoId = reader.ReadByte(); + writer.WriteNumber($"[{value.AttachInfoId.ReadNumber()}]附加信息Id", value.AttachInfoId); + value.AttachInfoLength = reader.ReadByte(); + writer.WriteNumber($"[{value.AttachInfoLength.ReadNumber()}]附加信息长度", value.AttachInfoLength); + value.AlarmId = reader.ReadUInt32(); + writer.WriteNumber($"[{value.AlarmId.ReadNumber()}]报警ID", value.AlarmId); + value.FlagState = reader.ReadByte(); + string flagStateString = "未知"; + switch (value.FlagState) + { + case 0: + flagStateString = "不可用"; + break; + case 1: + flagStateString = "开始标志"; + break; + case 2: + flagStateString = "结束标志"; + break; + } + writer.WriteNumber($"[{value.FlagState.ReadNumber()}]标志状态-{flagStateString}", value.FlagState); + value.Speed = reader.ReadByte(); + writer.WriteNumber($"[{value.Speed.ReadNumber()}]车速", value.Speed); + value.Altitude = reader.ReadUInt16(); + writer.WriteNumber($"[{value.Altitude.ReadNumber()}]高程", value.Altitude); + value.Latitude = (int)reader.ReadUInt32(); + writer.WriteNumber($"[{value.Latitude.ReadNumber()}]纬度", value.Latitude); + value.Longitude = (int)reader.ReadUInt32(); + writer.WriteNumber($"[{value.Longitude.ReadNumber()}]经度", value.Longitude); + value.AlarmTime = reader.ReadDateTime6(); + writer.WriteString($"[{value.AlarmTime.ToString("yyMMddHHmmss")}]日期时间", value.AlarmTime.ToString("yyyy-MM-dd HH:mm:ss")); + value.VehicleState = reader.ReadUInt16(); + writer.WriteNumber($"[{value.VehicleState.ReadNumber()}]车辆状态", value.VehicleState); + var vehicleStateBits = Convert.ToString(value.VehicleState, 2).PadLeft(16, '0'); + writer.WriteStartObject($"车辆状态对象[{vehicleStateBits}]"); + writer.WriteString($"[{vehicleStateBits[15]}]Bit0ACC状态", vehicleStateBits[15] == '0' ? "关闭" : "打开"); + writer.WriteString($"[{vehicleStateBits[14]}]Bit1左转向状态", vehicleStateBits[14] == '0' ? "关闭" : "打开"); + writer.WriteString($"[{vehicleStateBits[13]}]Bit2右转向状态", vehicleStateBits[13] == '0' ? "关闭" : "打开"); + writer.WriteString($"[{vehicleStateBits[12]}]Bit3雨刮器状态", vehicleStateBits[12] == '0' ? "关闭" : "打开"); + writer.WriteString($"[{vehicleStateBits[11]}]Bit4制动状态", vehicleStateBits[11] == '0' ? "未制动" : "制动"); + writer.WriteString($"[{vehicleStateBits[10]}]Bit5插卡状态", vehicleStateBits[10] == '0' ? "未插卡" : "已插卡"); + writer.WriteString($"[{vehicleStateBits[9]}]Bit6自定义", vehicleStateBits[9].ToString()); + writer.WriteString($"[{vehicleStateBits[8]}]Bit7自定义", vehicleStateBits[8].ToString()); + writer.WriteString($"[{vehicleStateBits[7]}]Bit8自定义", vehicleStateBits[7].ToString()); + writer.WriteString($"[{vehicleStateBits[6]}]Bit9自定义", vehicleStateBits[6].ToString()); + writer.WriteString($"[{vehicleStateBits[5]}]Bit10定位状态", vehicleStateBits[5] == '0' ? "未定位" : "已定位"); + writer.WriteString($"[{vehicleStateBits[4]}]Bit11自定义", vehicleStateBits[4].ToString()); + writer.WriteString($"[{vehicleStateBits[3]}]Bit12自定义", vehicleStateBits[3].ToString()); + writer.WriteString($"[{vehicleStateBits[2]}]Bit13自定义", vehicleStateBits[2].ToString()); + writer.WriteString($"[{vehicleStateBits[1]}]Bit14自定义", vehicleStateBits[1].ToString()); + writer.WriteString($"[{vehicleStateBits[0]}]Bit15自定义", vehicleStateBits[0].ToString()); + writer.WriteEndObject(); + value.AlarmIdentification = new AlarmIdentificationProperty(); + string terminalIDHex = reader.ReadVirtualArray(30).ToArray().ToHexString(); + value.AlarmIdentification.TerminalId = reader.ReadString(30); + value.AlarmIdentification.Time = reader.ReadDateTime6(); + value.AlarmIdentification.SN = reader.ReadByte(); + value.AlarmIdentification.AttachCount = reader.ReadByte(); + value.AlarmIdentification.Retain1 = reader.ReadByte(); + value.AlarmIdentification.Retain2 = reader.ReadByte(); + writer.WriteString($"[{terminalIDHex}]终端ID", value.AlarmIdentification.TerminalId); + writer.WriteString($"[{value.AlarmIdentification.Time.ToString("yyMMddHHmmss")}]日期时间", value.AlarmIdentification.Time.ToString("yyyy-MM-dd HH:mm:ss")); + writer.WriteNumber($"[{value.AlarmIdentification.SN.ReadNumber()}]序号", value.AlarmIdentification.SN); + writer.WriteNumber($"[{value.AlarmIdentification.AttachCount.ReadNumber()}]附件数量", value.AlarmIdentification.AttachCount); + writer.WriteNumber($"[{value.AlarmIdentification.Retain1.ReadNumber()}]预留1", value.AlarmIdentification.Retain1); + writer.WriteNumber($"[{value.AlarmIdentification.Retain2.ReadNumber()}]预留2", value.AlarmIdentification.Retain2); + value.AlarmOrEventCount = reader.ReadByte(); + writer.WriteNumber($"[{value.AlarmOrEventCount.ReadNumber()}]报警_事件列表总数", value.AlarmOrEventCount); + if (value.AlarmOrEventCount > 0) + { + writer.WriteStartArray("报警_事件列表"); + for (int i = 0; i < value.AlarmOrEventCount; i++) + { + writer.WriteStartObject(); + AlarmOrEventProperty item = new AlarmOrEventProperty(); + item.TirePressureAlarmPosition = reader.ReadByte(); + writer.WriteNumber($"[{item.TirePressureAlarmPosition.ReadNumber()}]胎压报警位置", item.TirePressureAlarmPosition); + item.AlarmOrEventType = reader.ReadUInt16(); + string alarmOrEventTypeString = ""; + switch (item.AlarmOrEventType) + { + case 0x01: + alarmOrEventTypeString = "前向碰撞报警"; + break; + case 0x02: + alarmOrEventTypeString = "车道偏离报警"; + break; + case 0x03: + alarmOrEventTypeString = "车距过近报警"; + break; + case 0x04: + alarmOrEventTypeString = "行人碰撞报警"; + break; + case 0x05: + alarmOrEventTypeString = "频繁变道报警"; + break; + case 0x06: + alarmOrEventTypeString = "道路标识超限报警"; + break; + case 0x07: + alarmOrEventTypeString = "障碍物报警"; + break; + case 0x08: + case 0x09: + case 0x0A: + case 0x0B: + case 0x0C: + case 0x0D: + case 0x0E: + case 0x0F: + alarmOrEventTypeString = "用户自定义"; + break; + case 0x10: + alarmOrEventTypeString = "道路标志识别事件"; + break; + case 0x11: + alarmOrEventTypeString = "主动抓拍事件"; + break; + case 0x12: + case 0x13: + case 0x14: + case 0x15: + case 0x16: + case 0x17: + case 0x18: + case 0x19: + case 0x1A: + case 0x1B: + case 0x1C: + case 0x1D: + case 0x1E: + case 0x1F: + alarmOrEventTypeString = "用户自定义"; + break; + } + writer.WriteNumber($"[{item.AlarmOrEventType.ReadNumber()}]报警_事件类型-{alarmOrEventTypeString}", item.AlarmOrEventType); + item.TirePressure = reader.ReadUInt16(); + writer.WriteNumber($"[{item.TirePressure.ReadNumber()}]胎压Kpa", item.TirePressure); + item.TireTemperature = reader.ReadUInt16(); + writer.WriteNumber($"[{item.TireTemperature.ReadNumber()}]胎温℃", item.TireTemperature); + item.BatteryLevel = reader.ReadUInt16(); + writer.WriteNumber($"[{item.BatteryLevel.ReadNumber()}]电池电量%", item.BatteryLevel); + writer.WriteEndObject(); + } + writer.WriteEndArray(); + } + } + /// + /// + /// + /// + /// + /// + public JT808_0x0200_0x66 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) + { + JT808_0x0200_0x66 value = new JT808_0x0200_0x66(); + value.AttachInfoId = reader.ReadByte(); + value.AttachInfoLength = reader.ReadByte(); + value.AlarmId = reader.ReadUInt32(); + value.FlagState = reader.ReadByte(); + value.Speed = reader.ReadByte(); + value.Altitude = reader.ReadUInt16(); + value.Latitude = (int)reader.ReadUInt32(); + value.Longitude = (int)reader.ReadUInt32(); + value.AlarmTime = reader.ReadDateTime6(); + value.VehicleState = reader.ReadUInt16(); + value.AlarmIdentification = new AlarmIdentificationProperty + { + TerminalId = reader.ReadString(30), + Time = reader.ReadDateTime6(), + SN = reader.ReadByte(), + AttachCount = reader.ReadByte(), + Retain1 = reader.ReadByte(), + Retain2 = reader.ReadByte() + }; + value.AlarmOrEventCount = reader.ReadByte(); + if (value.AlarmOrEventCount > 0) + { + value.AlarmOrEvents = new List(); + for (int i = 0; i < value.AlarmOrEventCount; i++) + { + AlarmOrEventProperty alarmOrEventProperty = new AlarmOrEventProperty(); + alarmOrEventProperty.TirePressureAlarmPosition = reader.ReadByte(); + alarmOrEventProperty.AlarmOrEventType = reader.ReadUInt16(); + alarmOrEventProperty.TirePressure = reader.ReadUInt16(); + alarmOrEventProperty.TireTemperature = reader.ReadUInt16(); + alarmOrEventProperty.BatteryLevel = reader.ReadUInt16(); + value.AlarmOrEvents.Add(alarmOrEventProperty); + } + } + return value; + } + /// + /// + /// + /// + /// + /// + public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0200_0x66 value, IJT808Config config) + { + writer.WriteByte(value.AttachInfoId); + writer.Skip(1, out int AttachInfoLengthPosition); + writer.WriteUInt32(value.AlarmId); + writer.WriteByte(value.FlagState); + writer.WriteByte(value.Speed); + writer.WriteUInt16(value.Altitude); + writer.WriteUInt32((uint)value.Latitude); + writer.WriteUInt32((uint)value.Longitude); + writer.WriteDateTime6(value.AlarmTime); + writer.WriteUInt16(value.VehicleState); + if (value.AlarmIdentification == null) + { + throw new NullReferenceException($"{nameof(AlarmIdentificationProperty)}不为空"); + } + writer.WriteString(value.AlarmIdentification.TerminalId.PadRight(30, '\0')); + writer.WriteDateTime6(value.AlarmIdentification.Time); + writer.WriteByte(value.AlarmIdentification.SN); + writer.WriteByte(value.AlarmIdentification.AttachCount); + writer.WriteByte(value.AlarmIdentification.Retain1); + writer.WriteByte(value.AlarmIdentification.Retain2); + if (value.AlarmOrEvents.Count > 0) + { + writer.WriteByte((byte)value.AlarmOrEvents.Count); + foreach (var item in value.AlarmOrEvents) + { + writer.WriteByte(item.TirePressureAlarmPosition); + writer.WriteUInt16(item.AlarmOrEventType); + writer.WriteUInt16(item.TirePressure); + writer.WriteUInt16(item.TireTemperature); + writer.WriteUInt16(item.BatteryLevel); + } + } + writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - AttachInfoLengthPosition - 1), AttachInfoLengthPosition); + } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x0200_0x67.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x0200_0x67.cs new file mode 100644 index 0000000..2dacb56 --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x0200_0x67.cs @@ -0,0 +1,283 @@ +using JT808.Protocol.Extensions.YueBiao.Metadata; +using JT808.Protocol.Formatters; +using JT808.Protocol.Interfaces; +using JT808.Protocol.MessageBody; +using JT808.Protocol.MessagePack; +using System; +using System.Collections.Generic; +using System.Text; +using System.Text.Json; + +namespace JT808.Protocol.Extensions.YueBiao.MessageBody +{ + /// + /// 盲区监测系统报警信息 + /// + public class JT808_0x0200_0x67 : JT808_0x0200_BodyBase, IJT808MessagePackFormatter, IJT808Analyze + { + /// + /// 盲区监测系统报警信息Id + /// + public override byte AttachInfoId { get; set; } = JT808_YueBiao_Constants.JT808_0X0200_0x67; + /// + /// 盲区监测系统报警信息长度 + /// + public override byte AttachInfoLength { get; set; } = 26; + /// + /// 报警ID + /// + public uint AlarmId { get; set; } + /// + /// 标志状态 + /// + public byte FlagState { get; set; } + /// + /// 报警/事件类型 + /// + public byte AlarmOrEventType{ get; set; } + /// + /// 报警/事件类型 + /// + public byte AlarmLevel { get; set; } + /// + /// 车速 + /// + public byte Speed { get; set; } + /// + /// 高程 + /// + public ushort Altitude { get; set; } + /// + /// 纬度 + /// + public int Latitude { get; set; } + /// + /// 经度 + /// + public int Longitude { get; set; } + /// + /// 日期时间 + /// YYMMDDhhmmss + /// BCD[6] + /// + public DateTime AlarmTime { get; set; } + /// + /// 车辆状态 + /// + public ushort VehicleState { get; set; } + /// + /// 报警标识号 + /// + public AlarmIdentificationProperty AlarmIdentification { get; set; } + /// + /// + /// + /// + /// + /// + public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) + { + JT808_0x0200_0x67 value = new JT808_0x0200_0x67(); + value.AttachInfoId = reader.ReadByte(); + writer.WriteNumber($"[{value.AttachInfoId.ReadNumber()}]附加信息Id", value.AttachInfoId); + value.AttachInfoLength = reader.ReadByte(); + writer.WriteNumber($"[{value.AttachInfoLength.ReadNumber()}]附加信息长度", value.AttachInfoLength); + value.AlarmId = reader.ReadUInt32(); + writer.WriteNumber($"[{value.AlarmId.ReadNumber()}]报警ID", value.AlarmId); + value.FlagState = reader.ReadByte(); + string flagStateString = "未知"; + switch (value.FlagState) + { + case 0: + flagStateString = "不可用"; + break; + case 1: + flagStateString = "开始标志"; + break; + case 2: + flagStateString = "结束标志"; + break; + } + writer.WriteNumber($"[{value.FlagState.ReadNumber()}]标志状态-{flagStateString}", value.FlagState); + value.AlarmOrEventType = reader.ReadByte(); + string alarmOrEventTypeString = ""; + switch (value.AlarmOrEventType) + { + case 0x01: + alarmOrEventTypeString = "前向碰撞报警"; + break; + case 0x02: + alarmOrEventTypeString = "车道偏离报警"; + break; + case 0x03: + alarmOrEventTypeString = "车距过近报警"; + break; + case 0x04: + alarmOrEventTypeString = "行人碰撞报警"; + break; + case 0x05: + alarmOrEventTypeString = "频繁变道报警"; + break; + case 0x06: + alarmOrEventTypeString = "道路标识超限报警"; + break; + case 0x07: + alarmOrEventTypeString = "障碍物报警"; + break; + case 0x08: + case 0x09: + case 0x0A: + case 0x0B: + case 0x0C: + case 0x0D: + case 0x0E: + case 0x0F: + alarmOrEventTypeString = "用户自定义"; + break; + case 0x10: + alarmOrEventTypeString = "道路标志识别事件"; + break; + case 0x11: + alarmOrEventTypeString = "主动抓拍事件"; + break; + case 0x12: + case 0x13: + case 0x14: + case 0x15: + case 0x16: + case 0x17: + case 0x18: + case 0x19: + case 0x1A: + case 0x1B: + case 0x1C: + case 0x1D: + case 0x1E: + case 0x1F: + alarmOrEventTypeString = "用户自定义"; + break; + } + writer.WriteNumber($"[{value.AlarmOrEventType.ReadNumber()}]报警_事件类型-{alarmOrEventTypeString}", value.AlarmOrEventType); + value.AlarmLevel = reader.ReadByte(); + string alarmLevelString = "未知"; + switch (value.AlarmLevel) + { + case 0x01: + alarmLevelString = "一级报警"; + break; + case 0x02: + alarmLevelString = "二级报警"; + break; + } + writer.WriteNumber($"[{value.AlarmLevel.ReadNumber()}]报警级别-{alarmLevelString}", value.AlarmLevel); + value.Speed = reader.ReadByte(); + writer.WriteNumber($"[{value.Speed.ReadNumber()}]车速", value.Speed); + value.Altitude = reader.ReadUInt16(); + writer.WriteNumber($"[{value.Altitude.ReadNumber()}]高程", value.Altitude); + value.Latitude = (int)reader.ReadUInt32(); + writer.WriteNumber($"[{value.Latitude.ReadNumber()}]纬度", value.Latitude); + value.Longitude = (int)reader.ReadUInt32(); + writer.WriteNumber($"[{value.Longitude.ReadNumber()}]经度", value.Longitude); + value.AlarmTime = reader.ReadDateTime6(); + writer.WriteString($"[{value.AlarmTime.ToString("yyMMddHHmmss")}]日期时间", value.AlarmTime.ToString("yyyy-MM-dd HH:mm:ss")); + value.VehicleState = reader.ReadUInt16(); + writer.WriteNumber($"[{value.VehicleState.ReadNumber()}]车辆状态", value.VehicleState); + var vehicleStateBits=Convert.ToString(value.VehicleState, 2).PadLeft(16, '0'); + writer.WriteStartObject($"车辆状态对象[{vehicleStateBits}]"); + writer.WriteString($"[{vehicleStateBits[15]}]Bit0ACC状态", vehicleStateBits[15]=='0'?"关闭":"打开"); + writer.WriteString($"[{vehicleStateBits[14]}]Bit1左转向状态", vehicleStateBits[14]=='0'?"关闭":"打开"); + writer.WriteString($"[{vehicleStateBits[13]}]Bit2右转向状态", vehicleStateBits[13]=='0'?"关闭":"打开"); + writer.WriteString($"[{vehicleStateBits[12]}]Bit3雨刮器状态", vehicleStateBits[12]=='0'?"关闭":"打开"); + writer.WriteString($"[{vehicleStateBits[11]}]Bit4制动状态", vehicleStateBits[11] == '0' ? "未制动" : "制动"); + writer.WriteString($"[{vehicleStateBits[10]}]Bit5插卡状态", vehicleStateBits[10] == '0' ? "未插卡" : "已插卡"); + writer.WriteString($"[{vehicleStateBits[9]}]Bit6自定义", vehicleStateBits[9].ToString()); + writer.WriteString($"[{vehicleStateBits[8]}]Bit7自定义", vehicleStateBits[8].ToString()); + writer.WriteString($"[{vehicleStateBits[7]}]Bit8自定义", vehicleStateBits[7].ToString()); + writer.WriteString($"[{vehicleStateBits[6]}]Bit9自定义", vehicleStateBits[6].ToString()); + writer.WriteString($"[{vehicleStateBits[5]}]Bit10定位状态", vehicleStateBits[5] == '0' ? "未定位" : "已定位"); + writer.WriteString($"[{vehicleStateBits[4]}]Bit11自定义", vehicleStateBits[4].ToString()); + writer.WriteString($"[{vehicleStateBits[3]}]Bit12自定义", vehicleStateBits[3].ToString()); + writer.WriteString($"[{vehicleStateBits[2]}]Bit13自定义", vehicleStateBits[2].ToString()); + writer.WriteString($"[{vehicleStateBits[1]}]Bit14自定义", vehicleStateBits[1].ToString()); + writer.WriteString($"[{vehicleStateBits[0]}]Bit15自定义", vehicleStateBits[0].ToString()); + writer.WriteEndObject(); + value.AlarmIdentification = new AlarmIdentificationProperty(); + string terminalIDHex = reader.ReadVirtualArray(30).ToArray().ToHexString(); + value.AlarmIdentification.TerminalId = reader.ReadString(30); + value.AlarmIdentification.Time = reader.ReadDateTime6(); + value.AlarmIdentification.SN = reader.ReadByte(); + value.AlarmIdentification.AttachCount = reader.ReadByte(); + value.AlarmIdentification.Retain1 = reader.ReadByte(); + value.AlarmIdentification.Retain2 = reader.ReadByte(); + writer.WriteString($"[{terminalIDHex}]终端ID", value.AlarmIdentification.TerminalId); + writer.WriteString($"[{value.AlarmIdentification.Time.ToString("yyMMddHHmmss")}]日期时间", value.AlarmIdentification.Time.ToString("yyyy-MM-dd HH:mm:ss")); + writer.WriteNumber($"[{value.AlarmIdentification.SN.ReadNumber()}]序号", value.AlarmIdentification.SN); + writer.WriteNumber($"[{value.AlarmIdentification.AttachCount.ReadNumber()}]附件数量", value.AlarmIdentification.AttachCount); + writer.WriteNumber($"[{value.AlarmIdentification.Retain1.ReadNumber()}]预留1", value.AlarmIdentification.Retain1); + writer.WriteNumber($"[{value.AlarmIdentification.Retain2.ReadNumber()}]预留2", value.AlarmIdentification.Retain2); + } + /// + /// + /// + /// + /// + /// + public JT808_0x0200_0x67 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) + { + JT808_0x0200_0x67 value = new JT808_0x0200_0x67(); + value.AttachInfoId = reader.ReadByte(); + value.AttachInfoLength = reader.ReadByte(); + value.AlarmId = reader.ReadUInt32(); + value.FlagState = reader.ReadByte(); + value.AlarmOrEventType = reader.ReadByte(); + value.AlarmLevel = reader.ReadByte(); + value.Speed = reader.ReadByte(); + value.Altitude = reader.ReadUInt16(); + value.Latitude = (int)reader.ReadUInt32(); + value.Longitude = (int)reader.ReadUInt32(); + value.AlarmTime = reader.ReadDateTime6(); + value.VehicleState = reader.ReadUInt16(); + value.AlarmIdentification = new AlarmIdentificationProperty + { + TerminalId = reader.ReadString(30), + Time = reader.ReadDateTime6(), + SN = reader.ReadByte(), + AttachCount = reader.ReadByte(), + Retain1 = reader.ReadByte(), + Retain2 = reader.ReadByte() + }; + return value; + } + /// + /// + /// + /// + /// + /// + public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0200_0x67 value, IJT808Config config) + { + writer.WriteByte(value.AttachInfoId); + writer.WriteByte(value.AttachInfoLength); + writer.WriteUInt32(value.AlarmId); + writer.WriteByte(value.FlagState); + writer.WriteByte(value.AlarmOrEventType); + writer.WriteByte(value.AlarmLevel); + writer.WriteByte(value.Speed); + writer.WriteUInt16(value.Altitude); + writer.WriteUInt32((uint)value.Latitude); + writer.WriteUInt32((uint)value.Longitude); + writer.WriteDateTime6(value.AlarmTime); + writer.WriteUInt16(value.VehicleState); + if (value.AlarmIdentification == null) + { + throw new NullReferenceException($"{nameof(AlarmIdentificationProperty)}不为空"); + } + writer.WriteString(value.AlarmIdentification.TerminalId.PadRight(30, '\0')); + writer.WriteDateTime6(value.AlarmIdentification.Time); + writer.WriteByte(value.AlarmIdentification.SN); + writer.WriteByte(value.AlarmIdentification.AttachCount); + writer.WriteByte(value.AlarmIdentification.Retain1); + writer.WriteByte(value.AlarmIdentification.Retain2); + } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x0900_0xF7.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x0900_0xF7.cs new file mode 100644 index 0000000..811ff9a --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x0900_0xF7.cs @@ -0,0 +1,122 @@ +using JT808.Protocol.Extensions.YueBiao.Enums; +using JT808.Protocol.Extensions.YueBiao.Metadata; +using JT808.Protocol.Formatters; +using JT808.Protocol.Interfaces; +using JT808.Protocol.MessageBody; +using JT808.Protocol.MessagePack; +using System; +using System.Collections.Generic; +using System.Text; +using System.Text.Json; + +namespace JT808.Protocol.Extensions.YueBiao.MessageBody +{ + /// + /// 透传数据 + /// + public class JT808_0x0900_0xF7 : JT808_0x0900_BodyBase, IJT808MessagePackFormatter, IJT808Analyze + { + /// + /// 透传类型 + /// + public override byte PassthroughType { get; set; } = JT808_YueBiao_Constants.JT808_0X0900_0xF7; + /// + /// 消息列表总数 + /// + public byte USBMessageCount { get; set; } + /// + /// 消息列表数据 + /// + public List USBMessages { get; set; } + /// + /// + /// + /// + /// + /// + public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) + { + JT808_0x0900_0xF7 value = new JT808_0x0900_0xF7(); + value.USBMessageCount = reader.ReadByte(); + writer.WriteNumber($"[{value.USBMessageCount.ReadNumber()}]消息列表总数", value.USBMessageCount); + if (value.USBMessageCount > 0) + { + writer.WriteStartArray("消息列表"); + for (int i = 0; i < value.USBMessageCount; i++) + { + writer.WriteStartObject(); + JT808_0x0900_0xF7_USB item = new JT808_0x0900_0xF7_USB(); + item.USBID = reader.ReadByte(); + writer.WriteNumber($"[{item.USBID.ReadNumber()}]外设ID", item.USBID); + item.MessageLength = reader.ReadByte(); + writer.WriteNumber($"[{item.MessageLength.ReadNumber()}]消息长度", item.MessageLength); + item.WorkingCondition = reader.ReadByte(); + var workingCondition = (WorkingConditionType)item.WorkingCondition; + writer.WriteNumber($"[{item.WorkingCondition.ReadNumber()}]工作状态-{workingCondition.ToString()}", item.WorkingCondition); + item.AlarmStatus = reader.ReadUInt32(); + writer.WriteNumber($"[{item.AlarmStatus.ReadNumber()}]报警状态", item.AlarmStatus); + var alarmStatusBits = Convert.ToString(item.AlarmStatus, 2).PadLeft(32, '0').AsSpan(); + writer.WriteStartObject($"报警状态对象[{alarmStatusBits.ToString()}]"); + writer.WriteString($"[bit12~bit31]预留", alarmStatusBits.Slice(12).ToString()); + writer.WriteString($"]bit11]定位模块异常", alarmStatusBits[11].ToString()); + writer.WriteString($"[bit10]通讯模块异常", alarmStatusBits[10].ToString()); + writer.WriteString($"[bit6~bit9]预留", alarmStatusBits.Slice(6,4).ToString()); + writer.WriteString($"[bit5]电池异常", alarmStatusBits[5].ToString()); + writer.WriteString($"[bit4]扬声器异常", alarmStatusBits[4].ToString()); + writer.WriteString($"[bit3]红外补光异常", alarmStatusBits[3].ToString()); + writer.WriteString($"[bit2]辅存储器异常", alarmStatusBits[2].ToString()); + writer.WriteString($"[bit1]主存储器异常", alarmStatusBits[1].ToString()); + writer.WriteString($"[bit0]摄像头异常", alarmStatusBits[0].ToString()); + writer.WriteEndObject(); + writer.WriteEndObject(); + } + writer.WriteEndArray(); + } + } + /// + /// + /// + /// + /// + /// + public JT808_0x0900_0xF7 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) + { + JT808_0x0900_0xF7 value = new JT808_0x0900_0xF7(); + value.USBMessageCount = reader.ReadByte(); + if (value.USBMessageCount > 0) + { + value.USBMessages = new List(); + for (int i = 0; i < value.USBMessageCount; i++) + { + JT808_0x0900_0xF7_USB item = new JT808_0x0900_0xF7_USB(); + item.USBID = reader.ReadByte(); + item.MessageLength = reader.ReadByte(); + item.WorkingCondition = reader.ReadByte(); + item.AlarmStatus = reader.ReadUInt32(); + value.USBMessages.Add(item); + } + } + return value; + } + /// + /// + /// + /// + /// + /// + public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0900_0xF7 value, IJT808Config config) + { + if (value.USBMessages != null && value.USBMessages.Count > 0) + { + writer.WriteByte((byte)value.USBMessages.Count); + foreach (var item in value.USBMessages) + { + writer.WriteByte(item.USBID); + writer.WriteByte(5); + writer.WriteByte(item.WorkingCondition); + writer.WriteUInt32(item.AlarmStatus); + } + } + } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x0900_0xF8.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x0900_0xF8.cs new file mode 100644 index 0000000..1ae0f4c --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x0900_0xF8.cs @@ -0,0 +1,175 @@ +using JT808.Protocol.Extensions.YueBiao.Metadata; +using JT808.Protocol.Formatters; +using JT808.Protocol.Interfaces; +using JT808.Protocol.MessageBody; +using JT808.Protocol.MessagePack; +using System; +using System.Collections.Generic; +using System.Text; +using System.Text.Json; + +namespace JT808.Protocol.Extensions.YueBiao.MessageBody +{ + /// + /// 透传数据 + /// + public class JT808_0x0900_0xF8 : JT808_0x0900_BodyBase, IJT808MessagePackFormatter, IJT808Analyze + { + /// + /// 透传类型 + /// + public override byte PassthroughType { get; set; } = JT808_YueBiao_Constants.JT808_0X0900_0xF8; + /// + /// 消息列表总数 + /// + public byte USBMessageCount { get; set; } + /// + /// + /// + public List USBMessages { get; set; } + /// + /// + /// + /// + /// + /// + public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) + { + JT808_0x0900_0xF8 value = new JT808_0x0900_0xF8(); + value.USBMessageCount = reader.ReadByte(); + writer.WriteNumber($"[{value.USBMessageCount.ReadNumber()}]消息列表总数", value.USBMessageCount); + if (value.USBMessageCount > 0) + { + writer.WriteStartArray("消息列表"); + for (int i = 0; i < value.USBMessageCount; i++) + { + writer.WriteStartObject(); + JT808_0x0900_0xF8_USB item = new JT808_0x0900_0xF8_USB(); + item.USBID = reader.ReadByte(); + writer.WriteNumber($"[{item.USBID.ReadNumber()}]外设ID", item.USBID); + item.MessageLength = reader.ReadByte(); + writer.WriteNumber($"[{item.MessageLength.ReadNumber()}]消息长度", item.MessageLength); + item.CompantNameLength = reader.ReadByte(); + writer.WriteNumber($"[{item.CompantNameLength.ReadNumber()}]公司名称长度", item.CompantNameLength); + + string compantNameHex = reader.ReadVirtualArray(item.CompantNameLength).ToArray().ToHexString(); + item.CompantName = reader.ReadString(item.CompantNameLength); + writer.WriteString($"[{compantNameHex}]公司名称", item.CompantName); + + item.ProductModelLength = reader.ReadByte(); + writer.WriteNumber($"[{item.ProductModelLength.ReadNumber()}]产品型号长度", item.ProductModelLength); + + string productModelHex = reader.ReadVirtualArray(item.ProductModelLength).ToArray().ToHexString(); + item.ProductModel = reader.ReadString(item.ProductModelLength); + writer.WriteString($"[{productModelHex}]产品型号", item.ProductModel); + + item.HardwareVersionNumberLength = reader.ReadByte(); + writer.WriteNumber($"[{item.HardwareVersionNumberLength.ReadNumber()}]硬件版本号长度", item.HardwareVersionNumberLength); + string hardwareVersionNumberHex = reader.ReadVirtualArray(item.HardwareVersionNumberLength).ToArray().ToHexString(); + item.HardwareVersionNumber = reader.ReadString(item.HardwareVersionNumberLength); + writer.WriteString($"[{hardwareVersionNumberHex}]硬件版本号", item.HardwareVersionNumber); + + item.SoftwareVersionNumberLength = reader.ReadByte(); + writer.WriteNumber($"[{item.SoftwareVersionNumberLength.ReadNumber()}]软件版本号长度", item.SoftwareVersionNumberLength); + string softwareVersionNumberHex = reader.ReadVirtualArray(item.SoftwareVersionNumberLength).ToArray().ToHexString(); + item.SoftwareVersionNumber = reader.ReadString(item.SoftwareVersionNumberLength); + writer.WriteString($"[{softwareVersionNumberHex}]软件版本号", item.SoftwareVersionNumber); + + item.DevicesIDLength = reader.ReadByte(); + writer.WriteNumber($"[{item.DevicesIDLength.ReadNumber()}]设备ID长度", item.DevicesIDLength); + string devicesIDHex = reader.ReadVirtualArray(item.DevicesIDLength).ToArray().ToHexString(); + item.DevicesID = reader.ReadString(item.DevicesIDLength); + writer.WriteString($"[{devicesIDHex}]设备ID", item.DevicesID); + + item.CustomerCodeLength = reader.ReadByte(); + writer.WriteNumber($"[{item.CustomerCodeLength.ReadNumber()}]客户代码长度", item.CustomerCodeLength); + string customerCodeHex = reader.ReadVirtualArray(item.CustomerCodeLength).ToArray().ToHexString(); + item.CustomerCode = reader.ReadString(item.CustomerCodeLength); + writer.WriteString($"[{customerCodeHex}]客户代码", item.CustomerCode); + + writer.WriteEndObject(); + } + writer.WriteEndArray(); + } + } + /// + /// + /// + /// + /// + /// + public JT808_0x0900_0xF8 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) + { + JT808_0x0900_0xF8 value = new JT808_0x0900_0xF8(); + value.USBMessageCount = reader.ReadByte(); + if (value.USBMessageCount > 0) + { + value.USBMessages = new List(); + for (int i = 0; i < value.USBMessageCount; i++) + { + JT808_0x0900_0xF8_USB item = new JT808_0x0900_0xF8_USB(); + item.USBID = reader.ReadByte(); + item.MessageLength = reader.ReadByte(); + item.CompantNameLength = reader.ReadByte(); + item.CompantName = reader.ReadString(item.CompantNameLength); + item.ProductModelLength = reader.ReadByte(); + item.ProductModel = reader.ReadString(item.ProductModelLength); + item.HardwareVersionNumberLength = reader.ReadByte(); + item.HardwareVersionNumber = reader.ReadString(item.HardwareVersionNumberLength); + item.SoftwareVersionNumberLength = reader.ReadByte(); + item.SoftwareVersionNumber = reader.ReadString(item.SoftwareVersionNumberLength); + item.DevicesIDLength = reader.ReadByte(); + item.DevicesID = reader.ReadString(item.DevicesIDLength); + item.CustomerCodeLength = reader.ReadByte(); + item.CustomerCode = reader.ReadString(item.CustomerCodeLength); + value.USBMessages.Add(item); + } + } + return value; + } + /// + /// + /// + /// + /// + /// + public void Serialize(ref JT808MessagePackWriter writer, JT808_0x0900_0xF8 value, IJT808Config config) + { + if (value.USBMessages != null && value.USBMessages.Count > 0) + { + writer.WriteByte((byte)value.USBMessages.Count); + foreach (var item in value.USBMessages) + { + writer.WriteByte(item.USBID); + writer.Skip(1,out int messageLengthPosition); + + writer.Skip(1, out int CompantNameLengthPosition); + writer.WriteString(item.CompantName); + writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - CompantNameLengthPosition - 1), CompantNameLengthPosition); + + writer.Skip(1, out int ProductModelLengthPosition); + writer.WriteString(item.ProductModel); + writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - ProductModelLengthPosition - 1), ProductModelLengthPosition); + + writer.Skip(1, out int HardwareVersionNumberLengthPosition); + writer.WriteString(item.HardwareVersionNumber); + writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - HardwareVersionNumberLengthPosition - 1), HardwareVersionNumberLengthPosition); + + writer.Skip(1, out int SoftwareVersionNumberLengthPosition); + writer.WriteString(item.SoftwareVersionNumber); + writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - SoftwareVersionNumberLengthPosition - 1), SoftwareVersionNumberLengthPosition); + + writer.Skip(1, out int DevicesIDLengthPosition); + writer.WriteString(item.DevicesID); + writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - DevicesIDLengthPosition - 1), DevicesIDLengthPosition); + + writer.Skip(1, out int CustomerCodeLengthPosition); + writer.WriteString(item.CustomerCode); + writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - CustomerCodeLengthPosition - 1), CustomerCodeLengthPosition); + + writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - messageLengthPosition - 1), messageLengthPosition); + } + } + } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x1210.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x1210.cs new file mode 100644 index 0000000..d766050 --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x1210.cs @@ -0,0 +1,179 @@ +using JT808.Protocol.Extensions.YueBiao.Metadata; +using JT808.Protocol.Formatters; +using JT808.Protocol.Interfaces; +using JT808.Protocol.MessagePack; +using System; +using System.Collections.Generic; +using System.Text; +using System.Text.Json; + +namespace JT808.Protocol.Extensions.YueBiao.MessageBody +{ + /// + /// 报警附件信息消息 + /// + public class JT808_0x1210: JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze,IJT808_2019_Version + { + /// + /// 终端 ID + /// 30 个字节，由大写字母和数字组成，此终端ID 由制造商自行定义，位数不足时，后补“0x00” + /// + public string TerminalId { get; set; } + /// + /// 报警标识号 + /// + public AlarmIdentificationProperty AlarmIdentification { get; set; } + /// + /// 平台给报警分配的唯一编号 + /// 32 + /// + public string AlarmId { get; set; } + /// + /// 信息类型 + /// 0x00：正常报警文件信息 + /// 0x01：补传报警文件信息 + /// + public byte InfoType { get; set; } + /// + /// 附件数量 + /// + public byte AttachCount { get; set; } + /// + /// 附件信息列表 + /// + public List AttachInfos { get; set; } + /// + /// 报警附件信息消息Id + /// + public override ushort MsgId => 0x1210; + /// + /// 报警附件信息消息 + /// + public override string Description => "报警附件信息消息"; + /// + /// + /// + /// + /// + /// + public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) + { + JT808_0x1210 value = new JT808_0x1210(); + string makerIdHex=reader.ReadVirtualArray(30).ToArray().ToHexString(); + value.TerminalId = reader.ReadString(30); + writer.WriteString($"[{makerIdHex}]终端ID", value.TerminalId); + value.AlarmIdentification = new AlarmIdentificationProperty(); + string terminalIdHex = reader.ReadVirtualArray(30).ToArray().ToHexString(); + value.AlarmIdentification.TerminalId = reader.ReadString(30); + value.AlarmIdentification.Time = reader.ReadDateTime6(); + value.AlarmIdentification.SN = reader.ReadByte(); + value.AlarmIdentification.AttachCount = reader.ReadByte(); + value.AlarmIdentification.Retain1 = reader.ReadByte(); + value.AlarmIdentification.Retain2 = reader.ReadByte(); + writer.WriteString($"[{terminalIdHex}]终端ID", value.AlarmIdentification.TerminalId); + writer.WriteString($"[{value.AlarmIdentification.Time.ToString("yyMMddHHmmss")}]日期时间", value.AlarmIdentification.Time.ToString("yyyy-MM-dd HH:mm:ss")); + writer.WriteNumber($"[{value.AlarmIdentification.SN.ReadNumber()}]序号", value.AlarmIdentification.SN); + writer.WriteNumber($"[{value.AlarmIdentification.AttachCount.ReadNumber()}]附件数量", value.AlarmIdentification.AttachCount); + writer.WriteNumber($"[{value.AlarmIdentification.Retain1.ReadNumber()}]预留1", value.AlarmIdentification.Retain1); + writer.WriteNumber($"[{value.AlarmIdentification.Retain2.ReadNumber()}]预留2", value.AlarmIdentification.Retain2); + string alarmIdHex = reader.ReadVirtualArray(32).ToArray().ToHexString(); + value.AlarmId = reader.ReadString(32); + writer.WriteString($"[{alarmIdHex}]平台给报警分配的唯一编号", value.AlarmId); + value.InfoType = reader.ReadByte(); + writer.WriteNumber($"[{value.InfoType.ReadNumber()}]信息类型", value.InfoType); + value.AttachCount = reader.ReadByte(); + writer.WriteNumber($"[{value.AttachCount.ReadNumber()}]附件数量", value.AttachCount); + if (value.AttachCount > 0) + { + writer.WriteStartArray("附件信息列表"); + for (int i = 0; i < value.AttachCount; i++) + { + writer.WriteStartObject(); + AttachProperty attachProperty = new AttachProperty(); + attachProperty.FileNameLength = reader.ReadByte(); + writer.WriteNumber($"[{attachProperty.FileNameLength.ReadNumber()}]文件名称长度", attachProperty.FileNameLength); + string fileNameHex = reader.ReadVirtualArray(attachProperty.FileNameLength).ToArray().ToHexString(); + attachProperty.FileName = reader.ReadString(attachProperty.FileNameLength); + writer.WriteString($"[{fileNameHex}]文件名称", attachProperty.FileName); + attachProperty.FileSize = reader.ReadUInt32(); + writer.WriteNumber($"[{ attachProperty.FileSize.ReadNumber()}]文件大小", attachProperty.FileSize); + writer.WriteEndObject(); + } + writer.WriteEndArray(); + } + } + /// + /// + /// + /// + /// + /// + public JT808_0x1210 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) + { + JT808_0x1210 value = new JT808_0x1210(); + value.TerminalId = reader.ReadString(30); + value.AlarmIdentification = new AlarmIdentificationProperty + { + TerminalId = reader.ReadString(30), + Time = reader.ReadDateTime6(), + SN = reader.ReadByte(), + AttachCount = reader.ReadByte(), + Retain1 = reader.ReadByte(), + Retain2 = reader.ReadByte() + }; + value.AlarmId = reader.ReadString(32); + value.InfoType = reader.ReadByte(); + value.AttachCount = reader.ReadByte(); + if (value.AttachCount > 0) + { + value.AttachInfos = new List(); + for (int i = 0; i < value.AttachCount; i++) + { + AttachProperty attachProperty = new AttachProperty(); + attachProperty.FileNameLength = reader.ReadByte(); + attachProperty.FileName = reader.ReadString(attachProperty.FileNameLength); + attachProperty.FileSize = reader.ReadUInt32(); + value.AttachInfos.Add(attachProperty); + } + } + return value; + } + /// + /// + /// + /// + /// + /// + public void Serialize(ref JT808MessagePackWriter writer, JT808_0x1210 value, IJT808Config config) + { + writer.WriteString(value.TerminalId.PadRight(30, '\0')); + if (value.AlarmIdentification == null) + { + throw new NullReferenceException($"{nameof(AlarmIdentificationProperty)}不为空"); + } + writer.WriteString(value.AlarmIdentification.TerminalId.PadRight(30, '\0')); + writer.WriteDateTime6(value.AlarmIdentification.Time); + writer.WriteByte(value.AlarmIdentification.SN); + writer.WriteByte(value.AlarmIdentification.AttachCount); + writer.WriteByte(value.AlarmIdentification.Retain1); + writer.WriteByte(value.AlarmIdentification.Retain2); + writer.WriteString(value.AlarmId); + writer.WriteByte(value.InfoType); + if (value.AttachInfos != null && value.AttachInfos.Count > 0) + { + writer.WriteByte((byte)value.AttachInfos.Count); + foreach (var item in value.AttachInfos) + { + writer.Skip(1, out int FileNameLengthPosition); + writer.WriteString(item.FileName); + writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - FileNameLengthPosition - 1), FileNameLengthPosition); + writer.WriteUInt32(item.FileSize); + } + } + else + { + writer.WriteByte(0); + } + } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x1211.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x1211.cs new file mode 100644 index 0000000..924688f --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x1211.cs @@ -0,0 +1,87 @@ +using JT808.Protocol.Formatters; +using JT808.Protocol.Interfaces; +using JT808.Protocol.MessagePack; +using System.Text.Json; + +namespace JT808.Protocol.Extensions.YueBiao.MessageBody +{ + /// + /// 文件信息上传 + /// + public class JT808_0x1211 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze + { + /// + /// 文件信息上传 + /// + public override string Description => "文件信息上传"; + /// + /// 文件名称长度 + /// + public byte FileNameLength { get; set; } + /// + /// 文件名称 + /// 形如：文件类型_通道号_报警类型_序号_报警编号.后缀名 + /// + public string FileName { get; set; } + /// + /// 文件类型 + /// + public byte FileType { get; set; } + /// + /// 文件大小 + /// + public uint FileSize { get; set; } + /// + /// 文件信息上传Id + /// + public override ushort MsgId => 0x1211; + /// + /// + /// + /// + /// + /// + public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) + { + JT808_0x1211 value = new JT808_0x1211(); + value.FileNameLength = reader.ReadByte(); + writer.WriteNumber($"[{value.FileNameLength.ReadNumber()}]文件名称长度", value.FileNameLength); + string fileNameHex = reader.ReadVirtualArray(value.FileNameLength).ToArray().ToHexString(); + value.FileName = reader.ReadString(value.FileNameLength); + writer.WriteString($"[{fileNameHex}]文件名称", value.FileName); + value.FileType = reader.ReadByte(); + writer.WriteNumber($"[{value.FileType.ReadNumber()}]文件类型", value.FileType); + value.FileSize = reader.ReadUInt32(); + writer.WriteNumber($"[{value.FileSize.ReadNumber()}]文件大小", value.FileSize); + } + /// + /// + /// + /// + /// + /// + public JT808_0x1211 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) + { + JT808_0x1211 value = new JT808_0x1211(); + value.FileNameLength = reader.ReadByte(); + value.FileName = reader.ReadString(value.FileNameLength); + value.FileType = reader.ReadByte(); + value.FileSize = reader.ReadUInt32(); + return value; + } + /// + /// + /// + /// + /// + /// + public void Serialize(ref JT808MessagePackWriter writer, JT808_0x1211 value, IJT808Config config) + { + writer.Skip(1, out int FileNameLengthPosition); + writer.WriteString(value.FileName); + writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - FileNameLengthPosition - 1), FileNameLengthPosition); + writer.WriteByte(value.FileType); + writer.WriteUInt32(value.FileSize); + } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x1212.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x1212.cs new file mode 100644 index 0000000..91719d4 --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x1212.cs @@ -0,0 +1,87 @@ +using JT808.Protocol.Formatters; +using JT808.Protocol.Interfaces; +using JT808.Protocol.MessagePack; +using System.Text.Json; + +namespace JT808.Protocol.Extensions.YueBiao.MessageBody +{ + /// + /// 文件上传完成消息 + /// + public class JT808_0x1212 : JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze + { + /// + /// 文件上传完成消息 + /// + public override string Description => "文件上传完成消息"; + /// + /// 文件名称长度 + /// + public byte FileNameLength { get; set; } + /// + /// 文件名称 + /// 形如：文件类型_通道号_报警类型_序号_报警编号.后缀名 + /// + public string FileName { get; set; } + /// + /// 文件类型 + /// + public byte FileType { get; set; } + /// + /// 文件大小 + /// + public uint FileSize { get; set; } + /// + /// 文件上传完成消息 + /// + public override ushort MsgId => 0x1212; + /// + /// + /// + /// + /// + /// + public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) + { + JT808_0x1212 value = new JT808_0x1212(); + value.FileNameLength = reader.ReadByte(); + writer.WriteNumber($"[{value.FileNameLength.ReadNumber()}]文件名称长度", value.FileNameLength); + string fileNameHex = reader.ReadVirtualArray(value.FileNameLength).ToArray().ToHexString(); + value.FileName = reader.ReadString(value.FileNameLength); + writer.WriteString($"[{fileNameHex}]文件名称", value.FileName); + value.FileType = reader.ReadByte(); + writer.WriteNumber($"[{value.FileType.ReadNumber()}]文件类型", value.FileType); + value.FileSize = reader.ReadUInt32(); + writer.WriteNumber($"[{value.FileSize.ReadNumber()}]文件大小", value.FileSize); + } + /// + /// + /// + /// + /// + /// + public JT808_0x1212 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) + { + JT808_0x1212 value = new JT808_0x1212(); + value.FileNameLength = reader.ReadByte(); + value.FileName = reader.ReadString(value.FileNameLength); + value.FileType = reader.ReadByte(); + value.FileSize = reader.ReadUInt32(); + return value; + } + /// + /// + /// + /// + /// + /// + public void Serialize(ref JT808MessagePackWriter writer, JT808_0x1212 value, IJT808Config config) + { + writer.Skip(1, out int FileNameLengthPosition); + writer.WriteString(value.FileName); + writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - FileNameLengthPosition - 1), FileNameLengthPosition); + writer.WriteByte(value.FileType); + writer.WriteUInt32(value.FileSize); + } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x8103_0xF364.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x8103_0xF364.cs new file mode 100644 index 0000000..f11578c --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x8103_0xF364.cs @@ -0,0 +1,456 @@ +using JT808.Protocol.Extensions.YueBiao.Enums; +using JT808.Protocol.Formatters; +using JT808.Protocol.Interfaces; +using JT808.Protocol.MessageBody; +using JT808.Protocol.MessagePack; +using System; +using System.Text.Json; + +namespace JT808.Protocol.Extensions.YueBiao.MessageBody +{ + /// + /// 高级驾驶辅助系统参数 + /// + public class JT808_0x8103_0xF364 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze + { + /// + /// 高级驾驶辅助系统参数 + /// + public override uint ParamId { get; set; } = JT808_YueBiao_Constants.JT808_0X8103_0xF364; + /// + /// 高级驾驶辅助系统参数长度 + /// + public override byte ParamLength { get; set; } + /// + /// 报警判断速度阈值 + /// + public byte AlarmJudgeSpeedThreshold { get; set; } + /// + /// 报警提示音量 + /// + public byte WarningVolume { get; set; } + /// + /// 主动拍照策略 + /// + /// + public byte ActivePhotographyStrategy { get; set; } + /// + /// 主动定时拍照时间间隔 + /// + public ushort ActivelyTimePhotoInterval { get; set; } + /// + /// 主动定距拍照距离间隔 + /// + public ushort ActiveDistancePhotographyDistanceInterval { get; set; } + /// + /// 单次主动拍照张数 + /// + public byte SingleInitiativePhotos { get; set; } + /// + /// 单次主动拍照时间间隔 + /// + public byte SingleInitiativePhotosInterval { get; set; } + /// + /// 拍照分辨率 + /// + /// + public byte PhotoResolution { get; set; } + /// + /// 视频录制分辨率 + /// + public byte VideoRecordingResolution { get; set; } + /// + /// 报警使能 + /// + public uint AlarmEnable { get; set; } + /// + /// 事件使能 + /// + public uint EventEnable { get; set; } + /// + /// 预留字段 + /// + public byte Placeholder1 { get; set; } + /// + /// 障碍物报警距离阈值 + /// + public byte DistanceThresholdObstacleAlarm { get; set; } + /// + /// 障碍物报警分级速度阈值 + /// + public byte HierarchicalSpeedThresholdObstacleAlarm { get; set; } + /// + /// 障碍物报警前后视频录制时间 + /// + public byte VideoRecordingTimeBeforeAndAfterObstacleAlarm { get; set; } + /// + /// 障碍物报警拍照张数 + /// + public byte BarrierAlarmPhotographs { get; set; } + /// + /// 障碍物报警拍照间隔 + /// + public byte ObstacleAlarmInterval { get; set; } + /// + /// 频繁变道报警判断时间段 + /// + public byte FrequentChannelChangeAlarmJudgmentTimePeriod { get; set; } + + /// + /// 频繁变道报警判断次数 + /// + public byte FrequentAlarmJudgmentNumberChannelChange { get; set; } + /// + /// 频繁变道报警分级速度阈值 + /// + public byte HierarchicalSpeedThresholdFrequentChannelChangeAlarm { get; set; } + /// + /// 频繁变道报警前后视频录制时间 + /// + public byte VideoRecordingTimeBeforeAndAfterFrequentLaneChangeAlarm { get; set; } + /// + /// 频繁变道报警拍照张数 + /// + public byte FrequentChannelChangeAlarmPhotos { get; set; } + /// + /// 频繁变道报警拍照间隔 + /// + public byte FrequentLaneChangeAlarmInterval { get; set; } + /// + /// 车道偏离报警分级速度阈值 + /// + public byte GradedSpeedThresholdLaneDeviationAlarm { get; set; } + /// + /// 车道偏离报警前后视频录制时间 + /// + public byte VideoRecordingTimeBeforeAndAfterLaneDepartureAlarm { get; set; } + /// + /// 车道偏离报警拍照张数 + /// + public byte LaneDepartureAlarmPhoto { get; set; } + /// + /// 车道偏离报警拍照间隔 + /// + public byte LaneDepartureAlarmPhotoInterval { get; set; } + /// + /// 前向碰撞报警时间阈值 + /// + public byte ForwardCollisionWarningTimeThreshold { get; set; } + /// + /// 前向碰撞报警分级速度阈值 + /// + public byte HierarchicalSpeedThresholdForwardCollisionWarning { get; set; } + /// + /// 前向碰撞报警前后视频录制时间 + /// + public byte VideoRecordingTimeBeforeAndAfterForwardCollisionAlarm { get; set; } + /// + /// 前向碰撞报警拍照张数 + /// + public byte ForwardCollisionAlarmPhotographs { get; set; } + /// + /// 前向碰撞报警拍照间隔 + /// + public byte ForwardCollisionAlarmInterval { get; set; } + /// + /// 行人碰撞报警时间阈值 + /// + public byte PedestrianCollisionAlarmTimeThreshold { get; set; } + /// + /// 行人碰撞报警使能速度阈值 + /// + public byte PedestrianCollisionAlarmEnablingSpeedThreshold { get; set; } + /// + /// 行人碰撞报警前后视频录制时间 + /// + public byte VideoRecordingTimeBeforeAndAfterPedestrianCollisionAlarm { get; set; } + /// + /// 行人碰撞报警拍照张数 + /// + public byte PedestrianCollisionAlarmPhotos { get; set; } + /// + /// 行人碰撞报警拍照间隔 + /// + public byte PedestrianCollisionAlarmInterval { get; set; } + /// + /// 车距监控报警距离阈值 + /// + public byte VehicleDistanceMonitoringAlarmDistanceThreshold { get; set; } + /// + /// 车距监控报警分级速度阈值 + /// + public byte VehicleDistanceMonitoringAndAlarmClassificationSpeedThreshold { get; set; } + /// + /// 车距过近报警前后视频录制时间 + /// + public byte VideoRecordingTimeBeforeAndAfterAlarmVehicleProximity { get; set; } + /// + /// 车距过近报警拍照张数 + /// + public byte AlarmPhotoVehicleCloseDistance { get; set; } + /// + /// 车距过近报警拍照间隔 + /// + public byte AlarmPhotoVehicleCloseDistanceInterval { get; set; } + /// + /// 道路标志识别拍照张数 + /// + public byte RoadSignRecognitionPhotographs { get; set; } + /// + /// 道路标志识别拍照间隔 + /// + public byte RoadSignRecognitionPhotographsInterval { get; set; } + /// + /// 保留字段 + /// + public byte[] Placeholder2 { get; set; } = new byte[4]; + /// + /// + /// + /// + /// + /// + public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) + { + JT808_0x8103_0xF364 value = new JT808_0x8103_0xF364(); + value.ParamId = reader.ReadUInt32(); + value.ParamLength = reader.ReadByte(); + writer.WriteNumber($"[{value.ParamId.ReadNumber()}]参数ID", value.ParamId); + writer.WriteNumber($"[{value.ParamLength.ReadNumber()}]参数长度", value.ParamLength); + value.AlarmJudgeSpeedThreshold = reader.ReadByte(); + writer.WriteNumber($"[{value.AlarmJudgeSpeedThreshold.ReadNumber()}]报警判断速度阈值", value.AlarmJudgeSpeedThreshold); + value.WarningVolume = reader.ReadByte(); + writer.WriteNumber($"[{value.WarningVolume.ReadNumber()}]报警提示音量", value.WarningVolume); + value.ActivePhotographyStrategy = reader.ReadByte(); + var activePhotographyStrategy = (ActivePhotographyStrategyType)ActivePhotographyStrategy; + writer.WriteNumber($"[{value.ActivePhotographyStrategy.ReadNumber()}]主动拍照策略-{activePhotographyStrategy.ToString()}", value.ActivePhotographyStrategy); + value.ActivelyTimePhotoInterval = reader.ReadUInt16(); + writer.WriteNumber($"[{value.ActivelyTimePhotoInterval.ReadNumber()}]主动定时拍照时间间隔", value.ActivelyTimePhotoInterval); + value.ActiveDistancePhotographyDistanceInterval = reader.ReadUInt16(); + writer.WriteNumber($"[{value.ActiveDistancePhotographyDistanceInterval.ReadNumber()}]主动定距拍照距离间隔", value.ActiveDistancePhotographyDistanceInterval); + value.SingleInitiativePhotos = reader.ReadByte(); + writer.WriteNumber($"[{value.SingleInitiativePhotos.ReadNumber()}]单次主动拍照张数", value.SingleInitiativePhotos); + value.SingleInitiativePhotosInterval = reader.ReadByte(); + writer.WriteNumber($"[{value.SingleInitiativePhotosInterval.ReadNumber()}]单次主动拍照时间间隔", value.SingleInitiativePhotosInterval); + value.PhotoResolution = reader.ReadByte(); + var photoResolutionType = (PhotoResolutionType)value.PhotoResolution; + writer.WriteNumber($"[{value.PhotoResolution.ReadNumber()}]拍照分辨率-{photoResolutionType.ToString()}", value.PhotoResolution); + value.VideoRecordingResolution = reader.ReadByte(); + var videoRecordingResolution = (VideoRecordingResolutionType)value.VideoRecordingResolution; + writer.WriteNumber($"[{value.VideoRecordingResolution.ReadNumber()}]视频录制分辨率-{videoRecordingResolution.ToString()}", value.VideoRecordingResolution); + value.AlarmEnable = reader.ReadUInt32(); + writer.WriteNumber($"[{value.AlarmEnable.ReadNumber()}]报警使能", value.AlarmEnable); + var alarmEnableBits = Convert.ToString(value.AlarmEnable, 2).PadLeft(32, '0').AsSpan(); + writer.WriteStartObject("报警使能对象"); + writer.WriteString("[bit30~bit31]预留", alarmEnableBits.Slice(30,2).ToString()); + writer.WriteString("[bit17~bit29]用户自定义", alarmEnableBits.Slice(17, 13).ToString()); + writer.WriteString("[bit16]道路标识超限报警", alarmEnableBits[16]=='0'?"关闭":"打开"); + writer.WriteString("[bit12~bit15]道路标识超限报警", alarmEnableBits.Slice(12, 4).ToString()); + writer.WriteString("[bit11]车距过近二级报警", alarmEnableBits[11] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit10]车距过近一级报警", alarmEnableBits[10] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit9]行人碰撞二级报警", alarmEnableBits[9] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit8]行人碰撞一级报警", alarmEnableBits[8] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit7]前向碰撞二级报警", alarmEnableBits[7] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit6]前向碰撞一级报警", alarmEnableBits[6] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit5]车道偏离二级报警", alarmEnableBits[5] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit4]车道偏离一级报警", alarmEnableBits[4] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit3]频繁变道二级报警", alarmEnableBits[3] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit2]频繁变道一级报警", alarmEnableBits[2] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit1]障碍检测二级报警", alarmEnableBits[1] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit0]障碍检测一级报警", alarmEnableBits[0] == '0' ? "关闭" : "打开"); + writer.WriteEndObject(); + value.EventEnable = reader.ReadUInt32(); + writer.WriteNumber($"[{value.EventEnable.ReadNumber()}]事件使能", value.EventEnable); + var eventEnableBits = Convert.ToString(value.EventEnable, 2).PadLeft(32, '0').AsSpan(); + writer.WriteStartObject("事件使能对象"); + writer.WriteString("[bit30~bit31]预留", eventEnableBits.Slice(30, 2).ToString()); + writer.WriteString("[bit2~bit29]用户自定义", alarmEnableBits.Slice(2, 28).ToString()); + writer.WriteString("[bit1]主动拍照", alarmEnableBits[1] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit0]道路标识识别", alarmEnableBits[0] == '0' ? "关闭" : "打开"); + writer.WriteEndObject(); + value.Placeholder1 = reader.ReadByte(); + writer.WriteNumber($"[{value.Placeholder1.ReadNumber()}]预留字段", value.Placeholder1); + value.DistanceThresholdObstacleAlarm = reader.ReadByte(); + writer.WriteNumber($"[{value.DistanceThresholdObstacleAlarm.ReadNumber()}]障碍物报警距离阈值", value.DistanceThresholdObstacleAlarm); + value.HierarchicalSpeedThresholdObstacleAlarm = reader.ReadByte(); + writer.WriteNumber($"[{value.HierarchicalSpeedThresholdObstacleAlarm.ReadNumber()}]障碍物报警分级速度阈值", value.HierarchicalSpeedThresholdObstacleAlarm); + value.VideoRecordingTimeBeforeAndAfterObstacleAlarm = reader.ReadByte(); + writer.WriteNumber($"[{value.VideoRecordingTimeBeforeAndAfterObstacleAlarm.ReadNumber()}]障碍物报警前后视频录制时间", value.VideoRecordingTimeBeforeAndAfterObstacleAlarm); + value.BarrierAlarmPhotographs = reader.ReadByte(); + writer.WriteNumber($"[{value.BarrierAlarmPhotographs.ReadNumber()}]障碍物报警拍照张数", value.BarrierAlarmPhotographs); + value.ObstacleAlarmInterval = reader.ReadByte(); + writer.WriteNumber($"[{value.ObstacleAlarmInterval.ReadNumber()}]障碍物报警拍照间隔", value.ObstacleAlarmInterval); + value.FrequentChannelChangeAlarmJudgmentTimePeriod = reader.ReadByte(); + writer.WriteNumber($"[{value.FrequentChannelChangeAlarmJudgmentTimePeriod.ReadNumber()}]频繁变道报警判断时间段", value.FrequentChannelChangeAlarmJudgmentTimePeriod); + value.FrequentAlarmJudgmentNumberChannelChange = reader.ReadByte(); + writer.WriteNumber($"[{value.FrequentAlarmJudgmentNumberChannelChange.ReadNumber()}]频繁变道报警判断次数", value.FrequentAlarmJudgmentNumberChannelChange); + value.HierarchicalSpeedThresholdFrequentChannelChangeAlarm = reader.ReadByte(); + writer.WriteNumber($"[{value.HierarchicalSpeedThresholdFrequentChannelChangeAlarm.ReadNumber()}]频繁变道报警分级速度阈值", value.HierarchicalSpeedThresholdFrequentChannelChangeAlarm); + value.VideoRecordingTimeBeforeAndAfterFrequentLaneChangeAlarm = reader.ReadByte(); + writer.WriteNumber($"[{value.VideoRecordingTimeBeforeAndAfterFrequentLaneChangeAlarm.ReadNumber()}]频繁变道报警前后视频录制时间", value.VideoRecordingTimeBeforeAndAfterFrequentLaneChangeAlarm); + value.FrequentChannelChangeAlarmPhotos = reader.ReadByte(); + writer.WriteNumber($"[{value.FrequentChannelChangeAlarmPhotos.ReadNumber()}]频繁变道报警拍照张数", value.FrequentChannelChangeAlarmPhotos); + value.FrequentLaneChangeAlarmInterval = reader.ReadByte(); + writer.WriteNumber($"[{value.FrequentLaneChangeAlarmInterval.ReadNumber()}]频繁变道报警拍照间隔", value.FrequentLaneChangeAlarmInterval); + value.GradedSpeedThresholdLaneDeviationAlarm = reader.ReadByte(); + writer.WriteNumber($"[{value.GradedSpeedThresholdLaneDeviationAlarm.ReadNumber()}]车道偏离报警分级速度阈值", value.GradedSpeedThresholdLaneDeviationAlarm); + value.VideoRecordingTimeBeforeAndAfterLaneDepartureAlarm = reader.ReadByte(); + writer.WriteNumber($"[{value.VideoRecordingTimeBeforeAndAfterLaneDepartureAlarm.ReadNumber()}]车道偏离报警前后视频录制时间", value.VideoRecordingTimeBeforeAndAfterLaneDepartureAlarm); + value.LaneDepartureAlarmPhoto = reader.ReadByte(); + writer.WriteNumber($"[{value.LaneDepartureAlarmPhoto.ReadNumber()}]车道偏离报警拍照张数", value.LaneDepartureAlarmPhoto); + value.LaneDepartureAlarmPhotoInterval = reader.ReadByte(); + writer.WriteNumber($"[{value.LaneDepartureAlarmPhotoInterval.ReadNumber()}]车道偏离报警拍照间隔", value.LaneDepartureAlarmPhotoInterval); + value.ForwardCollisionWarningTimeThreshold = reader.ReadByte(); + writer.WriteNumber($"[{value.ForwardCollisionWarningTimeThreshold.ReadNumber()}]前向碰撞报警时间阈值", value.ForwardCollisionWarningTimeThreshold); + value.HierarchicalSpeedThresholdForwardCollisionWarning = reader.ReadByte(); + writer.WriteNumber($"[{value.HierarchicalSpeedThresholdForwardCollisionWarning.ReadNumber()}]前向碰撞报警分级速度阈值", value.HierarchicalSpeedThresholdForwardCollisionWarning); + value.VideoRecordingTimeBeforeAndAfterForwardCollisionAlarm = reader.ReadByte(); + writer.WriteNumber($"[{value.VideoRecordingTimeBeforeAndAfterForwardCollisionAlarm.ReadNumber()}]前向碰撞报警前后视频录制时间", value.VideoRecordingTimeBeforeAndAfterForwardCollisionAlarm); + value.ForwardCollisionAlarmPhotographs = reader.ReadByte(); + writer.WriteNumber($"[{value.ForwardCollisionAlarmPhotographs.ReadNumber()}]前向碰撞报警拍照张数", value.ForwardCollisionAlarmPhotographs); + value.ForwardCollisionAlarmInterval = reader.ReadByte(); + writer.WriteNumber($"[{value.ForwardCollisionAlarmInterval.ReadNumber()}]前向碰撞报警拍照间隔", value.ForwardCollisionAlarmInterval); + value.PedestrianCollisionAlarmTimeThreshold = reader.ReadByte(); + writer.WriteNumber($"[{value.PedestrianCollisionAlarmTimeThreshold.ReadNumber()}]行人碰撞报警时间阈值", value.PedestrianCollisionAlarmTimeThreshold); + value.PedestrianCollisionAlarmEnablingSpeedThreshold = reader.ReadByte(); + writer.WriteNumber($"[{value.PedestrianCollisionAlarmEnablingSpeedThreshold.ReadNumber()}]行人碰撞报警使能速度阈值", value.PedestrianCollisionAlarmEnablingSpeedThreshold); + value.VideoRecordingTimeBeforeAndAfterPedestrianCollisionAlarm = reader.ReadByte(); + writer.WriteNumber($"[{value.VideoRecordingTimeBeforeAndAfterPedestrianCollisionAlarm.ReadNumber()}]行人碰撞报警前后视频录制时间", value.VideoRecordingTimeBeforeAndAfterPedestrianCollisionAlarm); + value.PedestrianCollisionAlarmPhotos = reader.ReadByte(); + writer.WriteNumber($"[{value.PedestrianCollisionAlarmPhotos.ReadNumber()}]行人碰撞报警拍照张数", value.PedestrianCollisionAlarmPhotos); + value.PedestrianCollisionAlarmInterval = reader.ReadByte(); + writer.WriteNumber($"[{value.PedestrianCollisionAlarmInterval.ReadNumber()}]行人碰撞报警拍照间隔", value.PedestrianCollisionAlarmInterval); + value.VehicleDistanceMonitoringAlarmDistanceThreshold = reader.ReadByte(); + writer.WriteNumber($"[{value.VehicleDistanceMonitoringAlarmDistanceThreshold.ReadNumber()}]车距监控报警距离阈值", value.VehicleDistanceMonitoringAlarmDistanceThreshold); + value.VehicleDistanceMonitoringAndAlarmClassificationSpeedThreshold = reader.ReadByte(); + writer.WriteNumber($"[{value.VehicleDistanceMonitoringAndAlarmClassificationSpeedThreshold.ReadNumber()}]车距监控报警分级速度阈值", value.VehicleDistanceMonitoringAndAlarmClassificationSpeedThreshold); + value.VideoRecordingTimeBeforeAndAfterAlarmVehicleProximity = reader.ReadByte(); + writer.WriteNumber($"[{value.VideoRecordingTimeBeforeAndAfterAlarmVehicleProximity.ReadNumber()}]车距过近报警前后视频录制时间", value.VideoRecordingTimeBeforeAndAfterAlarmVehicleProximity); + value.AlarmPhotoVehicleCloseDistance = reader.ReadByte(); + writer.WriteNumber($"[{value.AlarmPhotoVehicleCloseDistance.ReadNumber()}]车距过近报警拍照张数", value.AlarmPhotoVehicleCloseDistance); + value.AlarmPhotoVehicleCloseDistanceInterval = reader.ReadByte(); + writer.WriteNumber($"[{value.AlarmPhotoVehicleCloseDistanceInterval.ReadNumber()}]车距过近报警拍照间隔", value.AlarmPhotoVehicleCloseDistanceInterval); + value.RoadSignRecognitionPhotographs = reader.ReadByte(); + writer.WriteNumber($"[{value.RoadSignRecognitionPhotographs.ReadNumber()}]道路标志识别拍照张数", value.RoadSignRecognitionPhotographs); + value.RoadSignRecognitionPhotographsInterval = reader.ReadByte(); + writer.WriteNumber($"[{value.RoadSignRecognitionPhotographsInterval.ReadNumber()}]道路标志识别拍照间隔", value.RoadSignRecognitionPhotographsInterval); + value.Placeholder2 = reader.ReadArray(4).ToArray(); + writer.WriteString("保留字段", value.Placeholder2.ToHexString()); + } + /// + /// + /// + /// + /// + /// + public JT808_0x8103_0xF364 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) + { + JT808_0x8103_0xF364 value = new JT808_0x8103_0xF364(); + value.ParamId = reader.ReadUInt32(); + value.ParamLength = reader.ReadByte(); + value.AlarmJudgeSpeedThreshold = reader.ReadByte(); + value.WarningVolume = reader.ReadByte(); + value.ActivePhotographyStrategy = reader.ReadByte(); + value.ActivelyTimePhotoInterval = reader.ReadUInt16(); + value.ActiveDistancePhotographyDistanceInterval = reader.ReadUInt16(); + value.SingleInitiativePhotos = reader.ReadByte(); + value.SingleInitiativePhotosInterval = reader.ReadByte(); + value.PhotoResolution = reader.ReadByte(); + value.VideoRecordingResolution = reader.ReadByte(); + value.AlarmEnable = reader.ReadUInt32(); + value.EventEnable = reader.ReadUInt32(); + value.Placeholder1 = reader.ReadByte(); + value.DistanceThresholdObstacleAlarm = reader.ReadByte(); + value.HierarchicalSpeedThresholdObstacleAlarm = reader.ReadByte(); + value.VideoRecordingTimeBeforeAndAfterObstacleAlarm = reader.ReadByte(); + value.BarrierAlarmPhotographs = reader.ReadByte(); + value.ObstacleAlarmInterval = reader.ReadByte(); + value.FrequentChannelChangeAlarmJudgmentTimePeriod = reader.ReadByte(); + value.FrequentAlarmJudgmentNumberChannelChange = reader.ReadByte(); + value.HierarchicalSpeedThresholdFrequentChannelChangeAlarm = reader.ReadByte(); + value.VideoRecordingTimeBeforeAndAfterFrequentLaneChangeAlarm = reader.ReadByte(); + value.FrequentChannelChangeAlarmPhotos = reader.ReadByte(); + value.FrequentLaneChangeAlarmInterval = reader.ReadByte(); + value.GradedSpeedThresholdLaneDeviationAlarm = reader.ReadByte(); + value.VideoRecordingTimeBeforeAndAfterLaneDepartureAlarm = reader.ReadByte(); + value.LaneDepartureAlarmPhoto = reader.ReadByte(); + value.LaneDepartureAlarmPhotoInterval = reader.ReadByte(); + value.ForwardCollisionWarningTimeThreshold = reader.ReadByte(); + value.HierarchicalSpeedThresholdForwardCollisionWarning = reader.ReadByte(); + value.VideoRecordingTimeBeforeAndAfterForwardCollisionAlarm = reader.ReadByte(); + value.ForwardCollisionAlarmPhotographs = reader.ReadByte(); + value.ForwardCollisionAlarmInterval = reader.ReadByte(); + value.PedestrianCollisionAlarmTimeThreshold = reader.ReadByte(); + value.PedestrianCollisionAlarmEnablingSpeedThreshold = reader.ReadByte(); + value.VideoRecordingTimeBeforeAndAfterPedestrianCollisionAlarm = reader.ReadByte(); + value.PedestrianCollisionAlarmPhotos = reader.ReadByte(); + value.PedestrianCollisionAlarmInterval = reader.ReadByte(); + value.VehicleDistanceMonitoringAlarmDistanceThreshold = reader.ReadByte(); + value.VehicleDistanceMonitoringAndAlarmClassificationSpeedThreshold = reader.ReadByte(); + value.VideoRecordingTimeBeforeAndAfterAlarmVehicleProximity = reader.ReadByte(); + value.AlarmPhotoVehicleCloseDistance = reader.ReadByte(); + value.AlarmPhotoVehicleCloseDistanceInterval = reader.ReadByte(); + value.RoadSignRecognitionPhotographs = reader.ReadByte(); + value.RoadSignRecognitionPhotographsInterval = reader.ReadByte(); + value.Placeholder2 = reader.ReadArray(4).ToArray(); + return value; + } + /// + /// + /// + /// + /// + /// + public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0xF364 value, IJT808Config config) + { + writer.WriteUInt32(value.ParamId); + writer.Skip(1, out int ParamLengthPosition); + writer.WriteByte(value.AlarmJudgeSpeedThreshold); + writer.WriteByte(value.WarningVolume); + writer.WriteByte(value.ActivePhotographyStrategy); + writer.WriteUInt16(value.ActivelyTimePhotoInterval); + writer.WriteUInt16(value.ActiveDistancePhotographyDistanceInterval); + writer.WriteByte(value.SingleInitiativePhotos); + writer.WriteByte(value.SingleInitiativePhotosInterval); + writer.WriteByte(value.PhotoResolution); + writer.WriteByte(value.VideoRecordingResolution); + writer.WriteUInt32(value.AlarmEnable); + writer.WriteUInt32(value.EventEnable); + writer.WriteByte(value.Placeholder1); + writer.WriteByte(value.DistanceThresholdObstacleAlarm); + writer.WriteByte(value.HierarchicalSpeedThresholdObstacleAlarm); + writer.WriteByte(value.VideoRecordingTimeBeforeAndAfterObstacleAlarm); + writer.WriteByte(value.BarrierAlarmPhotographs); + writer.WriteByte(value.ObstacleAlarmInterval); + writer.WriteByte(value.FrequentChannelChangeAlarmJudgmentTimePeriod); + writer.WriteByte(value.FrequentAlarmJudgmentNumberChannelChange); + writer.WriteByte(value.HierarchicalSpeedThresholdFrequentChannelChangeAlarm); + writer.WriteByte(value.VideoRecordingTimeBeforeAndAfterFrequentLaneChangeAlarm); + writer.WriteByte(value.FrequentChannelChangeAlarmPhotos); + writer.WriteByte(value.FrequentLaneChangeAlarmInterval); + writer.WriteByte(value.GradedSpeedThresholdLaneDeviationAlarm); + writer.WriteByte(value.VideoRecordingTimeBeforeAndAfterLaneDepartureAlarm); + writer.WriteByte(value.LaneDepartureAlarmPhoto); + writer.WriteByte(value.LaneDepartureAlarmPhotoInterval); + writer.WriteByte(value.ForwardCollisionWarningTimeThreshold); + writer.WriteByte(value.HierarchicalSpeedThresholdForwardCollisionWarning); + writer.WriteByte(value.VideoRecordingTimeBeforeAndAfterForwardCollisionAlarm); + writer.WriteByte(value.ForwardCollisionAlarmPhotographs); + writer.WriteByte(value.ForwardCollisionAlarmInterval); + writer.WriteByte(value.PedestrianCollisionAlarmTimeThreshold); + writer.WriteByte(value.PedestrianCollisionAlarmEnablingSpeedThreshold); + writer.WriteByte(value.VideoRecordingTimeBeforeAndAfterPedestrianCollisionAlarm); + writer.WriteByte(value.PedestrianCollisionAlarmPhotos); + writer.WriteByte(value.PedestrianCollisionAlarmInterval); + writer.WriteByte(value.VehicleDistanceMonitoringAlarmDistanceThreshold); + writer.WriteByte(value.VehicleDistanceMonitoringAndAlarmClassificationSpeedThreshold); + writer.WriteByte(value.VideoRecordingTimeBeforeAndAfterAlarmVehicleProximity); + writer.WriteByte(value.AlarmPhotoVehicleCloseDistance); + writer.WriteByte(value.AlarmPhotoVehicleCloseDistanceInterval); + writer.WriteByte(value.RoadSignRecognitionPhotographs); + writer.WriteByte(value.RoadSignRecognitionPhotographsInterval); + writer.WriteArray(value.Placeholder2); + writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - ParamLengthPosition - 1), ParamLengthPosition); + } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x8103_0xF365.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x8103_0xF365.cs new file mode 100644 index 0000000..09231d9 --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x8103_0xF365.cs @@ -0,0 +1,365 @@ +using JT808.Protocol.Extensions.YueBiao.Enums; +using JT808.Protocol.Formatters; +using JT808.Protocol.Interfaces; +using JT808.Protocol.MessageBody; +using JT808.Protocol.MessagePack; +using System; +using System.Text.Json; + +namespace JT808.Protocol.Extensions.YueBiao.MessageBody +{ + /// + /// 驾驶员状态监测系统参数 + /// + public class JT808_0x8103_0xF365 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze + { + /// + /// 驾驶员状态监测系统参数 + /// + public override uint ParamId { get; set; } = JT808_YueBiao_Constants.JT808_0X8103_0xF365; + /// + /// 驾驶员状态监测系统参数长度 + /// + public override byte ParamLength { get; set; } + /// + /// 报警判断速度阈值 + /// + public byte AlarmJudgeSpeedThreshold { get; set; } + /// + /// 报警提示音量 + /// + public byte WarningVolume { get; set; } + /// + /// 主动拍照策略 + /// + public byte ActivePhotographyStrategy { get; set; } + /// + /// 主动定时拍照时间间隔 + /// + public ushort ActivelyTimePhotoInterval { get; set; } + /// + /// 主动定距拍照距离间隔 + /// + public ushort ActiveDistancePhotographyDistanceInterval { get; set; } + /// + /// 单次主动拍照张数 + /// + public byte SingleInitiativePhotos { get; set; } + /// + /// 单次主动拍照时间间隔 + /// + public byte SingleInitiativePhotosInterval { get; set; } + /// + /// 拍照分辨率 + /// + public byte PhotoResolution { get; set; } + /// + /// 视频录制分辨率 + /// + public byte VideoRecordingResolution { get; set; } + /// + /// 报警使能 + /// + public uint AlarmEnable { get; set; } + /// + /// 事件使能 + /// + public uint EventEnable { get; set; } + /// + /// 吸烟报警判断时间间隔 + /// + public ushort TimeIntervalSmokingAlarmJudgment { get; set; } + /// + /// 接打电话报警判断时间间隔 + /// + public ushort CallAlarmDetermineTimeInterval{ get; set; } + /// + /// 预留字段 + /// + public byte[] Reserve { get; set; } = new byte[3]; + /// + /// 疲劳驾驶报警分级速度阈值 + /// + public byte GradedSpeedThresholdFatigueDrivingAlarm { get; set; } + /// + /// 疲劳驾驶报警前后视频录制时间 + /// + public byte VideoRecordingTimeBeforeAndAfterFatigueDrivingAlarm { get; set; } + /// + /// 疲劳驾驶报警拍照张数 + /// + public byte FatigueDrivingAlarmPhotograph { get; set; } + /// + /// 疲劳驾驶报警拍照间隔时间 + /// + public byte FatigueDrivingAlarmPhotographInterval { get; set; } + /// + /// 接打电话报警分级速度阈值 + /// + public byte ClassifiedSpeedThresholdCallAlarm{ get; set; } + /// + /// 接打电话报警前后视频录制时间 + /// + public byte VideoRecordingTimeBeforeAndAfterCallAlarm{ get; set; } + /// + /// 接打电话报警拍驾驶员面部特征照片张数 + /// + public byte CallAlarmTakePicturesDriverFacialFeatures{ get; set; } + /// + /// 接打电话报警拍驾驶员面部特征照片间隔时间 + /// + public byte CallAlarmTakePicturesDriverFacialFeaturesInterval { get; set; } + /// + /// 抽烟报警分级车速阈值 + /// + public byte ClassifiedSpeedThresholdSmokingAlarm{ get; set; } + /// + /// 抽烟报警前后视频录制时间 + /// + public byte VideoRecordingTimeBeforeAndAfterSmokingAlarm{ get; set; } + /// + /// 抽烟报警拍驾驶员面部特征照片张数 + /// + public byte SmokingAlarmPhotographsDriverFaceCharacteristics { get; set; } + /// + /// 抽烟报警拍驾驶员面部特征照片间隔时间 + /// + public byte SmokingAlarmPhotographsDriverFaceCharacteristicsInterval { get; set; } + /// + /// 分神驾驶报警分级车速阈值 + /// + public byte ClassifiedSpeedThresholdDistractedDrivingAlarm { get; set; } + /// + /// 分神驾驶报警拍照张数 + /// + public byte DistractedDrivingAlarmPhotography{ get; set; } + /// + /// 分神驾驶报警拍照间隔时间 + /// + public byte DistractedDrivingAlarmPhotographyInterval { get; set; } + /// + /// 驾驶行为异常视频录制时间 + /// + public byte VideoRecordingTimeAbnormalDrivingBehavior{ get; set; } + /// + /// 驾驶行为异常抓拍照片张数 + /// + public byte PhotographsAbnormalDrivingBehavior{ get; set; } + /// + /// 驾驶行为异常拍照间隔 + /// + public byte PictureIntervalAbnormalDrivingBehavior{ get; set; } + /// + /// 驾驶员身份识别触发 + /// + public byte DriverIdentificationTrigger { get; set; } + /// + /// 保留字段 + /// + public byte[] Retain { get; set; } = new byte[2]; + /// + /// + /// + /// + /// + /// + public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) + { + JT808_0x8103_0xF365 value = new JT808_0x8103_0xF365(); + value.ParamId = reader.ReadUInt32(); + value.ParamLength = reader.ReadByte(); + writer.WriteNumber($"[{value.ParamId.ReadNumber()}]参数ID", value.ParamId); + writer.WriteNumber($"[{value.ParamLength.ReadNumber()}]参数长度", value.ParamLength); + value.AlarmJudgeSpeedThreshold = reader.ReadByte(); + writer.WriteNumber($"[{value.AlarmJudgeSpeedThreshold.ReadNumber()}]报警判断速度阈值", value.AlarmJudgeSpeedThreshold); + value.WarningVolume = reader.ReadByte(); + writer.WriteNumber($"[{value.WarningVolume.ReadNumber()}]报警提示音量", value.WarningVolume); + value.ActivePhotographyStrategy = reader.ReadByte(); + var activePhotographyStrategy = (ActivePhotographyStrategyType)ActivePhotographyStrategy; + writer.WriteNumber($"[{value.ActivePhotographyStrategy.ReadNumber()}]主动拍照策略-{activePhotographyStrategy.ToString()}", value.ActivePhotographyStrategy); + value.ActivelyTimePhotoInterval = reader.ReadUInt16(); + writer.WriteNumber($"[{value.ActivelyTimePhotoInterval.ReadNumber()}]主动定时拍照时间间隔", value.ActivelyTimePhotoInterval); + value.ActiveDistancePhotographyDistanceInterval = reader.ReadUInt16(); + writer.WriteNumber($"[{value.ActiveDistancePhotographyDistanceInterval.ReadNumber()}]主动定距拍照距离间隔", value.ActiveDistancePhotographyDistanceInterval); + value.SingleInitiativePhotos = reader.ReadByte(); + writer.WriteNumber($"[{value.SingleInitiativePhotos.ReadNumber()}]单次主动拍照张数", value.SingleInitiativePhotos); + value.SingleInitiativePhotosInterval = reader.ReadByte(); + writer.WriteNumber($"[{value.SingleInitiativePhotosInterval.ReadNumber()}]单次主动拍照时间间隔", value.SingleInitiativePhotosInterval); + value.PhotoResolution = reader.ReadByte(); + var photoResolutionType = (PhotoResolutionType)value.PhotoResolution; + writer.WriteNumber($"[{value.PhotoResolution.ReadNumber()}]拍照分辨率-{photoResolutionType.ToString()}", value.PhotoResolution); + value.VideoRecordingResolution = reader.ReadByte(); + var videoRecordingResolution = (VideoRecordingResolutionType)value.VideoRecordingResolution; + writer.WriteNumber($"[{value.VideoRecordingResolution.ReadNumber()}]视频录制分辨率-{videoRecordingResolution.ToString()}", value.VideoRecordingResolution); + value.AlarmEnable = reader.ReadUInt32(); + writer.WriteNumber($"[{value.AlarmEnable.ReadNumber()}]报警使能", value.AlarmEnable); + var alarmEnableBits = Convert.ToString(value.AlarmEnable, 2).PadLeft(32, '0').AsSpan(); + writer.WriteStartObject("报警使能对象"); + writer.WriteString("[bit30~bit31]预留", alarmEnableBits.Slice(30, 2).ToString()); + writer.WriteString("[bit17~bit29]用户自定义", alarmEnableBits.Slice(17, 13).ToString()); + writer.WriteString("[bit16]道路标识超限报警", alarmEnableBits[16] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit12~bit15]道路标识超限报警", alarmEnableBits.Slice(12, 4).ToString()); + writer.WriteString("[bit11]车距过近二级报警", alarmEnableBits[11] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit10]车距过近一级报警", alarmEnableBits[10] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit9]行人碰撞二级报警", alarmEnableBits[9] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit8]行人碰撞一级报警", alarmEnableBits[8] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit7]前向碰撞二级报警", alarmEnableBits[7] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit6]前向碰撞一级报警", alarmEnableBits[6] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit5]车道偏离二级报警", alarmEnableBits[5] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit4]车道偏离一级报警", alarmEnableBits[4] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit3]频繁变道二级报警", alarmEnableBits[3] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit2]频繁变道一级报警", alarmEnableBits[2] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit1]障碍检测二级报警", alarmEnableBits[1] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit0]障碍检测一级报警", alarmEnableBits[0] == '0' ? "关闭" : "打开"); + writer.WriteEndObject(); + value.EventEnable = reader.ReadUInt32(); + writer.WriteNumber($"[{value.EventEnable.ReadNumber()}]事件使能", value.EventEnable); + var eventEnableBits = Convert.ToString(value.EventEnable, 2).PadLeft(32, '0').AsSpan(); + writer.WriteStartObject("事件使能对象"); + writer.WriteString("[bit30~bit31]预留", eventEnableBits.Slice(30, 2).ToString()); + writer.WriteString("[bit2~bit29]用户自定义", alarmEnableBits.Slice(2, 28).ToString()); + writer.WriteString("[bit1]主动拍照", alarmEnableBits[1] == '0' ? "关闭" : "打开"); + writer.WriteString("[bit0]道路标识识别", alarmEnableBits[0] == '0' ? "关闭" : "打开"); + writer.WriteEndObject(); + value.TimeIntervalSmokingAlarmJudgment = reader.ReadUInt16(); + writer.WriteNumber($"[{value.TimeIntervalSmokingAlarmJudgment.ReadNumber()}]吸烟报警判断时间间隔", value.TimeIntervalSmokingAlarmJudgment); + value.CallAlarmDetermineTimeInterval = reader.ReadUInt16(); + writer.WriteNumber($"[{value.CallAlarmDetermineTimeInterval.ReadNumber()}]接打电话报警判断时间间隔", value.CallAlarmDetermineTimeInterval); + value.Reserve = reader.ReadArray(3).ToArray(); + writer.WriteString("预留字段", value.Reserve.ToHexString()); + value.GradedSpeedThresholdFatigueDrivingAlarm = reader.ReadByte(); + writer.WriteNumber($"[{value.GradedSpeedThresholdFatigueDrivingAlarm.ReadNumber()}]疲劳驾驶报警分级速度阈值", value.GradedSpeedThresholdFatigueDrivingAlarm); + value.VideoRecordingTimeBeforeAndAfterFatigueDrivingAlarm = reader.ReadByte(); + writer.WriteNumber($"[{value.VideoRecordingTimeBeforeAndAfterFatigueDrivingAlarm.ReadNumber()}]疲劳驾驶报警前后视频录制时间", value.VideoRecordingTimeBeforeAndAfterFatigueDrivingAlarm); + value.FatigueDrivingAlarmPhotograph = reader.ReadByte(); + writer.WriteNumber($"[{value.FatigueDrivingAlarmPhotograph.ReadNumber()}]疲劳驾驶报警拍照张数", value.FatigueDrivingAlarmPhotograph); + value.FatigueDrivingAlarmPhotographInterval = reader.ReadByte(); + writer.WriteNumber($"[{value.FatigueDrivingAlarmPhotographInterval.ReadNumber()}]疲劳驾驶报警拍照间隔时间", value.FatigueDrivingAlarmPhotographInterval); + value.ClassifiedSpeedThresholdCallAlarm = reader.ReadByte(); + writer.WriteNumber($"[{value.ClassifiedSpeedThresholdCallAlarm.ReadNumber()}]接打电话报警分级速度阈值", value.ClassifiedSpeedThresholdCallAlarm); + value.VideoRecordingTimeBeforeAndAfterCallAlarm = reader.ReadByte(); + writer.WriteNumber($"[{value.VideoRecordingTimeBeforeAndAfterCallAlarm.ReadNumber()}]接打电话报警前后视频录制时间", value.VideoRecordingTimeBeforeAndAfterCallAlarm); + value.CallAlarmTakePicturesDriverFacialFeatures = reader.ReadByte(); + writer.WriteNumber($"[{value.CallAlarmTakePicturesDriverFacialFeatures.ReadNumber()}]接打电话报警拍驾驶员面部特征照片张数", value.CallAlarmTakePicturesDriverFacialFeatures); + value.CallAlarmTakePicturesDriverFacialFeaturesInterval = reader.ReadByte(); + writer.WriteNumber($"[{value.CallAlarmTakePicturesDriverFacialFeaturesInterval.ReadNumber()}]接打电话报警拍驾驶员面部特征照片间隔时间", value.CallAlarmTakePicturesDriverFacialFeaturesInterval); + value.ClassifiedSpeedThresholdSmokingAlarm = reader.ReadByte(); + writer.WriteNumber($"[{value.ClassifiedSpeedThresholdSmokingAlarm.ReadNumber()}]抽烟报警分级车速阈值", value.ClassifiedSpeedThresholdSmokingAlarm); + value.VideoRecordingTimeBeforeAndAfterSmokingAlarm = reader.ReadByte(); + writer.WriteNumber($"[{value.VideoRecordingTimeBeforeAndAfterSmokingAlarm.ReadNumber()}]抽烟报警前后视频录制时间", value.VideoRecordingTimeBeforeAndAfterSmokingAlarm); + value.SmokingAlarmPhotographsDriverFaceCharacteristics = reader.ReadByte(); + writer.WriteNumber($"[{value.SmokingAlarmPhotographsDriverFaceCharacteristics.ReadNumber()}]抽烟报警拍驾驶员面部特征照片张数", value.SmokingAlarmPhotographsDriverFaceCharacteristics); + value.SmokingAlarmPhotographsDriverFaceCharacteristicsInterval = reader.ReadByte(); + writer.WriteNumber($"[{value.SmokingAlarmPhotographsDriverFaceCharacteristicsInterval.ReadNumber()}]抽烟报警拍驾驶员面部特征照片间隔时间", value.SmokingAlarmPhotographsDriverFaceCharacteristicsInterval); + value.ClassifiedSpeedThresholdDistractedDrivingAlarm = reader.ReadByte(); + writer.WriteNumber($"[{value.ClassifiedSpeedThresholdDistractedDrivingAlarm.ReadNumber()}]分神驾驶报警分级车速阈值", value.ClassifiedSpeedThresholdDistractedDrivingAlarm); + value.DistractedDrivingAlarmPhotography = reader.ReadByte(); + writer.WriteNumber($"[{value.DistractedDrivingAlarmPhotography.ReadNumber()}]分神驾驶报警拍照张数", value.DistractedDrivingAlarmPhotography); + value.DistractedDrivingAlarmPhotographyInterval = reader.ReadByte(); + writer.WriteNumber($"[{value.DistractedDrivingAlarmPhotographyInterval.ReadNumber()}]分神驾驶报警拍照间隔时间", value.DistractedDrivingAlarmPhotographyInterval); + value.VideoRecordingTimeAbnormalDrivingBehavior = reader.ReadByte(); + writer.WriteNumber($"[{value.VideoRecordingTimeAbnormalDrivingBehavior.ReadNumber()}]驾驶行为异常视频录制时间", value.VideoRecordingTimeAbnormalDrivingBehavior); + value.PhotographsAbnormalDrivingBehavior = reader.ReadByte(); + writer.WriteNumber($"[{value.PhotographsAbnormalDrivingBehavior.ReadNumber()}]驾驶行为异常抓拍照片张数", value.PhotographsAbnormalDrivingBehavior); + value.PictureIntervalAbnormalDrivingBehavior = reader.ReadByte(); + writer.WriteNumber($"[{value.PictureIntervalAbnormalDrivingBehavior.ReadNumber()}]驾驶行为异常拍照间隔", value.PictureIntervalAbnormalDrivingBehavior); + value.DriverIdentificationTrigger = reader.ReadByte(); + writer.WriteNumber($"[{value.DriverIdentificationTrigger.ReadNumber()}]驾驶员身份识别触发", value.DriverIdentificationTrigger); + value.Retain = reader.ReadArray(reader.ReadCurrentRemainContentLength()).ToArray(); + writer.WriteString("保留字段", value.Retain.ToHexString()); + } + /// + /// + /// + /// + /// + /// + public JT808_0x8103_0xF365 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) + { + JT808_0x8103_0xF365 value = new JT808_0x8103_0xF365(); + value.ParamId = reader.ReadUInt32(); + value.ParamLength = reader.ReadByte(); + value.AlarmJudgeSpeedThreshold = reader.ReadByte(); + value.WarningVolume = reader.ReadByte(); + value.ActivePhotographyStrategy = reader.ReadByte(); + value.ActivelyTimePhotoInterval = reader.ReadUInt16(); + value.ActiveDistancePhotographyDistanceInterval = reader.ReadUInt16(); + value.SingleInitiativePhotos = reader.ReadByte(); + value.SingleInitiativePhotosInterval = reader.ReadByte(); + value.PhotoResolution = reader.ReadByte(); + value.VideoRecordingResolution = reader.ReadByte(); + value.AlarmEnable = reader.ReadUInt32(); + value.EventEnable = reader.ReadUInt32(); + value.TimeIntervalSmokingAlarmJudgment = reader.ReadUInt16(); + value.CallAlarmDetermineTimeInterval = reader.ReadUInt16(); + value.Reserve = reader.ReadArray(3).ToArray(); + value.GradedSpeedThresholdFatigueDrivingAlarm = reader.ReadByte(); + value.VideoRecordingTimeBeforeAndAfterFatigueDrivingAlarm = reader.ReadByte(); + value.FatigueDrivingAlarmPhotograph = reader.ReadByte(); + value.FatigueDrivingAlarmPhotographInterval = reader.ReadByte(); + value.ClassifiedSpeedThresholdCallAlarm = reader.ReadByte(); + value.VideoRecordingTimeBeforeAndAfterCallAlarm = reader.ReadByte(); + value.CallAlarmTakePicturesDriverFacialFeatures = reader.ReadByte(); + value.CallAlarmTakePicturesDriverFacialFeaturesInterval = reader.ReadByte(); + value.ClassifiedSpeedThresholdSmokingAlarm = reader.ReadByte(); + value.VideoRecordingTimeBeforeAndAfterSmokingAlarm = reader.ReadByte(); + value.SmokingAlarmPhotographsDriverFaceCharacteristics = reader.ReadByte(); + value.SmokingAlarmPhotographsDriverFaceCharacteristicsInterval = reader.ReadByte(); + value.ClassifiedSpeedThresholdDistractedDrivingAlarm = reader.ReadByte(); + value.DistractedDrivingAlarmPhotography = reader.ReadByte(); + value.DistractedDrivingAlarmPhotographyInterval = reader.ReadByte(); + value.VideoRecordingTimeAbnormalDrivingBehavior = reader.ReadByte(); + value.PhotographsAbnormalDrivingBehavior = reader.ReadByte(); + value.PictureIntervalAbnormalDrivingBehavior = reader.ReadByte(); + value.DriverIdentificationTrigger = reader.ReadByte(); + value.Retain = reader.ReadArray(reader.ReadCurrentRemainContentLength()).ToArray(); + return value; + } + /// + /// + /// + /// + /// + /// + public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0xF365 value, IJT808Config config) + { + writer.WriteUInt32(value.ParamId); + writer.Skip(1, out int ParamLengthPosition); + writer.WriteByte(value.AlarmJudgeSpeedThreshold); + writer.WriteByte(value.WarningVolume); + writer.WriteByte(value.ActivePhotographyStrategy); + writer.WriteUInt16(value.ActivelyTimePhotoInterval); + writer.WriteUInt16(value.ActiveDistancePhotographyDistanceInterval); + writer.WriteByte(value.SingleInitiativePhotos); + writer.WriteByte(value.SingleInitiativePhotosInterval); + writer.WriteByte(value.PhotoResolution); + writer.WriteByte(value.VideoRecordingResolution); + writer.WriteUInt32(value.AlarmEnable); + writer.WriteUInt32(value.EventEnable); + writer.WriteUInt16(value.TimeIntervalSmokingAlarmJudgment); + writer.WriteUInt16(value.CallAlarmDetermineTimeInterval); + writer.WriteArray(value.Reserve); + writer.WriteByte(value.GradedSpeedThresholdFatigueDrivingAlarm); + writer.WriteByte(value.VideoRecordingTimeBeforeAndAfterFatigueDrivingAlarm); + writer.WriteByte(value.FatigueDrivingAlarmPhotograph); + writer.WriteByte(value.FatigueDrivingAlarmPhotographInterval); + writer.WriteByte(value.ClassifiedSpeedThresholdCallAlarm); + writer.WriteByte(value.VideoRecordingTimeBeforeAndAfterCallAlarm); + writer.WriteByte(value.CallAlarmTakePicturesDriverFacialFeatures); + writer.WriteByte(value.CallAlarmTakePicturesDriverFacialFeaturesInterval); + writer.WriteByte(value.ClassifiedSpeedThresholdSmokingAlarm); + writer.WriteByte(value.VideoRecordingTimeBeforeAndAfterSmokingAlarm); + writer.WriteByte(value.SmokingAlarmPhotographsDriverFaceCharacteristics); + writer.WriteByte(value.SmokingAlarmPhotographsDriverFaceCharacteristicsInterval); + writer.WriteByte(value.ClassifiedSpeedThresholdDistractedDrivingAlarm); + writer.WriteByte(value.DistractedDrivingAlarmPhotography); + writer.WriteByte(value.DistractedDrivingAlarmPhotographyInterval); + writer.WriteByte(value.VideoRecordingTimeAbnormalDrivingBehavior); + writer.WriteByte(value.PhotographsAbnormalDrivingBehavior); + writer.WriteByte(value.PictureIntervalAbnormalDrivingBehavior); + writer.WriteByte(value.DriverIdentificationTrigger); + writer.WriteArray(value.Retain); + writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - ParamLengthPosition - 1), ParamLengthPosition); + } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x8103_0xF366.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x8103_0xF366.cs new file mode 100644 index 0000000..2635e8d --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x8103_0xF366.cs @@ -0,0 +1,151 @@ +using JT808.Protocol.Formatters; +using JT808.Protocol.Interfaces; +using JT808.Protocol.MessageBody; +using JT808.Protocol.MessagePack; +using System.Text.Json; + +namespace JT808.Protocol.Extensions.YueBiao.MessageBody +{ + /// + /// 胎压监测系统参数 + /// + public class JT808_0x8103_0xF366 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze + { + /// + /// 胎压监测系统参数Id + /// + public override uint ParamId { get; set; } = JT808_YueBiao_Constants.JT808_0X8103_0xF366; + /// + /// 胎压监测系统参数长度 + /// + public override byte ParamLength { get; set; } = 46; + /// + /// 轮胎规格型号 12位 + /// + public string TyreSpecificationType { get; set; } + /// + /// 胎压单位 + /// + public ushort TyrePressureUnit { get; set; } + /// + /// 正常胎压值 + /// + public ushort NormalFetalPressure { get; set; } + /// + /// 胎压不平衡门限 + /// + public ushort ThresholdUnbalancedTirePressure { get; set; } + /// + /// 慢漏气门限 + /// + public ushort SlowLeakageThreshold { get; set; } + /// + /// 低压阈值 + /// + public ushort LowVoltageThreshold { get; set; } + /// + /// 高压阈值 + /// + public ushort HighVoltageThreshold { get; set; } + /// + /// 高温阈值 + /// + public ushort HighTemperatureThreshold { get; set; } + /// + /// 电压阈值 + /// + public ushort VoltageThreshold { get; set; } + /// + /// 定时上报时间间隔 + /// + public ushort TimedReportingInterval { get; set; } + /// + /// 保留项 + /// + public byte[] Retain { get; set; } = new byte[6]; + /// + /// + /// + /// + /// + /// + public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) + { + JT808_0x8103_0xF366 value = new JT808_0x8103_0xF366(); + value.ParamId = reader.ReadUInt32(); + value.ParamLength = reader.ReadByte(); + writer.WriteNumber($"[{value.ParamId.ReadNumber()}]参数ID", value.ParamId); + writer.WriteNumber($"[{value.ParamLength.ReadNumber()}]参数长度", value.ParamLength); + string tyreSpecificationTypeHex = reader.ReadVirtualArray(12).ToArray().ToHexString(); + value.TyreSpecificationType = reader.ReadString(12); + writer.WriteString($"[{tyreSpecificationTypeHex}]轮胎规格型号", value.TyreSpecificationType); + value.TyrePressureUnit = reader.ReadUInt16(); + writer.WriteNumber($"[{value.TyrePressureUnit.ReadNumber()}]胎压单位", value.TyrePressureUnit); + value.NormalFetalPressure = reader.ReadUInt16(); + writer.WriteNumber($"[{value.NormalFetalPressure.ReadNumber()}]正常胎压值", value.NormalFetalPressure); + value.ThresholdUnbalancedTirePressure = reader.ReadUInt16(); + writer.WriteNumber($"[{value.ThresholdUnbalancedTirePressure.ReadNumber()}]胎压不平衡门限", value.ThresholdUnbalancedTirePressure); + value.SlowLeakageThreshold = reader.ReadUInt16(); + writer.WriteNumber($"[{value.SlowLeakageThreshold.ReadNumber()}]慢漏气门限", value.SlowLeakageThreshold); + value.LowVoltageThreshold = reader.ReadUInt16(); + writer.WriteNumber($"[{value.LowVoltageThreshold.ReadNumber()}]低压阈值", value.LowVoltageThreshold); + value.HighVoltageThreshold = reader.ReadUInt16(); + writer.WriteNumber($"[{value.HighVoltageThreshold.ReadNumber()}]高压阈值", value.HighVoltageThreshold); + value.HighTemperatureThreshold = reader.ReadUInt16(); + writer.WriteNumber($"[{value.HighTemperatureThreshold.ReadNumber()}]高温阈值", value.HighTemperatureThreshold); + value.VoltageThreshold = reader.ReadUInt16(); + writer.WriteNumber($"[{value.VoltageThreshold.ReadNumber()}]电压阈值", value.VoltageThreshold); + value.TimedReportingInterval = reader.ReadUInt16(); + writer.WriteNumber($"[{value.TimedReportingInterval.ReadNumber()}]定时上报时间间隔", value.TimedReportingInterval); + value.Retain = reader.ReadArray(reader.ReadCurrentRemainContentLength()).ToArray(); + writer.WriteString("保留项", value.Retain.ToHexString()); + } + /// + /// + /// + /// + /// + /// + public JT808_0x8103_0xF366 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) + { + JT808_0x8103_0xF366 value = new JT808_0x8103_0xF366(); + value.ParamId = reader.ReadUInt32(); + value.ParamLength = reader.ReadByte(); + value.TyreSpecificationType = reader.ReadString(12); + value.TyrePressureUnit = reader.ReadUInt16(); + value.NormalFetalPressure = reader.ReadUInt16(); + value.ThresholdUnbalancedTirePressure = reader.ReadUInt16(); + value.SlowLeakageThreshold = reader.ReadUInt16(); + value.LowVoltageThreshold = reader.ReadUInt16(); + value.HighVoltageThreshold = reader.ReadUInt16(); + value.HighTemperatureThreshold = reader.ReadUInt16(); + value.VoltageThreshold = reader.ReadUInt16(); + value.TimedReportingInterval = reader.ReadUInt16(); + value.Retain = reader.ReadArray(reader.ReadCurrentRemainContentLength()).ToArray(); + return value; + } + /// + /// + /// + /// + /// + /// + public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0xF366 value, IJT808Config config) + { + writer.WriteUInt32(value.ParamId); + writer.Skip(1, out int ParamLengthPosition); + writer.WriteString(value.TyreSpecificationType); + writer.WriteUInt16(value.TyrePressureUnit); + writer.WriteUInt16(value.NormalFetalPressure); + writer.WriteUInt16(value.ThresholdUnbalancedTirePressure); + writer.WriteUInt16(value.SlowLeakageThreshold); + writer.WriteUInt16(value.LowVoltageThreshold); + writer.WriteUInt16(value.HighVoltageThreshold); + writer.WriteUInt16(value.HighTemperatureThreshold); + writer.WriteUInt16(value.VoltageThreshold); + writer.WriteUInt16(value.TimedReportingInterval); + writer.WriteArray(value.Retain); + writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - ParamLengthPosition - 1), ParamLengthPosition); + } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x8103_0xF367.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x8103_0xF367.cs new file mode 100644 index 0000000..4d1afcb --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x8103_0xF367.cs @@ -0,0 +1,77 @@ +using JT808.Protocol.Formatters; +using JT808.Protocol.Interfaces; +using JT808.Protocol.MessageBody; +using JT808.Protocol.MessagePack; +using System.Text.Json; + +namespace JT808.Protocol.Extensions.YueBiao.MessageBody +{ + /// + /// 盲区监测系统参数 + /// + public class JT808_0x8103_0xF367 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter, IJT808Analyze + { + /// + /// 盲区监测系统参数Id + /// + public override uint ParamId { get; set; } = JT808_YueBiao_Constants.JT808_0X8103_0xF367; + /// + /// 盲区监测系统参数长度 + /// + public override byte ParamLength { get; set; } = 2; + /// + /// 后方接近报警时间阈值 + /// + public byte RearApproachAlarmTimeThreshold { get; set; } + /// + /// 侧后方接近报警时间阈值 + /// + public byte LateralRearApproachAlarmTimeThreshold { get; set; } + /// + /// + /// + /// + /// + /// + public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) + { + JT808_0x8103_0xF367 value = new JT808_0x8103_0xF367(); + value.ParamId = reader.ReadUInt32(); + value.ParamLength = reader.ReadByte(); + writer.WriteNumber($"[{ value.ParamId.ReadNumber()}]参数ID", value.ParamId); + writer.WriteNumber($"[{value.ParamLength.ReadNumber()}]参数长度", value.ParamLength); + value.RearApproachAlarmTimeThreshold = reader.ReadByte(); + writer.WriteNumber($"[{value.RearApproachAlarmTimeThreshold.ReadNumber()}]后方接近报警时间阈值", value.RearApproachAlarmTimeThreshold); + value.LateralRearApproachAlarmTimeThreshold = reader.ReadByte(); + writer.WriteNumber($"[{value.LateralRearApproachAlarmTimeThreshold.ReadNumber()}]侧后方接近报警时间阈值", value.LateralRearApproachAlarmTimeThreshold); + } + /// + /// + /// + /// + /// + /// + public JT808_0x8103_0xF367 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) + { + JT808_0x8103_0xF367 value = new JT808_0x8103_0xF367(); + value.ParamId = reader.ReadUInt32(); + value.ParamLength = reader.ReadByte(); + value.RearApproachAlarmTimeThreshold = reader.ReadByte(); + value.LateralRearApproachAlarmTimeThreshold = reader.ReadByte(); + return value; + } + /// + /// + /// + /// + /// + /// + public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0xF367 value, IJT808Config config) + { + writer.WriteUInt32(value.ParamId); + writer.WriteByte(2); + writer.WriteByte(value.RearApproachAlarmTimeThreshold); + writer.WriteByte(value.LateralRearApproachAlarmTimeThreshold); + } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x8900_0xF7.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x8900_0xF7.cs new file mode 100644 index 0000000..5627e69 --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x8900_0xF7.cs @@ -0,0 +1,90 @@ +using JT808.Protocol.Formatters; +using JT808.Protocol.Interfaces; +using JT808.Protocol.MessageBody; +using JT808.Protocol.MessagePack; +using System.Collections.Generic; +using System.Text.Json; + +namespace JT808.Protocol.Extensions.YueBiao.MessageBody +{ + /// + /// 状态查询 + /// + public class JT808_0x8900_0xF7 : JT808_0x8900_BodyBase, IJT808MessagePackFormatter, IJT808Analyze + { + /// + /// 查询基本信息类型 + /// 外设状态信息：外设工作状态、设备报警信息 + /// + public override byte PassthroughType { get; set; } = JT808_YueBiao_Constants.JT808_0X0900_0xF7; + /// + /// 外设ID列表总数 + /// + public byte USBCount { get; set; } + /// + /// 外设ID + /// + public List MultipleUSB { get; set; } + /// + /// + /// + /// + /// + /// + public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) + { + JT808_0x8900_0xF7 value = new JT808_0x8900_0xF7(); + value.USBCount = reader.ReadByte(); + writer.WriteNumber($"[{value.USBCount.ReadNumber()}]外设ID列表总数", value.USBCount); + if (value.USBCount > 0) + { + writer.WriteStartArray("外设ID列表"); + for (int i = 0; i < value.USBCount; i++) + { + writer.WriteStartObject(); + byte usbId = reader.ReadByte(); + writer.WriteNumber($"[{usbId.ReadNumber()}]外设ID", usbId); + writer.WriteEndObject(); + } + writer.WriteEndArray(); + } + } + /// + /// + /// + /// + /// + /// + public JT808_0x8900_0xF7 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) + { + JT808_0x8900_0xF7 value = new JT808_0x8900_0xF7(); + value.USBCount = reader.ReadByte(); + if (value.USBCount > 0) + { + value.MultipleUSB = new List(); + for (int i = 0; i < value.USBCount; i++) + { + value.MultipleUSB.Add(reader.ReadByte()); + } + } + return value; + } + /// + /// + /// + /// + /// + /// + public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8900_0xF7 value, IJT808Config config) + { + if (value.MultipleUSB != null && value.MultipleUSB.Count > 0) + { + writer.WriteByte((byte)value.MultipleUSB.Count); + foreach (var item in value.MultipleUSB) + { + writer.WriteByte(item); + } + } + } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x8900_0xF8.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x8900_0xF8.cs new file mode 100644 index 0000000..1fea038 --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x8900_0xF8.cs @@ -0,0 +1,90 @@ +using JT808.Protocol.Formatters; +using JT808.Protocol.Interfaces; +using JT808.Protocol.MessageBody; +using JT808.Protocol.MessagePack; +using System.Collections.Generic; +using System.Text.Json; + +namespace JT808.Protocol.Extensions.YueBiao.MessageBody +{ + /// + /// 信息查询 + /// + public class JT808_0x8900_0xF8 : JT808_0x8900_BodyBase, IJT808MessagePackFormatter, IJT808Analyze + { + /// + /// 查询基本信息透传类型 + /// 外设传感器的基本信息：公司信息、 产品代码、 版本号、 外设 ID、 客户代码。对应的消息内容见表 + /// + public override byte PassthroughType { get; set; } = JT808_YueBiao_Constants.JT808_0X0900_0xF8; + /// + /// 外设ID列表总数 + /// + public byte USBCount { get; set; } + /// + /// 外设ID + /// + public List MultipleUSB { get; set; } + /// + /// + /// + /// + /// + /// + public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) + { + JT808_0x8900_0xF8 value = new JT808_0x8900_0xF8(); + value.USBCount = reader.ReadByte(); + writer.WriteNumber($"[{value.USBCount.ReadNumber()}]外设ID列表总数", value.USBCount); + if (value.USBCount > 0) + { + writer.WriteStartArray("外设ID列表"); + for (int i = 0; i < value.USBCount; i++) + { + writer.WriteStartObject(); + byte usbId = reader.ReadByte(); + writer.WriteNumber($"[{usbId.ReadNumber()}]外设ID", usbId); + writer.WriteEndObject(); + } + writer.WriteEndArray(); + } + } + /// + /// + /// + /// + /// + /// + public JT808_0x8900_0xF8 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) + { + JT808_0x8900_0xF8 value = new JT808_0x8900_0xF8(); + value.USBCount = reader.ReadByte(); + if (value.USBCount > 0) + { + value.MultipleUSB = new List(); + for (int i = 0; i < value.USBCount; i++) + { + value.MultipleUSB.Add(reader.ReadByte()); + } + } + return value; + } + /// + /// + /// + /// + /// + /// + public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8900_0xF8 value, IJT808Config config) + { + if (value.MultipleUSB != null && value.MultipleUSB.Count > 0) + { + writer.WriteByte((byte)value.MultipleUSB.Count); + foreach (var item in value.MultipleUSB) + { + writer.WriteByte(item); + } + } + } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x9208.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x9208.cs new file mode 100644 index 0000000..1dfd08a --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x9208.cs @@ -0,0 +1,143 @@ +using JT808.Protocol.Extensions.YueBiao.Metadata; +using JT808.Protocol.Formatters; +using JT808.Protocol.Interfaces; +using JT808.Protocol.MessagePack; +using System; +using System.Text.Json; + +namespace JT808.Protocol.Extensions.YueBiao.MessageBody +{ + /// + /// 报警附件上传指令 + /// + public class JT808_0x9208: JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze + { + /// + /// Description + /// + public override string Description => "报警附件上传指令"; + /// + /// 服务IP地址长度 + /// + public byte AttachmentServerIPLength { get; set; } + /// + /// 服务IP地址 + /// + public string AttachmentServerIP { get; set; } + /// + /// TCP端口 + /// + public ushort AttachmentServerIPTcpPort { get; set; } + /// + /// UDP端口 + /// + public ushort AttachmentServerIPUdpPort { get; set; } + /// + /// 报警标识号 + /// + public AlarmIdentificationProperty AlarmIdentification { get; set; } + /// + /// 平台给报警分配的唯一编号 + /// 32 + /// + public string AlarmId { get; set; } + /// + /// 预留 + /// + public byte[] Retain { get; set; } = new byte[16]; + /// + /// 报警附件上传指令Id + /// + public override ushort MsgId => 0x9208; + /// + /// + /// + /// + /// + /// + public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) + { + JT808_0x9208 value = new JT808_0x9208(); + value.AttachmentServerIPLength = reader.ReadByte(); + writer.WriteNumber($"[{value.AttachmentServerIPLength.ReadNumber()}]服务IP地址长度", value.AttachmentServerIPLength); + string attachmentServerIPHex = reader.ReadVirtualArray(value.AttachmentServerIPLength).ToArray().ToHexString(); + value.AttachmentServerIP = reader.ReadString(value.AttachmentServerIPLength); + writer.WriteString($"[{AttachmentServerIP}]服务IP地址", value.AttachmentServerIP); + value.AttachmentServerIPTcpPort = reader.ReadUInt16(); + writer.WriteNumber($"[{value.AttachmentServerIPTcpPort.ReadNumber()}]TCP端口", value.AttachmentServerIPTcpPort); + value.AttachmentServerIPUdpPort = reader.ReadUInt16(); + writer.WriteNumber($"[{value.AttachmentServerIPUdpPort.ReadNumber()}]UDP端口", value.AttachmentServerIPUdpPort); + value.AlarmIdentification = new AlarmIdentificationProperty(); + string terminalIdHex = reader.ReadVirtualArray(30).ToArray().ToHexString(); + value.AlarmIdentification.TerminalId = reader.ReadString(30); + value.AlarmIdentification.Time = reader.ReadDateTime6(); + value.AlarmIdentification.SN = reader.ReadByte(); + value.AlarmIdentification.AttachCount = reader.ReadByte(); + value.AlarmIdentification.Retain1 = reader.ReadByte(); + value.AlarmIdentification.Retain2 = reader.ReadByte(); + writer.WriteString($"[{terminalIdHex}]终端ID", value.AlarmIdentification.TerminalId); + writer.WriteString($"[{value.AlarmIdentification.Time.ToString("yyMMddHHmmss")}]日期时间", value.AlarmIdentification.Time.ToString("yyyy-MM-dd HH:mm:ss")); + writer.WriteNumber($"[{value.AlarmIdentification.SN.ReadNumber()}]序号", value.AlarmIdentification.SN); + writer.WriteNumber($"[{value.AlarmIdentification.AttachCount.ReadNumber()}]附件数量", value.AlarmIdentification.AttachCount); + writer.WriteNumber($"[{value.AlarmIdentification.Retain1.ReadNumber()}]预留1", value.AlarmIdentification.Retain1); + writer.WriteNumber($"[{value.AlarmIdentification.Retain2.ReadNumber()}]预留2", value.AlarmIdentification.Retain2); + string alarmIdHex = reader.ReadVirtualArray(32).ToArray().ToHexString(); + value.AlarmId = reader.ReadString(32); + writer.WriteString($"[{alarmIdHex}]平台给报警分配的唯一编号", value.AlarmId); + string retainHex = reader.ReadVirtualArray(16).ToArray().ToHexString(); + writer.WriteString($"预留", retainHex); + } + /// + /// + /// + /// + /// + /// + public JT808_0x9208 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) + { + JT808_0x9208 value = new JT808_0x9208(); + value.AttachmentServerIPLength = reader.ReadByte(); + value.AttachmentServerIP = reader.ReadString(value.AttachmentServerIPLength); + value.AttachmentServerIPTcpPort = reader.ReadUInt16(); + value.AttachmentServerIPUdpPort = reader.ReadUInt16(); + value.AlarmIdentification = new AlarmIdentificationProperty + { + TerminalId = reader.ReadString(30), + Time = reader.ReadDateTime6(), + SN = reader.ReadByte(), + AttachCount = reader.ReadByte(), + Retain1 = reader.ReadByte(), + Retain2 = reader.ReadByte() + }; + value.AlarmId = reader.ReadString(32); + value.Retain = reader.ReadArray(16).ToArray(); + return value; + } + /// + /// + /// + /// + /// + /// + public void Serialize(ref JT808MessagePackWriter writer, JT808_0x9208 value, IJT808Config config) + { + writer.Skip(1, out int AttachmentServerIPLengthPosition); + writer.WriteString(value.AttachmentServerIP); + writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - AttachmentServerIPLengthPosition - 1), AttachmentServerIPLengthPosition); + writer.WriteUInt16(value.AttachmentServerIPTcpPort); + writer.WriteUInt16(value.AttachmentServerIPUdpPort); + if (value.AlarmIdentification == null) + { + throw new NullReferenceException($"{nameof(AlarmIdentificationProperty)}不为空"); + } + writer.WriteString(value.AlarmIdentification.TerminalId.PadRight(30, '\0')); + writer.WriteDateTime6(value.AlarmIdentification.Time); + writer.WriteByte(value.AlarmIdentification.SN); + writer.WriteByte(value.AlarmIdentification.AttachCount); + writer.WriteByte(value.AlarmIdentification.Retain1); + writer.WriteByte(value.AlarmIdentification.Retain2); + writer.WriteString(value.AlarmId); + writer.WriteArray(value.Retain); + } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x9212.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x9212.cs new file mode 100644 index 0000000..0e4bf41 --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/MessageBody/JT808_0x9212.cs @@ -0,0 +1,139 @@ +using JT808.Protocol.Extensions.YueBiao.Metadata; +using JT808.Protocol.Formatters; +using JT808.Protocol.Interfaces; +using JT808.Protocol.MessagePack; +using System.Collections.Generic; +using System.Text.Json; + +namespace JT808.Protocol.Extensions.YueBiao.MessageBody +{ + /// + /// 文件上传完成消息应答 + /// + public class JT808_0x9212: JT808Bodies, IJT808MessagePackFormatter, IJT808Analyze + { + /// + /// 文件上传完成消息应答 + /// + public override string Description => "文件上传完成消息应答"; + /// + /// 文件名称长度 + /// + public byte FileNameLength { get; set; } + /// + /// 文件名称 + /// + public string FileName { get; set; } + /// + /// 文件类型 + /// + public byte FileType { get; set; } + /// + /// 上传结果 + /// + public byte UploadResult { get; set; } + /// + /// 补传数据包数量 + /// 需要补传的数据包数量，无补传时该值为0 + /// + public byte DataPackageCount { get; set; } + /// + /// 补传数据包列表 + /// + public List DataPackages { get; set; } + /// + /// 文件上传完成消息应答Id + /// + public override ushort MsgId => 0x9212; + /// + /// + /// + /// + /// + /// + public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config) + { + JT808_0x9212 value = new JT808_0x9212(); + value.FileNameLength = reader.ReadByte(); + writer.WriteNumber($"[{value.FileNameLength.ReadNumber()}]文件名称长度", value.FileNameLength); + string fileNameHex = reader.ReadVirtualArray(value.FileNameLength).ToArray().ToHexString(); + value.FileName = reader.ReadString(value.FileNameLength); + writer.WriteString($"[{fileNameHex}]文件名称", value.FileName); + value.FileType = reader.ReadByte(); + writer.WriteNumber($"[{value.FileType.ReadNumber()}]文件类型", value.FileType); + value.UploadResult = reader.ReadByte(); + writer.WriteNumber($"[{value.UploadResult.ReadNumber()}]上传结果", value.UploadResult); + value.DataPackageCount = reader.ReadByte(); + writer.WriteNumber($"[{value.DataPackageCount.ReadNumber()}]补传数据包数量", value.DataPackageCount); + if (value.DataPackageCount > 0) + { + writer.WriteStartArray("补传数据包列表"); + for (int i = 0; i < value.DataPackageCount; i++) + { + writer.WriteStartObject(); + DataPackageProperty dataPackageProperty = new DataPackageProperty(); + dataPackageProperty.Offset = reader.ReadUInt32(); + writer.WriteNumber($"[{dataPackageProperty.Offset.ReadNumber()}]数据偏移量", dataPackageProperty.Offset); + dataPackageProperty.Length = reader.ReadUInt32(); + writer.WriteNumber($"[{dataPackageProperty.Length.ReadNumber()}]数据长度", dataPackageProperty.Length); + writer.WriteEndObject(); + } + writer.WriteEndArray(); + } + } + /// + /// + /// + /// + /// + /// + public JT808_0x9212 Deserialize(ref JT808MessagePackReader reader, IJT808Config config) + { + JT808_0x9212 value = new JT808_0x9212(); + value.FileNameLength = reader.ReadByte(); + value.FileName = reader.ReadString(value.FileNameLength); + value.FileType = reader.ReadByte(); + value.UploadResult = reader.ReadByte(); + value.DataPackageCount = reader.ReadByte(); + if (value.DataPackageCount > 0) + { + value.DataPackages = new List(); + for (int i = 0; i < value.DataPackageCount; i++) + { + DataPackageProperty dataPackageProperty = new DataPackageProperty(); + dataPackageProperty.Offset = reader.ReadUInt32(); + dataPackageProperty.Length = reader.ReadUInt32(); + value.DataPackages.Add(dataPackageProperty); + } + } + return value; + } + /// + /// + /// + /// + /// + /// + public void Serialize(ref JT808MessagePackWriter writer, JT808_0x9212 value, IJT808Config config) + { + writer.Skip(1, out int FileNameLengthPosition); + writer.WriteString(value.FileName); + writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - FileNameLengthPosition - 1), FileNameLengthPosition); + writer.WriteByte(value.FileType); + writer.WriteByte(value.UploadResult); + if (value.DataPackages != null && value.DataPackages.Count > 0) + { + writer.WriteByte((byte)value.DataPackages.Count); + foreach (var item in value.DataPackages) + { + writer.WriteUInt32(item.Offset); + writer.WriteUInt32(item.Length); + } + } + else + { + writer.WriteByte(0); + } + } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Metadata/AlarmIdentificationProperty.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Metadata/AlarmIdentificationProperty.cs new file mode 100644 index 0000000..bb07ceb --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Metadata/AlarmIdentificationProperty.cs @@ -0,0 +1,40 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace JT808.Protocol.Extensions.YueBiao.Metadata +{ + /// + /// 报警标识号 + /// 报警附件信息消息数据格式 + /// + public class AlarmIdentificationProperty + { + /// + /// 终端ID + /// 30 + /// + public string TerminalId { get; set; } + /// + /// YY-MM-DD-hh-mm-ss + /// BCD[6] + /// + public DateTime Time { get; set; } + /// + /// 序号 + /// + public byte SN { get; set; } + /// + /// 附件数量 + /// + public byte AttachCount { get; set; } + /// + /// 预留1 + /// + public byte Retain1 { get; set; } + /// + /// 预留2 + /// + public byte Retain2 { get; set; } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Metadata/AlarmOrEventProperty.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Metadata/AlarmOrEventProperty.cs new file mode 100644 index 0000000..b5d4ce1 --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Metadata/AlarmOrEventProperty.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace JT808.Protocol.Extensions.YueBiao.Metadata +{ + /// + /// 胎压监测系统报警/事件信息 + /// + public class AlarmOrEventProperty + { + /// + /// 胎压报警位置 + /// + public byte TirePressureAlarmPosition { get; set; } + /// + /// 报警/事件类型 + /// + public ushort AlarmOrEventType { get; set; } + /// + /// 胎压 + /// + public ushort TirePressure { get; set; } + /// + /// 胎温 + /// + public ushort TireTemperature { get; set; } + /// + /// 电池电量 + /// + public ushort BatteryLevel { get; set; } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Metadata/AttachProperty.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Metadata/AttachProperty.cs new file mode 100644 index 0000000..d7b3bec --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Metadata/AttachProperty.cs @@ -0,0 +1,26 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace JT808.Protocol.Extensions.YueBiao.Metadata +{ + /// + /// 附件信息 + /// + public class AttachProperty + { + /// + /// 文件名称长度 + /// + public byte FileNameLength { get; set; } + /// + /// 文件名称 + /// 形如：文件类型_通道号_报警类型_序号_报警编号.后缀名 + /// + public string FileName{ get; set; } + /// + /// 文件大小 + /// + public uint FileSize { get; set; } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Metadata/DataPackageProperty.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Metadata/DataPackageProperty.cs new file mode 100644 index 0000000..4ad2820 --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Metadata/DataPackageProperty.cs @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace JT808.Protocol.Extensions.YueBiao.Metadata +{ + /// + /// 补传数据包信息 + /// + public class DataPackageProperty + { + /// + /// 数据偏移量 + /// + public uint Offset { get; set; } + /// + /// 数据长度 + /// + public uint Length { get; set; } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Metadata/JT808_0x0900_0xF7_USB.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Metadata/JT808_0x0900_0xF7_USB.cs new file mode 100644 index 0000000..9661b6b --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Metadata/JT808_0x0900_0xF7_USB.cs @@ -0,0 +1,31 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace JT808.Protocol.Extensions.YueBiao.Metadata +{ + /// + /// + /// + public class JT808_0x0900_0xF7_USB + { + /// + /// 外设ID + /// + /// + public byte USBID { get; set; } + /// + /// 消息长度 + /// + public byte MessageLength { get; set; } + /// + /// 工作状态 + /// + /// + public byte WorkingCondition { get; set; } + /// + /// 报警状态 + /// + public uint AlarmStatus { get; set; } + } +} diff --git a/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Metadata/JT808_0x0900_0xF8_USB.cs b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Metadata/JT808_0x0900_0xF8_USB.cs new file mode 100644 index 0000000..703a378 --- /dev/null +++ b/src/JT808.Protocol.Extensions/JT808.Protocol.Extensions.YueBiao/Metadata/JT808_0x0900_0xF8_USB.cs @@ -0,0 +1,72 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace JT808.Protocol.Extensions.YueBiao.Metadata +{ + /// + /// + /// + public class JT808_0x0900_0xF8_USB + { + /// + /// 外设ID + /// + /// + public byte USBID { get; set; } + /// + /// 消息长度 + /// + public byte MessageLength { get; set; } + /// + /// 公司名称长度 + /// + public byte CompantNameLength { get; set; } + /// + /// 公司名称 + /// + public string CompantName { get; set; } + /// + /// 产品型号长度 + /// + public byte ProductModelLength { get; set; } + /// + /// 产品型号 + /// + public string ProductModel { get; set; } + /// + /// 硬件版本号长度 + /// + public byte HardwareVersionNumberLength { get; set; } + /// + /// 硬件版本号 + /// ASCII + /// + public string HardwareVersionNumber { get; set; } + /// + /// 软件版本号长度 + /// + public byte SoftwareVersionNumberLength { get; set; } + /// + /// 软件版本号 + /// ASCII + /// + public string SoftwareVersionNumber { get; set; } + /// + /// 设备ID长度 + /// + public byte DevicesIDLength { get; set; } + /// + /// 设备ID + /// + public string DevicesID { get; set; } + /// + /// 客户代码长度 + /// + public byte CustomerCodeLength { get; set; } + /// + /// 客户代码 + /// + public string CustomerCode { get; set; } + } +} diff --git a/src/JT808.Protocol/JT808.Protocol.xml b/src/JT808.Protocol/JT808.Protocol.xml index 9d70f32..73cd840 100644 --- a/src/JT808.Protocol/JT808.Protocol.xml +++ b/src/JT808.Protocol/JT808.Protocol.xml @@ -9726,6 +9726,13 @@ 附加信息长度 + + + 附加信息长度扩展 + 4个字节 + 注意：只适用于已知的协议才行 + + 自定义位置附加信息 diff --git a/src/JT808.Protocol/MessageBody/JT808_0x0200_BodyBase.cs b/src/JT808.Protocol/MessageBody/JT808_0x0200_BodyBase.cs index c33f307..0980e62 100644 --- a/src/JT808.Protocol/MessageBody/JT808_0x0200_BodyBase.cs +++ b/src/JT808.Protocol/MessageBody/JT808_0x0200_BodyBase.cs @@ -17,5 +17,11 @@ namespace JT808.Protocol.MessageBody /// 附加信息长度 /// public abstract byte AttachInfoLength { get; set; } + /// + /// 附加信息长度扩展 + /// 4个字节 + /// 注意：只适用于已知的协议才行 + /// + public virtual uint AttachInfoLengthExtend { get; set; } } }