yangyakun921/MoGoEagleEye
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[8.1.0][adas] 鄂州NDE接口（13个场景）

Browse Source
This commit is contained in:
xinfengkun
2025-05-28 15:21:13 +08:00
parent 1ad3dbebf2
commit 092d248d64
42 changed files with 5018 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/common/MessageType.java
View File

@@ -97,6 +97,7 @@ public enum MessageType {
TYPE_SEND_SSM_FUNC_STATUS_QUERY(MessagePad.MessageType.MsgTypeSSMFuncStatusQuery, "SSM功能状态查询"),
TYPE_RECEIVE_SSM_FUNC_STATUS_QUERY(MessagePad.MessageType.MsgTypeSSMFuncStatusQuery, "SSM功能状态响应"),
TYPE_SEND_CAPTURE_IMG_REQ_ON_TAKE_OVER(MessagePad.MessageType.MsgTypeCaptureImgReqOnTakeOver, "接管时摄像头数据请求"),
TYPE_RECEIVE_CLOUD_CONTROL(MessagePad.MessageType.MsgTypeEzhouCloud, "云控数据"),
TYPE_SEND_COPY_BAG(MessagePad.MessageType.MsgTypeCopyBag, "数据落盘控制"),
TYPE_RECEIVE_COPY_BAG(MessagePad.MessageType.MsgTypeCopyBag, "数据落盘响应"),
TYPE_SEND_CLOUD_CONFIG(MessagePad.MessageType.MsgTypeCloudConfig, "云端配置查询"),

59
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/common/cloud/AdviceComRsiEventSource.java Normal file
View File

@@ -0,0 +1,59 @@
package com.zhjt.mogo.adas.common.cloud;
import androidx.annotation.NonNull;
/**
* 实时决策建议 控车变道建议转向状态
* 出口定义从当前道路逆时针算起
*/
public enum AdviceComRsiEventSource {
ERROR(-1, "异常"),
UNDEFINED(255, "缺省"),
UNKNOWN(0, "未知来源"),
TRAFFIC_POLICE(1, "交管部门"),
GOVERNMENT(2, "其他政府部门"),
METEOROLOGY(3, "气象部门"),
INTERNET(4, "互联网"),
SENSING(5, "路侧或云端感知"),
OTHER(6, "其他来源"),
;
public final int type;
/**
* 描述
*/
public final String desc;
private int errorRealType;//当异常时真实的type
public static final AdviceComRsiEventSource[] ALL = values();
AdviceComRsiEventSource(int type, String desc) {
this.type = type;
this.desc = desc;
}
public int getErrorRealType() {
return errorRealType;
}
public static AdviceComRsiEventSource getType(int type) {
for (AdviceComRsiEventSource tem : ALL) {
if (type == tem.type) {
return tem;
}
}
ERROR.errorRealType = type;
return ERROR;
}
@NonNull
@Override
public String toString() {
if (type == -1) {
return desc + "(" + errorRealType + ")";
} else {
return desc + "(" + type + ")";
}
}
}

53
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/common/cloud/AdviceEventType.java Normal file
View File

@@ -0,0 +1,53 @@
package com.zhjt.mogo.adas.common.cloud;
import androidx.annotation.NonNull;
/**
* 实时决策建议 事件分类
*/
public enum AdviceEventType {
ERROR(-1, "异常"),
UNKNOWN(0, "未知类型"),
TRAFFIC_EVENT(1, "道路交通事件"),
TRAFFIC_SIGN(2, "道路交通标志"),
CLOUD_DECISION(3, "云端决策建议"),
;
public final int type;
/**
* 描述
*/
public final String desc;
private int errorRealType;//当异常时真实的type
public static final AdviceEventType[] ALL = values();
AdviceEventType(int type, String desc) {
this.type = type;
this.desc = desc;
}
public int getErrorRealType() {
return errorRealType;
}
public static AdviceEventType getType(int type) {
for (AdviceEventType tem : ALL) {
if (type == tem.type) {
return tem;
}
}
ERROR.errorRealType = type;
return ERROR;
}
@NonNull
@Override
public String toString() {
if (type == -1) {
return desc + "(" + errorRealType + ")";
} else {
return desc + "(" + type + ")";
}
}
}

67
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/common/cloud/AdviceEvwType.java Normal file
View File

@@ -0,0 +1,67 @@
package com.zhjt.mogo.adas.common.cloud;
import androidx.annotation.NonNull;
/**
* 实时决策建议 紧急车辆预警指令 车辆类型
*/
public enum AdviceEvwType {
ERROR(-1, "异常"),
RESERVED(-2, "预留"),
UNDEFINED(255, "缺省"),
INVALID(0, "失效"),
AMBULANCE(1, "救护车"),
POLICE_CAR(2, "警车"),
FIRE_TRUCK(3, "消防车"),
;
public final int type;
/**
* 描述
*/
public final String desc;
private int errorRealType;//当异常时真实的type
private int reservedRealType;//当异预留真实的type
public static final AdviceEvwType[] ALL = values();
AdviceEvwType(int type, String desc) {
this.type = type;
this.desc = desc;
}
public int getErrorRealType() {
return errorRealType;
}
public int getReservedRealType() {
return reservedRealType;
}
public static AdviceEvwType getType(int type) {
if (type >= 4 && type <= 10) {
RESERVED.reservedRealType = type;
return RESERVED;
}
for (AdviceEvwType tem : ALL) {
if (type == tem.type) {
return tem;
}
}
ERROR.errorRealType = type;
return ERROR;
}
@NonNull
@Override
public String toString() {
if (type == -1) {
return desc + "(" + errorRealType + ")";
} else if (type == -2) {
return desc + "(" + reservedRealType + ")";
} else {
return desc + "(" + type + ")";
}
}
}

55
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/common/cloud/AdviceGlosaSpdExpManeuver.java Normal file
View File

@@ -0,0 +1,55 @@
package com.zhjt.mogo.adas.common.cloud;
import androidx.annotation.NonNull;
/**
* 实时决策建议 信号灯路口车速引导功能指令 车道方向建议速度 通行行为
*/
public enum AdviceGlosaSpdExpManeuver {
UNKNOWN(-1, "未知"),
UNDEFINED(255, "缺省"),
STRAIGHT(0, "直行"),
LEFT(1, "左转"),
RIGHT(3, "右转"),
U_TURN(4, "掉头"),
;
public final int type;
/**
* 描述
*/
public final String desc;
private int unknownRealType;//当未知时真实的type
public static final AdviceGlosaSpdExpManeuver[] ALL = values();
AdviceGlosaSpdExpManeuver(int type, String desc) {
this.type = type;
this.desc = desc;
}
public int getUnknownRealType() {
return unknownRealType;
}
public static AdviceGlosaSpdExpManeuver getType(int type) {
for (AdviceGlosaSpdExpManeuver tem : ALL) {
if (type == tem.type) {
return tem;
}
}
UNKNOWN.unknownRealType = type;
return UNKNOWN;
}
@NonNull
@Override
public String toString() {
if (type == -1) {
return desc + "(" + unknownRealType + ")";
} else {
return desc + "(" + type + ")";
}
}
}

53
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/common/cloud/AdviceGlosaType.java Normal file
View File

@@ -0,0 +1,53 @@
package com.zhjt.mogo.adas.common.cloud;
import androidx.annotation.NonNull;
/**
* 实时决策建议 信号灯路口车速引导功能指令 命令标识
*/
public enum AdviceGlosaType {
ERROR(-1, "异常"),
INVALID(0, "失效"),
GUIDE(1, "引导"),
PARK(2, "停车指令"),
START(3, "启动指令"),
;
public final int type;
/**
* 描述
*/
public final String desc;
private int errorRealType;//当异常时真实的type
public static final AdviceGlosaType[] ALL = values();
AdviceGlosaType(int type, String desc) {
this.type = type;
this.desc = desc;
}
public int getErrorRealType() {
return errorRealType;
}
public static AdviceGlosaType getType(int type) {
for (AdviceGlosaType tem : ALL) {
if (type == tem.type) {
return tem;
}
}
ERROR.errorRealType = type;
return ERROR;
}
@NonNull
@Override
public String toString() {
if (type == -1) {
return desc + "(" + errorRealType + ")";
} else {
return desc + "(" + type + ")";
}
}
}

63
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/common/cloud/AdviceInstructDirection.java Normal file
View File

@@ -0,0 +1,63 @@
package com.zhjt.mogo.adas.common.cloud;
import androidx.annotation.NonNull;
/**
* 实时决策建议 控车变道建议转向状态
* 出口定义从当前道路逆时针算起
*/
public enum AdviceInstructDirection {
ERROR(-1, "异常"),
UNDEFINED(255, "缺省"),
KEEP_LANE(0, "沿车道行驶"),
EXIT_1(1, "第一出口"),
EXIT_2(2, "第二出口"),
EXIT_3(3, "第三出口"),
EXIT_4(4, "第四出口"),
EXIT_5(5, "第五出口"),
EXIT_6(6, "第六出口"),
EXIT_7(7, "第七出口"),
EXIT_8(8, "第八出口"),
CHANGE_LEFT(9, "左变道"),
CHANGE_RIGHT(10, "右变道"),
;
public final int type;
/**
* 描述
*/
public final String desc;
private int errorRealType;//当异常时真实的type
public static final AdviceInstructDirection[] ALL = values();
AdviceInstructDirection(int type, String desc) {
this.type = type;
this.desc = desc;
}
public int getErrorRealType() {
return errorRealType;
}
public static AdviceInstructDirection getType(int type) {
for (AdviceInstructDirection tem : ALL) {
if (type == tem.type) {
return tem;
}
}
ERROR.errorRealType = type;
return ERROR;
}
@NonNull
@Override
public String toString() {
if (type == -1) {
return desc + "(" + errorRealType + ")";
} else {
return desc + "(" + type + ")";
}
}
}

72
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/common/cloud/AdviceType.java Normal file
View File

@@ -0,0 +1,72 @@
package com.zhjt.mogo.adas.common.cloud;
import androidx.annotation.NonNull;
/**
* 实时决策建议 建议类型
*/
public enum AdviceType {
ERROR(-1, "异常"),
CLOUD2VEH_ADVICE_GLOSA(1, "信号灯路口车速引导功能指令"),
VEH2CLOUD_ADVICE_GLOSA_RES(2, "信号灯路口车速引导功能指令返回"),
CLOUD2VEH_ADVICE_NTLAR(3, "无信号灯路口右转功能指令"),
VEH2CLOUD_ADVICE_NTLAR_RES(4, "无信号灯路口右转功能指令返回"),
CLOUD2VEH_ADVICE_LANESPDLMT(5, "动态车道级限速指令"),
VEH2CLOUD_ADVICE_LANESPDLMT_RES(6, "动态车道级限速指令返回"),
CLOUD2VEH_ADVICE_RAMP_INTENT_CHANGE(7, "匝道汇回预警指令"),
VEH2CLOUD_ADVICE_RAMP_INTENT_CHANGE_RES(8, "匝道汇回预警指令返回"),
CLOUD2VEH_ADVICE_FCW(9, "前向碰撞预警指令"),
VEH2CLOUD_ADVICE_FCW_RES(10, "前向碰撞预警返回"),
CLOUD2VEH_ADVICE_AVW(11, "异常车辆预警指令"),
VEH2CLOUD_ADVICE_AVW_RES(12, "异常车辆预警返回"),
CLOUD2VEH_ADVICE_EVW(13, "紧急车辆预警指令"),
VEH2CLOUD_ADVICE_EVW_RES(14, "紧急车辆预警返回"),
CLOUD2VEH_ADVICE_RAMP_ASSIST(15, "匝道辅助指令"),
VEH2CLOUD_ADVICE_RAMP_ASSIST_RES(16, "匝道辅助返回"),
CLOUD2VEH_ADVICE_COM_RSI(17, "通用RSI预警指令"),
VEH2CLOUD_ADVICE_COM_RSI_RES(18, "通用RSI预警返回"),
CLOUD2VEH_ADVICE_GUIDANCE(19, "路线规划指令"),
VEH2CLOUD_ADVICE_GUIDANCE_RES(20, "路线规划返回"),
;
public final int type;
/**
* 描述
*/
public final String desc;
private int errorRealType;//当异常时真实的type
public static final AdviceType[] ALL = values();
AdviceType(int type, String desc) {
this.type = type;
this.desc = desc;
}
public int getErrorRealType() {
return errorRealType;
}
public static AdviceType getType(int type) {
for (AdviceType tem : ALL) {
if (type == tem.type) {
return tem;
}
}
ERROR.errorRealType = type;
return ERROR;
}
@NonNull
@Override
public String toString() {
if (type == -1) {
return desc + "(" + errorRealType + ")";
} else {
return desc + "(" + type + ")";
}
}
}

66
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/common/cloud/AstFuncTlmControlMode.java Normal file
View File

@@ -0,0 +1,66 @@
package com.zhjt.mogo.adas.common.cloud;
import androidx.annotation.NonNull;
/**
* 云端辅助功能 云端下发信号灯信息 红绿灯控制方式
*/
public enum AstFuncTlmControlMode {
ERROR(-1, "异常"),
RESERVED(-2, "预留"),
UNDEFINED(255, "缺省"),
PERIODIC(1, "固定周期"),
MANUAL(2, "手动控制"),
YELLOW_FLASH(3, "黄闪控制"),
;
public final int type;
/**
* 描述
*/
public final String desc;
private int errorRealType;//当异常时真实的type
private int reservedRealType;//当异预留真实的type
public static final AstFuncTlmControlMode[] ALL = values();
AstFuncTlmControlMode(int type, String desc) {
this.type = type;
this.desc = desc;
}
public int getErrorRealType() {
return errorRealType;
}
public int getReservedRealType() {
return reservedRealType;
}
public static AstFuncTlmControlMode getType(int type) {
if (type >= 4 && type <= 254) {
RESERVED.reservedRealType = type;
return RESERVED;
}
for (AstFuncTlmControlMode tem : ALL) {
if (type == tem.type) {
return tem;
}
}
ERROR.errorRealType = type;
return ERROR;
}
@NonNull
@Override
public String toString() {
if (type == -1) {
return desc + "(" + errorRealType + ")";
} else if (type == -2) {
return desc + "(" + reservedRealType + ")";
} else {
return desc + "(" + type + ")";
}
}
}

72
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/common/cloud/AstFuncTlmPhaseStateLightState.java Normal file
View File

@@ -0,0 +1,72 @@
package com.zhjt.mogo.adas.common.cloud;
import androidx.annotation.NonNull;
/**
* 云端辅助功能 云端下发信号灯信息 红绿灯控制方式
*/
public enum AstFuncTlmPhaseStateLightState {
ERROR(-1, "异常"),
RESERVED(-2, "预留"),
UNKNOWN(0, "未知状态"),
OFF(1, "信号灯未工作"),
RED_FLASH(2, "红闪"),
RED(3, "红灯状态"),
GREEN_WAIT(4, "绿灯待行状态"),
GREEN(5, "绿灯状态"),
GREEN_PROTECTED(6, "受保护相位绿灯（箭头灯）"),
YELLOW(7, "黄灯状态"),
YELLOW_FLASH(8, "黄闪"),
FAULT(255, "故障"),
;
public final int type;
/**
* 描述
*/
public final String desc;
private int errorRealType;//当异常时真实的type
private int reservedRealType;//当异预留真实的type
public static final AstFuncTlmPhaseStateLightState[] ALL = values();
AstFuncTlmPhaseStateLightState(int type, String desc) {
this.type = type;
this.desc = desc;
}
public int getErrorRealType() {
return errorRealType;
}
public int getReservedRealType() {
return reservedRealType;
}
public static AstFuncTlmPhaseStateLightState getType(int type) {
if (type >= 9 && type <= 254) {
RESERVED.reservedRealType = type;
return RESERVED;
}
for (AstFuncTlmPhaseStateLightState tem : ALL) {
if (type == tem.type) {
return tem;
}
}
ERROR.errorRealType = type;
return ERROR;
}
@NonNull
@Override
public String toString() {
if (type == -1) {
return desc + "(" + errorRealType + ")";
} else if (type == -2) {
return desc + "(" + reservedRealType + ")";
} else {
return desc + "(" + type + ")";
}
}
}

79
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/common/cloud/AstFuncTlmPhaseStateLightType.java Normal file
View File

@@ -0,0 +1,79 @@
package com.zhjt.mogo.adas.common.cloud;
import androidx.annotation.NonNull;
/**
* 云端辅助功能 云端下发信号灯信息 红绿灯控制方式
*/
public enum AstFuncTlmPhaseStateLightType {
ERROR(-1, "异常"),
RESERVED(-2, "预留"),
STRAIGHT(1, "直行方向指示信号灯"),
LEFT(2, "左转方向指示信号灯"),
RIGHT(3, "右转方向指示信号灯"),
VEHICLE(4, "机动车信号灯"),
NON_MOTOR_LEFT(5, "左转非机动车信号灯"),
NON_MOTOR_RIGHT(6, "右转非机动车信号灯"),
NON_MOTOR(7, "非机动车信号灯"),
PEDESTRIAN(8, "人行横道信号灯"),
U_TURN(9, "掉头信号灯"),
LANE(10, "车道信号灯"),
CROSSING(11, "道口信号灯"),
WARNING_FLASH(12, "闪光警告信号灯"),
TRAM_STRAIGHT(13, "有轨电车专用信号灯（直行）"),
TRAM_LEFT(14, "有轨电车专用信号灯（左转）"),
TRAM_RIGHT(15, "有轨电车专用信号灯（右转）"),
INVALID(255, "无效或未知灯组类型")
;
public final int type;
/**
* 描述
*/
public final String desc;
private int errorRealType;//当异常时真实的type
private int reservedRealType;//当异预留真实的type
public static final AstFuncTlmPhaseStateLightType[] ALL = values();
AstFuncTlmPhaseStateLightType(int type, String desc) {
this.type = type;
this.desc = desc;
}
public int getErrorRealType() {
return errorRealType;
}
public int getReservedRealType() {
return reservedRealType;
}
public static AstFuncTlmPhaseStateLightType getType(int type) {
if (type >= 17 && type <= 254) {
RESERVED.reservedRealType = type;
return RESERVED;
}
for (AstFuncTlmPhaseStateLightType tem : ALL) {
if (type == tem.type) {
return tem;
}
}
ERROR.errorRealType = type;
return ERROR;
}
@NonNull
@Override
public String toString() {
if (type == -1) {
return desc + "(" + errorRealType + ")";
} else if (type == -2) {
return desc + "(" + reservedRealType + ")";
} else {
return desc + "(" + type + ")";
}
}
}

62
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/common/cloud/AstFuncType.java Normal file
View File

@@ -0,0 +1,62 @@
package com.zhjt.mogo.adas.common.cloud;
import androidx.annotation.NonNull;
/**
* 云端辅助功能信息 辅助功能类别
*/
public enum AstFuncType {
ERROR(-1, "异常"),
CLOUD2VEH_ASTFUNC_STREAM_VIDEO(1, "云端请求车辆视频流上传指令"),
VEH2CLOUD_ASTFUNC_STREAM_VIDEO_RES(2, "云端请求车辆视频流上传指令返回"),
CLOUD2VEH_ASTFUNC_HIST_VIDEO(3, "云端请求车辆历史视频上传指令"),
VEH2CLOUD_ASTFUNC_HIST_VIDEO_RES(4, "云端请求车辆历史视频上传指令返回"),
CLOUD2VEH_ASTFUNC_HIST_EDR(5, "云端请求车端上传EDR数据"),
CLOUD2VEH_ASTFUNC_HIST_EDR_RES(6, "云端请求车端上传EDR数据返回"),
CLOUD2VEH_ASTFUNC_TLM(7, "云端下发信号灯信息"),
CLOUD2VEH_ASTFUNC_RTCM(9, "云端下发定位增强信息"),
VEH2CLOUD_ASTFUNC_RTCM_RES(10, "云端下发定位增强信息返回"),
CLOUD2VEH_ASTFUNC_RSM(11, "云端下发实时感知信息"),
;
public final int type;
/**
* 描述
*/
public final String desc;
private int errorRealType;//当异常时真实的type
public static final AstFuncType[] ALL = values();
AstFuncType(int type, String desc) {
this.type = type;
this.desc = desc;
}
public int getErrorRealType() {
return errorRealType;
}
public static AstFuncType getType(int type) {
for (AstFuncType tem : ALL) {
if (type == tem.type) {
return tem;
}
}
ERROR.errorRealType = type;
return ERROR;
}
@NonNull
@Override
public String toString() {
if (type == -1) {
return desc + "(" + errorRealType + ")";
} else {
return desc + "(" + type + ")";
}
}
}

70
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/common/cloud/CloudDataType.java Normal file
View File

@@ -0,0 +1,70 @@
package com.zhjt.mogo.adas.common.cloud;
import androidx.annotation.NonNull;
/**
* 数据传输类型
*/
public enum CloudDataType {
ERROR((byte) 0xFF, "异常"),
HEARTBEAT((byte) 0x0C, "心跳"),
HEARTBEAT_RES((byte) 0x0D, "心跳回应"),
VEH2CLOUD_STATE((byte) 0x15, "车辆运行状态信息"),
CLOUD2VEH_INSTRUCT((byte) 0x1E, "云端实时控制建议"),
CLOUD2VEH_REMOTECTL((byte) 0x1F, "云端远程控制"),
VEH2CLOUD_INH((byte) 0x34, "车辆准静态参数上报"),
CLOUD2VEH_INH_RES((byte) 0x35, "车辆准静态参数上报返回"),
VEH2CLOUD_SUBS((byte) 0x36, "车辆功能订阅信息"),
CLOUD2VEH_SUBS_RES((byte) 0x37, "车辆功能订阅信息返回"),
CLOUD2VEH_ADVICE((byte) 0x3C, "实时决策建议"),
VEH2CLOUD_ADVICE_RES((byte) 0x3D, "实时决策建议返回"),
CLOUD2VEH_ASTFUNC((byte) 0x3E, "辅助功能"),
VEH2CLOUD_ASTFUNC_RES((byte) 0x3F, "辅助功能返回"),
VEH2CLOUD_TEST((byte) 0x5C, "上行自定义功能"),
CLOUD2VEH_TEST_RES((byte) 0x5D, "上行自定义功能返回"),
CLOUD2VEH_TEST((byte) 0x5E, "下行自定义功能"),
VEH2CLOUD_TEST_RES((byte) 0x5D, "下行自定义功能返回"),
VEH2CLOUD_STATE_RESEND((byte) 0x60, "车辆运行状态信息补发"),
CLOUD2VEH_STATE_RESEND_RES((byte) 0x61, "车辆运行状态信息补发返回"),
;
public final byte type;
/**
* 描述
*/
public final String desc;
private byte errorRealType;//当异常时真实的type
public static final CloudDataType[] ALL = values();
CloudDataType(byte type, String desc) {
this.type = type;
this.desc = desc;
}
public byte getErrorRealType() {
return errorRealType;
}
public static CloudDataType getType(byte type) {
for (CloudDataType tem : ALL) {
if (type == tem.type) {
return tem;
}
}
ERROR.errorRealType = type;
return ERROR;
}
@NonNull
@Override
public String toString() {
if (type == (byte) 0xFF) {
return desc + "(" + errorRealType + ")";
} else {
return desc + "(" + type + ")";
}
}
}

62
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/common/cloud/RsiCloudDecisionEventType.java Normal file
View File

@@ -0,0 +1,62 @@
package com.zhjt.mogo.adas.common.cloud;
import androidx.annotation.NonNull;
/**
* 通用RSI预警指令 云端决策 交通事件类型
*/
public enum RsiCloudDecisionEventType {
UNKNOWN(-1, "未知/异常"),
RED_LIGHT_RUNNING_WARNING(6011, "闯红灯预警功能"),
ROAD_HAZARD_ALERT_SERVICE_6021(6021, "道路危险状况提示服务功能"),
ROAD_HAZARD_ALERT_SERVICE_6022(6022, "道路危险状况提示服务功能"),
DRIVING_LANE_SUGGESTION_6031(6031, "行驶车道建议功能"),
DRIVING_LANE_SUGGESTION_6032(6032, "行驶车道建议功能"),
INTERSECTION_RED_LIGHT_WARNING(6041, "路口其他车辆闯红灯预警功能"),
OVER_THE_HORIZON_VULNERABLE_ROAD_USER_WARNING(6051, "超视距弱势交通参与者预警功能"),
TRAFFIC_CONGESTION_ALERT(6061, "交通拥堵提醒功能"),
VISIBILITY_WARNING(6071, "能见度预警功能"),
ROAD_DEBRIS_WARNING(6081, "路面遗撒预警功能"),
RED_LIGHT_TO_GREEN_ALERT(6012, "红灯即将变绿功能"),
GREEN_LIGHT_TO_RED_ALERT(6013, "绿灯即将变红功能"),
;
public final int type;
/**
* 描述
*/
public final String desc;
private int unknownRealType;//当异常时真实的type
public static final RsiCloudDecisionEventType[] ALL = values();
RsiCloudDecisionEventType(int type, String desc) {
this.type = type;
this.desc = desc;
}
public int getUnknownRealType() {
return unknownRealType;
}
public static RsiCloudDecisionEventType getType(int type) {
for (RsiCloudDecisionEventType tem : ALL) {
if (type == tem.type) {
return tem;
}
}
UNKNOWN.unknownRealType = type;
return UNKNOWN;
}
@NonNull
@Override
public String toString() {
if (type == -1) {
return desc + "(" + unknownRealType + ")";
} else {
return desc + "(" + type + ")";
}
}
}

73
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/common/cloud/RsiEventType.java Normal file
View File

@@ -0,0 +1,73 @@
package com.zhjt.mogo.adas.common.cloud;
import androidx.annotation.NonNull;
/**
* 通用RSI预警指令 交通事件类型
*/
public enum RsiEventType {
UNKNOWN(-1, "未知/异常"),
PEDESTRIAN_WARNING(5501, "行人提醒"),
NON_MOTOR_WARNING(5502, "非机动车提醒"),
EMERGENCY_BRAKE_WARNING(5503, "紧急制动预警"),
REVERSING_WARNING(5504, "倒车预警"),
WRONG_WAY_WARNING(5505, "逆行预警"),
ABNORMALLY_LOW_SPEED(5506, "异常低速预警"),
ABNORMAL_PARKING(5507, "异常停车预警"),
OVERSPEED_WARNING(5508, "超速预警"),
TRAFFIC_JAM(5509, "交通拥堵预警"),
SPECIAL_VEHICLE_WARNING(5510, "特殊车辆预警"),
EMERGENCY_VEHICLE_WARNING(5511, "紧急车辆预警"),
VEHICLE_STATUS_ABNORMAL(5512, "车辆状态异常预警"),
CONTINUOUS_LANE_CHANGE(5513, "连续并道预警"),
RAMP_TO_MAIN_ROAD(5514, "匝道退回主路预警"),
TRAFFIC_CONTROL(5515, "交通管控预警"),
LOW_FRICTION_ROAD(5516, "路面低摩阻预警"),
LANE_LEVEL_SPEED_LIMIT(5517, "动态车道级限速预警"),
OBSTACLE_REMINDER(5518, "障碍物提醒"),
TRAFFIC_LIGHT_FAULT(5519, "红绿灯故障预警"),
VULNERABLE_PARTICIPANT(5520, "弱势交通参与者预警"),
RED_LIGHT_VIOLATION_WARNING(5521, "闯红灯预警"),
SOLID_LINE_LANE_CHANGE(5522, "机动车压实线变道"),
WRONG_GUIDE_DIRECTION(5523, "机动车不按导向标识行驶"),
;
public final int type;
/**
* 描述
*/
public final String desc;
private int unknownRealType;//当异常时真实的type
public static final RsiEventType[] ALL = values();
RsiEventType(int type, String desc) {
this.type = type;
this.desc = desc;
}
public int getUnknownRealType() {
return unknownRealType;
}
public static RsiEventType getType(int type) {
for (RsiEventType tem : ALL) {
if (type == tem.type) {
return tem;
}
}
UNKNOWN.unknownRealType = type;
return UNKNOWN;
}
@NonNull
@Override
public String toString() {
if (type == -1) {
return desc + "(" + unknownRealType + ")";
} else {
return desc + "(" + type + ")";
}
}
}

354
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/common/cloud/RsiSignType.java Normal file
View File

@@ -0,0 +1,354 @@
package com.zhjt.mogo.adas.common.cloud;
import androidx.annotation.NonNull;
/**
* 通用RSI预警指令 交通标志类型
*/
public enum RsiSignType {
UNKNOWN(-1, "未知/异常"),
CROSS_ROAD(1, "交叉路口"),
SHARP_CURVE(2, "急弯路"),
REVERSE_CURVE(3, "反向弯路"),
CONTINUOUS_CURVES(4, "连续弯路"),
STEEP_SLOPE(5, "陡坡"),
CONTINUOUS_DOWNHILL(6, "连续下坡"),
NARROW_ROAD(7, "窄路"),
NARROW_BRIDGE(8, "窄桥"),
TWO_WAY_TRAFFIC(9, "双向交通"),
CAUTION_PEDESTRIANS(10, "注意行人"),
CAUTION_CHILDREN(11, "注意儿童"),
CAUTION_LIVESTOCK(12, "注意牲畜"),
CAUTION_WILDLIFE(13, "注意野生动物"),
CAUTION_TRAFFIC_LIGHTS(14, "注意信号灯"),
CAUTION_ROCKFALL(15, "注意落石"),
CAUTION_CROSSWIND(16, "注意横风"),
SLIPPERY_ROAD(17, "易滑"),
DANGEROUS_MOUNTAIN_ROAD(18, "傍山险路"),
DAM_ROAD(19, "堤坝路"),
VILLAGE(20, "村庄"),
TUNNEL(21, "隧道"),
FERRY(22, "渡口"),
HUMP_BACK_BRIDGE(23, "驼峰桥"),
UNEVEN_ROAD(24, "路面不平"),
BUMP_DECELERATION_HUMP(25, "路面高突/减速丘"),
LOWLAND_ROAD(26, "路面低洼"),
FLOODED_ROAD(27, "过水路面/过水路面（或漫水桥）"),
GUARDED_RAILWAY_CROSSING(28, "有人看守铁路道口"),
UNGUARDED_RAILWAY_CROSSING(29, "无人看守铁路道口"),
FORK_SYMBOL(30, "叉形符号"),
SLASH_SYMBOL(31, "斜杠符号"),
CAUTION_NON_MOTOR_VEHICLES(32, "注意非机动车"),
CAUTION_DISABLED(33, "注意残疾人"),
ACCIDENT_PRONE_AREA(34, "事故易发路段"),
SLOW_DOWN(35, "慢行"),
CAUTION_OBSTACLES(36, "注意障碍物"),
DANGER(37, "注意危险"),
CONSTRUCTION(38, "施工"),
SUGGESTED_SPEED(39, "建议速度"),
TUNNEL_LIGHTS_ON(40, "隧道开车灯"),
CAUTION_TIDE_LANE(41, "注意潮汐车道"),
MAINTAIN_SAFE_DISTANCE(42, "注意保持车距"),
CAUTION_SEPARATED_ROAD(43, "注意分离式道路"),
CAUTION_MERGE(44, "注意合流"),
EMERGENCY_LANE(45, "避险车道"),
CAUTION_ADVERSE_WEATHER(46, "注意路面结冰、注意雨（雪）天、注意雾天、注意不利气象条件"),
CAUTION_TRAFFIC_QUEUE(47, "注意前方车辆排队"),
STOP_AND_YIELD(48, "停车让行"),
SLOW_DOWN_AND_YIELD(49, "减速让行"),
GIVE_WAY_IN_MEETING(50, "会车让行"),
NO_ENTRY(51, "禁止通行"),
NO_ENTRY_FOR_VEHICLES(52, "禁止驶入"),
NO_MOTOR_VEHICLES(53, "禁止机动车驶入"),
NO_TRUCKS(54, "禁止载货汽车驶入"),
NO_ELECTRIC_TRICYCLES(55, "禁止电动三轮车驶入/禁止三轮车驶入"),
NO_LARGE_BUSES(56, "禁止大型客车驶入/禁止大型载客汽车驶入"),
NO_SMALL_CARS(57, "禁止小型客车驶入/禁止小型载客汽车驶入"),
NO_TRAILERS(58, "禁止挂车、半挂车驶入"),
NO_TRACTORS(59, "禁止拖拉机驶入"),
NO_THREE_WHEELERS_LOW_SPEED_TRUCKS(60, "禁止三轮汽车、低速货车驶入"),
NO_MOTORCYCLES(61, "禁止摩托车驶入"),
NO_TWO_TYPES_VEHICLES(62, "禁止某两种车驶入"),
NO_NON_MOTOR_VEHICLES(63, "禁止非机动车进入"),
NO_LIVESTOCK_VEHICLES(64, "禁止畜力车进入"),
NO_PASSENGER_RICKSHAWS(65, "禁止人力客运三轮车进入"),
NO_CARGO_RICKSHAWS(66, "禁止人力货运三轮车进入"),
NO_HUMAN_POWERED_VEHICLES(67, "禁止人力车进入"),
NO_PEDESTRIANS(68, "禁止行人进入"),
NO_LEFT_TURN(69, "禁止向左转弯"),
NO_RIGHT_TURN(70, "禁止向右转弯"),
NO_STRAIGHT(71, "禁止直行"),
NO_LEFT_RIGHT_TURNS(72, "禁止向左向右转弯"),
NO_STRAIGHT_LEFT_TURN(73, "禁止直行和向左转弯"),
NO_STRAIGHT_RIGHT_TURN(74, "禁止直行和向右转弯"),
NO_UTURN(75, "禁止掉头"),
NO_OVERTAKING(76, "禁止超车"),
OVERTAKING_PERMITTED(77, "解除禁止超车"),
NO_PARKING(78, "禁止停车/禁止车辆停放"),
NO_LONG_TERM_PARKING(79, "禁止长时停车/禁止车辆长时停放"),
NO_HORN(80, "禁止鸣喇叭"),
WIDTH_LIMIT(81, "限制宽度"),
HEIGHT_LIMIT(82, "限制高度"),
WEIGHT_LIMIT(83, "限制质量"),
AXLE_WEIGHT_LIMIT(84, "限制轴重"),
SPEED_LIMIT(85, "限制速度"),
SPEED_LIMIT_LIFTED(86, "解除限制速度"),
STOP_FOR_INSPECTION(87, "停车检查"),
NO_HAZARDOUS_MATERIALS(88, "禁止运输危险物品车辆驶入/禁止危险物品运输车辆驶入"),
CUSTOMS(89, "海关"),
AREA_SPEED_LIMIT(90, "区域限制速度"),
AREA_SPEED_LIMIT_LIFTED(91, "区域限制速度解除"),
AREA_NO_LONG_TERM_PARKING(92, "区域禁止长时停车/区域禁止车辆长时停车"),
AREA_NO_LONG_TERM_PARKING_LIFTED(93, "区域禁止长时停车解除/区域禁止车辆长时停车解除解除"),
AREA_NO_PARKING(94, "区域禁止停车/区域禁止车辆停放"),
AREA_NO_PARKING_LIFTED(95, "区域禁止停车解除/区域禁止车辆停放解除"),
GO_STRAIGHT(96, "直行"),
TURN_LEFT(97, "向左转弯"),
TURN_RIGHT(98, "向右转弯"),
STRAIGHT_AND_LEFT(99, "直行和向左转弯"),
STRAIGHT_AND_RIGHT(100, "直行和向右转弯"),
TURN_LEFT_AND_RIGHT(101, "向左和向右转弯"),
KEEP_RIGHT(102, "靠右侧道路行驶/分隔带右侧行驶"),
KEEP_LEFT(103, "靠左侧道路行驶/分隔带左侧行驶"),
OVERPASS_STRAIGHT_LEFT(104, "立体交叉直行和左转弯行驶"),
OVERPASS_STRAIGHT_RIGHT(105, "立体交叉直行和右转弯行驶"),
ROUNDABOUT(106, "环岛行驶"),
ONE_WAY_LEFT_RIGHT(107, "单行路（向左或向右）"),
ONE_WAY_STRAIGHT(108, "单行路（直行）"),
PEDESTRIAN_ONLY(109, "步行/行人"),
USE_HORN(110, "鸣喇叭"),
MINIMUM_SPEED(111, "最低限速"),
INTERSECTION_PRIORITY(112, "路口优先通行"),
GIVE_WAY_IN_MEETING_PRIORITY(113, "会车先行"),
PEDESTRIAN_CROSSING(114, "人行横道"),
RIGHT_TURN_LANE(115, "右转车道"),
LEFT_TURN_LANE(116, "左转车道"),
STRAIGHT_LANE(117, "直行车道"),
STRAIGHT_RIGHT_COMBINED_LANE(118, "直行和右转合用车道"),
STRAIGHT_LEFT_COMBINED_LANE(119, "直行和左转合用车道"),
U_TURN_LANE(120, "掉头车道"),
U_TURN_LEFT_COMBINED_LANE(121, "掉头和左转合用车道"),
DIRECTIONAL_LANES(122, "分向行驶车道"),
BUS_LANE(123, "公交线路专用车道/公交专用车道"),
MOTOR_VEHICLE_LANE(124, "机动车行驶"),
MOTOR_VEHICLE_ONLY(125, "机动车车道"),
NON_MOTOR_VEHICLE_LANE(126, "非机动车行驶"),
NON_MOTOR_VEHICLE_ONLY(127, "非机动车车道"),
BRT_LANE(128, "快速公交系统专用车道/快速公交系统（BRT）专用车道"),
HOV_LANE(129, "多乘员车辆专用车道/多乘员车辆（HOV）专用车道"),
PARKING_SPACE(130, "停车位"),
U_TURN_PERMITTED(131, "允许掉头"),
FOUR_LANE_INTERSECTION_ADVANCE(132, "四车道及以上公路交叉路口预告"),
HIGH_TRAFFIC_INTERSECTION_ADVANCE(133, "大交通量的四车道以上公路交叉路口预告"),
ROAD_NUMBER_INTERSECTION_ADVANCE(134, "箭头杆上标识公路编号、道路名称的公路交叉路口预告"),
CROSS_INTERSECTION(135, "十字交叉路口"),
T_INTERSECTION(136, "丁字交叉路口"),
Y_INTERSECTION(137, "Y型交叉路口"),
ROUNDABOUT_SIGN(138, "环形交叉路口"),
INTERCHANGE(139, "互通式立体交叉"),
FORK(140, "分岔处"),
NATIONAL_ROAD_NUMBER(141, "国道编号"),
PROVINCIAL_ROAD_NUMBER(142, "省道编号"),
COUNTY_ROAD_NUMBER(143, "县道编号"),
TOWNSHIP_ROAD_NUMBER(144, "乡道编号"),
STREET_NAME(145, "街道名称/路名"),
ROAD_NAME_SIGN(146, "路名牌"),
DISTANCE_TO_LOCATION(147, "地点距离"),
PLACE_NAME(148, "地名"),
FAMOUS_PLACE(149, "著名地点"),
ADMINISTRATIVE_BOUNDARY(150, "行政区划分界"),
ROAD_MANAGEMENT_BOUNDARY(151, "道路管理分界"),
PLACE_IDENTIFICATION(152, "地点识别"),
PARKING_AREA(153, "停车场/停车场（区）"),
PASSING_PLACE(154, "错车道"),
PEDESTRIAN_OVERPASS(155, "人行天桥"),
PEDESTRIAN_UNDERPASS(156, "人行地下通道"),
ACCESSIBLE_FACILITIES(157, "残疾人专用设施/无障碍设施"),
VIEWING_PLATFORM(158, "观景台"),
EMERGENCY_SHELTER(159, "应急避难设施（场所）"),
REST_AREA(160, "休息区"),
DETOUR(161, "绕行"),
ROAD_CLOSED(162, "此路不通"),
LANES_DECREASING(163, "车道数变少"),
LANES_INCREASING(164, "车道数增加"),
TRAFFIC_MONITORING(165, "交通监控设备"),
TUNNEL_EXIT_DISTANCE(166, "隧道出口距离预告/隧道出口距离"),
BASIC_UNIT(167, "基本单元"),
COMBINED_USE(168, "组合使用"),
BOTH_SIDES_PASSAGE(169, "两侧通行"),
RIGHT_SIDE_PASSAGE(170, "右侧通行"),
LEFT_SIDE_PASSAGE(171, "左侧通行"),
ENTRANCE_ADVANCE(172, "入口预告"),
DIRECTION_AND_PLACE(173, "地点、方向"),
ROUTE_NUMBER(174, "编号"),
NAMED_NUMBER(175, "命名编号"),
ROAD_NAME_SIGNAGE(176, "路名"),
DISTANCE_INFORMATION(177, "地点距离"),
MULTIPLE_EXITS_DISTANCE(178, "城市区域多个出口时的地点距离/城市区域多个出口时地点距离"),
NEXT_EXIT_ADVANCE(179, "下一出口预告"),
EXIT_NUMBER(180, "出口编号"),
RIGHT_EXIT_ADVANCE(181, "右侧出口预告"),
LEFT_EXIT_ADVANCE(182, "左侧出口预告"),
EXIT_SIGN(183, "出口标志及出口地点方向"),
HIGHWAY_START(184, "高速公路起点"),
END_ADVANCE(185, "终点预告"),
END_NOTICE(186, "终点提示"),
EXPRESSWAY_END(187, "国家高速公路、省级高速公路终点"),
TRAFFIC_INFORMATION(188, "道路交通信息"),
MILESTONE(189, "里程牌"),
HUNDRED_METER_SIGN(190, "百米牌"),
STOP_FOR_CARD(191, "停车领卡"),
CAR_DISTANCE_CONFIRM(192, "车距确认"),
SPECIAL_WEATHER_SPEED(193, "特殊天气建议速度"),
EMERGENCY_TELEPHONE(194, "紧急电话"),
PHONE_LOCATION(195, "电话位置指示"),
RESCUE_TELEPHONE(196, "救援电话"),
NO_ETC_TOLL_STATION(197, "不设电子不停车收费（ETC）车道的收费站预告及收费站"),
ETC_TOLL_STATION(198, "设有电子不停车收费（ETC）车道的收费站预告及收费站"),
ETC_LANE_GUIDE(199, "ETC车道指示/电子不停车收费（ETC）车道指引"),
WEIGH_IN_MOTION(200, "计重收费"),
GAS_STATION(201, "加油站"),
EMERGENCY_STOP_AREA(202, "紧急停车带/港湾式紧急停车带"),
SERVICE_AREA_ADVANCE(203, "服务区预告"),
PARKING_AREA_ADVANCE(204, "停车区预告"),
PARKING_LOT_ADVANCE(205, "停车场预告"),
HIGHWAY_PARKING(206, "停车场"),
CLIMBING_LANE(207, "爬坡车道"),
OVERWEIGHT_INSPECTION(208, "超限超载检测站/超限检测站"),
DIRECTION_IN_SIGN(209, "设置在指路标志版面中的方向"),
DIRECTION_OUT_SIGN(210, "设置在指路标志版面外的方向"),
TOURIST_AREA_DISTANCE(211, "旅游区距离"),
TOURIST_AREA_DIRECTION(212, "旅游区方向"),
INFORMATION_CENTER(213, "问讯处/信息服务"),
HIKING(214, "徒步"),
CABLE_CAR(215, "索道"),
CAMPGROUND(216, "野营地"),
CAMPFIRE(217, "营火"),
PLAYGROUND(218, "游戏场"),
HORSEBACK_RIDING(219, "骑马"),
FISHING(220, "钓鱼"),
GOLF(221, "高尔夫球"),
DIVING(222, "潜水"),
SWIMMING(223, "游泳"),
BOATING(224, "划船"),
WINTER_TOURIST_AREA(225, "冬季游览区"),
SKIING(226, "滑雪"),
SKATING(227, "滑冰"),
TIME_RANGE(228, "时间范围"),
EXCEPT_BUS(229, "除公共汽车外/公交车除外"),
MOTOR_VEHICLES_ONLY(230, "机动车"),
TRUCKS_ONLY(231, "货车"),
TRUCKS_AND_TRACTORS(232, "货车、拖拉机"),
PRIVATE_EXCLUSIVE(233, "私人专属"),
DIRECTION_SIGN(234, "行驶方向标志/行驶方向"),
AHEAD_200M(235, "向前200m"),
LEFT_100M(236, "向左100m"),
LEFT_RIGHT_50M(237, "向左、向右各50m"),
RIGHT_100M(238, "向右100m"),
WITHIN_AREA(239, "某区域内"),
DISTANCE_200M(240, "距离某地200m"),
LENGTH(241, "长度"),
SCHOOL(242, "学校"),
CUSTOMS_CHECK(243, "海关"),
ACCIDENT_AREA(244, "事故"),
LANDSLIDE(245, "塌方"),
INSTRUCTOR_CAR_ROUTE(246, "教练车行驶路线"),
DRIVING_TEST_ROUTE(247, "驾驶考试路线"),
SCHOOL_BUS_STOP(248, "校车停靠站点"),
COMBO_ASSIST_SIGN(249, "组合辅助/组合辅助标志"),
NO_E_BIKE_ENTRY(250, "禁止电动自行车进入"),
TURN_ON_LIGHTS(251, "开车灯"),
CAR_LANE(252, "小型客车车道"),
TRAM_LANE(253, "有轨电车专用车道"),
E_BIKE_RIDING(254, "电动自行车行驶"),
E_BIKE_LANE(255, "电动自行车车道"),
SEPARATED_NON_MOTOR_PEDESTRIAN(256, "非机动车与行人分开空间通行"),
SHARED_NON_MOTOR_PEDESTRIAN(257, "非机动车与行人共享空间通行"),
NON_MOTOR_PUSH(258, "非机动车推行"),
KEEP_RIGHT_LANE(259, "靠右侧车道行驶"),
HARD_SHOULDER_PERMITTED(260, "硬路肩允许行驶"),
TRUCKS_PERMITTED(261, "货车通行"),
CAUTION_E_BIKE(262, "注意电动自行车"),
TRAFFIC_ACCIDENT_MANAGEMENT(263, "交通事故管理"),
CAUTION_LANES_DECREASING(264, "注意车道数变少"),
INTERSECTION_DIAGRAM(265, "交叉路口图形式"),
ROUNDABOUT_DIAGRAM(266, "环岛图形式"),
STACKED_TYPE(267, "堆叠式"),
LANE_TYPE(268, "车道式"),
ROAD_NAME_DIRECTION(269, "道路名称方向"),
SERVICE_STATION(270, "服务站"),
STOP_POINT(271, "停车点"),
DIRECTIONAL_SIGN(272, "方向标志"),
ENTRANCE_TWO_DIRECTIONS(273, "入口预告（进入后2个方向）"),
ENTRANCE_ONE_DIRECTION(274, "入口预告（进入后1个方向）"),
UNNAMED_HWY_ENTRANCE(275, "无编号高速公路或城市快速路入口预告"),
CONCURRENT_HWY_ENTRANCE(276, "两条高速公路路段重合的入口预告"),
PLACE_DIRECTION(277, "地点、方向"),
PLACE_DIRECTION_WITH_NUMBER(278, "带编号信息的地点、方向"),
PLACE_DIRECTION_FULL(279, "带编号、方向信息的地点、方向"),
PLACE_DISTANCE_INFO(280, "地点距离"),
FORWARD_DISTANCE_GUIDE(281, "同时指引前方到达道路上的地点距离"),
NORMAL_INTERCHANGE_EXIT_NUMBED(282, "一般互通式立体交叉出口后道路有编号的出口预告"),
NORMAL_EXIT_DIRECTION_NUMBED(283, "一般互通式立体交叉出口后道路有编号的出口方向"),
NORMAL_INTERCHANGE_EXIT_UNNUMBED(284, "一般互通式立体交叉出口后道路无编号的出口预告"),
NORMAL_EXIT_DIRECTION_UNNUMBED(285, "一般互通式立体交叉出口后道路无编号的出口方向"),
HUB_INTERCHANGE_EXIT_ADVANCE(286, "枢纽互通式立体交叉的出口预告"),
HUB_EXIT_DIRECTION(287, "枢纽互通式立体交叉出口方向"),
STRAIGHT_EXIT_DIRECTION(288, "直出车道出口方向"),
ROAD_FORK_ADVANCE(289, "道路分岔预告"),
TWO_EXIT_HUB_EXIT_ADVANCE(290, "双出口枢纽式互通立体交叉的出口预告"),
TWO_LANE_HUB_EXIT_DIRECTION(291, "出口匝道为2条车道枢纽式互通立体交叉的出口方向"),
EXIT_300_200_100M(292, "300m、200m、100m出口预告"),
EXIT_SIGNAGE(293, "出口"),
UNNAMED_HWY_START(294, "无编号的高速公路或城市快速路起点"),
UNNAMED_HWY_END_ADVANCE(295, "无编号的高速公路或城市快速路终点预告"),
UNNAMED_HWY_END(296, "无编号的高速公路或城市快速路终点"),
MILESTONE_SIGN(297, "里程牌"),
UNNAMED_HWY_MILESTONE(298, "无编号的高速公路或城市快速路里程牌"),
ETC_LANE(299, "电子不停车收费（ETC）车道"),
MANUAL_Toll_LANE(300, "人工收费车道"),
GREEN_CHANNEL(301, "绿色通道"),
RV_CAMP(302, "旅居车营地"),
LEFT_RIGHT_DIRECTION(303, "向左、向右"),
;
public final int type;
/**
* 描述
*/
public final String desc;
private int unknownRealType;//当异常时真实的type
public static final RsiSignType[] ALL = values();
RsiSignType(int type, String desc) {
this.type = type;
this.desc = desc;
}
public int getUnknownRealType() {
return unknownRealType;
}
public static RsiSignType getType(int type) {
for (RsiSignType tem : ALL) {
if (type == tem.type) {
return tem;
}
}
UNKNOWN.unknownRealType = type;
return UNKNOWN;
}
@NonNull
@Override
public String toString() {
if (type == -1) {
return desc + "(" + unknownRealType + ")";
} else {
return desc + "(" + type + ")";
}
}
}

50
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/component/Position.java Normal file
View File

@@ -0,0 +1,50 @@
package com.zhjt.mogo.adas.data.bean.cloud.component;
/**
* 位置
*/
public final class Position {
/**
* 经度，单位：°，表示-180.0000000°～180.0000000°，大于0 表示东经，不可缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double longitude;
/**
* 纬度，单位：°，表示-90.0000000°～90.0000000°，大于 0 表示北纬，不可缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double latitude;
/**
* 海拔高度，单位：m，表示-500.0 m～6500.0 m，0xFFFFFFFF表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double elevation;
public Position(int longitude, int latitude, int elevation) {
if (longitude == -1) {
this.longitude = Double.MIN_VALUE;
} else {
this.longitude = (longitude / 10000000.0D) - 180.0;
}
if (latitude == -1) {
this.latitude = Double.MIN_VALUE;
} else {
this.latitude = (latitude / 10000000.0D) - 90.0;
}
if (elevation == -1) {
this.elevation = Double.MIN_VALUE;
} else {
this.elevation = (elevation - 5000.0) / 10.0D;
}
}
@Override
public String toString() {
return "{" +
"经度=" + longitude +
"°, 纬度=" + latitude +
"°, 高程=" + elevation +
"m}";
}
}

30
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/component/SpeedLimit.java Normal file
View File

@@ -0,0 +1,30 @@
package com.zhjt.mogo.adas.data.bean.cloud.component;
/**
* 限速信息
*/
public final class SpeedLimit {
/**
* 车道编号
* [0..255]，0表示车道编号无效；以该车道行驶方向为参考，自左向右从1 开始编号
*/
public final int laneId;
/**
* 限速值
* [0...255]，速度限制值，单位：km/h，0 表示未知限速
*/
public final int speedLimit;
public SpeedLimit(int laneId, int speedLimit) {
this.laneId = laneId;
this.speedLimit = speedLimit;
}
@Override
public String toString() {
return "{" +
"车道编号=" + laneId +
", 限速值=" + speedLimit +
"km/h}";
}
}

140
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/info/AdviceAvwInfo.java Normal file
View File

@@ -0,0 +1,140 @@
package com.zhjt.mogo.adas.data.bean.cloud.info;
import com.zhjt.mogo.adas.data.bean.cloud.component.Position;
import java.util.Arrays;
/**
* 8.5.11 异常车辆预警指令
*/
public final class AdviceAvwInfo {
/**
* 事件唯一标识
* 一组固定长度为 36 个字节的字符串，UTF-8 编码，标识命令唯一编号；同一影响目标交通参与物同一 uuid
* null 表示解析失败/异常
*/
public final String uuid;
/**
* 事件生成时间戳
* 事件生成的时间戳，UTC 时间（东八区），单位：ms，不可缺省
* {@link Long#MIN_VALUE}或-1 表示解析失败/异常
*/
public final long timestamp;
/**
* 告警类型
* 用于匹配 RSI，取值为 6503，6505，6506，6507，6508
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int alertType;
/**
* 告警半径
* [0..102.4]，单位：m，6553.5表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double alertRadius;
/**
* 路径点数量
* [0..31]，告警路径中路径点数量，取值为 0 时，不发送告警路径
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int pointNum;
/**
* 告警路径
* N 个路径点，其中 N 为路径点数量。如果传递一个点则生成RSI 时改为两个一样的点，如果未传递，则生成 RSI 时填入两个默认零点[0,0,0]，POSITION 数据结构应符合表 2 的要求
* (pointNum == {@link Integer#MIN_VALUE} && alertPath == null) 表示解析失败/异常
*/
public final Position[] alertPath;
/**
* 车速
* [0..200.00]，异常车辆的行驶速度，单位：m/s，655.35表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double velocity;
/**
* 航向角
* [0..360.0000]，异常车辆的航向角，为正北方向顺时针旋转至与车辆当前运动方向重合所转过的角度，单位：°，-1表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double heading;
/**
* 事件状态 ---提醒指令的事件状态
* [0..1] 0: 生成事件信息；1： 取消事件信息
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int status;
/**
* 决策建议消息的生成与消散
* 0：无效 1：有效 255：缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int valid;
/**
* 异常车辆所在车道, 异常车辆所在车道编号 0-255 0： 无效； 1：最内侧车道，向外依次递增 ； 255： 缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int rsiLaneId;
/**
* 当前车道road序号 车道编号 0：无效, 0xFFFFFFFF 缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int roadId;
/**
* 距离
* 单位：m，65535表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double distance;
/**
* 异常车辆目标物体uuid
* null 表示解析失败/异常
*/
public final String objectId;
public AdviceAvwInfo(String uuid, long timestamp, int alertType, double alertRadius, int pointNum, Position[] alertPath, double velocity, double heading, int status, int valid, int rsiLaneId, int roadId, double distance, String objectId) {
this.uuid = uuid;
this.timestamp = timestamp;
this.alertType = alertType;
this.alertRadius = alertRadius;
this.pointNum = pointNum;
this.alertPath = alertPath;
this.velocity = velocity;
this.heading = heading;
this.status = status;
this.valid = valid;
this.rsiLaneId = rsiLaneId;
this.roadId = roadId;
this.distance = distance;
this.objectId = objectId;
}
@Override
public String toString() {
return "异常车辆预警指令{" +
"事件唯一标识=" + uuid +
", 事件生成时间戳=" + timestamp +
", 告警类型=" + alertType +
", 告警半径=" + alertRadius +
"m, 路径点数量=" + pointNum +
", 告警路径=" + Arrays.toString(alertPath) +
", 车速=" + velocity +
"m/s, 航向角=" + heading +
"°, 提醒指令事件状态=" + status +
", 决策建议消息的生成与消散=" + valid +
", 异常车辆所在车道=" + rsiLaneId +
", 当前车道road序号=" + roadId +
", 距离=" + distance +
"m, 异常车辆目标物体UUID=" + objectId +
'}';
}
}

318
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/info/AdviceComRsiInfo.java Normal file
View File

@@ -0,0 +1,318 @@
package com.zhjt.mogo.adas.data.bean.cloud.info;
import com.zhjt.mogo.adas.common.cloud.AdviceComRsiEventSource;
import com.zhjt.mogo.adas.common.cloud.AdviceEventType;
import com.zhjt.mogo.adas.common.cloud.RsiCloudDecisionEventType;
import com.zhjt.mogo.adas.common.cloud.RsiEventType;
import com.zhjt.mogo.adas.common.cloud.RsiSignType;
import com.zhjt.mogo.adas.data.bean.cloud.component.Position;
import com.zhjt.mogo.adas.data.bean.cloud.info.rsi.AdviceRsiAbandonInfo;
import com.zhjt.mogo.adas.data.bean.cloud.info.rsi.AdviceRsiLaneProposalInfo;
import com.zhjt.mogo.adas.data.bean.cloud.info.rsi.AdviceRsiLightWarningInfo;
import com.zhjt.mogo.adas.data.bean.cloud.info.rsi.AdviceRsiOtherCarBreakReadWarningInfo;
import com.zhjt.mogo.adas.data.bean.cloud.info.rsi.AdviceRsiOverSightDistanceInfo;
import com.zhjt.mogo.adas.data.bean.cloud.info.rsi.AdviceRsiRoadDangerHintInfo;
import com.zhjt.mogo.adas.data.bean.cloud.info.rsi.AdviceRsiTrafficJamInfo;
import com.zhjt.mogo.adas.data.bean.cloud.info.rsi.AdviceRsiVisibilityInfo;
import com.zhjt.mogo.adas.data.bean.cloud.pojo.AdvicePojo;
import java.util.Arrays;
/**
* 通用RSI预警指令
*/
public final class AdviceComRsiInfo {
/**
* 交通事件和交通标志信息数量
* 道路交通事件信息的数量
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int rsisNum;
/**
* 交交通事件和交通标志信息
* N 条道路交通事件和交通标志信息，道路交通事件和交通标志信息数据结构应符合表 43 的要求
* (rsisNum == {@link Integer#MIN_VALUE} && rsis == null) 表示解析失败/异常
*/
public final Rsi[] rsis;
public AdviceComRsiInfo(int rsisNum, Rsi[] rsis) {
this.rsisNum = rsisNum;
this.rsis = rsis;
}
@Override
public String toString() {
return "通用RSI预警指令{" +
"交通事件和交通标志信息数量=" + rsisNum +
", 交交通事件和交通标志信息=" + Arrays.toString(rsis) +
'}';
}
public final static class Rsi {
/**
* 事件唯一标识
* 一组固定长度为 36 个字节的字符串，UTF-8 编码，标识命令唯一编号
* null 表示解析失败/异常
*/
public final String uuid;
/**
* 事件生成时间戳
* 事件生成的时间戳，UTC 时间（东八区），单位：ms，不可缺省，0xFFFFFFFFFFFFFFFF 表示异常
* {@link Long#MIN_VALUE} 表示解析失败/异常
*/
public final long timestamp;
/**
* 交通事件位置点
* 交通事件经纬度及高程信息，POSITION 数据结构应符合表2 的要求
* null 表示解析失败/异常
*/
public final Position eventPosition;
/**
* 事件分类
* 枚举类型：[0..3]，0：未知类型；1：交通事件类；2：道路交通标志；3：云端决策建议，不可缺省
* {@link AdviceEventType#ERROR} 表示解析失败/异常
*/
public final AdviceEventType adviceEventType;
/**
* 道路交通事件信息类型
* 当RSI描述的信息为RTS时，对应YD/T 3709中的signType，按照GB5768.2-2022要求，定义及取值见附录E表E.2； {@link RsiSignType}
* 当RSI描述的信息为RTE时，对应YD/T 3709中的eventType，按照GB/T29100要求，其中路侧识别事件定义见附录E表E.1 {@link RsiEventType}
* <p>
* 需要根据{@link AdvicePojo#eventType} 进行解析
* 如果 {@link AdvicePojo#eventType} == {@link AdviceEventType#TRAFFIC_SIGN} 则需要使用 {@link RsiSignType#getType(int)} 进行解析
* 如果 {@link AdvicePojo#eventType} == {@link AdviceEventType#TRAFFIC_EVENT} 则需要使用 {@link RsiEventType#getType(int)} 进行解析
* 如果 {@link AdvicePojo#eventType} == {@link AdviceEventType#CLOUD_DECISION} 则需要使用 {@link RsiCloudDecisionEventType#getType(int)} 进行解析
*/
public final int eventType;
/**
* 事件来源
* 枚举类型：[0..6]，0：未知来源；1：交管部门；2：其他政府部门；3：气象部门；4：互联网；5：路侧或云端感知；6：其他来源；255表示缺省
* {@link AdviceComRsiEventSource#ERROR} 表示解析失败/异常
*/
public final AdviceComRsiEventSource eventSource;
/**
* 事件（影响）半径
* [0..6553.4],单位：m，6553.5表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double eventRadius;
/**
* 关联路段数量
* [0..65535]，取值为 0 时，不发送关联路段信息
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int referenceLinksNum;
/**
* 关联路段信息
* N 个关联路段信息，其中 N 为关联路段数量，关联路段信息数据结构应符合表 44 的要求
* (referenceLinksNum == {@link Integer#MIN_VALUE} && referenceLinks == null) 表示解析失败/异常
*/
public final ReferenceLink[] referenceLinks;
/**
* 优先级
* [0..7]，从低到高表示优先级从低到高，默认为0，255表示缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int priority;
/**
* 交通事件/标志作用中心线坐标点
* null 表示解析失败/异常
*/
public final Position alertPath;
/**
* 交通标志/事件作用中心线范围半径
* [0..102.4]，单位：m，6553.5表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double pathRadius;
/**
* 事件状态
* 枚举类型：[0..1]，0：生成事件消息；1：取消事件消息
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int status;
/**
* 自定义内容长度
* [0..65535]，描述自定义字段长度，取值为0 时不发送自定义字段内容
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int userDefinedDataLength;
/**
* 自定义内容
* 自定义数据字段，长度为 N 个字节，其中 N 为自定义字段长度
* (userDefinedDataLength == {@link Integer#MIN_VALUE} && userDefinedData == null) 表示解析失败/异常
*/
public final String userDefinedData;
/**
* 闯红灯预警功能-扩展字段补充
* 当
* {@link AdvicePojo#eventType} == {@link AdviceEventType#CLOUD_DECISION}
* &&
* {@link Rsi#eventType} == {@link RsiCloudDecisionEventType#RED_LIGHT_RUNNING_WARNING}
* 使用
*/
public final AdviceRsiLightWarningInfo adviceRsiLightWarningInfo;
/**
* 道路危险状况提示服务功能-扩展字段补充
* 当
* {@link AdvicePojo#eventType} == {@link AdviceEventType#CLOUD_DECISION}
* &&
* {@link Rsi#eventType} == ({@link RsiCloudDecisionEventType#ROAD_HAZARD_ALERT_SERVICE_6021} || {@link RsiCloudDecisionEventType#ROAD_HAZARD_ALERT_SERVICE_6022})
* 使用
*/
public final AdviceRsiRoadDangerHintInfo adviceRsiRoadDangerHintInfo;
/**
* 实时决策建议 rsi 行驶车道建议功能-扩展字段补充
* 当
* {@link AdvicePojo#eventType} == {@link AdviceEventType#CLOUD_DECISION}
* &&
* {@link Rsi#eventType} == ({@link RsiCloudDecisionEventType#DRIVING_LANE_SUGGESTION_6031} || {@link RsiCloudDecisionEventType#DRIVING_LANE_SUGGESTION_6032)
* 使用
*/
public final AdviceRsiLaneProposalInfo adviceRsiLaneProposalInfo;
public final AdviceRsiOtherCarBreakReadWarningInfo adviceRsiOtherCarBreakReadWarningInfo;
public final AdviceRsiTrafficJamInfo adviceRsiTrafficJamInfo;
public final AdviceRsiOverSightDistanceInfo adviceRsiOverSightDistanceInfo;
public final AdviceRsiVisibilityInfo adviceRsiVisibilityInfo;
public final AdviceRsiAbandonInfo adviceRsiAbandonInfo;
public Rsi(String uuid, long timestamp, Position eventPosition, AdviceEventType adviceEventType, int eventType, int eventSource, double eventRadius, int referenceLinksNum, ReferenceLink[] referenceLinks, int priority, Position alertPath, double pathRadius, int status, int userDefinedDataLength, String userDefinedData, AdviceRsiLightWarningInfo adviceRsiLightWarningInfo, AdviceRsiRoadDangerHintInfo adviceRsiRoadDangerHintInfo, AdviceRsiLaneProposalInfo adviceRsiLaneProposalInfo, AdviceRsiOtherCarBreakReadWarningInfo adviceRsiOtherCarBreakReadWarningInfo, AdviceRsiTrafficJamInfo adviceRsiTrafficJamInfo, AdviceRsiOverSightDistanceInfo adviceRsiOverSightDistanceInfo, AdviceRsiVisibilityInfo adviceRsiVisibilityInfo, AdviceRsiAbandonInfo adviceRsiAbandonInfo) {
this.uuid = uuid;
this.timestamp = timestamp;
this.eventPosition = eventPosition;
this.adviceEventType = adviceEventType;
this.eventType = eventType;
this.eventSource = AdviceComRsiEventSource.getType(eventSource);
this.eventRadius = eventRadius;
this.referenceLinksNum = referenceLinksNum;
this.referenceLinks = referenceLinks;
this.priority = priority;
this.alertPath = alertPath;
this.pathRadius = pathRadius;
this.status = status;
this.userDefinedDataLength = userDefinedDataLength;
this.userDefinedData = userDefinedData;
this.adviceRsiLightWarningInfo = adviceRsiLightWarningInfo;
this.adviceRsiRoadDangerHintInfo = adviceRsiRoadDangerHintInfo;
this.adviceRsiLaneProposalInfo = adviceRsiLaneProposalInfo;
this.adviceRsiOtherCarBreakReadWarningInfo = adviceRsiOtherCarBreakReadWarningInfo;
this.adviceRsiTrafficJamInfo = adviceRsiTrafficJamInfo;
this.adviceRsiOverSightDistanceInfo = adviceRsiOverSightDistanceInfo;
this.adviceRsiVisibilityInfo = adviceRsiVisibilityInfo;
this.adviceRsiAbandonInfo = adviceRsiAbandonInfo;
}
@Override
public String toString() {
String eventTypeTemp = "";
String userDefinedDataTemp = userDefinedData;
if (adviceEventType == AdviceEventType.TRAFFIC_SIGN) {
eventTypeTemp += RsiSignType.getType(eventType);
} else if (adviceEventType == AdviceEventType.TRAFFIC_EVENT) {
eventTypeTemp += RsiEventType.getType(eventType);
} else if (adviceEventType == AdviceEventType.CLOUD_DECISION) {
RsiCloudDecisionEventType type = RsiCloudDecisionEventType.getType(eventType);
eventTypeTemp += type;
if (type == RsiCloudDecisionEventType.RED_LIGHT_RUNNING_WARNING) {
userDefinedDataTemp = adviceRsiLightWarningInfo + "";
} else if (type == RsiCloudDecisionEventType.ROAD_HAZARD_ALERT_SERVICE_6021 || type == RsiCloudDecisionEventType.ROAD_HAZARD_ALERT_SERVICE_6022) {
userDefinedDataTemp = adviceRsiRoadDangerHintInfo + "";
} else if (type == RsiCloudDecisionEventType.DRIVING_LANE_SUGGESTION_6031 || type == RsiCloudDecisionEventType.DRIVING_LANE_SUGGESTION_6032) {
userDefinedDataTemp = adviceRsiLaneProposalInfo + "";
} else if (type == RsiCloudDecisionEventType.INTERSECTION_RED_LIGHT_WARNING) {
userDefinedDataTemp = adviceRsiOtherCarBreakReadWarningInfo + "";
} else if (type == RsiCloudDecisionEventType.TRAFFIC_CONGESTION_ALERT) {
userDefinedDataTemp = adviceRsiTrafficJamInfo + "";
} else if (type == RsiCloudDecisionEventType.OVER_THE_HORIZON_VULNERABLE_ROAD_USER_WARNING) {
userDefinedDataTemp = adviceRsiOverSightDistanceInfo + "";
} else if (type == RsiCloudDecisionEventType.VISIBILITY_WARNING) {
userDefinedDataTemp = adviceRsiVisibilityInfo + "";
} else if (type == RsiCloudDecisionEventType.ROAD_DEBRIS_WARNING) {
userDefinedDataTemp = adviceRsiAbandonInfo + "";
}
} else {
eventTypeTemp = "AdviceEventType 异常，eventType 原始数据=" + eventType;
}
return "事件唯一标识=" + uuid +
", 事件生成时间戳=" + timestamp +
", 交通事件位置点=" + eventPosition +
", 道路交通事件信息类型=" + eventTypeTemp +
", 事件来源=" + eventSource +
", 事件（影响）半径=" + eventRadius +
"m, 关联路段数量=" + referenceLinksNum +
", 关联路段信息=" + Arrays.toString(referenceLinks) +
", 优先级=" + priority +
", 交通事件/标志作用中心线坐标点=" + alertPath +
", 交通标志/事件作用中心线范围半径=" + pathRadius +
", 事件状态=" + status +
", 自定义内容长度=" + userDefinedDataLength +
", 自定义内容=" + userDefinedDataTemp +
'}';
}
public final static class ReferenceLink {
/**
* 上游节点编号
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int upstreamNodeId;
/**
* 下游节点编号
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int downstreamNodeId;
/**
* 受影响车道数量
* [0..16]
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int referenceLanesNum;
/**
* 受影响车道
* N 个受影响车道，其中 N 为受影响车道数量，单个车道取值范围[0..15]，其中，0：保留位，1-15 分别表示车道1-车道15
* (referenceLanesNum == {@link Integer#MIN_VALUE} && referenceLanes == null) 表示解析失败/异常
*/
public final int[] referenceLanes;
public ReferenceLink(int upstreamNodeId, int downstreamNodeId, int referenceLanesNum, int[] referenceLanes) {
this.upstreamNodeId = upstreamNodeId;
this.downstreamNodeId = downstreamNodeId;
this.referenceLanesNum = referenceLanesNum;
this.referenceLanes = referenceLanes;
}
@Override
public String toString() {
return "{" +
"上游节点编号=" + upstreamNodeId +
", 下游节点编号=" + downstreamNodeId +
", 受影响车道数量=" + referenceLanesNum +
", 受影响车道=" + Arrays.toString(referenceLanes) +
'}';
}
}
}
}

119
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/info/AdviceEvwInfo.java Normal file
View File

@@ -0,0 +1,119 @@
package com.zhjt.mogo.adas.data.bean.cloud.info;
import com.zhjt.mogo.adas.common.cloud.AdviceEvwType;
import com.zhjt.mogo.adas.data.bean.cloud.component.Position;
import java.util.Arrays;
/**
* 实时决策建议 紧急车辆预警指令
*/
public final class AdviceEvwInfo {
/**
* 事件唯一标识
* 一组固定长度为 36 个字节的字符串，UTF-8 编码，标识命令唯一编号；同一影响目标交通参与物同一 uuid
* null 表示解析失败/异常
*/
public final String uuid;
/**
* 事件生成时间戳
* 事件生成的时间戳，UTC 时间（东八区），单位：ms，不可缺省
* {@link Long#MIN_VALUE}或-1 表示解析失败/异常
*/
public final long timestamp;
/**
* 告警类型
* 固定值为 6511，用于匹配 RSI
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int alertType;
/**
* 告警半径
* [0..102.4]，单位：m，6553.5表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double alertRadius;
/**
* 路径点数量
* [0..31]，告警路径中路径点数量，取值为0 时，不发送告警路径
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int pointNum;
/**
* 告警路径
* N 个路径点，其中 N 为路径点数量。如果传递一个点则生成RSI 时改为两个一样的点，如果未传递，则生成 RSI 时填入两个默认零点[0,0,0]，POSITION 数据结构应符合表 2 的要求
* (pointNum == {@link Integer#MIN_VALUE} && alertPath == null) 表示解析失败/异常
*/
public final Position[] alertPath;
/**
* 车辆类型
* 枚举类型：[0..10]，0：失效；1：救护车；2：警车；3：消防车；4-10：预留；255表示缺省
* {@link AdviceEvwType#ERROR} 表示解析失败/异常
*/
public final AdviceEvwType type;
/**
* 车速
* [0..200.00]，紧急车辆的行驶速度，单位：m/s，655.35表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double velocity;
/**
* 航向角
* [0..360.0000]，紧急车辆的航向角，为正北方向顺时针旋转至与车辆当前运动方向重合所转过的角度，单位：°，-1表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double heading;
/**
* 决策建议消息的生成与消散
* 0：无效 1：有效 255：缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int valid;
/**
* 紧急车辆位置
* null 表示解析失败/异常
*/
public final Position position;
public AdviceEvwInfo(String uuid, long timestamp, int alertType, double alertRadius, int pointNum, Position[] alertPath, int type, double velocity, double heading, int valid, Position position) {
this.uuid = uuid;
this.timestamp = timestamp;
this.alertType = alertType;
this.alertRadius = alertRadius;
this.pointNum = pointNum;
this.alertPath = alertPath;
this.type = AdviceEvwType.getType(type);
this.velocity = velocity;
this.heading = heading;
this.valid = valid;
this.position = position;
}
@Override
public String toString() {
return "紧急车辆预警指令{" +
"事件唯一标识=" + uuid +
", 事件生成时间戳=" + timestamp +
", 告警类型=" + alertType +
", 告警半径=" + alertRadius +
"m, 路径点数量=" + pointNum +
", 告警路径=" + Arrays.toString(alertPath) +
", 车辆类型=" + type +
", 车速=" + velocity +
"m/s, 航向角=" + heading +
"°, 决策建议消息的生成与消散=" + valid +
", 紧急车辆位置=" + position +
'}';
}
}

147
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/info/AdviceGlosaInfo.java Normal file
View File

@@ -0,0 +1,147 @@
package com.zhjt.mogo.adas.data.bean.cloud.info;
import com.zhjt.mogo.adas.common.cloud.AdviceGlosaSpdExpManeuver;
import com.zhjt.mogo.adas.common.cloud.AdviceGlosaType;
import java.util.Arrays;
/**
* 信号灯路口车速引导功能指令
*/
public final class AdviceGlosaInfo {
/**
* 事件唯一标识
* 一组固定长度为 36 个字节的字符串，UTF-8 编码，标识命令唯一编号
* null 表示解析失败/异常
*/
public final String uuid;
/**
* 事件生成时间戳
* 事件生成的时间戳，UTC 时间（东八区），单位：ms，不可缺省，0xFFFFFFFFFFFFFFFF 表示异常
* {@link Long#MIN_VALUE}或-1 表示解析失败/异常
*/
public final long timestamp;
/**
* 告警类型
* 固定值为 6523，用于匹配 RSI
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int alertType;
/**
* 有效标识
* 枚举类型：[0..1]，0：失效；1：有效
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int valid;
/**
* 命令标识
* 枚举类型：[0..3]，0：失效；1：引导；2：停车指令；3：启动指令
* {@link AdviceGlosaType#ERROR} 表示解析失败/异常
*/
public final AdviceGlosaType type;
/**
* 车辆所在位置到停止线距离
* [0..655.34]，单位：m，655.35表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double d2StopLine;
/**
* 车道方向建议速度组数
* [0..255]，0 表示无效，不发送车道方向建议车速数据，其他值均表示有效的车道方向建议速度组数
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int spdExpNum;
/**
* 车道方向建议速度
* N 组车道方向建议车速信息，车道方向建议车速信息数据结构应符合表 26 的要求
* (spdExpNum == {@link Integer#MIN_VALUE} && spdExps == null) 表示解析失败/异常
*/
public final SpdExp[] spdExps;
public AdviceGlosaInfo(String uuid, long timestamp, int alertType, int valid, int type, double d2StopLine, int spdExpNum, SpdExp[] spdExps) {
this.uuid = uuid;
this.timestamp = timestamp;
this.alertType = alertType;
this.valid = valid;
this.type = AdviceGlosaType.getType(type);
this.d2StopLine = d2StopLine;
this.spdExpNum = spdExpNum;
this.spdExps = spdExps;
}
@Override
public String toString() {
return "信号灯路口车速引导功能指令{" +
"事件唯一标识=" + uuid +
", 事件生成时间戳=" + timestamp +
", 告警类型=" + alertType +
", 有效标识=" + valid +
", 命令标识=" + type +
", 车辆所在位置到停止线距离=" + d2StopLine +
"m, 车道方向建议速度组数=" + spdExpNum +
", 车道方向建议速度=" + Arrays.toString(spdExps) +
'}';
}
/**
* 车道方向建议速度
*/
public final static class SpdExp {
/**
* 车速上限
* [0..200.00]，单位：m/s，655.35表示缺省
*/
public final double spdMax;
/**
* 车速下限
* [0..200.00]，单位：m/s，655.35表示缺省
*/
public final double spdMin;
/**
* 建议车速
* [0..200.00]，单位：m/s，655.35表示缺省
*/
public final double spdExp;
/**
* 通行行为
* 枚举类型：[0..4]，车辆下个路口的通行行为，0：直行；1：左转；3：右转；4：掉头；255表示缺省
*/
public final AdviceGlosaSpdExpManeuver maneuver;
/**
* 绿灯通过前方路口数量
* [0..254]，车辆绿灯通过前方路口数量，其中0 表示无法绿灯通过前方路口，255表示缺省
*/
public final int numIntersection;
public SpdExp(double spdMax, double spdMin, double spdExp, int maneuver, int numIntersection) {
this.spdMax = spdMax;
this.spdMin = spdMin;
this.spdExp = spdExp;
this.maneuver = AdviceGlosaSpdExpManeuver.getType(maneuver);
this.numIntersection = numIntersection;
}
@Override
public String toString() {
return "{" +
"车速上限=" + spdMax +
"m/s, 车速下限=" + spdMin +
"m/s, 建议车速=" + spdExp +
"m/s, 通行行为=" + maneuver +
", 绿灯通过前方路口数量=" + numIntersection +
'}';
}
}
}

101
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/info/AdviceLaneSpdLmtInfo.java Normal file
View File

@@ -0,0 +1,101 @@
package com.zhjt.mogo.adas.data.bean.cloud.info;
import com.zhjt.mogo.adas.data.bean.cloud.component.Position;
import com.zhjt.mogo.adas.data.bean.cloud.component.SpeedLimit;
import java.util.Arrays;
/**
* 实时决策建议 动态车道级限速指令
*/
public final class AdviceLaneSpdLmtInfo {
/**
* 事件唯一标识
* 一组固定长度为 36 个字节的字符串，UTF-8 编码，标识命令唯一编号
* null 表示解析失败/异常
*/
public final String uuid;
/**
* 事件生成时间戳
* 事件生成的时间戳，UTC 时间（东八区），单位：ms，不可缺省，0xFFFFFFFFFFFFFFFF 表示异常
* {@link Long#MIN_VALUE}或-1 表示解析失败/异常
*/
public final long timestamp;
/**
* 告警类型
* 固定值为 6517，用于匹配 RSI
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int alertType;
/**
* 告警半径
* [0..102.4]，单位：m，6553.5表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double alertRadius;
/**
* 路径点数量
* [0..31]，告警路径中路径点数量，取值为0 时，不发送告警路径
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int pointNum;
/**
* 告警路径
* N 个路径点，其中 N 为路径点数量。如果传递一个点则生成RSI 时改为两个一样的点，如果未传递，则生成 RSI 时填入两个默认零点[0,0,0]，POSITION 数据结构应符合表 2 的要求
* (pointNum == {@link Integer#MIN_VALUE} && alertPath == null) 表示解析失败/异常
*/
public final Position[] alertPath;
/**
* 车道数量
* 当前道路上包含的车道数量
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int laneNum;
/**
* 限速数据
* N 个限速信息，其中 N 为车道数量，SPEEDLIMIT 数据结构应符合表2 的要求
* (laneNum == {@link Integer#MIN_VALUE} && speedLmt == null) 表示解析失败/异常
*/
public final SpeedLimit[] speedLmt;
/**
* 决策建议消息的生成与消散
* 0：无效 1：有效 255：缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int valid;
public AdviceLaneSpdLmtInfo(String uuid, long timestamp, int alertType, double alertRadius, int pointNum, Position[] alertPath, int laneNum, SpeedLimit[] speedLmt, int valid) {
this.uuid = uuid;
this.timestamp = timestamp;
this.alertType = alertType;
this.alertRadius = alertRadius;
this.pointNum = pointNum;
this.alertPath = alertPath;
this.laneNum = laneNum;
this.speedLmt = speedLmt;
this.valid = valid;
}
@Override
public String toString() {
return "动态车道级限速指令{" +
"事件唯一标识=" + uuid +
", 事件生成时间戳=" + timestamp +
", 告警类型=" + alertType +
", 告警半径=" + alertRadius +
"m, 路径点数量=" + pointNum +
", 告警路径=" + Arrays.toString(alertPath) +
", 车道数量=" + laneNum +
", 限速数据=" + Arrays.toString(speedLmt) +
", 决策建议消息的生成与消散=" + valid +
'}';
}
}

157
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/info/AstFuncTlmInfo.java Normal file
View File

@@ -0,0 +1,157 @@
package com.zhjt.mogo.adas.data.bean.cloud.info;
import com.zhjt.mogo.adas.common.cloud.AstFuncTlmControlMode;
import com.zhjt.mogo.adas.common.cloud.AstFuncTlmPhaseStateLightState;
import com.zhjt.mogo.adas.common.cloud.AstFuncTlmPhaseStateLightType;
import java.util.Arrays;
/**
* 云端下发信号灯信息
*/
public final class AstFuncTlmInfo {
/**
* 红绿灯控制方式
* 枚举类型：[1..254]，1：固定周期；2：手动控制；3：黄闪控制，4-254：预留；0xFF 表示缺省，填缺省值时数据无效
* {@link AstFuncTlmControlMode#ERROR} 表示解析失败/异常
*/
public final AstFuncTlmControlMode controlMode;
/**
* 区域 ID
* [0..65535]，信号灯作用位置所在区域唯一编号,与路口ID 一起确定唯一路口
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int regionId;
/**
* 路口 ID
* [0..65535]，信号灯作用位置在该区域内唯一编号,与区域ID 一起确定唯一路口
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int nodeId;
/**
* 车辆所在车道对应信号灯相位数量
* [0..253]，车辆所在车道对应前方第一个信号灯路口内所绑定支持的相位数量，255 表示无效，异常或无效时，不发送车辆所在车道对应信号灯相位 ID 列表字段
* {@link Integer#MIN_VALUE}或254 表示解析失败/异常
*/
public final int numOfLanePhase;
/**
* 车辆所在车道对应信号灯相位 ID 列表
* M 个车辆所在车道对应前方第一个信号灯路口内所有的相位ID（如：车道方向直行、左转、右转、掉头对应的相位ID），表示单个车道绑定的所有相位 ID，其中 M 为车辆所在车道对应信号灯相位数量
* (numOfLanePhase == Integer#MIN_VALUE && lanePhaseIds == null) 表示解析失败/异常
*/
public final int[] lanePhaseIds;
/**
* 车辆到前方停止线距离
* [0..655.34]，单位：m，655.35表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double d2StopLine;
/**
* 相位数量
* [0..255]，信号灯相位数量
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int phaseNumber;
/**
* 信号灯相位状态
* N 个信号灯等相位状态数据，其中 N 为相位数量，当云端可以获取车辆行驶路径时，可以只发送相应相位的红绿灯信息。信号灯相位状态数据接口应符合表 65 的要求
* (phaseNumber == {@link Integer#MIN_VALUE} && phaseState == null) 表示解析失败/异常
*/
public final PhaseState[] phaseState;
public AstFuncTlmInfo(int controlMode, int regionId, int nodeId, int numOfLanePhase, int[] lanePhaseIds, double d2StopLine, int phaseNumber, PhaseState[] phaseState) {
this.controlMode = AstFuncTlmControlMode.getType(controlMode);
this.regionId = regionId;
this.nodeId = nodeId;
this.numOfLanePhase = numOfLanePhase;
this.lanePhaseIds = lanePhaseIds;
this.d2StopLine = d2StopLine;
this.phaseNumber = phaseNumber;
this.phaseState = phaseState;
}
@Override
public String toString() {
return "云端下发信号灯信息{" +
"红绿灯控制方式=" + controlMode +
", 区域 ID=" + regionId +
", 路口 ID=" + nodeId +
", 车辆所在车道对应信号灯相位数量=" + numOfLanePhase +
", 车辆所在车道对应信号灯相位 ID 列表=" + Arrays.toString(lanePhaseIds) +
", 车辆到前方停止线距离=" + d2StopLine +
"m, 相位数量=" + phaseNumber +
", 信号灯相位状态=" + Arrays.toString(phaseState) +
'}';
}
/**
* 信号灯相位状态
*/
public final static class PhaseState {
/**
* 相位编号
* [0..255]，当前道路向某下游节点行驶时所对应的信号灯相位ID
*/
public final int phaseID;
/**
* 当前灯色
* 枚举类型：[0..255]，0：未知状态；1：信号灯未工作；2：红闪；3：红灯状态；4：绿灯待行状态；5：绿灯状态；6：受保护相位绿灯（箭头灯）；7：黄灯状态；8：黄闪；9-254：预留；255：故障；不可缺省
*/
public final AstFuncTlmPhaseStateLightState lightState;
/**
* 当前灯色剩余时间
* [0..255]，信号灯组灯色剩余时间，单位：秒；0：不确定；1-254：剩余时间；255：剩余时间超过254s；不可缺省
*/
public final int timeLeft;
/**
* 下一阶段灯色
* 枚举类型：[0..255]，0：未知状态；1：信号灯未工作；2：红闪；3：红灯状态；4：绿灯待行状态；5：绿灯状态；6：受保护相位绿灯（箭头灯）；7：黄灯状态；8：黄闪；9-254：预留；255：故障；不可缺省
*/
public final AstFuncTlmPhaseStateLightState nextLightState;
/**
* 下一阶段灯色持续时间
* [0..255]，信号灯组灯色剩余时间，单位：秒；0：不确定；1-254：剩余时间；255：剩余时间超过 254s；不可缺省
*/
public final int nextLightTime;
/**
* 灯组类型
* 枚举类型：[1..254]，1：直行方向指示信号灯；2：左转方向指示信号灯；3：右转方向指示信号灯；4：机动车信号灯；5：左转非机动车信号灯；6：右转非机动车信号灯；7：非机动车信号灯；8：人行横道信号灯；9：掉头信号灯；10：车道信号灯；11：道口信号灯；12：闪光警告信号灯；13：有轨电车专用信号灯（直行）；14：有轨电车专用信号灯（左转）；15：有轨电车专用信号灯（右转）；17-254：预留；0xFF 表示无效或未知灯组类型
*/
public final AstFuncTlmPhaseStateLightType lightType;
public PhaseState(int phaseID, int lightState, int timeLeft, int nextLightState, int nextLightTime, int lightType) {
this.phaseID = phaseID;
this.lightState = AstFuncTlmPhaseStateLightState.getType(lightState);
this.timeLeft = timeLeft;
this.nextLightState = AstFuncTlmPhaseStateLightState.getType(nextLightState);
this.nextLightTime = nextLightTime;
this.lightType = AstFuncTlmPhaseStateLightType.getType(lightType);
}
@Override
public String toString() {
return "{" +
"相位编号=" + phaseID +
", 当前灯色=" + lightState +
", 当前灯色剩余时间=" + timeLeft +
", 下一阶段灯色=" + nextLightState +
", 下一阶段灯色持续时间=" + nextLightTime +
", 灯组类型=" + lightType +
'}';
}
}
}

122
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/info/rsi/AdviceRsiAbandonInfo.java Normal file
View File

@@ -0,0 +1,122 @@
package com.zhjt.mogo.adas.data.bean.cloud.info.rsi;
import com.zhjt.mogo.adas.common.cloud.AdviceEventType;
import com.zhjt.mogo.adas.common.cloud.RsiCloudDecisionEventType;
import com.zhjt.mogo.adas.data.bean.cloud.component.Position;
import com.zhjt.mogo.adas.data.bean.cloud.info.AdviceComRsiInfo;
import com.zhjt.mogo.adas.data.bean.cloud.pojo.AdvicePojo;
import java.util.Arrays;
/**
* 实时决策建议 rsi 路面遗撒预警功能-扩展字段补充
* 当
* {@link AdvicePojo#eventType} == {@link AdviceEventType#CLOUD_DECISION}
* &&
* {@link AdviceComRsiInfo.Rsi#eventType} == {@link RsiCloudDecisionEventType#ROAD_DEBRIS_WARNING}
* 使用
*/
public final class AdviceRsiAbandonInfo {
/**
* 决策建议消息的生成与消散
* 0：无效 1：有效 255：缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int valid;
/**
* 路面遗撒事件特征物的长度
* [0..655.34]，655.35 表示缺省，单位：m
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double len;
/**
* 路面遗撒事件特征物的宽度
* [0..655.34]，655.35 表示缺省，单位：m
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double width;
/**
* 路面遗撒事件特征物的高度
* [0..655.34]，655.35 表示缺省，单位：m
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double height;
/**
* 障碍物所在车道对应的 road车道编号 0：无效
* {@link Long#MIN_VALUE} 或 -1 表示解析失败/异常
*/
public final long roadId;
/**
* 异常车辆所在车道, 异常车辆所在车道编号 0-255 0： 无效； 1：最内侧车道，向外依次递增 ； 255： 缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int laneId;
/**
* 受事件影响不能通行车道数量
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int laneOfEventNum;
/**
* 受事件影响不能通行车道
* (laneOfEventNum == {@link Integer#MIN_VALUE} && lanOfEvent == null) 表示解析失败/异常
*/
public final int[] lanOfEvent;
/**
* 事件影响范围数量
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int boundPolyWktNum;
/**
* 事件影响范围，为多个点的集合
* (boundPolyWktNum == {@link Integer#MIN_VALUE} && boundPolyWkt == null) 表示解析失败/异常
*/
public final Position[] boundPolyWkt;
/**
* 距离
* [0..655.34]，单位：m，655.35 表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double distance;
public AdviceRsiAbandonInfo(int valid, double len, double width, double height, long roadId, int laneId, int laneOfEventNum, int[] lanOfEvent, int boundPolyWktNum, Position[] boundPolyWkt, double distance) {
this.valid = valid;
this.len = len;
this.width = width;
this.height = height;
this.roadId = roadId;
this.laneId = laneId;
this.laneOfEventNum = laneOfEventNum;
this.lanOfEvent = lanOfEvent;
this.boundPolyWktNum = boundPolyWktNum;
this.boundPolyWkt = boundPolyWkt;
this.distance = distance;
}
@Override
public String toString() {
return "路面遗撒预警功能-扩展字段补充{" +
"决策建议消息的生成与消散=" + valid +
", 路面遗撒事件特征物的长度=" + len +
"m, 路面遗撒事件特征物的宽度=" + width +
"m, 路面遗撒事件特征物的高度=" + height +
"m, 障碍物所在车道对应的road车道编号=" + roadId +
", 异常车辆所在车道=" + laneId +
", 受事件影响不能通行车道数量=" + laneOfEventNum +
", 受事件影响不能通行车道=" + Arrays.toString(lanOfEvent) +
", 事件影响范围数量=" + boundPolyWktNum +
", 事件影响范围=" + Arrays.toString(boundPolyWkt) +
", 距离=" + distance +
"m}";
}
}

109
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/info/rsi/AdviceRsiLaneProposalInfo.java Normal file
View File

@@ -0,0 +1,109 @@
package com.zhjt.mogo.adas.data.bean.cloud.info.rsi;
import com.zhjt.mogo.adas.common.cloud.AdviceEventType;
import com.zhjt.mogo.adas.common.cloud.RsiCloudDecisionEventType;
import com.zhjt.mogo.adas.data.bean.cloud.info.AdviceComRsiInfo;
import com.zhjt.mogo.adas.data.bean.cloud.pojo.AdvicePojo;
import java.util.Arrays;
/**
* 实时决策建议 rsi 行驶车道建议功能-扩展字段补充
* 当
* {@link AdvicePojo#eventType} == {@link AdviceEventType#CLOUD_DECISION}
* &&
* {@link AdviceComRsiInfo.Rsi#eventType} == ({@link RsiCloudDecisionEventType#DRIVING_LANE_SUGGESTION_6031} || {@link RsiCloudDecisionEventType#DRIVING_LANE_SUGGESTION_6032)
* 使用
*/
public final class AdviceRsiLaneProposalInfo {
/**
* 决策建议消息的生成与消散
* 0：无效 1：有效 255：缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int valid;
/**
* 建议目标车道数量
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int tagLaneDataNum;
/**
* 建议目标车道信息
* (tagLaneDataNum == {@link Integer#MIN_VALUE} && tagLaneData == null) 表示解析失败/异常
*/
public final TagLaneData[] tagLaneData;
/**
* 当前车道序号 车道编号 0-255 ,0：无效 ，1:为最内侧车道，向外依次递增，255：缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int curLaneSeq;
/**
* 当前车道road序号 车道编号 0：无效, -1 缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int curRoadSeq;
/**
* 车道转向 0-255，0：无效，1：直行，2：左转， 3：右转，4：掉头，255：缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int directionType;
/**
* 变道方向 0-255，0：无效，1：左变道，2：右变道，3：按当前车道，255：缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int laneChgType;
public AdviceRsiLaneProposalInfo(int valid, int tagLaneDataNum, TagLaneData[] tagLaneData, int curLaneSeq, int curRoadSeq, int directionType, int laneChgType) {
this.valid = valid;
this.tagLaneDataNum = tagLaneDataNum;
this.tagLaneData = tagLaneData;
this.curLaneSeq = curLaneSeq;
this.curRoadSeq = curRoadSeq;
this.directionType = directionType;
this.laneChgType = laneChgType;
}
@Override
public String toString() {
return "行驶车道建议功能-扩展字段补充{" +
"决策建议消息的生成与消散=" + valid +
", 建议目标车道数量=" + tagLaneDataNum +
", 建议目标车道信息=" + Arrays.toString(tagLaneData) +
", 当前车道序号=" + curLaneSeq +
", 当前车道road序号=" + curRoadSeq +
", 车道转向=" + directionType +
", 变道方向=" + laneChgType +
'}';
}
public static final class TagLaneData {
/**
* 建议（目标）车道序号 车道编号 0-255 ,0：无效 ，1:为最内侧车道，向外依次递增，255：缺省
*/
public final int tagLaneSeq;
/**
* 建议（目标）车道road序号 车道编号 0：无效, -1缺省
*/
public final int tagRoadSeq;
public TagLaneData(int tagLaneSeq, int tagRoadSeq) {
this.tagLaneSeq = tagLaneSeq;
this.tagRoadSeq = tagRoadSeq;
}
@Override
public String toString() {
return "{" +
"建议（目标）车道序号=" + tagLaneSeq +
", 建议（目标）车道road序号=" + tagRoadSeq +
'}';
}
}
}

80
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/info/rsi/AdviceRsiLightWarningInfo.java Normal file
View File

@@ -0,0 +1,80 @@
package com.zhjt.mogo.adas.data.bean.cloud.info.rsi;
import com.zhjt.mogo.adas.common.cloud.AdviceEventType;
import com.zhjt.mogo.adas.common.cloud.RsiCloudDecisionEventType;
import com.zhjt.mogo.adas.data.bean.cloud.info.AdviceComRsiInfo;
import com.zhjt.mogo.adas.data.bean.cloud.pojo.AdvicePojo;
import java.util.Arrays;
/**
* 实时决策建议 rsi 闯红灯预警功能-扩展字段补充
* 当
* {@link AdvicePojo#eventType} == {@link AdviceEventType#CLOUD_DECISION}
* &&
* {@link AdviceComRsiInfo.Rsi#eventType} == {@link RsiCloudDecisionEventType#RED_LIGHT_RUNNING_WARNING}
* 使用
*/
public final class AdviceRsiLightWarningInfo {
/**
* 决策建议消息的生成与消散
* 0：无效 1：有效 255：缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int valid;
/**
* 车辆所在位置到停止线的距离
* 单位：m，0xFFFF 表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double d2StopLine;
/**
* 预警相位个数
* 0-255，0：无效，255：缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int numPhase;
/**
* 预警相位列表
* null 表示解析失败/异常
*/
public final int[] spatWarning;
/**
* 预警方向相位ID
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int phaseId;
/**
* 预警类型
* 0-255，0：无效，1：表示当前为红灯状态，2：表示当前为非红灯状态，255：缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int warningType;
public AdviceRsiLightWarningInfo(int valid, double d2StopLine, int numPhase, int[] spatWarning, int phaseId, int warningType) {
this.valid = valid;
this.d2StopLine = d2StopLine;
this.numPhase = numPhase;
this.spatWarning = spatWarning;
this.phaseId = phaseId;
this.warningType = warningType;
}
@Override
public String toString() {
return "闯红灯预警功能-扩展字段补充{" +
"决策建议消息的生成与消散=" + valid +
", 车辆所在位置到停止线的距离=" + d2StopLine +
"m, 预警相位个数=" + numPhase +
", 预警相位列表=" + Arrays.toString(spatWarning) +
", 预警方向相位ID=" + phaseId +
", 预警类型=" + warningType +
'}';
}
}

164
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/info/rsi/AdviceRsiOtherCarBreakReadWarningInfo.java Normal file
View File

@@ -0,0 +1,164 @@
package com.zhjt.mogo.adas.data.bean.cloud.info.rsi;
import com.zhjt.mogo.adas.common.cloud.AdviceEventType;
import com.zhjt.mogo.adas.common.cloud.RsiCloudDecisionEventType;
import com.zhjt.mogo.adas.data.bean.cloud.info.AdviceComRsiInfo;
import com.zhjt.mogo.adas.data.bean.cloud.pojo.AdvicePojo;
import java.util.Arrays;
/**
* 实时决策建议 rsi 路口其他车辆闯红灯预警功能-扩展字段补充
* 当
* {@link AdvicePojo#eventType} == {@link AdviceEventType#CLOUD_DECISION}
* &&
* {@link AdviceComRsiInfo.Rsi#eventType} == {@link RsiCloudDecisionEventType#INTERSECTION_RED_LIGHT_WARNING}
* 使用
*/
public final class AdviceRsiOtherCarBreakReadWarningInfo {
/**
* 决策建议消息的生成与消散
* 0：无效 1：有效 255：缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int valid;
/**
* 车辆所在位置到停止线的距离
* [0..655.34]，单位：m，655.35表示缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final double d2StopLine;
/**
* 建议目标车道数量
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int numPhase;
/**
* 预警相位
* (numPhase == {@link Integer#MIN_VALUE} && spatWaring == null) 表示解析失败/异常
*/
public final int[] spatWaring;
/**
* 预警方向相位 ID
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int phaseId;
/**
* 预警类型，0-255，0：无效，1：表示当前为红灯状态，2：表示当前为非红灯状态，255：缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int warningType;
/**
* 目标车辆数量
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int objectiveNum;
/**
* 车辆列表
* (objectiveNum == {@link Integer#MIN_VALUE} && objective == null) 表示解析失败/异常
*/
public final OtherCar[] objective;
public AdviceRsiOtherCarBreakReadWarningInfo(int valid, double d2StopLine, int numPhase, int[] spatWaring, int phaseId, int warningType, int objectiveNum, OtherCar[] objective) {
this.valid = valid;
this.d2StopLine = d2StopLine;
this.numPhase = numPhase;
this.spatWaring = spatWaring;
this.phaseId = phaseId;
this.warningType = warningType;
this.objectiveNum = objectiveNum;
this.objective = objective;
}
@Override
public String toString() {
return "路口其他车辆闯红灯预警功能-扩展字段补充{" +
"决策建议消息的生成与消散=" + valid +
", 车辆所在位置到停止线的距离=" + d2StopLine +
"m, 建议目标车道数量=" + numPhase +
", 预警相位=" + Arrays.toString(spatWaring) +
", 预警方向相位ID=" + phaseId +
", 预警类型=" + warningType +
", 目标车辆数量=" + objectiveNum +
", 车辆列表=" + Arrays.toString(objective) +
'}';
}
public static final class OtherCar {
/**
* 事件唯一标识
* null 表示解析失败/异常
*/
public final String uuid;
/**
* 车辆类型
* 2：乘用车
* 4：特殊用车辆
* 5：公交车
* 7：卡车
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int type;
/**
* 异常车辆的行驶速度
* [0..200.00]，单位：m/s，655.35 表示缺省
*/
public final double speed;
/**
* 经度，单位：°，表示-180.0000000°～180.0000000°，大于0 表示东经，不可缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double longitude;
/**
* 纬度，单位：°，表示-90.0000000°～90.0000000°，大于 0 表示北纬，不可缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double latitude;
/**
* 航向角
* [0..360.0000]，异常车辆的航向角，为正北方向顺时针旋转至与车辆当前运动方向重合所转过的角度，单位：°，-1表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double heading;
public OtherCar(String uuid, int type, double speed, int longitude, int latitude, int heading) {
this.uuid = uuid;
this.type = type;
this.speed = speed;
if (longitude == -1) {
this.longitude = Double.MIN_VALUE;
} else {
this.longitude = (longitude / 10000000.0D) - 180.0;
}
if (latitude == -1) {
this.latitude = Double.MIN_VALUE;
} else {
this.latitude = (latitude / 10000000.0D) - 90.0;
}
if (heading == -1) {
this.heading = Double.MIN_VALUE;
} else {
this.heading = heading / 10000.0D;
}
}
@Override
public String toString() {
return "{" +
"事件唯一标识='" + uuid + '\'' +
", 车辆类型=" + type +
", 异常车辆的行驶速度=" + speed +
"m/s, 经度=" + longitude +
"°, 纬度=" + latitude +
"°, 航向角=" + heading +
"°}";
}
}
}

75
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/info/rsi/AdviceRsiOverSightDistanceInfo.java Normal file
View File

@@ -0,0 +1,75 @@
package com.zhjt.mogo.adas.data.bean.cloud.info.rsi;
import com.zhjt.mogo.adas.common.cloud.AdviceEventType;
import com.zhjt.mogo.adas.common.cloud.RsiCloudDecisionEventType;
import com.zhjt.mogo.adas.data.bean.cloud.info.AdviceComRsiInfo;
import com.zhjt.mogo.adas.data.bean.cloud.pojo.AdvicePojo;
/**
* 实时决策建议 rsi 超视距弱势交通参与者预警功能-扩展字段补充
* 当
* {@link AdvicePojo#eventType} == {@link AdviceEventType#CLOUD_DECISION}
* &&
* {@link AdviceComRsiInfo.Rsi#eventType} == {@link RsiCloudDecisionEventType#ROAD_HAZARD_ALERT_SERVICE_6021}
* 使用
*/
public final class AdviceRsiOverSightDistanceInfo {
/**
* 决策建议消息的生成与消散
* 0：无效 1：有效 255：缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int valid;
/**
* 弱势交通参与者类型 0： 未知； 1： 行人； 2：非机动车； 255： 缺省； 其他：预留
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int type;
/**
* 异常车辆的行驶速度
* [0..200.00]，单位：m/s，655.35 表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double velocity;
/**
* 航向角
* [0..360.0000]，异常车辆的航向角，为正北方向顺时针旋转至与车辆当前运动方向重合所转过的角度，单位：°，-1表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double heading;
/**
* 距离
* [0..655.34]，单位：m，655.35 表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double distance;
public AdviceRsiOverSightDistanceInfo(int valid, int type, double velocity, int heading, double distance) {
this.valid = valid;
this.type = type;
this.velocity = velocity;
if (heading == -1) {
this.heading = Double.MIN_VALUE;
} else {
this.heading = heading / 10000.0D;
}
this.distance = distance;
}
@Override
public String toString() {
return "超视距弱势交通参与者预警功能-扩展字段补充{" +
"决策建议消息的生成与消散=" + valid +
", 弱势交通参与者类型=" + type +
", 异常车辆的行驶速度=" + velocity +
"m/s, heading=" + heading +
"°, distance=" + distance +
"m}";
}
}

105
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/info/rsi/AdviceRsiRoadDangerHintInfo.java Normal file
View File

@@ -0,0 +1,105 @@
package com.zhjt.mogo.adas.data.bean.cloud.info.rsi;
import com.zhjt.mogo.adas.common.cloud.AdviceEventType;
import com.zhjt.mogo.adas.common.cloud.RsiCloudDecisionEventType;
import com.zhjt.mogo.adas.data.bean.cloud.component.Position;
import com.zhjt.mogo.adas.data.bean.cloud.info.AdviceComRsiInfo;
import com.zhjt.mogo.adas.data.bean.cloud.pojo.AdvicePojo;
import java.util.Arrays;
/**
* 实时决策建议 rsi 道路危险状况提示服务功能-扩展字段补充
* 当
* {@link AdvicePojo#eventType} == {@link AdviceEventType#CLOUD_DECISION}
* &&
* {@link AdviceComRsiInfo.Rsi#eventType} == ({@link RsiCloudDecisionEventType#ROAD_HAZARD_ALERT_SERVICE_6021} || {@link RsiCloudDecisionEventType#ROAD_HAZARD_ALERT_SERVICE_6022})
* 使用
*/
public final class AdviceRsiRoadDangerHintInfo {
/**
* 决策建议消息的生成与消散
* 0：无效 1：有效 255：缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int valid;
/**
* 危险事件编码
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int alterType;
/**
* 受事件影响不能通行的车道数量
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int laneOfEventNum;
/**
* 受事件影响不能通行的车道，最内侧车道 id 为 1，
* 往外依次递增
* null 表示解析失败/异常
*/
public final int[] laneOfEvent;
/**
* 车辆所在位置到停止线的距离
* [0..655.34]，单位：m，65535表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double d2Event;
/**
* 事件开始时间
* {@link Long#MIN_VALUE} 表示解析失败/异常
*/
public final long startTime;
/**
* 事件结束时间
* {@link Long#MIN_VALUE} 表示解析失败/异常
*/
public final long endTime;
/**
* 点集合数量
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int boundPolyWktNum;
/**
* 事件影响范围，为多个点的集合
* (boundPolyWktNum == {@link Integer#MIN_VALUE} && boundPolyWkt == null) 表示解析失败/异常
*/
public final Position[] boundPolyWkt;
public AdviceRsiRoadDangerHintInfo(int valid, int alterType, int laneOfEventNum, int[] laneOfEvent, double d2Event, long startTime, long endTime, int boundPolyWktNum, Position[] boundPolyWkt) {
this.valid = valid;
this.alterType = alterType;
this.laneOfEventNum = laneOfEventNum;
this.laneOfEvent = laneOfEvent;
this.d2Event = d2Event;
this.startTime = startTime;
this.endTime = endTime;
this.boundPolyWktNum = boundPolyWktNum;
this.boundPolyWkt = boundPolyWkt;
}
@Override
public String toString() {
return "道路危险状况提示服务功能-扩展字段补充{" +
"决策建议消息的生成与消散=" + valid +
", 危险事件编码=" + alterType +
", 受事件影响不能通行的车道数量=" + laneOfEventNum +
", 受事件影响不能通行的车道=" + Arrays.toString(laneOfEvent) +
", 车辆所在位置到停止线的距离=" + d2Event +
"m, 事件开始时间=" + startTime +
", 事件结束时间=" + endTime +
", 点集合数量=" + boundPolyWktNum +
", 事件影响范围=" + Arrays.toString(boundPolyWkt) +
'}';
}
}

92
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/info/rsi/AdviceRsiTrafficJamInfo.java Normal file
View File

@@ -0,0 +1,92 @@
package com.zhjt.mogo.adas.data.bean.cloud.info.rsi;
import com.zhjt.mogo.adas.common.cloud.AdviceEventType;
import com.zhjt.mogo.adas.common.cloud.RsiCloudDecisionEventType;
import com.zhjt.mogo.adas.data.bean.cloud.info.AdviceComRsiInfo;
import com.zhjt.mogo.adas.data.bean.cloud.pojo.AdvicePojo;
import java.util.Arrays;
/**
* 实时决策建议 rsi 交通拥堵提醒功能-扩展字段补充
* 当
* {@link AdvicePojo#eventType} == {@link AdviceEventType#CLOUD_DECISION}
* &&
* {@link AdviceComRsiInfo.Rsi#eventType} == {@link RsiCloudDecisionEventType#TRAFFIC_CONGESTION_ALERT}
* 使用
*/
public final class AdviceRsiTrafficJamInfo {
/**
* 决策建议消息的生成与消散
* 0：无效 1：有效 255：缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int valid;
/**
* 车辆所在位置到停止线的距离
* [0..655.34]，单位：m，655.35 表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double dis2start;
/**
* 车道road序号数量
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int roadIdNum;
/**
* 车道road序号 车道编号 0：无效
* (roadIdNum == {@link Long#MIN_VALUE} && roadIds == null) 表示解析失败/异常
*/
public final long[] roadIds;
/**
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int rsiLaneId;
/**
* 异常车辆的行驶速度
* [0..200.00]，，单位：m/s，655.35 表示缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final double vaLane;
/**
* [0..655.34]，单位：m，655.35 表示缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final double queueLength;
/**
* 拥堵程度。0:畅通; 1:缓行; 2:拥堵; 3:重拥堵
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int eventLevel;
public AdviceRsiTrafficJamInfo(int valid, double dis2start, int roadIdNum, long[] roadIds, int rsiLaneId, double vaLane, double queueLength, int eventLevel) {
this.valid = valid;
this.dis2start = dis2start;
this.roadIdNum = roadIdNum;
this.roadIds = roadIds;
this.rsiLaneId = rsiLaneId;
this.vaLane = vaLane;
this.queueLength = queueLength;
this.eventLevel = eventLevel;
}
@Override
public String toString() {
return "交通拥堵提醒功能-扩展字段补充{" +
"决策建议消息的生成与消散=" + valid +
", dis2start=" + dis2start +
"m, 车道road序号数量=" + roadIdNum +
", 车道road序号=" + Arrays.toString(roadIds) +
", rsiLaneId=" + rsiLaneId +
", 异常车辆的行驶速度=" + vaLane +
"m, queueLength=" + queueLength +
"m, 拥堵程度=" + eventLevel +
'}';
}
}

42
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/info/rsi/AdviceRsiVisibilityInfo.java Normal file
View File

@@ -0,0 +1,42 @@
package com.zhjt.mogo.adas.data.bean.cloud.info.rsi;
import com.zhjt.mogo.adas.common.cloud.AdviceEventType;
import com.zhjt.mogo.adas.common.cloud.RsiCloudDecisionEventType;
import com.zhjt.mogo.adas.data.bean.cloud.info.AdviceComRsiInfo;
import com.zhjt.mogo.adas.data.bean.cloud.pojo.AdvicePojo;
/**
* 实时决策建议 rsi 能见度预警功能-扩展字段补充
* 当
* {@link AdvicePojo#eventType} == {@link AdviceEventType#CLOUD_DECISION}
* &&
* {@link AdviceComRsiInfo.Rsi#eventType} == {@link RsiCloudDecisionEventType#VISIBILITY_WARNING}
* 使用
*/
public final class AdviceRsiVisibilityInfo {
/**
* 能见度距离
* [0..655.34]，单位：m，655.35 表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double visibilityDis;
/**
* 决策建议消息的生成与消散
* 0：无效 1：有效 255：缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int valid;
public AdviceRsiVisibilityInfo(double visibilityDis, int valid) {
this.visibilityDis = visibilityDis;
this.valid = valid;
}
@Override
public String toString() {
return "超视距弱势交通参与者预警功能-扩展字段补充{" +
"能见度距离=" + visibilityDis +
"m, 决策建议消息的生成与消散=" + valid +
'}';
}
}

84
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/pojo/AdvicePojo.java Normal file
View File

@@ -0,0 +1,84 @@
package com.zhjt.mogo.adas.data.bean.cloud.pojo;
import com.zhjt.mogo.adas.common.cloud.AdviceEventType;
import com.zhjt.mogo.adas.common.cloud.AdviceInstructDirection;
import com.zhjt.mogo.adas.common.cloud.AdviceType;
import com.zhjt.mogo.adas.utils.ByteUtil;
/**
* 实时决策建议
* 注：请求的决策建议为通用RSI功能时，当RSIS为多组数据包时，表中车速建议、加速度建议、控车变道建议转向状态3个字段填缺省值，每组数据对应的决策信息通过自定义字段传输。
*/
public final class AdvicePojo extends BasePojo {
/**
* 建议类型
* 各项功能对应的 adviceType，若为单一功能决策结果时，功能及对应的取值应符合表 24 中的要求，若为多功能决策时，取值为254，不可缺省
* {@link AdviceType#ERROR} 表示解析失败/异常
*/
public final AdviceType adviceType;
/**
* 事件分类
* 枚举类型：[0..3]，0：未知类型；1：交通事件类；2：道路交通标志；3：云端决策建议，不可缺省
* {@link AdviceEventType#ERROR} 表示解析失败/异常
*/
public final AdviceEventType eventType;
/**
* 车速建议
* [0..200.00]，单位：m/s，655.35表示缺省，描述给车辆下发的决策建议速度
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double spdExp;
/**
* 加速度建议
* 云端向车辆下发的行驶纵向加速度建议，单位：m/s2，表示-100.00 m/s2～100.00m/s2，555.35表示缺省
* {@link Double#MIN_VALUE} 表示解析失败/异常
*/
public final double accExp;
/**
* 控车变道建议转向状态
* 枚举类型：[0..10]，0：沿车道行驶；1：第一出口；2：第二出口；3：第三出口；4：第四出口；5：第五出口；6：第六出口；7：第七出口；8：第八出口；9：左变道；10：右变道；0xFF 表示缺省；出口定义从当前道路逆时针算起，描述给车辆下发的控车变道决策指令
* {@link AdviceInstructDirection#ERROR} 表示解析失败/异常
*/
public final AdviceInstructDirection instructDirection;
/**
* 命令长度
* [0..65535]，不可缺省，0 表示命令失效，此时该条消息全部无效
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int dataLen;
/**
* 命令数据
* 长度为 N 个字节，其中 N 为命令长度，数据结构根据功能不同应分别符合 8.5.5-8.5.15 的要求
* (dataLen == Integer.MIN_VALUE && adviceData == null) 表示解析失败/异常
*/
public final byte[] adviceData;
public AdvicePojo(String vehicleId, long seq, int adviceType, int eventType, double spdExp, double accExp, int instructDirection, int dataLen, byte[] adviceData) {
super(vehicleId, seq);
this.adviceType = AdviceType.getType(adviceType);
this.eventType = AdviceEventType.getType(eventType);
this.spdExp = spdExp;
this.accExp = accExp;
this.instructDirection = AdviceInstructDirection.getType(instructDirection);
this.dataLen = dataLen;
this.adviceData = adviceData;
}
@Override
public String toString() {
return "实时决策建议{" +
super.toString() +
", 建议类型=" + adviceType +
", 事件分类=" + eventType +
", 车速建议=" + spdExp +
"m/s, 加速度建议=" + accExp +
"m/s², 控车变道建议转向状态=" + instructDirection +
", 命令长度=" + dataLen +
", 命令数据=" + ByteUtil.byteArrToHex(adviceData) +
'}';
}
}

49
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/pojo/AstFuncPojo.java Normal file
View File

@@ -0,0 +1,49 @@
package com.zhjt.mogo.adas.data.bean.cloud.pojo;
import com.zhjt.mogo.adas.common.cloud.AstFuncType;
import com.zhjt.mogo.adas.utils.ByteUtil;
/**
* 云端辅助功能信息
*/
public final class AstFuncPojo extends BasePojo {
/**
* 辅助功能类别
* 各项功能对应的 astFuncType，功能及对应的取值应符合表57 中的要求
* {@link AstFuncType#ERROR} 表示解析失败/异常
*/
public final AstFuncType astFuncType;
/**
* 命令长度
* [0..65535]，不可缺省
* {@link Integer#MIN_VALUE} 表示解析失败/异常
*/
public final int dataLen;
/**
* 命令数据
* 长度为 N 个字节，其中 N 为命令长度，数据结构根据功能不同应分别符合 8.8.6～8.8.11 的要求
* (dataLen == {@link Integer#MIN_VALUE} && infoData == null) 表示解析失败/异常
*/
public final byte[] infoData;
public AstFuncPojo(String vehicleId, long seq, int astFuncType, int dataLen, byte[] infoData) {
super(vehicleId, seq);
this.astFuncType = AstFuncType.getType(astFuncType);
this.dataLen = dataLen;
this.infoData = infoData;
}
@Override
public String toString() {
return "辅助功能{" +
super.toString() +
", 辅助功能类别=" + astFuncType +
", 命令长度=" + dataLen +
", 命令数据=" + ByteUtil.byteArrToHex(infoData) +
'}';
}
}

27
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/cloud/pojo/BasePojo.java Normal file
View File

@@ -0,0 +1,27 @@
package com.zhjt.mogo.adas.data.bean.cloud.pojo;
public abstract class BasePojo {
/**
* 车辆编号
* 长度为 8 个字节的字符串，该车辆编号必须在云控基础平台中进行登记/注册，车辆编号定义见附录 B vehicleId 编码规则，不可缺省
* null 表示解析失败/异常
*/
public final String vehicleId;
/**
* 消息标识
* [0..264-1]，云端维护（计数）下发消息中seq，车端向云端反馈收到的云端消息中的 seq 以确认接收
* {@link Long#MIN_VALUE} 表示解析失败/异常
*/
public final long seq;
public BasePojo(String vehicleId, long seq) {
this.vehicleId = vehicleId;
this.seq = seq;
}
@Override
public String toString() {
return "车辆编号=" + vehicleId + ", 消息标识=" + seq;
}
}

5
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/utils/ByteUtil.java
View File

@@ -75,6 +75,10 @@ public class ByteUtil {
return value;
}
public static int get8bitUnsignedValue(byte data) {
return data & 0xFF;
}
/**
* 无符号
* 合并 2 byte
@@ -121,6 +125,7 @@ public class ByteUtil {
* 合并 4 byte
* 使用后将 Index中的index移动到下一个数据的开始位
* *
* 0xFFFFFFFF 还是-1,返回值换成long类型可以表示无符号类型
*
* @param index 开始下标
* @param data

9
libraries/mogo-adas-data/src/main/proto/message_pad.proto
View File

@@ -102,7 +102,7 @@ enum MessageType
MsgTypeSSMFuncStatusQuery = 0x10130;//SSM功能状态查询及返回(上下行)
// MsgTypeHeartbeat = 0x10131;//PAD给域控下发心跳 1Hz 空数据 TODO 废弃，改用发送"6e 68 6f 69"数据作为心跳
MsgTypeCaptureImgReqOnTakeOver = 0x10132;//人工接管时PAD请求前后摄像头数据
MsgTypeEzhouCloud = 0x10133;//NED pad通信（不仅限于鄂州） bus ros1 MAP500版本支持， bus ros2 MAP480版本支持，taxi 还没有上
MsgTypeEzhouCloud = 0x10133;//NED鄂州pad通信（不仅限于鄂州） bus ros1 MAP500版本支持， bus ros2 MAP480版本支持，taxi 还没有上
MsgTypeCopyBag = 0x10134;//数据落盘(上下行)
MsgTypeCloudConfig = 0x10135;//云端配置查询和返回(上下行)
MsgTypeImgUploadCloudEnable = 0x10136;//摄像头上传NDE云开关
@@ -991,6 +991,13 @@ message CaptureImgOnTakeOver
bytes data = 2;
}
//message definition for MsgTypeEzhouCloud
//鄂州数据
message EZhouCloud
{
bytes data = 1;
}
//message definition for MsgTypeCloudConfig
//云连接地址
message CloudLinkAddr

3
libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/AdasChannel.java
View File

@@ -319,6 +319,8 @@ public class AdasChannel implements IAdasNetCommApi, FpgaSocket.IWebSocketConnec
dispatchHandlers.put(MessagePad.MessageType.MsgTypeM1StitchedVideo, new DispatchHandler(MessagePad.MessageType.MsgTypeM1StitchedVideo, this));
//FSM2024
dispatchHandlers.put(MessagePad.MessageType.MsgTypeFSM2024State, new DispatchHandler(MessagePad.MessageType.MsgTypeFSM2024State, this));
//NED鄂州pad通信（不仅限于鄂州）
dispatchHandlers.put(MessagePad.MessageType.MsgTypeEzhouCloud, new DispatchHandler(MessagePad.MessageType.MsgTypeEzhouCloud, this));
}
private void initSsmDispatch(AdasConstants.SsmSource source) {
@@ -666,6 +668,7 @@ public class AdasChannel implements IAdasNetCommApi, FpgaSocket.IWebSocketConnec
callError(raw.getProtocolStatus(), raw.originalData.toByteArray());
}
} catch (Exception e) {
Log.e(TAG, "onDispatchRaw", e);
callError(ProtocolStatus.BUSINESS_DATA_PARSE_FAILED, raw.originalData.toByteArray(), e);
}
}

71
libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/OnAdasListener.java
View File

@@ -16,6 +16,14 @@ import com.zhjt.mogo.adas.data.bean.LaunchConditionData;
import com.zhjt.mogo.adas.data.bean.NodeStateInfo;
import com.zhjt.mogo.adas.data.bean.ReceivedAck;
import com.zhjt.mogo.adas.data.bean.UnableLaunchReason;
import com.zhjt.mogo.adas.data.bean.cloud.info.AdviceAvwInfo;
import com.zhjt.mogo.adas.data.bean.cloud.info.AdviceComRsiInfo;
import com.zhjt.mogo.adas.data.bean.cloud.info.AdviceEvwInfo;
import com.zhjt.mogo.adas.data.bean.cloud.info.AdviceGlosaInfo;
import com.zhjt.mogo.adas.data.bean.cloud.info.AdviceLaneSpdLmtInfo;
import com.zhjt.mogo.adas.data.bean.cloud.info.AstFuncTlmInfo;
import com.zhjt.mogo.adas.data.bean.cloud.pojo.AdvicePojo;
import com.zhjt.mogo.adas.data.bean.cloud.pojo.AstFuncPojo;
import com.zhjt.mogo.adas.data.bean.power.PowerData;
import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable;
import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask;
@@ -672,6 +680,69 @@ public interface OnAdasListener {
*/
void onImgUploadCloudStatusResp(@NonNull MessagePad.Header header, @NonNull MessagePad.ImgUploadCloudStatusResp resp);
/**
* NDE下发 信号灯信息
*
* @param header 头
* @param astFuncPojo 云端辅助功能信息
* @param astFuncTlmInfo 云端下发信号灯信息
*/
void onNdeCloudAstFuncTlm(@NonNull MessagePad.Header header, @NonNull AstFuncPojo astFuncPojo, @NonNull AstFuncTlmInfo astFuncTlmInfo);
/**
* NDE下发 信号灯路口车速引导功能指令
*
* @param header 头
* @param advicePojo 实时决策建议
* @param adviceGlosaInfo 信号灯路口车速引导功能指令
*/
void onNdeCloudAdviceGlosa(@NonNull MessagePad.Header header, @NonNull AdvicePojo advicePojo, @NonNull AdviceGlosaInfo adviceGlosaInfo);
/**
* NDE下发 通用 RSI 预警指令
* 包含：
* 闯红灯预警
* 行驶车道建议
* 交通拥堵提醒
* 道路危险状况提示
* 超视距弱势交通参与者提醒
* 路口其他车辆闯红灯预警
* 障碍物(路面遗撒)预警
* 能见度预警
*
* @param header 头
* @param advicePojo 实时决策建议
* @param adviceComRsiInfo 通用RSI预警指令
*/
void onNdeCloudAdviceComRsi(@NonNull MessagePad.Header header, @NonNull AdvicePojo advicePojo, @NonNull AdviceComRsiInfo adviceComRsiInfo);
/**
* NDE下发 紧急车辆预警指令
*
* @param header 头
* @param advicePojo 实时决策建议
* @param adviceEvwInfo 紧急车辆预警指令
*/
void onNdeCloudAdviceEvw(@NonNull MessagePad.Header header, @NonNull AdvicePojo advicePojo, @NonNull AdviceEvwInfo adviceEvwInfo);
/**
* NDE下发 动态车道级限速指令
*
* @param header 头
* @param advicePojo 实时决策建议
* @param adviceLaneSpdLmtInfo 动态车道级限速指令
*/
void onNdeCloudAdviceLaneSpdLmt(@NonNull MessagePad.Header header, @NonNull AdvicePojo advicePojo, @NonNull AdviceLaneSpdLmtInfo adviceLaneSpdLmtInfo);
/**
* NDE下发 异常车辆预警指令
*
* @param header 头
* @param advicePojo 实时决策建议
* @param adviceAvwInfo 异常车辆预警指令
*/
void onNdeCloudAdviceAvw(@NonNull MessagePad.Header header, @NonNull AdvicePojo advicePojo, @NonNull AdviceAvwInfo adviceAvwInfo);
/**
* 是否有能力启动自动驾驶
*

1551
libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/msg/CloudControlMessage.java Normal file
View File

File diff suppressed because it is too large Load Diff

7
libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/msg/MyMessageFactory.java
View File

@@ -56,6 +56,7 @@ public class MyMessageFactory implements IMyMessageFactory {
private IMsg powerUnitMessage;//电源模块
private IMsg padSsmFuncMsgMessage;//SSM功能
private IMsg captureImgOnTakeOverMessage;//接管时前方和后方摄像头数据请求的响应
private IMsg cloudControlMessage;//云控数据
private IMsg copyBagMessage;//数据落盘
private IMsg cloudConfigMessage;//云端配置
private IMsg imgUploadCloudStatusRespMessage;//摄像头上传NDE云状态响应
@@ -327,6 +328,12 @@ public class MyMessageFactory implements IMyMessageFactory {
captureImgOnTakeOverMessage = new CaptureImgOnTakeOverMessage();
}
return captureImgOnTakeOverMessage;
} else if (messageType == MessageType.TYPE_RECEIVE_CLOUD_CONTROL.typeCode) {
//云控数据
if (cloudControlMessage == null) {
cloudControlMessage = new CloudControlMessage();
}
return cloudControlMessage;
} else if (messageType == MessageType.TYPE_RECEIVE_COPY_BAG.typeCode) {
//数据落盘
if (copyBagMessage == null) {