Добавлены новые UDS DTS

This commit is contained in:
cfif 2026-11-03 13:34:57 +03:00
parent af0ba61edb
commit 596b244414
7 changed files with 238 additions and 113 deletions

View File

@ -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, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");

View File

@ -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...")

View File

@ -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));

View File

@ -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];

View File

@ -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");

View File

@ -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);

View File

@ -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