Добавлены новые UDS DTS
This commit is contained in:
parent
af0ba61edb
commit
596b244414
|
|
@ -569,7 +569,6 @@ static _Noreturn void Adc0_Thread(tAdc0Task *env) {
|
|||
++env->step;
|
||||
|
||||
if (env->step > MAX_ADC_FILTER_SIZE * 5) {
|
||||
|
||||
/*
|
||||
LoggerErrorStatic(LOGGER, LOG_SIGN, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
|
||||
|
||||
|
|
|
|||
|
|
@ -99,8 +99,6 @@ static _Noreturn void Mma_Thread(tMma *env) {
|
|||
countQueue_space = osMessageQueueGetSpace(env->adcTask0.queueCmdBusADCData);
|
||||
}
|
||||
|
||||
SystemDelayMs(50);
|
||||
|
||||
ModelTask_StartThread(&env->ModelTask);
|
||||
|
||||
LoggerInfoStatic(LOGGER, LOG_TASK_ARB, "Waiting for the model to run...")
|
||||
|
|
|
|||
|
|
@ -647,8 +647,6 @@ uint8_t getVehicleTypeArmoredFromVin(tModelTask *env, const char* vin) {
|
|||
|
||||
lfs_file_t file;
|
||||
|
||||
volatile bool is_Global_Soft_T15 = false;
|
||||
|
||||
static _Noreturn void ModelTask_Thread(tModelTask *env) {
|
||||
|
||||
lfs_soff_t lfs_err = lfs_file_open(&fs.lfs, &file, "dtc.bin", LFS_O_RDONLY);
|
||||
|
|
@ -735,9 +733,15 @@ static _Noreturn void ModelTask_Thread(tModelTask *env) {
|
|||
model_Status_EMS_For_Model_input.EMS_Chiller_Req = rtDW.CCUCAN_EMS_HVC_REQ_MSG_MODEL.EMS_eCompChiller_Req;
|
||||
|
||||
if (rtDW.CCUCAN_BCM_VEH_STATE_model.BCM_T15_Stat) {
|
||||
is_Global_Soft_T15 = true;
|
||||
env->is_Global_Soft_T15 = true;
|
||||
} else {
|
||||
is_Global_Soft_T15 = false;
|
||||
env->is_Global_Soft_T15 = false;
|
||||
}
|
||||
|
||||
if (rtDW.CCUCAN_BCM_VEH_STATE_model.BCM_T30d_Stat) {
|
||||
env->is_Global_Soft_T30d = true;
|
||||
} else {
|
||||
env->is_Global_Soft_T30d = false;
|
||||
}
|
||||
|
||||
//конец--------------------------------------------------ВХОД МОДЕЛИ CAN------------------------------------------------
|
||||
|
|
@ -756,7 +760,75 @@ static _Noreturn void ModelTask_Thread(tModelTask *env) {
|
|||
Lin123_Output_Get_From_Model(env->linTaskActuator2, env->LIN2_ERROR_MISSING);
|
||||
Lin123_Output_Get_From_Model(env->linTaskActuator3, env->LIN3_ERROR_MISSING);
|
||||
Lin4_Output_Get_From_Model(env->lin4TaskSensor, env->LIN4_ERROR_MISSING);
|
||||
|
||||
if (rtDW.LIN4_Aroma_Stat_Model.Aroma_Err_Stat == 1) {
|
||||
env->diagnostic->state.d_DTC_AROMATIZATION_OPEN = 1;
|
||||
} else {
|
||||
env->diagnostic->state.d_DTC_AROMATIZATION_OPEN = 0;
|
||||
}
|
||||
if (rtDW.LIN4_Aroma_Stat_Model.Aroma_Err_Stat == 2) {
|
||||
env->diagnostic->state.d_DTC_AROMATIZATION_SHORT_GND = 1;
|
||||
} else {
|
||||
env->diagnostic->state.d_DTC_AROMATIZATION_SHORT_GND = 0;
|
||||
}
|
||||
if (rtDW.LIN4_Aroma_Stat_Model.Aroma_Err_Stat == 3) {
|
||||
env->diagnostic->state.d_DTC_AROMATIZATION_MALFUNCTION = 1;
|
||||
} else {
|
||||
env->diagnostic->state.d_DTC_AROMATIZATION_MALFUNCTION = 0;
|
||||
}
|
||||
|
||||
if (rtDW.LIN4_AirQS_Stat_Model.AirQS_Err_Stat == 2) {
|
||||
env->diagnostic->state.d_DTC_AIR_QUALITY_SENSOR_OPEN = 1;
|
||||
} else {
|
||||
env->diagnostic->state.d_DTC_AIR_QUALITY_SENSOR_OPEN = 0;
|
||||
}
|
||||
if (rtDW.LIN4_AirQS_Stat_Model.AirQS_Err_Stat == 3) {
|
||||
env->diagnostic->state.d_DTC_AIR_QUALITY_SENSOR_SHORT_GND = 1;
|
||||
} else {
|
||||
env->diagnostic->state.d_DTC_AIR_QUALITY_SENSOR_SHORT_GND = 0;
|
||||
}
|
||||
if (rtDW.LIN4_AirQS_Stat_Model.AirQS_Err_Stat == 4) {
|
||||
env->diagnostic->state.d_DTC_AIR_QUALITY_SENSOR_MALFUNCTION = 1;
|
||||
} else {
|
||||
env->diagnostic->state.d_DTC_AIR_QUALITY_SENSOR_MALFUNCTION = 0;
|
||||
}
|
||||
|
||||
if (rtDW.LIN4_Ionizer_Stat_Model.Ionizer_Err_Stat == 1) {
|
||||
env->diagnostic->state.d_DTC_IONIZER_OPEN = 1;
|
||||
} else {
|
||||
env->diagnostic->state.d_DTC_IONIZER_OPEN = 0;
|
||||
}
|
||||
if (rtDW.LIN4_Ionizer_Stat_Model.Ionizer_Err_Stat == 2) {
|
||||
env->diagnostic->state.d_DTC_IONIZER_SHORT_GND = 1;
|
||||
} else {
|
||||
env->diagnostic->state.d_DTC_IONIZER_SHORT_GND = 0;
|
||||
}
|
||||
if (rtDW.LIN4_Ionizer_Stat_Model.Ionizer_Err_Stat == 3) {
|
||||
env->diagnostic->state.d_DTC_IONIZER_MALFUNCTION = 1;
|
||||
} else {
|
||||
env->diagnostic->state.d_DTC_IONIZER_MALFUNCTION = 0;
|
||||
}
|
||||
|
||||
Lin5_Output_Get_From_Model(env->lin5TaskSensor, env->LIN5_ERROR_MISSING);
|
||||
|
||||
if (((rtDW.LIN5_SENSON_ADR_Stat_model.Err_Stat[0] == 1) || (rtDW.LIN5_SENSON_ADR_Stat_model.Err_Stat[1] == 1) ||
|
||||
(rtDW.LIN5_SENSON_ADR_Stat_model.Err_Stat[2] == 1) || (rtDW.LIN5_SENSON_ADR_Stat_model.Err_Stat[3] == 1)) ||
|
||||
((rtDW.LIN5_SENSON_ADR_Stat_model.LinRespErr_Stat[0] == 1) || (rtDW.LIN5_SENSON_ADR_Stat_model.LinRespErr_Stat[1] == 1) ||
|
||||
(rtDW.LIN5_SENSON_ADR_Stat_model.LinRespErr_Stat[2] == 1) || (rtDW.LIN5_SENSON_ADR_Stat_model.LinRespErr_Stat[3] == 1))) {
|
||||
env->diagnostic->state.d_DTC_DRS_FRONT_ZONE_MALFUNCTION = 1;
|
||||
} else {
|
||||
env->diagnostic->state.d_DTC_DRS_FRONT_ZONE_MALFUNCTION = 0;
|
||||
}
|
||||
|
||||
if (((rtDW.LIN5_SENSON_ADR_Stat_model.Err_Stat[4] == 1) || (rtDW.LIN5_SENSON_ADR_Stat_model.Err_Stat[5] == 1) ||
|
||||
(rtDW.LIN5_SENSON_ADR_Stat_model.Err_Stat[6] == 1) || (rtDW.LIN5_SENSON_ADR_Stat_model.Err_Stat[7] == 1)) ||
|
||||
((rtDW.LIN5_SENSON_ADR_Stat_model.LinRespErr_Stat[4] == 1) || (rtDW.LIN5_SENSON_ADR_Stat_model.LinRespErr_Stat[5] == 1) ||
|
||||
(rtDW.LIN5_SENSON_ADR_Stat_model.LinRespErr_Stat[6] == 1) || (rtDW.LIN5_SENSON_ADR_Stat_model.LinRespErr_Stat[7] == 1))) {
|
||||
env->diagnostic->state.d_DTC_DRS_REAR_ZONE_MALFUNCTION = 1;
|
||||
} else {
|
||||
env->diagnostic->state.d_DTC_DRS_REAR_ZONE_MALFUNCTION = 0;
|
||||
}
|
||||
|
||||
//конец--------------------------------------------------ВХОД МОДЕЛИ LIN4 LIN5------------------------------------------
|
||||
|
||||
//ШАГ МОДЕЛИ-------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
|
@ -947,7 +1019,7 @@ static _Noreturn void ModelTask_Thread(tModelTask *env) {
|
|||
//конец--------------------------------------------------ВЫХОД МОДЕЛИ ДЛЯ PWM-------------------------------------------
|
||||
|
||||
//начало-------------------------------------------------ВЫХОД МОДЕЛИ ДЛЯ SlEEP-----------------------------------------
|
||||
if (is_Global_Soft_T15) {
|
||||
if (env->is_Global_Soft_T15) {
|
||||
memcpy((void *) &CCU_STAT1_MODEL_SAVE, &rtY.CCU_Stat1_model, sizeof(CmdCAN_CCU_STAT1_Bus));
|
||||
memcpy((void *) &CCU_STAT2_MODEL_SAVE, &rtY.CCU_Stat2_model, sizeof(CmdCAN_CCU_STAT2_Bus));
|
||||
memcpy((void *) &CCU_STAT3_MODEL_SAVE, &rtY.CCU_Stat3_model, sizeof(CmdCAN_CCU_STAT3_Bus));
|
||||
|
|
@ -964,11 +1036,23 @@ static _Noreturn void ModelTask_Thread(tModelTask *env) {
|
|||
//==============================================DTC===============================================================================================
|
||||
//==============================================DTC===============================================================================================
|
||||
//==============================================DTC===============================================================================================
|
||||
if (env->is_Global_Soft_T15) {
|
||||
env->diagnostic->state.isT15 = env->is_Global_Soft_T15;
|
||||
env->diagnostic->state.isT30d = env->is_Global_Soft_T30d;
|
||||
env->diagnostic->state.P_BATT = PBATT_CHECK_16;
|
||||
env->diagnostic->state.CCU_Errors = &env->ccu_candb_tx.CCU_Errors;
|
||||
env->diagnostic->state.dtc_state_error_model = env->dtc_state_error;
|
||||
env->diagnostic->state.VIN = env->GET_HVAC_VIN;
|
||||
env->diagnostic->state.CAN_ERROR_MISSING = &env->CAN_ERROR_MISSING;
|
||||
env->diagnostic->state.CAN_TIME_MISSING = &env->CAN_TIME_MISSING;
|
||||
env->diagnostic->state.LIN1_ERROR_MISSING = env->LIN1_ERROR_MISSING;
|
||||
env->diagnostic->state.LIN2_ERROR_MISSING = env->LIN2_ERROR_MISSING;
|
||||
env->diagnostic->state.LIN3_ERROR_MISSING = env->LIN3_ERROR_MISSING;
|
||||
env->diagnostic->state.LIN4_ERROR_MISSING = env->LIN4_ERROR_MISSING;
|
||||
env->diagnostic->state.LIN5_ERROR_MISSING = env->LIN5_ERROR_MISSING;
|
||||
|
||||
set_Dtc_state(env->diagnostic, is_Global_Soft_T15, PBATT_CHECK_16, &env->ccu_candb_tx.CCU_Errors, env->dtc_state_error,
|
||||
env->GET_HVAC_VIN, &env->CAN_ERROR_MISSING, &env->CAN_TIME_MISSING, env->LIN1_ERROR_MISSING,
|
||||
env->LIN2_ERROR_MISSING, env->LIN3_ERROR_MISSING, env->LIN4_ERROR_MISSING,
|
||||
env->LIN5_ERROR_MISSING);
|
||||
set_Dtc_state(env->diagnostic);
|
||||
}
|
||||
//конец--------------------------------------------------ВЫХОД МОДЕЛИ ДЛЯ DTC-------------------------------------------
|
||||
|
||||
memcpy(&env->ccu_candb_tx.CCU_Stat1, &rtY.CCU_Stat1_model, sizeof(env->ccu_candb_tx.CCU_Stat1));
|
||||
|
|
|
|||
|
|
@ -88,6 +88,9 @@ typedef struct {
|
|||
|
||||
bool isRunning;
|
||||
|
||||
bool is_Global_Soft_T15;
|
||||
bool is_Global_Soft_T30d;
|
||||
|
||||
struct {
|
||||
osThreadId_t id;
|
||||
//uint32_t stack[1024];
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@
|
|||
const char *DTC_Error_Code_Strings[COUNT_DTC_CODE_ERROR] = {
|
||||
"DTC_CCU_POWER_SUPPLY_VOLTAGE_OUT_OF_RANGE", // 0xA0101C
|
||||
"DTC_IGNITION_VOLTAGE_OUT_OF_RANGE", // 0xA0111C
|
||||
"DTC_REAR_HVAC_AROMA_CONFIG_INVALID", // 0xA02056
|
||||
"DTC_AROMA_CONFIG_INVALID", // 0xA02056
|
||||
"DTC_INCAR_TEMP_FRONT_LEFT_SHORT_BAT_OPEN", // 0xA03015
|
||||
"DTC_INCAR_TEMP_FRONT_LEFT_SHORT_GND", // 0xA03011
|
||||
"DTC_INCAR_TEMP_FRONT_RIGHT_SHORT_BAT_OPEN", // 0xA03115
|
||||
|
|
@ -362,37 +362,35 @@ extern volatile uint32_t dtcCan0BusOffDeadline; // когда снять FAIL
|
|||
volatile bool isSendingCAN = 0;
|
||||
|
||||
static void
|
||||
setErrorDTC_CAN(tDiagnostic *env, bool isT15, uint16_t P_BATT, uint8_t *dtc_state_error_model, ccu_candb_error_missing_rx_t *CAN_ERROR_MISSING, char *VIN,
|
||||
CCU_Errors_t *CCU_Errors) {
|
||||
setErrorDTC_CAN(tDiagnostic *env) {
|
||||
|
||||
if ((P_BATT >= V_SEND_LOW) && (P_BATT <= V_SEND_HIGH)) {
|
||||
if ((env->state.P_BATT >= V_SEND_LOW) && (env->state.P_BATT <= V_SEND_HIGH)) {
|
||||
isSendingCAN = true;
|
||||
} else {
|
||||
isSendingCAN = false;
|
||||
}
|
||||
|
||||
// uint32_t timeCanSpamReceiver = getCanTimeReceived(env->canSpamReceiver, isCan0BusOff, isT15) + 3000;
|
||||
uint32_t time = SystemGetMs();
|
||||
|
||||
if (env->tDiagStart > time) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ((P_BATT < V_DIAG_LOW) || (P_BATT > V_DIAG_HIGH)) {
|
||||
if ((env->state.P_BATT < V_DIAG_LOW) || (env->state.P_BATT > V_DIAG_HIGH)) {
|
||||
env->tDiagStart = SystemGetMs() + TDiagStart;
|
||||
return;
|
||||
}
|
||||
|
||||
if (isT15 == false) {
|
||||
if (env->state.isT15 == false) {
|
||||
env->tDiagStart = SystemGetMs() + TDiagStart;
|
||||
return;
|
||||
}
|
||||
|
||||
if (dtcCan0BusOffActive) {
|
||||
if (time < dtcCan0BusOffDeadline) {
|
||||
dtc_state_error_model[DTC_BODY_CAN_BUS_OFF] = DTC_TEST_FAILED_CONFIRMED;
|
||||
env->state.dtc_state_error_model[DTC_BODY_CAN_BUS_OFF] = DTC_TEST_FAILED_CONFIRMED;
|
||||
} else {
|
||||
dtc_state_error_model[DTC_BODY_CAN_BUS_OFF] = dtc_state_error[DTC_BODY_CAN_BUS_OFF] & (~(DTC_TEST_FAILED));
|
||||
env->state.dtc_state_error_model[DTC_BODY_CAN_BUS_OFF] = dtc_state_error[DTC_BODY_CAN_BUS_OFF] & (~(DTC_TEST_FAILED));
|
||||
dtcCan0BusOffActive = false; // ← окно закрыто
|
||||
}
|
||||
|
||||
|
|
@ -400,146 +398,174 @@ setErrorDTC_CAN(tDiagnostic *env, bool isT15, uint16_t P_BATT, uint8_t *dtc_stat
|
|||
return;
|
||||
}
|
||||
|
||||
setErrorDTC_CAN_VIN(dtc_state_error_model, CAN_ERROR_MISSING, VIN, CCU_Errors);
|
||||
setErrorDTC_CAN_VIN(env->state.dtc_state_error_model, env->state.CAN_ERROR_MISSING, env->state.VIN, env->state.CCU_Errors);
|
||||
|
||||
// U010087 (EMS/VCU) - 0x298 OR 0x150 OR 0x153 - OK
|
||||
if ((CAN_ERROR_MISSING->EMS_HVC_Req_Msg) || (CAN_ERROR_MISSING->EMS_Veh) || (CAN_ERROR_MISSING->EMS_Veh_02)) {
|
||||
dtc_state_error_model[DTC_LOST_COMM_ECM_PCM] = DTC_TEST_FAILED_CONFIRMED;
|
||||
if ((env->state.CAN_ERROR_MISSING->EMS_HVC_Req_Msg) || (env->state.CAN_ERROR_MISSING->EMS_Veh) || (env->state.CAN_ERROR_MISSING->EMS_Veh_02)) {
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_ECM_PCM] = DTC_TEST_FAILED_CONFIRMED;
|
||||
} else {
|
||||
dtc_state_error_model[DTC_LOST_COMM_ECM_PCM] = dtc_state_error[DTC_LOST_COMM_ECM_PCM] & (~(DTC_TEST_FAILED));
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_ECM_PCM] = dtc_state_error[DTC_LOST_COMM_ECM_PCM] & (~(DTC_TEST_FAILED));
|
||||
}
|
||||
|
||||
// U012287 (ESP)- 0x100 OR 0x3C1 - OK
|
||||
if ((CAN_ERROR_MISSING->ESC_04) || (CAN_ERROR_MISSING->ESC_08)) {
|
||||
dtc_state_error_model[DTC_LOST_COMM_ESP] = DTC_TEST_FAILED_CONFIRMED;
|
||||
if ((env->state.CAN_ERROR_MISSING->ESC_04) || (env->state.CAN_ERROR_MISSING->ESC_08)) {
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_ESP] = DTC_TEST_FAILED_CONFIRMED;
|
||||
} else {
|
||||
dtc_state_error_model[DTC_LOST_COMM_ESP] = dtc_state_error[DTC_LOST_COMM_ESP] & (~(DTC_TEST_FAILED));
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_ESP] = dtc_state_error[DTC_LOST_COMM_ESP] & (~(DTC_TEST_FAILED));
|
||||
}
|
||||
|
||||
// U014187 (BCM) - 0x365 OR 0x157 OR 0x152 OR 0x280 OR 0x51A - OK
|
||||
if ((CAN_ERROR_MISSING->BCM_CLIMATIC_DATA) || (CAN_ERROR_MISSING->BCM_EEM) || (CAN_ERROR_MISSING->BCM_Powertrain) ||
|
||||
(CAN_ERROR_MISSING->BCM_VEH_STATE) || (CAN_ERROR_MISSING->VEH_VIN)) {
|
||||
dtc_state_error_model[DTC_LOST_COMM_BCM] = DTC_TEST_FAILED_CONFIRMED;
|
||||
if ((env->state.CAN_ERROR_MISSING->BCM_CLIMATIC_DATA) || (env->state.CAN_ERROR_MISSING->BCM_EEM) || (env->state.CAN_ERROR_MISSING->BCM_Powertrain) ||
|
||||
(env->state.CAN_ERROR_MISSING->BCM_VEH_STATE) || (env->state.CAN_ERROR_MISSING->VEH_VIN)) {
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_BCM] = DTC_TEST_FAILED_CONFIRMED;
|
||||
} else {
|
||||
dtc_state_error_model[DTC_LOST_COMM_BCM] = dtc_state_error[DTC_LOST_COMM_BCM] & (~(DTC_TEST_FAILED));
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_BCM] = dtc_state_error[DTC_LOST_COMM_BCM] & (~(DTC_TEST_FAILED));
|
||||
}
|
||||
|
||||
// U016B87 (HVC) - 0x25A OR 0x305 - OK
|
||||
if ((CAN_ERROR_MISSING->HVC_CCU_Status_Msg) || (CAN_ERROR_MISSING->HVC_Err_Status_Msg)) {
|
||||
dtc_state_error_model[DTC_LOST_COMM_AC_COMPRESSOR] = DTC_TEST_FAILED_CONFIRMED;
|
||||
if ((env->state.CAN_ERROR_MISSING->HVC_CCU_Status_Msg) || (env->state.CAN_ERROR_MISSING->HVC_Err_Status_Msg)) {
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_AC_COMPRESSOR] = DTC_TEST_FAILED_CONFIRMED;
|
||||
} else {
|
||||
dtc_state_error_model[DTC_LOST_COMM_AC_COMPRESSOR] =
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_AC_COMPRESSOR] =
|
||||
dtc_state_error[DTC_LOST_COMM_AC_COMPRESSOR] & (~(DTC_TEST_FAILED));
|
||||
}
|
||||
|
||||
// U019987 (DMFL) - 0x244 - OK
|
||||
if ((CAN_ERROR_MISSING->DMFR_Msg1)) {
|
||||
dtc_state_error_model[DTC_LOST_COMM_DOOR_MODULE_A_DMFL] = DTC_TEST_FAILED_CONFIRMED;
|
||||
if ((env->state.CAN_ERROR_MISSING->DMFR_Msg1)) {
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_DOOR_MODULE_A_DMFL] = DTC_TEST_FAILED_CONFIRMED;
|
||||
} else {
|
||||
dtc_state_error_model[DTC_LOST_COMM_DOOR_MODULE_A_DMFL] =
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_DOOR_MODULE_A_DMFL] =
|
||||
dtc_state_error[DTC_LOST_COMM_DOOR_MODULE_A_DMFL] & (~(DTC_TEST_FAILED));
|
||||
}
|
||||
|
||||
// U020087 (DMFR) - 0x243 - OK
|
||||
if ((CAN_ERROR_MISSING->DMFL_Msg1)) {
|
||||
dtc_state_error_model[DTC_LOST_COMM_DOOR_MODULE_B_DMFR] = DTC_TEST_FAILED_CONFIRMED;
|
||||
if ((env->state.CAN_ERROR_MISSING->DMFL_Msg1)) {
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_DOOR_MODULE_B_DMFR] = DTC_TEST_FAILED_CONFIRMED;
|
||||
} else {
|
||||
dtc_state_error_model[DTC_LOST_COMM_DOOR_MODULE_B_DMFR] =
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_DOOR_MODULE_B_DMFR] =
|
||||
dtc_state_error[DTC_LOST_COMM_DOOR_MODULE_B_DMFR] & (~(DTC_TEST_FAILED));
|
||||
}
|
||||
|
||||
// U020887 (SMFL) 0x4D0 OR 0x521 - OK
|
||||
if ((CAN_ERROR_MISSING->SMFL_status) || (CAN_ERROR_MISSING->OCUFL_MSG)) {
|
||||
dtc_state_error_model[DTC_LOST_COMM_SEAT_MODULE_A_SMFL] = DTC_TEST_FAILED_CONFIRMED;
|
||||
if ((env->state.CAN_ERROR_MISSING->SMFL_status) || (env->state.CAN_ERROR_MISSING->OCUFL_MSG)) {
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_SEAT_MODULE_A_SMFL] = DTC_TEST_FAILED_CONFIRMED;
|
||||
} else {
|
||||
dtc_state_error_model[DTC_LOST_COMM_SEAT_MODULE_A_SMFL] =
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_SEAT_MODULE_A_SMFL] =
|
||||
dtc_state_error[DTC_LOST_COMM_SEAT_MODULE_A_SMFL] & (~(DTC_TEST_FAILED));
|
||||
}
|
||||
|
||||
// U020987 (SMFR) 0x4D1 OR 0x522 - OK
|
||||
if ((CAN_ERROR_MISSING->SMFR_status) || (CAN_ERROR_MISSING->OCUFR_MSG)) {
|
||||
dtc_state_error_model[DTC_LOST_COMM_SEAT_MODULE_B_SMFR] = DTC_TEST_FAILED_CONFIRMED;
|
||||
if ((env->state.CAN_ERROR_MISSING->SMFR_status) || (env->state.CAN_ERROR_MISSING->OCUFR_MSG)) {
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_SEAT_MODULE_B_SMFR] = DTC_TEST_FAILED_CONFIRMED;
|
||||
} else {
|
||||
dtc_state_error_model[DTC_LOST_COMM_SEAT_MODULE_B_SMFR] =
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_SEAT_MODULE_B_SMFR] =
|
||||
dtc_state_error[DTC_LOST_COMM_SEAT_MODULE_B_SMFR] & (~(DTC_TEST_FAILED));
|
||||
}
|
||||
|
||||
// U021087 (SMRL) 0x4D2 OR 0x523 - OK
|
||||
if ((CAN_ERROR_MISSING->SMRL_status) || (CAN_ERROR_MISSING->OCURL_MSG)) {
|
||||
dtc_state_error_model[DTC_LOST_COMM_SEAT_MODULE_C_SMRL] = DTC_TEST_FAILED_CONFIRMED;
|
||||
if ((env->state.CAN_ERROR_MISSING->SMRL_status) || (env->state.CAN_ERROR_MISSING->OCURL_MSG)) {
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_SEAT_MODULE_C_SMRL] = DTC_TEST_FAILED_CONFIRMED;
|
||||
} else {
|
||||
dtc_state_error_model[DTC_LOST_COMM_SEAT_MODULE_C_SMRL] =
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_SEAT_MODULE_C_SMRL] =
|
||||
dtc_state_error[DTC_LOST_COMM_SEAT_MODULE_C_SMRL] & (~(DTC_TEST_FAILED));
|
||||
}
|
||||
|
||||
// U021187 (SMRR) 0x4D3 OR 0x524 - OK
|
||||
if ((CAN_ERROR_MISSING->SMRR_status) || (CAN_ERROR_MISSING->OCURR_MSG)) {
|
||||
dtc_state_error_model[DTC_LOST_COMM_SEAT_MODULE_D_SMRR] = DTC_TEST_FAILED_CONFIRMED;
|
||||
if ((env->state.CAN_ERROR_MISSING->SMRR_status) || (env->state.CAN_ERROR_MISSING->OCURR_MSG)) {
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_SEAT_MODULE_D_SMRR] = DTC_TEST_FAILED_CONFIRMED;
|
||||
} else {
|
||||
dtc_state_error_model[DTC_LOST_COMM_SEAT_MODULE_D_SMRR] =
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_SEAT_MODULE_D_SMRR] =
|
||||
dtc_state_error[DTC_LOST_COMM_SEAT_MODULE_D_SMRR] & (~(DTC_TEST_FAILED));
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
setErrorDTC_LIN(uint8_t *dtc_state_error_model, const uint8_t *LIN1_ERROR_MISSING, const uint8_t *LIN2_ERROR_MISSING,
|
||||
const uint8_t
|
||||
*LIN3_ERROR_MISSING, const uint8_t *LIN4_ERROR_MISSING, const uint8_t *LIN5_ERROR_MISSING) {
|
||||
setErrorDTC_LIN(tDiagnostic *env) {
|
||||
|
||||
for (uint8_t i = 0; i < 9; ++i) {
|
||||
if (LIN1_ERROR_MISSING[i]) {
|
||||
dtc_state_error_model[i + 93] = DTC_TEST_FAILED_CONFIRMED;
|
||||
if (env->state.LIN1_ERROR_MISSING[i]) {
|
||||
env->state.dtc_state_error_model[i + 93] = DTC_TEST_FAILED_CONFIRMED;
|
||||
} else {
|
||||
dtc_state_error_model[i + 93] = dtc_state_error[i + 93] & (~(DTC_TEST_FAILED));
|
||||
env->state.dtc_state_error_model[i + 93] = dtc_state_error[i + 93] & (~(DTC_TEST_FAILED));
|
||||
}
|
||||
}
|
||||
|
||||
for (uint8_t i = 0; i < 6; ++i) {
|
||||
if (LIN2_ERROR_MISSING[i]) {
|
||||
dtc_state_error_model[i + 102] = DTC_TEST_FAILED_CONFIRMED;
|
||||
if (env->state.LIN2_ERROR_MISSING[i]) {
|
||||
env->state.dtc_state_error_model[i + 102] = DTC_TEST_FAILED_CONFIRMED;
|
||||
} else {
|
||||
dtc_state_error_model[i + 102] = dtc_state_error[i + 102] & (~(DTC_TEST_FAILED));
|
||||
env->state.dtc_state_error_model[i + 102] = dtc_state_error[i + 102] & (~(DTC_TEST_FAILED));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
for (uint8_t i = 0; i < 9; ++i) {
|
||||
if (LIN3_ERROR_MISSING[i]) {
|
||||
dtc_state_error_model[i + 109] = DTC_TEST_FAILED_CONFIRMED;
|
||||
if (env->state.LIN3_ERROR_MISSING[i]) {
|
||||
env->state.dtc_state_error_model[i + 109] = DTC_TEST_FAILED_CONFIRMED;
|
||||
} else {
|
||||
dtc_state_error_model[i + 109] = dtc_state_error[i + 109] & (~(DTC_TEST_FAILED));
|
||||
env->state.dtc_state_error_model[i + 109] = dtc_state_error[i + 109] & (~(DTC_TEST_FAILED));
|
||||
}
|
||||
}
|
||||
|
||||
for (uint8_t i = 0; i < 7; ++i) {
|
||||
if (LIN4_ERROR_MISSING[i]) {
|
||||
dtc_state_error_model[i + 117] = DTC_TEST_FAILED_CONFIRMED;
|
||||
if (env->state.LIN4_ERROR_MISSING[i]) {
|
||||
env->state.dtc_state_error_model[i + 117] = DTC_TEST_FAILED_CONFIRMED;
|
||||
} else {
|
||||
dtc_state_error_model[i + 117] = dtc_state_error[i + 117] & (~(DTC_TEST_FAILED));
|
||||
env->state.dtc_state_error_model[i + 117] = dtc_state_error[i + 117] & (~(DTC_TEST_FAILED));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if ((LIN5_ERROR_MISSING[2]) || (LIN5_ERROR_MISSING[3]) || (LIN5_ERROR_MISSING[6]) || (LIN5_ERROR_MISSING[7])) {
|
||||
dtc_state_error_model[DTC_LOST_COMM_DRS_FRONT] = DTC_TEST_FAILED_CONFIRMED;
|
||||
if ((env->state.LIN5_ERROR_MISSING[0]) || (env->state.LIN5_ERROR_MISSING[1]) || (env->state.LIN5_ERROR_MISSING[2]) || (env->state.LIN5_ERROR_MISSING[3])) {
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_DRS_FRONT] = DTC_TEST_FAILED_CONFIRMED;
|
||||
} else {
|
||||
dtc_state_error_model[DTC_LOST_COMM_DRS_FRONT] =
|
||||
dtc_state_error[DTC_LOST_COMM_DRS_FRONT] & (~(DTC_TEST_FAILED));
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_DRS_FRONT] = dtc_state_error[DTC_LOST_COMM_DRS_FRONT] & (~(DTC_TEST_FAILED));
|
||||
}
|
||||
|
||||
if ((LIN5_ERROR_MISSING[0]) || (LIN5_ERROR_MISSING[1]) || (LIN5_ERROR_MISSING[4]) || (LIN5_ERROR_MISSING[5])) {
|
||||
dtc_state_error_model[DTC_LOST_COMM_DRS_REAR] = DTC_TEST_FAILED_CONFIRMED;
|
||||
if ((env->state.LIN5_ERROR_MISSING[4]) || (env->state.LIN5_ERROR_MISSING[5]) || (env->state.LIN5_ERROR_MISSING[6]) || (env->state.LIN5_ERROR_MISSING[7])) {
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_DRS_REAR] = DTC_TEST_FAILED_CONFIRMED;
|
||||
} else {
|
||||
dtc_state_error_model[DTC_LOST_COMM_DRS_REAR] = dtc_state_error[DTC_LOST_COMM_DRS_REAR] & (~(DTC_TEST_FAILED));
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_DRS_REAR] = dtc_state_error[DTC_LOST_COMM_DRS_REAR] & (~(DTC_TEST_FAILED));
|
||||
}
|
||||
|
||||
// Если AromaConfiguration нет или не настроен
|
||||
if (statusData.ecu.Status_CCU_Configuration.AromaConfiguration != AROMA_PRESENT) {
|
||||
env->state.dtc_state_error_model[DTC_AROMA_CONFIG_INVALID] = DTC_TEST_FAILED_CONFIRMED;
|
||||
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_AROMATIZATION] = 0;
|
||||
env->state.dtc_state_error_model[DTC_AROMATIZATION_OPEN] = 0;
|
||||
env->state.dtc_state_error_model[DTC_AROMATIZATION_SHORT_GND] = 0;
|
||||
env->state.dtc_state_error_model[DTC_AROMATIZATION_MALFUNCTION] = 0;
|
||||
|
||||
|
||||
} else {
|
||||
env->state.dtc_state_error_model[DTC_AROMA_CONFIG_INVALID] = dtc_state_error[DTC_AROMA_CONFIG_INVALID] & (~(DTC_TEST_FAILED));
|
||||
|
||||
env->state.dtc_state_error_model[DTC_AROMATIZATION_OPEN] = env->state.d_DTC_AROMATIZATION_OPEN;
|
||||
env->state.dtc_state_error_model[DTC_AROMATIZATION_SHORT_GND] = env->state.d_DTC_AROMATIZATION_SHORT_GND;
|
||||
env->state.dtc_state_error_model[DTC_AROMATIZATION_MALFUNCTION] = env->state.d_DTC_AROMATIZATION_MALFUNCTION;
|
||||
}
|
||||
|
||||
env->state.dtc_state_error_model[DTC_IONIZER_OPEN] = env->state.d_DTC_IONIZER_OPEN;
|
||||
env->state.dtc_state_error_model[DTC_IONIZER_SHORT_GND] = env->state.d_DTC_IONIZER_SHORT_GND;
|
||||
env->state.dtc_state_error_model[DTC_IONIZER_MALFUNCTION] = env->state.d_DTC_IONIZER_MALFUNCTION;
|
||||
|
||||
env->state.dtc_state_error_model[DTC_AIR_QUALITY_SENSOR_OPEN] = env->state.d_DTC_AIR_QUALITY_SENSOR_OPEN;
|
||||
env->state.dtc_state_error_model[DTC_AIR_QUALITY_SENSOR_SHORT_GND] = env->state.d_DTC_AIR_QUALITY_SENSOR_SHORT_GND;
|
||||
env->state.dtc_state_error_model[DTC_AIR_QUALITY_SENSOR_MALFUNCTION] = env->state.d_DTC_AIR_QUALITY_SENSOR_MALFUNCTION;
|
||||
|
||||
env->state.dtc_state_error_model[DTC_DRS_FRONT_ZONE_MALFUNCTION] = env->state.d_DTC_DRS_FRONT_ZONE_MALFUNCTION;
|
||||
env->state.dtc_state_error_model[DTC_DRS_REAR_ZONE_MALFUNCTION] = env->state.d_DTC_DRS_REAR_ZONE_MALFUNCTION;
|
||||
|
||||
// Только в электричке
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_FRONT_TXV] = 0;
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_REAR_TXV] = 0;
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_HV_BATTERY_CHILLER_TXV] = 0;
|
||||
env->state.dtc_state_error_model[DTC_LOST_COMM_HEAT_PUMP_CHILLER_TXV] = 0;
|
||||
|
||||
}
|
||||
|
||||
void set_Dtc_state(tDiagnostic *env, bool isT15, uint16_t P_BATT, CCU_Errors_t *CCU_Errors,
|
||||
uint8_t *dtc_state_error_model, char *VIN,
|
||||
ccu_candb_error_missing_rx_t *CAN_ERROR_MISSING, ccu_candb_time_missing_rx_t *CAN_TIME_MISSING,
|
||||
uint8_t *LIN1_ERROR_MISSING, uint8_t *LIN2_ERROR_MISSING, uint8_t *LIN3_ERROR_MISSING,
|
||||
uint8_t *LIN4_ERROR_MISSING, uint8_t *LIN5_ERROR_MISSING) {
|
||||
void set_Dtc_state(tDiagnostic *env) {
|
||||
|
||||
if (osMutexAcquire(env->access, 5000) == osOK) {
|
||||
|
||||
|
|
@ -555,28 +581,19 @@ void set_Dtc_state(tDiagnostic *env, bool isT15, uint16_t P_BATT, CCU_Errors_t *
|
|||
}
|
||||
|
||||
for (uint8_t i = 0; i < COUNT_DTC_CODE_ERROR; ++i) {
|
||||
if (dtc_state_error_model[i]) {
|
||||
dtc_state_error_model[i] = DTC_TEST_FAILED_CONFIRMED;
|
||||
if (env->state.dtc_state_error_model[i]) {
|
||||
env->state.dtc_state_error_model[i] = DTC_TEST_FAILED_CONFIRMED;
|
||||
} else {
|
||||
dtc_state_error_model[i] = dtc_state_error[i] & (~(DTC_TEST_FAILED));
|
||||
env->state.dtc_state_error_model[i] = dtc_state_error[i] & (~(DTC_TEST_FAILED));
|
||||
}
|
||||
}
|
||||
|
||||
setErrorDTC_LIN(dtc_state_error_model, LIN1_ERROR_MISSING, LIN2_ERROR_MISSING, LIN3_ERROR_MISSING,
|
||||
LIN4_ERROR_MISSING, LIN5_ERROR_MISSING);
|
||||
setErrorDTC_LIN(env);
|
||||
|
||||
// Если не было изначально сообщений
|
||||
setErrorDTC_CAN(env, isT15, P_BATT, dtc_state_error_model, CAN_ERROR_MISSING, VIN, CCU_Errors);
|
||||
setErrorDTC_CAN(env);
|
||||
|
||||
// if () {
|
||||
// dtc_state_error_model[DTC_REAR_HVAC_AROMA_CONFIG_INVALID] = DTC_TEST_FAILED_CONFIRMED;
|
||||
// } else {
|
||||
// dtc_state_error_model[DTC_REAR_HVAC_AROMA_CONFIG_INVALID] = dtc_state_error[DTC_REAR_HVAC_AROMA_CONFIG_INVALID] & (~(DTC_TEST_FAILED));
|
||||
// }
|
||||
|
||||
|
||||
|
||||
if (memcmp(dtc_state_error, dtc_state_error_model, sizeof(dtc_state_error)) != 0) {
|
||||
if (memcmp(dtc_state_error, env->state.dtc_state_error_model, sizeof(dtc_state_error)) != 0) {
|
||||
|
||||
bool isDTC_FileWrite = false;
|
||||
|
||||
|
|
@ -584,19 +601,19 @@ void set_Dtc_state(tDiagnostic *env, bool isT15, uint16_t P_BATT, CCU_Errors_t *
|
|||
LoggerInfoStatic(LOGGER, LOG_SIGN, "begin------------------------------DTC-------------------------------")
|
||||
#endif
|
||||
for (uint8_t i = 0; i < COUNT_DTC_CODE_ERROR; ++i) {
|
||||
if (dtc_state_error_model[i]) {
|
||||
if (env->state.dtc_state_error_model[i]) {
|
||||
|
||||
if ((dtc_state_error[i] & DTC_TEST_CONFIRMED) != (dtc_state_error_model[i] & DTC_TEST_CONFIRMED)) {
|
||||
if ((dtc_state_error[i] & DTC_TEST_CONFIRMED) != (env->state.dtc_state_error_model[i] & DTC_TEST_CONFIRMED)) {
|
||||
isDTC_FileWrite = true;
|
||||
}
|
||||
#if (LOG_DTC == 1)
|
||||
bool failed = false;
|
||||
bool confirmed = false;
|
||||
|
||||
if (dtc_state_error_model[i] & DTC_TEST_FAILED) {
|
||||
if (env->state.dtc_state_error_model[i] & DTC_TEST_FAILED) {
|
||||
failed = true;
|
||||
}
|
||||
if (dtc_state_error_model[i] & DTC_TEST_CONFIRMED) {
|
||||
if (env->state.dtc_state_error_model[i] & DTC_TEST_CONFIRMED) {
|
||||
confirmed = true;
|
||||
}
|
||||
|
||||
|
|
@ -609,12 +626,12 @@ void set_Dtc_state(tDiagnostic *env, bool isT15, uint16_t P_BATT, CCU_Errors_t *
|
|||
LoggerInfoStatic(LOGGER, LOG_SIGN, "end------------------------------DTC---------------------------------")
|
||||
#endif
|
||||
|
||||
memcpy(dtc_state_error, dtc_state_error_model, sizeof(dtc_state_error));
|
||||
memcpy(dtc_state_error, env->state.dtc_state_error_model, sizeof(dtc_state_error));
|
||||
|
||||
if (isDTC_FileWrite) {
|
||||
|
||||
for (uint8_t i = 0; i < COUNT_DTC_CODE_ERROR; ++i) {
|
||||
dtc_state_error_model[i] = dtc_state_error[i] & (~(DTC_TEST_FAILED));
|
||||
env->state.dtc_state_error_model[i] = dtc_state_error[i] & (~(DTC_TEST_FAILED));
|
||||
}
|
||||
|
||||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Write dtc.bin");
|
||||
|
|
@ -623,7 +640,7 @@ void set_Dtc_state(tDiagnostic *env, bool isT15, uint16_t P_BATT, CCU_Errors_t *
|
|||
|
||||
if (lfs_err == LFS_ERR_OK) {
|
||||
|
||||
int writes = lfs_file_write(&fs.lfs, &file, dtc_state_error_model, sizeof(dtc_state_error));
|
||||
int writes = lfs_file_write(&fs.lfs, &file, env->state.dtc_state_error_model, sizeof(dtc_state_error));
|
||||
|
||||
if (writes != sizeof(dtc_state_error)) {
|
||||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Error write dtc.bin");
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
#include "CanSpamReceiver.h"
|
||||
#include "lfs.h"
|
||||
|
||||
#define LOG_DTC 0
|
||||
#define LOG_DTC 1
|
||||
|
||||
#define V_DIAG_LOW 95
|
||||
#define V_DIAG_HIGH 155
|
||||
|
|
@ -33,24 +33,48 @@ typedef struct {
|
|||
typedef struct {
|
||||
osMutexId_t access;
|
||||
tLoggerInterface *logger;
|
||||
|
||||
uint32_t tDiagStart;
|
||||
|
||||
tCanSpamReceiver *canSpamReceiver;
|
||||
|
||||
bool isNoBitsDTC;
|
||||
|
||||
bool isCleanDTC;
|
||||
|
||||
struct {
|
||||
bool isT15;
|
||||
bool isT30d;
|
||||
uint16_t P_BATT;
|
||||
CCU_Errors_t *CCU_Errors;
|
||||
uint8_t *dtc_state_error_model;
|
||||
char *VIN;
|
||||
ccu_candb_error_missing_rx_t *CAN_ERROR_MISSING;
|
||||
ccu_candb_time_missing_rx_t *CAN_TIME_MISSING;
|
||||
uint8_t *LIN1_ERROR_MISSING;
|
||||
uint8_t *LIN2_ERROR_MISSING;
|
||||
uint8_t *LIN3_ERROR_MISSING;
|
||||
uint8_t *LIN4_ERROR_MISSING;
|
||||
uint8_t *LIN5_ERROR_MISSING;
|
||||
|
||||
uint8_t d_DTC_AROMATIZATION_OPEN;
|
||||
uint8_t d_DTC_AROMATIZATION_SHORT_GND;
|
||||
uint8_t d_DTC_AROMATIZATION_MALFUNCTION;
|
||||
|
||||
uint8_t d_DTC_AIR_QUALITY_SENSOR_OPEN;
|
||||
uint8_t d_DTC_AIR_QUALITY_SENSOR_SHORT_GND;
|
||||
uint8_t d_DTC_AIR_QUALITY_SENSOR_MALFUNCTION;
|
||||
|
||||
uint8_t d_DTC_IONIZER_OPEN;
|
||||
uint8_t d_DTC_IONIZER_SHORT_GND;
|
||||
uint8_t d_DTC_IONIZER_MALFUNCTION;
|
||||
|
||||
uint8_t d_DTC_DRS_FRONT_ZONE_MALFUNCTION;
|
||||
uint8_t d_DTC_DRS_REAR_ZONE_MALFUNCTION;
|
||||
|
||||
} state;
|
||||
|
||||
} tDiagnostic;
|
||||
|
||||
void Diagnostic_Init(tDiagnostic *env, tCanSpamReceiver *canSpamReceiver, tLoggerInterface *logger);
|
||||
void set_NoBitsDTC(tDiagnostic *env, bool noBitsDTC);
|
||||
void set_Dtc_state(tDiagnostic *env, bool isT15, uint16_t P_BATT, CCU_Errors_t *CCU_Errors,
|
||||
uint8_t *dtc_state_error_model, char *VIN,
|
||||
ccu_candb_error_missing_rx_t *CAN_ERROR_MISSLE, ccu_candb_time_missing_rx_t *CAN_TIME_MISSLE,
|
||||
uint8_t *LIN1_ERROR_MISSING, uint8_t *LIN2_ERROR_MISSING, uint8_t *LIN3_ERROR_MISSING,
|
||||
uint8_t *LIN4_ERROR_MISSING, uint8_t *LIN5_ERROR_MISSING);
|
||||
void set_Dtc_state(tDiagnostic *env);
|
||||
uint32_t diagnostic_ClearDiagnosticInformation_14(tDiagnostic *env);
|
||||
uint32_t diagnostic_UDS_ReadDTCInformation_19_count(tDiagnostic *env, tDiagnosticDTC *diagnosticDTC);
|
||||
uint32_t diagnostic_UDS_ReadDTCInformation_19_dtc(tDiagnostic *env, tDiagnosticDTC *diagnosticDTC);
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ extern uint8_t dtc_state_FIX_error[COUNT_DTC_CODE_ERROR];
|
|||
enum eDTC_Error_Code {
|
||||
DTC_CCU_POWER_SUPPLY_VOLTAGE_OUT_OF_RANGE = 0, // 0xA0101C
|
||||
DTC_IGNITION_VOLTAGE_OUT_OF_RANGE = 1, // 0xA0111C
|
||||
DTC_REAR_HVAC_AROMA_CONFIG_INVALID = 2, // 0xA02056
|
||||
DTC_AROMA_CONFIG_INVALID = 2, // 0xA02056
|
||||
DTC_INCAR_TEMP_FRONT_LEFT_SHORT_BAT_OPEN = 3, // 0xA03015
|
||||
DTC_INCAR_TEMP_FRONT_LEFT_SHORT_GND = 4, // 0xA03011
|
||||
DTC_INCAR_TEMP_FRONT_RIGHT_SHORT_BAT_OPEN = 5, // 0xA03115
|
||||
|
|
|
|||
Loading…
Reference in New Issue