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

[660][adas][data-center] 添加节点检测功能，节点状态接口，移除节点超时接口

Browse Source
This commit is contained in:
xinfengkun
2024-08-22 16:27:53 +08:00
parent 7b5adcf470
commit 36584260b3
21 changed files with 362 additions and 306 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
OCH/common/common/src/main/java/com/mogo/och/common/module/manager/autopilot/autopilot/IOchAutopilotStatusListener.java
View File

@@ -64,14 +64,6 @@ public interface IOchAutopilotStatusListener {
default void onAutopilotIpcConnectStatusChanged(AdasConstants.IpcConnectionStatus status, String reason) {
}
/**
* 域控SSM接口接收超时
* 状态变动时才会回调，默认SSM状态正常
*
* @param isTimeout true：SSM接口接收超时 false：SSM接口恢复正常
*/
default void onSsmReceiveTimeout(boolean isTimeout) {
}
/**
* 工控机主动查询 AdasManager#sendStatusQueryReq()，后会收到如下回调

8
OCH/common/common/src/main/java/com/mogo/och/common/module/manager/autopilot/autopilot/OchAutoPilotStatusListenerManager.kt
View File

@@ -148,14 +148,6 @@ object OchAutoPilotStatusListenerManager : CallerBase<IOchAutopilotStatusListene
}
}
override fun onSsmReceiveTimeout(isTimeout: Boolean) {
super.onSsmReceiveTimeout(isTimeout)
M_LISTENERS.forEach {
val listener = it.value
listener.onSsmReceiveTimeout(isTimeout)
}
}
override fun onAutopilotStatusRespByQuery(status: SystemStatusInfo.StatusInfo) {
super.onAutopilotStatusRespByQuery(status)
M_LISTENERS.forEach {

10
OCH/sweeper/driver/src/main/java/com/mogo/och/sweeper/cloud/model/SweeperCloudTaskModel.java
View File

@@ -783,18 +783,8 @@ public class SweeperCloudTaskModel implements IMoGoSweeperFutianCloudTaskListene
}
@Override
public void onSsmReceiveTimeout(boolean isTimeout) {
}
@Override
public void onAutopilotTrajectoryDownloadReq(@NonNull AutopilotControlParameters.AutoPilotLine autoPilotLine, int downloadType) {
}
@Override
public void onFsmReceiveTimeout(boolean isTimeout) {
}
}

10
OCH/sweeper/driver/src/main/java/com/mogo/och/sweeper/operate/presenter/SweeperOperatePresenter.java
View File

@@ -461,17 +461,7 @@ public class SweeperOperatePresenter extends Presenter<SweeperOperateFragment>
public void onAutopilotDockerInfo(@NonNull String dockerVersion) {
}
@Override
public void onSsmReceiveTimeout(boolean isTimeout) {
}
@Override
public void onAutopilotTrajectoryDownloadReq(@NonNull AutopilotControlParameters.AutoPilotLine autoPilotLine, int downloadType) {
}
@Override
public void onFsmReceiveTimeout(boolean isTimeout) {
}
}

3
core/function-impl/mogo-core-function-datacenter/src/main/java/com/mogo/eagle/core/function/datacenter/autopilot/MoGoAutopilotControlProvider.kt
View File

@@ -68,6 +68,7 @@ import com.zhjt.mogo.adas.common.MessageType
import com.zhjt.mogo.adas.data.Adas
import com.zhjt.mogo.adas.data.AdasConstants
import com.zhjt.mogo.adas.data.bean.MogoReport
import com.zhjt.mogo.adas.data.bean.NodeStateInfo
import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable
import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask
import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume
@@ -1376,7 +1377,7 @@ class MoGoAutopilotControlProvider :
return AdasManager.getInstance().sendSeatPressure(driver, copilot, backRow) > -1
}
override fun getNodeStateInfo(name: AdasConstants.NodeName): Adas.NodeStateInfo {
override fun getNodeStateInfo(name: AdasConstants.NodeName): NodeStateInfo {
return AdasManager.getInstance().getNodeStateInfo(name)
}

52
core/function-impl/mogo-core-function-datacenter/src/main/java/com/mogo/eagle/core/function/datacenter/autopilot/adapter/MoGoAdasListenerImpl.kt
View File

@@ -29,6 +29,9 @@ import com.mogo.eagle.core.data.deva.chain.ChainConstant.Companion.CHAIN_TYPE_SO
import com.mogo.eagle.core.data.deva.chain.ChainConstant.Companion.CHAIN_TYPE_SOCKET_TRAJECTORY
import com.mogo.eagle.core.data.deva.chain.ChainConstant.Companion.CHAIN_TYPE_SOCKET_VEHICLE
import com.mogo.eagle.core.data.deva.chain.ChainConstant.Companion.CHAIN_TYPE_STATUS
import com.mogo.eagle.core.data.msgbox.MsgBoxBean
import com.mogo.eagle.core.data.msgbox.MsgBoxType
import com.mogo.eagle.core.data.msgbox.SSMMsg
import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotStatusListenerManager
import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotStatusListenerManager.invokeArriveAtStation
import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotStatusListenerManager.invokeAutopilotGuardian
@@ -70,6 +73,7 @@ import com.mogo.eagle.core.function.call.autopilot.CallerSweeperFutianCloudTaskL
import com.mogo.eagle.core.function.call.autopilot.CallerNodeStateListenerManager
import com.mogo.eagle.core.function.call.autopilot.CallerV2XListenerManager
import com.mogo.eagle.core.function.call.autopilot.CallerV2nNioEventListenerManager
import com.mogo.eagle.core.function.call.msgbox.CallerMsgBoxManager
import com.mogo.eagle.core.function.call.obu.CallerObuMapMathListenerManager
import com.mogo.eagle.core.function.call.obu.CallerObuWarningRsiListenerManager
import com.mogo.eagle.core.function.call.obu.CallerObuWarningRsmListenerManager
@@ -83,11 +87,12 @@ import com.zhidao.support.adas.high.chain.AdasChain
import com.zhjt.mogo.adas.data.bean.AdasParam
import com.zhidao.support.adas.high.common.ProtocolStatus
import com.zhjt.mogo.adas.common.MessageType
import com.zhjt.mogo.adas.data.Adas
import com.zhjt.mogo.adas.data.AdasConstants
import com.zhjt.mogo.adas.data.AdasConstants.NodeExistState
import com.zhjt.mogo.adas.data.AiCloudTask
import com.zhjt.mogo.adas.data.bean.AutopilotStatistics
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.sweeper.bootable.SweeperBootable
@@ -1007,32 +1012,29 @@ class MoGoAdasListenerImpl : OnAdasListener {
* 目前包含状态 节点是否存在；节点是否超时；
* SSM 只判断超时状态
* FSM 是否存在；是否超时；
* <p>
* 状态变动时才会回调
* 主动获取状态：{@link AdasManager#getNodeStateInfo(AdasConstants.NodeName)}
*
* @param name 节点名称
* @param stateInfo 节点状态信息 包含：未知；存在；不存在； 以及存在的一些状态
* @param stateInfo 节点状态
* {@link NodeStateInfo#getNodeState()}包含：未知；存在；不存在；
* {@link NodeStateInfo#getExistState()}包含：正常；超时；
*/
override fun onNodeStateInfo(name: AdasConstants.NodeName, stateInfo: Adas.NodeStateInfo) {
CallerNodeStateListenerManager.invokeNodeState(name, stateInfo)
}
/**
* 域控SSM接口接收超时
* 状态变动时才会回调，默认SSM状态正常
*
* @param isTimeout true：SSM接口接收超时 false：SSM接口恢复正常
*/
override fun onSsmReceiveTimeout(isTimeout: Boolean) {
CallerAutoPilotStatusListenerManager.invokeSsmReceiveTimeout(isTimeout)
}
/**
* 域控FSM接口接收超时
* 状态变动时才会回调，默认FSM状态正常 前提是存在FSM接口
*
* @param isTimeout true：FSM接口接收超时 false：FSM接口恢复正常
*/
override fun onFsm2024ReceiveTimeout(isTimeout: Boolean) {
CallerAutoPilotStatusListenerManager.invokeFsmReceiveTimeout(isTimeout)
override fun onNodeStateInfo(stateInfo: NodeStateInfo) {
CallerNodeStateListenerManager.invokeNodeState(stateInfo)
if (stateInfo.existState != null) {
if (stateInfo.nodeName == AdasConstants.NodeName.SSM) {
//域控SSM接口接收是否超时
if (stateInfo.existState == NodeExistState.NODE_EXIST_TIMEOUT) {
CallerMsgBoxManager.saveMsgBox(MsgBoxBean(MsgBoxType.SSMINFO, SSMMsg(0, "连接超时", "SSM超时无响应", System.currentTimeMillis())))
} else {
CallerMsgBoxManager.saveMsgBox(MsgBoxBean(MsgBoxType.SSMINFO, SSMMsg(0, "连接恢复", "SSM连接恢复", System.currentTimeMillis())))
}
} else if (stateInfo.nodeName == AdasConstants.NodeName.FSM2024) {
//域控FSM接口接收是否超时
// (stateInfo.existState == NodeExistState.NODE_EXIST_TIMEOUT)
}
}
}
/**

6
core/function-impl/mogo-core-function-devatools/src/main/java/com/zhjt/mogo_core_function_devatools/status/flow/fsm/FSMImpl.kt
View File

@@ -12,8 +12,8 @@ import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger
import com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant.Companion.M_DEVA
import com.mogo.eagle.core.utilcode.util.DateTimeUtils
import com.mogo.eagle.core.utilcode.util.UiThreadHandler
import com.zhjt.mogo.adas.data.Adas
import com.zhjt.mogo.adas.data.AdasConstants
import com.zhjt.mogo.adas.data.bean.NodeStateInfo
import com.zhjt.mogo_core_function_devatools.status.entity.FSMStateCode
import com.zhjt.mogo_core_function_devatools.status.entity.FSMStatus
import com.zhjt.mogo_core_function_devatools.status.flow.IFlow
@@ -129,10 +129,10 @@ internal class FSMImpl(ctx: Context) : IFlow<FSMStatus>(ctx), IMoGoAutopilotStat
* @param name 节点名称
* @param stateInfo 节点状态信息 包含：未知；存在；不存在； 以及存在的一些状态
*/
override fun onNodeStateInfo(name: AdasConstants.NodeName, stateInfo: Adas.NodeStateInfo) {
override fun onNodeStateInfo(stateInfo: NodeStateInfo) {
CallerLogger.d(
"$M_DEVA$TAG",
"-- onNodeStateInfo[nodeName=$name, stateName=${stateInfo.nodeState.name}] --"
"-- onNodeStateInfo[stateName=${stateInfo.nodeState.name}] --"
)
val fsmStatusCode = getStateCodeByNodeStateInfo(stateInfo.nodeState)
val fsmStatusDesc = getStateDescByNodeStateInfo(stateInfo.nodeState)

6
core/function-impl/mogo-core-function-hmi/src/main/java/com/mogo/eagle/core/function/hmi/ui/msgbox/DriverMsgBoxBubbleView.kt
View File

@@ -32,9 +32,9 @@ import com.mogo.eagle.core.function.msgbox.MsgBoxConfig
import com.mogo.eagle.core.utilcode.mogo.AppIdentityModeUtils
import com.mogo.eagle.core.utilcode.util.SoundPoolUtils
import com.mogo.eagle.core.utilcode.util.UiThreadHandler
import com.zhjt.mogo.adas.data.Adas
import com.zhjt.mogo.adas.data.AdasConstants
import com.zhjt.mogo.adas.data.AdasConstants.NodeState
import com.zhjt.mogo.adas.data.bean.NodeStateInfo
import kotlinx.android.synthetic.main.layout_driver_msg_box_bubble.view.*
import java.util.concurrent.atomic.AtomicReference
@@ -221,8 +221,8 @@ class DriverMsgBoxBubbleView @JvmOverloads constructor(
* @param name 节点名称
* @param stateInfo 节点状态信息 包含：未知；存在；不存在； 以及存在的一些状态
*/
override fun onNodeStateInfo(name: AdasConstants.NodeName, stateInfo: Adas.NodeStateInfo) {
if (AdasConstants.NodeName.FSM2024 == name) {
override fun onNodeStateInfo(stateInfo: NodeStateInfo) {
if (AdasConstants.NodeName.FSM2024 == stateInfo.nodeName) {
fsmNodeState.set(stateInfo.nodeState)
}
}

3
core/mogo-core-function-api/src/main/java/com/mogo/eagle/core/function/api/autopilot/IMoGoAutopilotControlProvider.kt
View File

@@ -7,6 +7,7 @@ import com.mogo.eagle.core.data.deva.badcase.BagManagerEntity
import com.mogo.eagle.core.function.api.base.IMoGoFunctionServerProvider
import com.zhjt.mogo.adas.data.Adas
import com.zhjt.mogo.adas.data.AdasConstants
import com.zhjt.mogo.adas.data.bean.NodeStateInfo
import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable.IsBootable
import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.GetTaskReq
import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.StartTaskResp
@@ -612,6 +613,6 @@ interface IMoGoAutopilotControlProvider : IMoGoFunctionServerProvider {
* @param name 节点名称 目前只有SSM和FSM2024
* @return 状态 SSM只能查询到超时状态；FSM2024可以查询到节点是否存在状态以及超时状态；
*/
fun getNodeStateInfo(name: AdasConstants.NodeName): Adas.NodeStateInfo
fun getNodeStateInfo(name: AdasConstants.NodeName): NodeStateInfo
}

15
core/mogo-core-function-api/src/main/java/com/mogo/eagle/core/function/api/autopilot/IMoGoAutopilotStatusListener.kt
View File

@@ -49,21 +49,6 @@ interface IMoGoAutopilotStatusListener {
*/
fun onAutopilotIpcConnectStatusChanged(status: AdasConstants.IpcConnectionStatus, reason: String?) {}
/**
* 域控SSM接口接收超时
* 状态变动时才会回调，默认SSM状态正常
* @param isTimeout true：SSM接口接收超时 false：SSM接口恢复正常
*/
fun onSsmReceiveTimeout(isTimeout: Boolean) {}
/**
* 域控FSM接口接收超时
* 状态变动时才会回调，默认FSM状态正常 前提是存在FSM接口
*
* @param isTimeout true：FSM接口接收超时 false：FSM接口恢复正常
*/
fun onFsmReceiveTimeout(isTimeout: Boolean) {}
/**
* 工控机主动查询 AdasManager#sendStatusQueryReq()，后会收到如下回调
*/

6
core/mogo-core-function-api/src/main/java/com/mogo/eagle/core/function/api/autopilot/IMoGoNodeStateListener.kt
View File

@@ -1,7 +1,6 @@
package com.mogo.eagle.core.function.api.autopilot
import com.zhjt.mogo.adas.data.Adas
import com.zhjt.mogo.adas.data.AdasConstants
import com.zhjt.mogo.adas.data.bean.NodeStateInfo
/**
*节点状态
@@ -17,8 +16,7 @@ interface IMoGoNodeStateListener {
* @param name 节点名称
* @param stateInfo 节点状态信息 包含：未知；存在；不存在； 以及存在的一些状态
*/
fun onNodeStateInfo(name: AdasConstants.NodeName, stateInfo: Adas.NodeStateInfo)
fun onNodeStateInfo(stateInfo: NodeStateInfo)
}

3
core/mogo-core-function-call/src/main/java/com/mogo/eagle/core/function/call/autopilot/CallerAutoPilotControlManager.kt
View File

@@ -30,6 +30,7 @@ import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume.Suspend
import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm.TaskConfirmResp
import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop.StopTaskResp
import com.zhjt.mogo.adas.data.AdasConstants
import com.zhjt.mogo.adas.data.bean.NodeStateInfo
import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume.BigTaskActionResp
import com.zhjt.service.chain.ChainLog
import com.zhjt.service_biz.BizConfig
@@ -927,7 +928,7 @@ object CallerAutoPilotControlManager {
* @param name 节点名称 目前只有SSM和FSM2024
* @return 状态 SSM只能查询到超时状态；FSM2024可以查询到节点是否存在状态以及超时状态；
*/
fun getNodeStateInfo(name: AdasConstants.NodeName): Adas.NodeStateInfo? {
fun getNodeStateInfo(name: AdasConstants.NodeName): NodeStateInfo? {
return providerApi?.getNodeStateInfo(name)
}
}

29
core/mogo-core-function-call/src/main/java/com/mogo/eagle/core/function/call/autopilot/CallerAutoPilotStatusListenerManager.kt
View File

@@ -224,35 +224,6 @@ object CallerAutoPilotStatusListenerManager : CallerBase<IMoGoAutopilotStatusLis
}
}
/**
* 域控SSM接口接收超时
* 状态变动时才会回调，默认SSM状态正常
* @param isTimeout true：SSM接口接收超时 false：SSM接口恢复正常
*/
fun invokeSsmReceiveTimeout(isTimeout: Boolean) {
M_LISTENERS.forEach {
val listener = it.value
listener.onSsmReceiveTimeout(isTimeout)
}
if (isTimeout) {
CallerMsgBoxManager.saveMsgBox(MsgBoxBean(MsgBoxType.SSMINFO, SSMMsg(0, "连接超时", "ssm超时无响应", System.currentTimeMillis())))
} else {
CallerMsgBoxManager.saveMsgBox(MsgBoxBean(MsgBoxType.SSMINFO, SSMMsg(0, "连接恢复", "ssm连接恢复", System.currentTimeMillis())))
}
}
/**
* 域控FSM接口接收超时
* 状态变动时才会回调，默认FSM状态正常 前提是存在FSM接口
*
* @param isTimeout true：FSM接口接收超时 false：FSM接口恢复正常
*/
fun invokeFsmReceiveTimeout(isTimeout: Boolean) {
M_LISTENERS.forEach {
val listener = it.value
listener.onFsmReceiveTimeout(isTimeout)
}
}
/**
* 主动调查询接口：AdasManager#sendStatusQueryReq(), 会收到以下回调

19
core/mogo-core-function-call/src/main/java/com/mogo/eagle/core/function/call/autopilot/CallerNodeStateListenerManager.kt
View File

@@ -2,8 +2,8 @@ package com.mogo.eagle.core.function.call.autopilot
import com.mogo.eagle.core.function.api.autopilot.IMoGoNodeStateListener
import com.mogo.eagle.core.function.call.base.CallerBase
import com.zhjt.mogo.adas.data.Adas
import com.zhjt.mogo.adas.data.AdasConstants
import com.zhjt.mogo.adas.data.bean.NodeStateInfo
/**
*节点状态
@@ -11,6 +11,9 @@ import com.zhjt.mogo.adas.data.AdasConstants
object CallerNodeStateListenerManager : CallerBase<IMoGoNodeStateListener>() {
private val mutableMap = mutableMapOf<String, Set<AdasConstants.NodeName>>()
/**
* nodeName传入要监听的节点状态名称，如果传递注册的时候将返回所有节点的状态
*/
fun addNodeStateListener(
tag: String,
nodeName: Set<AdasConstants.NodeName>?,
@@ -29,15 +32,15 @@ object CallerNodeStateListenerManager : CallerBase<IMoGoNodeStateListener>() {
super.removeListener(tag)
}
fun invokeNodeState(name: AdasConstants.NodeName, stateInfo: Adas.NodeStateInfo) {
fun invokeNodeState(stateInfo: NodeStateInfo) {
M_LISTENERS.forEach {
val names = mutableMap[it.key]
val listener = it.value
if (names.isNullOrEmpty()) {
listener.onNodeStateInfo(name, stateInfo)
listener.onNodeStateInfo(stateInfo)
} else {
if (names.contains(name)) {
listener.onNodeStateInfo(name, stateInfo)
if (names.contains(stateInfo.nodeName)) {
listener.onNodeStateInfo(stateInfo)
}
}
}
@@ -47,11 +50,11 @@ object CallerNodeStateListenerManager : CallerBase<IMoGoNodeStateListener>() {
super.doSomeAfterAddListener(tag, listener)
mutableMap.forEach { it ->
if (it.key == tag) {
val value = it.value
value.forEach { name ->
val names = it.value
names.forEach { name ->
val state = CallerAutoPilotControlManager.getNodeStateInfo(name)
state?.let {
listener.onNodeStateInfo(name, state)
listener.onNodeStateInfo(state)
}
}
}

65
libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/NodeStateInfo.java Normal file
View File

@@ -0,0 +1,65 @@
package com.zhjt.mogo.adas.data.bean;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.zhjt.mogo.adas.data.AdasConstants;
import java.util.Objects;
public class NodeStateInfo {
private final AdasConstants.NodeName nodeName; //节点名称
@NonNull
private AdasConstants.NodeState nodeState;//节点主状态 包含：未知；存在；不存在；
@Nullable
private AdasConstants.NodeExistState existState;//节点存在时的状态 null表示未知
public NodeStateInfo(AdasConstants.NodeName nodeName, @NonNull AdasConstants.NodeState nodeState) {
this.nodeName = nodeName;
this.nodeState = nodeState;
}
public AdasConstants.NodeName getNodeName() {
return nodeName;
}
@NonNull
public AdasConstants.NodeState getNodeState() {
return nodeState;
}
public void setNodeState(@NonNull AdasConstants.NodeState nodeState) {
this.nodeState = nodeState;
}
@Nullable
public AdasConstants.NodeExistState getExistState() {
return existState;
}
public void setExistState(@Nullable AdasConstants.NodeExistState existState) {
this.existState = existState;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
NodeStateInfo that = (NodeStateInfo) o;
return nodeName == that.nodeName && nodeState == that.nodeState && existState == that.existState;
}
@Override
public int hashCode() {
return Objects.hash(nodeName, nodeState, existState);
}
@Override
public String toString() {
return "NodeStateInfo{" +
"nodeName=" + nodeName +
", nodeState=" + nodeState +
", existState=" + existState +
'}';
}
}

8
libraries/mogo-adas-data/src/main/proto/personal/adas.proto
View File

@@ -3,7 +3,6 @@ package mogo.telematics.pad;
option java_package = "com.zhjt.mogo.adas.data";
import "message_pad.proto";
import "personal/adas_constants.proto";
//发送的数据ID持久化，只保留最后一条的消息id，每天重新累计
message LastMessage{
@@ -16,10 +15,3 @@ message LastMessage{
message MessageIdInfo{
map<uint64, LastMessage> lastMessages = 1;// key：data（日期） value：数据
}
//节点状态信息
message NodeStateInfo{
com.zhjt.mogo.adas.data.NodeName nodeName = 1;//节点名称
com.zhjt.mogo.adas.data.NodeState nodeState = 2;//节点主状态 包含：未知；存在；不存在；
com.zhjt.mogo.adas.data.NodeExistState existState = 3;//节点存在时的状态
}

5
libraries/mogo-adas-data/src/main/proto/personal/adas_constants.proto
View File

@@ -110,9 +110,8 @@ enum SubscribeType {
* 节点名称
*/
enum NodeName{
DEFAULT_NAME = 0;//无用
SSM = 1;//SSM默认存在
FSM2024 = 2;//FSM 2024版本的Topic名称
SSM = 0;//SSM默认存在
FSM2024 = 1;//FSM 2024版本的Topic名称
}
/**

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

@@ -19,6 +19,7 @@ import com.zhjt.mogo.adas.common.MessageType;
import com.zhjt.mogo.adas.data.Adas;
import com.zhjt.mogo.adas.data.AdasConstants;
import com.zhjt.mogo.adas.data.bean.AdasParam;
import com.zhjt.mogo.adas.data.bean.NodeStateInfo;
import com.zhjt.mogo.adas.data.bean.ReceivedAck;
import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable;
import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask;
@@ -1721,7 +1722,7 @@ public class AdasManager implements IAdasNetCommApi {
* @param name 节点名称 目前只有SSM和FSM2024
* @return 状态 SSM只能查询到超时状态；FSM2024可以查询到节点是否存在状态以及超时状态；
*/
public Adas.NodeStateInfo getNodeStateInfo(AdasConstants.NodeName name) {
public NodeStateInfo getNodeStateInfo(@NonNull AdasConstants.NodeName name) {
return AutopilotAbilityManager.getInstance().getNodeStateInfo(name);
}

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

@@ -7,12 +7,12 @@ import com.google.protobuf.ByteString;
import com.mogo.support.obu.ObuScene;
import com.zhidao.support.adas.high.common.ProtocolStatus;
import com.zhjt.mogo.adas.common.MessageType;
import com.zhjt.mogo.adas.data.Adas;
import com.zhjt.mogo.adas.data.AdasConstants;
import com.zhjt.mogo.adas.data.AiCloudTask;
import com.zhjt.mogo.adas.data.bean.AdasParam;
import com.zhjt.mogo.adas.data.bean.AutopilotStatistics;
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.sweeper.bootable.SweeperBootable;
@@ -538,27 +538,15 @@ public interface OnAdasListener {
* 目前包含状态 节点是否存在；节点是否超时；
* SSM 只判断超时状态
* FSM 是否存在；是否超时；
* <p>
* 状态变动时才会回调
* 主动获取状态：{@link AdasManager#getNodeStateInfo(AdasConstants.NodeName)}
*
* @param name 节点名称
* @param stateInfo 节点状态信息 包含：未知；存在；不存在； 以及存在的一些状态
* @param stateInfo 节点状态
* {@link NodeStateInfo#getNodeState()}包含：未知；存在；不存在；
* {@link NodeStateInfo#getExistState()}包含：正常；超时；
*/
void onNodeStateInfo(@NonNull AdasConstants.NodeName name, @NonNull Adas.NodeStateInfo stateInfo);
/**
* 域控SSM接口接收超时
* 状态变动时才会回调，默认SSM状态正常
*
* @param isTimeout true：SSM接口接收超时 false：SSM接口恢复正常
*/
void onSsmReceiveTimeout(boolean isTimeout);
/**
* 域控FSM接口接收超时
* 状态变动时才会回调，默认FSM状态正常 前提是存在FSM接口
*
* @param isTimeout true：FSM接口接收超时 false：FSM接口恢复正常
*/
void onFsm2024ReceiveTimeout(boolean isTimeout);
void onNodeStateInfo(@NonNull NodeStateInfo stateInfo);
/**
* 是否有能力启动自动驾驶

4
libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/common/autopilot/ability/AutopilotAbility440.java → libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/common/autopilot/ability/AutopilotAbilityFSM.java
View File

@@ -13,7 +13,7 @@ import fsm.Fsm2024;
* 是否可以启动自动驾驶能力检测 工控机版本>=4400&&(isJinlv||isJinlvM1||isJinlvM) 使用此类
* 目前监控了FSM2024状态
*/
public class AutopilotAbility440 {
public class AutopilotAbilityFSM {
private final String TAG = this.getClass().getSimpleName();
@NonNull
@@ -21,7 +21,7 @@ public class AutopilotAbility440 {
private OnAutopilotAbilityListener listener;
public AutopilotAbility440(@NonNull AutopilotAbilityManager manager) {
public AutopilotAbilityFSM(@NonNull AutopilotAbilityManager manager) {
this.manager = manager;
}

377
libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/common/autopilot/ability/AutopilotAbilityManager.java
View File

@@ -1,6 +1,8 @@
package com.zhidao.support.adas.high.common.autopilot.ability;
import android.text.TextUtils;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
@@ -9,18 +11,20 @@ import com.zhidao.support.adas.high.AdasOptions;
import com.zhidao.support.adas.high.BuildConfig;
import com.zhidao.support.adas.high.OnAdasListener;
import com.zhidao.support.adas.high.common.CupidLogUtils;
import com.zhjt.mogo.adas.data.Adas;
import com.zhjt.mogo.adas.data.AdasConstants;
import com.zhjt.mogo.adas.data.bean.LaunchConditionData;
import com.zhjt.mogo.adas.data.bean.NodeStateInfo;
import com.zhjt.mogo.adas.data.bean.UnableLaunchReason;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import chassis.Chassis;
import chassis.ChassisStatesOuterClass;
@@ -59,17 +63,19 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
private AutopilotAbility330 autopilotAbility330;
private AutopilotAbility350And360 autopilotAbility350And360;
private AutopilotAbility360 autopilotAbility360;
private AutopilotAbility440 autopilotAbility440;
private AutopilotAbilityFSM autopilotAbilityFsm;
private Timer startTimer;
private Timer timeoutTimer;//SSM和FSM超时计时器
private long ssmReceiveTime;//SSM接收时间
private long fsmReceiveTime;//FSM接收时间
private final AtomicBoolean isInitAutopilotAbility = new AtomicBoolean(false);//是否初始化完成
private final AtomicBoolean isOldSsmTimeout = new AtomicBoolean(false);//SSM是否超时 老状态
private final AtomicBoolean isOldFsmTimeout = new AtomicBoolean(false);//FSM是否超时 老状态
private final AtomicBoolean isInitCarConfig = new AtomicBoolean(false);//车辆信息是否初始化
private final Map<AdasConstants.NodeName, Adas.NodeStateInfo> nodeStateInfos = new HashMap<>();
private boolean isSupportFSM2024 = false;
private final AtomicInteger isSupportFSM2024 = new AtomicInteger(-1);//-1：未初始化 0：不支持 1：通过SSM V2判断支持 2：通过FSM数据源判断支持
private final Map<AdasConstants.NodeName, NodeStateInfo> nodeStateInfos = new ConcurrentHashMap<>();
private AutopilotAbilityManager() {
}
@@ -85,6 +91,20 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
return INSTANCE;
}
private void initStartData() {
nodeStateInfos.clear();
NodeStateInfo ssmInfo = new NodeStateInfo(AdasConstants.NodeName.SSM, AdasConstants.NodeState.NODE_EXIST);
ssmInfo.setExistState(AdasConstants.NodeExistState.NODE_EXIST_NORMAL);
nodeStateInfos.put(AdasConstants.NodeName.SSM, ssmInfo);
nodeStateInfos.put(AdasConstants.NodeName.FSM2024, new NodeStateInfo(AdasConstants.NodeName.FSM2024, AdasConstants.NodeState.NODE_UNKNOWN));
}
private void initStopData() {
nodeStateInfos.clear();
nodeStateInfos.put(AdasConstants.NodeName.SSM, new NodeStateInfo(AdasConstants.NodeName.SSM, AdasConstants.NodeState.NODE_UNKNOWN));
nodeStateInfos.put(AdasConstants.NodeName.FSM2024, new NodeStateInfo(AdasConstants.NodeName.FSM2024, AdasConstants.NodeState.NODE_UNKNOWN));
}
public void setLaunchAutopilotGear(Set<Chassis.GearPosition> launchAutopilotGear) {
if (autopilotAbility230 != null) {
autopilotAbility230.setLaunchAutopilotGear(launchAutopilotGear);
@@ -156,7 +176,7 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
*/
public void setStatusInfo(SystemStatusInfo.StatusInfo statusInfo) {
ssmReceiveTime = System.currentTimeMillis();
onCallSSMTimeout(false);
onCallSSMTimeout(AdasConstants.SsmSource.SSM_VER1, false);
if (autopilotAbility250 != null) {
autopilotAbility250.setStatusInfo(statusInfo);
}
@@ -167,7 +187,8 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
public void setStatusInfo(SsmInfo.SsmStatusInf statusInfo) {
ssmReceiveTime = System.currentTimeMillis();
onCallSSMTimeout(false);
onCallSSMTimeout(AdasConstants.SsmSource.SSM_VER2, false);
detectionTopicExistence(statusInfo);
if (autopilotAbility350And360 != null) {
autopilotAbility350And360.setStatusInfo(statusInfo);
}
@@ -177,10 +198,10 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
}
public void setFSM2024State(Fsm2024.FSMStateMsg fsmState) {
fsmReceiveTime = System.currentTimeMillis();
updateFSMNormalStateFromFSM();
onCallFSMTimeout(false);
if (autopilotAbility440 != null) {
autopilotAbility440.setFSMState(fsmState);
if (autopilotAbilityFsm != null) {
autopilotAbilityFsm.setFSMState(fsmState);
}
}
@@ -219,67 +240,85 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
* @param name 节点名称 目前只有SSM和FSM2024
* @return 状态 SSM只能查询到超时状态；FSM2024可以查询到节点是否存在状态以及超时状态；
*/
public Adas.NodeStateInfo getNodeStateInfo(AdasConstants.NodeName name) {
Adas.NodeStateInfo state = nodeStateInfos.get(name);
public NodeStateInfo getNodeStateInfo(@NonNull AdasConstants.NodeName name) {
NodeStateInfo state = nodeStateInfos.get(name);
if (state == null) {
state = Adas.NodeStateInfo.newBuilder().setNodeState(AdasConstants.NodeState.NODE_UNKNOWN).build();
nodeStateInfos.put(name, state);
return new NodeStateInfo(name, AdasConstants.NodeState.NODE_UNKNOWN);
}
return state;
}
//检测节点是否存在
private void detectionTopicExistence() {
/**
* 检测节点是否存在
* 判断条件：SSM消息中冷启动完成（statusInfo.getAutoPilotReady()==ture）
* 后查询自动驾驶关键节点列表中是否有包含fsm节点名称
*/
private void detectionTopicExistence(SsmInfo.SsmStatusInf statusInfo) {
if (isSupportFSM2024.get() == -1) {
if (statusInfo.getAutoPilotReady()) {
List<SsmInfo.NodeInf> list = statusInfo.getAutoPilotUnreadyListList();
boolean isSupport = false;
for (SsmInfo.NodeInf info : list) {
String name = info.getNodeName();
if (!TextUtils.isEmpty(name) && name.toLowerCase().contains("fsm")) {
//支持FSM
isSupport = true;
break;
}
}
updateFSMStateFromSSM(isSupport ? 1 : 0);
}
}
}
private void initAutopilotAbility() {
stopAllTimer();
isSupportFSM2024 = false;
if (mapVersion >= 40400 && (isJinlv || isJinlvM1 || isJinlvM2)) {
isSupportFSM2024 = true;
CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：440");
if (autopilotAbility440 == null) {
autopilotAbility440 = new AutopilotAbility440(this);
autopilotAbility440.start(this);
}
} else if (mapVersion >= 30600 && isFutianSweeper) {
CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：360清扫车专用");
if (autopilotAbility360 == null) {
autopilotAbility360 = new AutopilotAbility360(this);
autopilotAbility360.start(this);
}
} else if ((mapVersion >= 30500 && (isJinlvM1 || isHQ)) || mapVersion >= 30600) {
CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：350和360共用");
if (autopilotAbility350And360 == null) {
autopilotAbility350And360 = new AutopilotAbility350And360(this);
autopilotAbility350And360.start(this);
}
if (!isInitAutopilotAbility.get()) {
isInitAutopilotAbility.set(true);
stopAllTimer();
if (isSupportFSM2024.get() > 0) {
CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：FSM版本");
if (autopilotAbilityFsm == null) {
autopilotAbilityFsm = new AutopilotAbilityFSM(this);
autopilotAbilityFsm.start(this);
}
} else if (mapVersion >= 30600 && isFutianSweeper) {
CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：360清扫车专用");
if (autopilotAbility360 == null) {
autopilotAbility360 = new AutopilotAbility360(this);
autopilotAbility360.start(this);
}
} else if ((mapVersion >= 30500 && (isJinlvM1 || isHQ)) || mapVersion >= 30600) {
CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：350和360共用");
if (autopilotAbility350And360 == null) {
autopilotAbility350And360 = new AutopilotAbility350And360(this);
autopilotAbility350And360.start(this);
}
} else if (mapVersion >= 30300 && isFutianSweeper) {//目前只有MAP330的清扫车用的新的FSM状态原因查询
CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：330清扫车专用");
if (autopilotAbility330 == null) {
autopilotAbility330 = new AutopilotAbility330(this, mapVersion);
autopilotAbility330.start(this);
} else if (mapVersion >= 30300 && isFutianSweeper) {//目前只有MAP330的清扫车用的新的FSM状态原因查询
CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：330清扫车专用");
if (autopilotAbility330 == null) {
autopilotAbility330 = new AutopilotAbility330(this, mapVersion);
autopilotAbility330.start(this);
}
} else if (mapVersion >= 20500) {
CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：250");
if (autopilotAbility250 == null) {
autopilotAbility250 = new AutopilotAbility250(this);
autopilotAbility250.start(this);
}
} else {
CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：230");
if (autopilotAbility230 == null) {
autopilotAbility230 = new AutopilotAbility230(this);
autopilotAbility230.start(this);
}
}
} else if (mapVersion >= 20500) {
CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：250");
if (autopilotAbility250 == null) {
autopilotAbility250 = new AutopilotAbility250(this);
autopilotAbility250.start(this);
}
} else {
CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：230");
if (autopilotAbility230 == null) {
autopilotAbility230 = new AutopilotAbility230(this);
autopilotAbility230.start(this);
startTimeoutTimer();//MAP230及以下没有SSM和FSM所以不需要超时
}
Set<Chassis.GearPosition> launchAutopilotGear = getGearPositions();
setLaunchAutopilotGear(launchAutopilotGear);
}
if (autopilotAbility230 == null) {
startTimeoutTimer();//MAP230及以下没有SSM和FSM所以不需要超时
}
Set<Chassis.GearPosition> launchAutopilotGear = getGearPositions();
setLaunchAutopilotGear(launchAutopilotGear);
}
private @Nullable Set<Chassis.GearPosition> getGearPositions() {
@@ -307,6 +346,130 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
return launchAutopilotGear;
}
/**
* 连接工控机成功调用此函数，如果dockerVersion还未获取到将启动最低版本的启动自动驾驶能力检测
* 此函数为保险措施 以防无法获取工控机版本时 也能 正常执行逻辑
*/
public synchronized void start() {
isInitAutopilotAbility.set(false);
initStartData();
if (startTimer == null) {
startTimer = new Timer();
startTimer.schedule(new TimerTask() {
@Override
public void run() {
if (!isInitCarConfig.get() && AdasManager.getInstance().getIpcConnectionStatus() == AdasConstants.IpcConnectionStatus.CONNECTED) {
mapVersion = 20300;
isSupportFSM2024.set(-1);
initAutopilotAbility();
isInitAutopilotAbility.set(false);
}
}
}, 15000L);//15秒原因：需要后去CarConfig 对象，两个地方调用initAutopilotAbility(); 初始化 一个在这，另一个在setCarConfig(),如果setCarConfig() 证明获取版本还未成功，获取版本会重试3次每次间隔四秒
}
}
/**
* 连接工控机成功调用此函数，如果dockerVersion还未获取到将启动最低版本的启动自动驾驶能力检测
* 此函数为保险措施 以防无法获取工控机版本时 也能 正常执行逻辑
*/
public synchronized void startTimeoutTimer() {
if (timeoutTimer == null) {
ssmReceiveTime = System.currentTimeMillis();
fsmReceiveTime = System.currentTimeMillis();
timeoutTimer = new Timer();
timeoutTimer.schedule(new TimerTask() {
@Override
public void run() {
//SSM超时检测
long timeDifference = System.currentTimeMillis() - ssmReceiveTime;
if (timeDifference >= DEFAULT_TIMEOUT) {
onCallSSMTimeout(AdasConstants.SsmSource.SSM_UNKNOWN, true);
//超时
if (autopilotAbility250 != null) {
autopilotAbility250.onCallTimeout();
}
if (autopilotAbility330 != null) {
autopilotAbility330.onCallTimeout();
}
if (autopilotAbility350And360 != null) {
autopilotAbility350And360.onCallTimeout();
}
if (autopilotAbility360 != null) {
autopilotAbility360.onCallTimeout();
}
}
//FSM超时检测
if (isSupportFSM2024.get() > 0) {
timeDifference = System.currentTimeMillis() - fsmReceiveTime;
if (timeDifference >= DEFAULT_TIMEOUT) {
onCallFSMTimeout(true);
if (autopilotAbilityFsm != null) {
autopilotAbilityFsm.onCallFsmTimeout();
}
}
}
}
}, 1000L, DEFAULT_TIMEOUT);
}
}
private void updateFSMNormalStateFromFSM() {
fsmReceiveTime = System.currentTimeMillis();
if (isSupportFSM2024.get() != 2) {
updateFSMSupportState(2, AdasConstants.NodeExistState.NODE_EXIST_NORMAL);
}
}
private void updateFSMStateFromSSM(int isSupport) {
if (isSupportFSM2024.get() == -1) {
updateFSMSupportState(isSupport, null);
}
}
private void updateFSMSupportState(int isSupport, AdasConstants.NodeExistState existState) {
isSupportFSM2024.set(isSupport);
CupidLogUtils.i(TAG, "是否支持FSM=" + isSupport);
if (isSupport > 0) {
isInitAutopilotAbility.set(false);
initAutopilotAbility();
}
NodeStateInfo info = getNodeStateInfo(AdasConstants.NodeName.FSM2024);
info.setNodeState(isSupport > 0 ? AdasConstants.NodeState.NODE_EXIST : AdasConstants.NodeState.NODE_NOT_EXIST);
info.setExistState(existState);
listener.onNodeStateInfo(info);
}
private synchronized void onCallSSMTimeout(AdasConstants.SsmSource source, boolean isTimeout) {
if (isTimeout != isOldSsmTimeout.get()) {
isOldSsmTimeout.set(isTimeout);
if (!isTimeout) {
if (source == AdasConstants.SsmSource.SSM_VER1) {
//SSM 1版本时 不支持FSM
CupidLogUtils.i(TAG, "SSM版本1不支持FSM");
updateFSMStateFromSSM(0);
}
}
NodeStateInfo info = getNodeStateInfo(AdasConstants.NodeName.SSM);
info.setNodeState(AdasConstants.NodeState.NODE_EXIST);
info.setExistState(isTimeout ? AdasConstants.NodeExistState.NODE_EXIST_TIMEOUT : AdasConstants.NodeExistState.NODE_EXIST_NORMAL);
listener.onNodeStateInfo(info);
}
}
private synchronized void onCallFSMTimeout(boolean isTimeout) {
if (isTimeout != isOldFsmTimeout.get()) {
isOldFsmTimeout.set(isTimeout);
NodeStateInfo info = getNodeStateInfo(AdasConstants.NodeName.FSM2024);
info.setNodeState(AdasConstants.NodeState.NODE_EXIST);
info.setExistState(isTimeout ? AdasConstants.NodeExistState.NODE_EXIST_TIMEOUT : AdasConstants.NodeExistState.NODE_EXIST_NORMAL);
listener.onNodeStateInfo(info);
}
}
private void stop230() {
if (autopilotAbility230 != null) {
autopilotAbility230.stop();
@@ -343,9 +506,9 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
}
private void stop440() {
if (autopilotAbility440 != null) {
autopilotAbility440.stop();
autopilotAbility440 = null;
if (autopilotAbilityFsm != null) {
autopilotAbilityFsm.stop();
autopilotAbilityFsm = null;
}
}
@@ -356,97 +519,13 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
}
}
/**
* 连接工控机成功调用此函数，如果dockerVersion还未获取到将启动最低版本的启动自动驾驶能力检测
* 此函数为保险措施 以防无法获取工控机版本时 也能 正常执行逻辑
*/
public synchronized void start() {
if (startTimer == null) {
startTimer = new Timer();
startTimer.schedule(new TimerTask() {
@Override
public void run() {
if (!isInitCarConfig.get() && AdasManager.getInstance().getIpcConnectionStatus() == AdasConstants.IpcConnectionStatus.CONNECTED) {
mapVersion = 20300;
initAutopilotAbility();
}
}
}, 15000L);//15秒原因：需要后去CarConfig 对象，两个地方调用initAutopilotAbility(); 初始化 一个在这，另一个在setCarConfig(),如果setCarConfig() 证明获取版本还未成功，获取版本会重试3次每次间隔四秒
}
}
private void stopTimeoutTimer() {
if (timeoutTimer != null) {
isOldSsmTimeout.set(false);
isOldFsmTimeout.set(false);
ssmReceiveTime = 0;
fsmReceiveTime = 0;
timeoutTimer.cancel();
timeoutTimer = null;
}
}
/**
* 连接工控机成功调用此函数，如果dockerVersion还未获取到将启动最低版本的启动自动驾驶能力检测
* 此函数为保险措施 以防无法获取工控机版本时 也能 正常执行逻辑
*/
public synchronized void startTimeoutTimer() {
if (timeoutTimer == null) {
ssmReceiveTime = System.currentTimeMillis();
fsmReceiveTime = System.currentTimeMillis();
timeoutTimer = new Timer();
timeoutTimer.schedule(new TimerTask() {
@Override
public void run() {
//SSM超时检测
long timeDifference = System.currentTimeMillis() - ssmReceiveTime;
if (timeDifference >= DEFAULT_TIMEOUT) {
onCallSSMTimeout(true);
//超时
if (autopilotAbility250 != null) {
autopilotAbility250.onCallTimeout();
}
if (autopilotAbility330 != null) {
autopilotAbility330.onCallTimeout();
}
if (autopilotAbility350And360 != null) {
autopilotAbility350And360.onCallTimeout();
}
if (autopilotAbility360 != null) {
autopilotAbility360.onCallTimeout();
}
}
//FSM超时检测
if (isSupportFSM2024) {
timeDifference = System.currentTimeMillis() - fsmReceiveTime;
if (timeDifference >= DEFAULT_TIMEOUT) {
onCallFSMTimeout(true);
if (autopilotAbility440 != null) {
autopilotAbility440.onCallFsmTimeout();
}
}
}
}
}, 1000L, DEFAULT_TIMEOUT);
}
}
private synchronized void onCallSSMTimeout(boolean isTimeout) {
if (isTimeout != isOldSsmTimeout.get()) {
isOldSsmTimeout.set(isTimeout);
listener.onSsmReceiveTimeout(isTimeout);
}
}
private synchronized void onCallFSMTimeout(boolean isTimeout) {
if (isTimeout != isOldFsmTimeout.get()) {
isOldFsmTimeout.set(isTimeout);
listener.onFsm2024ReceiveTimeout(isTimeout);
}
}
private void stopAllTimer() {
stopTimeoutTimer();
stopTimer();
@@ -456,10 +535,17 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
stop350And360();
stop360();
stop440();
isOldSsmTimeout.set(false);
isOldFsmTimeout.set(false);
ssmReceiveTime = 0;
fsmReceiveTime = 0;
}
public synchronized void stop() {
stopAllTimer();
initStopData();
isInitAutopilotAbility.set(false);
isSupportFSM2024.set(-1);
isInitCarConfig.set(false);
mapVersion = -1;
isFutianSweeper = false;
@@ -469,7 +555,6 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
isJinlvM1 = false;
isJinlvM2 = false;
isKaiwo = false;
isSupportFSM2024 = false;
}
}