628 lines
28 KiB
C
628 lines
28 KiB
C
//
|
||
// Created by cfif on 23.01.2026.
|
||
//
|
||
#include "DiagnosticTask.h"
|
||
#include "CmsisRtosThreadUtils.h"
|
||
#include "StatusData.h"
|
||
#include "StatusError.h"
|
||
#include "HVAC_model.h"
|
||
#include "SystemDelayInterface.h"
|
||
#include "lfs.h"
|
||
#include "lfs_file_utils.h"
|
||
#include "LittleFsInterface.h"
|
||
|
||
#define LOG_SIGN "DIAGNOSTIC"
|
||
#define LOGGER env->logger
|
||
|
||
#if (LOG_DTC == 1)
|
||
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_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
|
||
"DTC_INCAR_TEMP_FRONT_RIGHT_SHORT_GND", // 0xA03111
|
||
"DTC_INCAR_TEMP_REAR_LEFT_SHORT_BAT_OPEN", // 0xA05415
|
||
"DTC_INCAR_TEMP_REAR_LEFT_SHORT_GND", // 0xA05411
|
||
"DTC_INCAR_TEMP_REAR_RIGHT_SHORT_BAT_OPEN", // 0xA05515
|
||
"DTC_INCAR_TEMP_REAR_RIGHT_SHORT_GND", // 0xA05511
|
||
"DTC_AMBIENT_TEMP_SHORT_BAT_OPEN", // 0xA03215
|
||
"DTC_AMBIENT_TEMP_SHORT_GND", // 0xA03211
|
||
"DTC_FRONT_EVAP_TEMP_SHORT_BAT_OPEN", // 0xA03315
|
||
"DTC_FRONT_EVAP_TEMP_SHORT_GND", // 0xA03311
|
||
"DTC_REAR_EVAP_TEMP_SHORT_BAT_OPEN", // 0xA03415
|
||
"DTC_REAR_EVAP_TEMP_SHORT_GND", // 0xA03411
|
||
"DTC_DUCT_VENT_FL_SHORT_BAT_OPEN", // 0xA03515
|
||
"DTC_DUCT_VENT_FL_SHORT_GND", // 0xA03511
|
||
"DTC_DUCT_VENT_FR_SHORT_BAT_OPEN", // 0xA03615
|
||
"DTC_DUCT_VENT_FR_SHORT_GND", // 0xA03611
|
||
"DTC_DUCT_FOOT_FL_SHORT_BAT_OPEN", // 0xA03715
|
||
"DTC_DUCT_FOOT_FL_SHORT_GND", // 0xA03711
|
||
"DTC_DUCT_FOOT_FR_SHORT_BAT_OPEN", // 0xA03815
|
||
"DTC_DUCT_FOOT_FR_SHORT_GND", // 0xA03811
|
||
"DTC_DUCT_VENT_SIDE_FL_SHORT_BAT_OPEN", // 0xA04115
|
||
"DTC_DUCT_VENT_SIDE_FL_SHORT_GND", // 0xA04111
|
||
"DTC_DUCT_VENT_SIDE_FR_SHORT_BAT_OPEN", // 0xA04215
|
||
"DTC_DUCT_VENT_SIDE_FR_SHORT_GND", // 0xA04211
|
||
"DTC_DUCT_VENT_RL_SHORT_BAT_OPEN", // 0xA03915
|
||
"DTC_DUCT_VENT_RL_SHORT_GND", // 0xA03911
|
||
"DTC_DUCT_VENT_RR_SHORT_BAT_OPEN", // 0xA04015
|
||
"DTC_DUCT_VENT_RR_SHORT_GND", // 0xA04011
|
||
"DTC_DUCT_FOOT_RL_SHORT_BAT_OPEN", // 0xA04515
|
||
"DTC_DUCT_FOOT_RL_SHORT_GND", // 0xA04511
|
||
"DTC_DUCT_FOOT_RR_SHORT_BAT_OPEN", // 0xA04615
|
||
"DTC_DUCT_FOOT_RR_SHORT_GND", // 0xA04611
|
||
"DTC_UV_LAMP_OPEN_SHORT_BAT", // 0xA04713
|
||
"DTC_UV_LAMP_SHORT_GND", // 0xA04711
|
||
"DTC_AROMATIZATION_OPEN", // 0xA04813
|
||
"DTC_AROMATIZATION_SHORT_GND", // 0xA04811
|
||
"DTC_AROMATIZATION_MALFUNCTION", // 0xA04896
|
||
"DTC_IONIZER_OPEN", // 0xA04913
|
||
"DTC_IONIZER_SHORT_GND", // 0xA04911
|
||
"DTC_IONIZER_MALFUNCTION", // 0xA04996
|
||
"DTC_DRS_FRONT_ZONE_MALFUNCTION", // 0xA05096
|
||
"DTC_DRS_REAR_ZONE_MALFUNCTION", // 0xA05196
|
||
"DTC_AIR_QUALITY_SENSOR_OPEN", // 0xA04315
|
||
"DTC_AIR_QUALITY_SENSOR_SHORT_GND", // 0xA04311
|
||
"DTC_AIR_QUALITY_SENSOR_MALFUNCTION", // 0xA04396
|
||
"DTC_AC_PRESSURE_SHORT_BAT", // 0xA04412
|
||
"DTC_AC_PRESSURE_SHORT_GND_OPEN", // 0xA04414
|
||
"DTC_AC_PRESSURE_SIGNAL_BELOW_RANGE", // 0xA04484
|
||
"DTC_FRONT_BLOWER_TXV_PERFORMANCE", // 0xA05692
|
||
"DTC_REAR_BLOWER_TXV_PERFORMANCE", // 0xA05892
|
||
"DTC_DEFROSTER_GATE_POSITION_NOT_REACHED", // 0xA07004
|
||
"DTC_RECIRC_GATE_POSITION_NOT_REACHED", // 0xA07104
|
||
"DTC_RECIRC_OSA_GATE_POSITION_NOT_REACHED", // 0xA09304
|
||
"DTC_TEMP_UP_FL_GATE_POSITION_NOT_REACHED", // 0xA07204
|
||
"DTC_VENT_CFL_GATE_POSITION_NOT_REACHED", // 0xA07304
|
||
"DTC_VENT_SFL_GATE_POSITION_NOT_REACHED", // 0xA07404
|
||
"DTC_TEMP_DN_FL_GATE_POSITION_NOT_REACHED", // 0xA07504
|
||
"DTC_FOOT_FL_GATE_POSITION_NOT_REACHED", // 0xA07604
|
||
"DTC_REAR_FOOT_FL_GATE_POSITION_NOT_REACHED", // 0xA07704
|
||
"DTC_TEMP_UP_FR_GATE_POSITION_NOT_REACHED", // 0xA07804
|
||
"DTC_VENT_CFR_GATE_POSITION_NOT_REACHED", // 0xA07904
|
||
"DTC_VENT_SFR_GATE_POSITION_NOT_REACHED", // 0xA08004
|
||
"DTC_TEMP_DN_FR_GATE_POSITION_NOT_REACHED", // 0xA08104
|
||
"DTC_FOOT_FR_GATE_POSITION_NOT_REACHED", // 0xA08204
|
||
"DTC_REAR_FOOT_FR_GATE_POSITION_NOT_REACHED", // 0xA08304
|
||
"DTC_TEMP_RR_GATE_POSITION_NOT_REACHED", // 0xA08404
|
||
"DTC_TEMP_RL_GATE_POSITION_NOT_REACHED", // 0xA08504
|
||
"DTC_VENT_SRL_GATE_POSITION_NOT_REACHED", // 0xA08604
|
||
"DTC_FOOT_RL_GATE_POSITION_NOT_REACHED", // 0xA08704
|
||
"DTC_VENT_CRL_GATE_POSITION_NOT_REACHED", // 0xA08804
|
||
"DTC_VENT_CRR_GATE_POSITION_NOT_REACHED", // 0xA08904
|
||
"DTC_FOOT_RR_GATE_POSITION_NOT_REACHED", // 0xA09004
|
||
"DTC_VENT_SRR_GATE_POSITION_NOT_REACHED", // 0xA09104
|
||
"DTC_SEALING_VALVE_GATE_POSITION_NOT_REACHED", // 0xA09204
|
||
"DTC_BODY_CAN_BUS_OFF", // 0xC02888
|
||
"DTC_HVAC_CAN_BUS_OFF", // 0xC03788
|
||
"DTC_LOST_COMM_ECM_PCM (EMS/VCU)", // 0xC10087
|
||
"DTC_LOST_COMM_ESP (ESP)", // 0xC12287
|
||
"DTC_LOST_COMM_BCM (BCM)", // 0xC14187
|
||
"DTC_LOST_COMM_AC_COMPRESSOR (HVC)", // 0xC16B87
|
||
"DTC_LOST_COMM_DOOR_MODULE_A_DMFL (DMFL)", // 0xC19987
|
||
"DTC_LOST_COMM_DOOR_MODULE_B_DMFR (DMFR)", // 0xC20087
|
||
"DTC_LOST_COMM_SEAT_MODULE_A_SMFL (SMFL)", // 0xC20887
|
||
"DTC_LOST_COMM_SEAT_MODULE_B_SMFR (SMFR)", // 0xC20987
|
||
"DTC_LOST_COMM_SEAT_MODULE_C_SMRL (SMRL)", // 0xC21087
|
||
"DTC_LOST_COMM_SEAT_MODULE_D_SMRR (SMRR)", // 0xC21187
|
||
"DTC_LOST_COMM_TRUNK_CCPF_CCPR", // 0xE2A187
|
||
"DTC_LOST_COMM_CGW", // 0xE2A287
|
||
"DTC_LOST_COMM_DEFROSTER_GATE", // 0xE23087
|
||
"DTC_LOST_COMM_RECIRC_GATE", // 0xE23187
|
||
"DTC_LOST_COMM_RECIRC_OSA_GATE", // 0xE26287
|
||
"DTC_LOST_COMM_TEMP_UP_FL_GATE", // 0xE23287
|
||
"DTC_LOST_COMM_VENT_CFL_GATE", // 0xE23387
|
||
"DTC_LOST_COMM_FOOT_FR_GATE_LIN1", // 0xE23487
|
||
"DTC_LOST_COMM_TEMP_DN_FL_GATE", // 0xE23587
|
||
"DTC_LOST_COMM_FOOT_FL_GATE", // 0xE23687
|
||
"DTC_LOST_COMM_REAR_FOOT_FL_GATE", // 0xE23787
|
||
"DTC_LOST_COMM_TEMP_UP_FR_GATE", // 0xE23887
|
||
"DTC_LOST_COMM_VENT_CFR_GATE", // 0xE23987
|
||
"DTC_LOST_COMM_VENT_SFR_GATE", // 0xE24087
|
||
"DTC_LOST_COMM_TEMP_DN_FR_GATE", // 0xE24187
|
||
"DTC_LOST_COMM_FOOT_FR_GATE", // 0xE24287
|
||
"DTC_LOST_COMM_REAR_FOOT_FR_GATE", // 0xE24387
|
||
"DTC_LOST_COMM_TEMP_RR_GATE", // 0xE24487
|
||
"DTC_LOST_COMM_TEMP_RL_GATE", // 0xE24587
|
||
"DTC_LOST_COMM_VENT_SRL_GATE", // 0xE24687
|
||
"DTC_LOST_COMM_TEMP_RL_GATE2", // 0xE24787
|
||
"DTC_LOST_COMM_VENT_CRL_GATE", // 0xE24887
|
||
"DTC_LOST_COMM_VENT_CRR_GATE", // 0xE24987
|
||
"DTC_LOST_COMM_FOOT_RR_GATE", // 0xE25087
|
||
"DTC_LOST_COMM_VENT_SRR_GATE", // 0xE25187
|
||
"DTC_LOST_COMM_SEALING_VALVE_GATE", // 0xE25287
|
||
"DTC_LOST_COMM_AIR_QUALITY_SENSOR", // 0xE25387
|
||
"DTC_LOST_COMM_IONIZER", // 0xE25487
|
||
"DTC_LOST_COMM_AROMATIZATION", // 0xE25587
|
||
"DTC_LOST_COMM_FRONT_TXV", // 0xE25687
|
||
"DTC_LOST_COMM_REAR_TXV", // 0xE25787
|
||
"DTC_LOST_COMM_HV_BATTERY_CHILLER_TXV", // 0xE25887
|
||
"DTC_LOST_COMM_HEAT_PUMP_CHILLER_TXV", // 0xE25987
|
||
"DTC_LOST_COMM_DRS_FRONT", // 0xE26087
|
||
"DTC_LOST_COMM_DRS_REAR", // 0xE26187
|
||
"DTC_VIN_INVALID_CONFIG" // 0xF00256
|
||
};
|
||
#endif
|
||
|
||
void Diagnostic_Init(tDiagnostic *env, tCanSpamReceiver *canSpamReceiver, tLoggerInterface *logger) {
|
||
|
||
env->logger = logger;
|
||
env->canSpamReceiver = canSpamReceiver;
|
||
env->access = osMutexNew(NULL);
|
||
|
||
|
||
// for (uint8_t i = 0; i < COUNT_DTC_CODE_ERROR; ++i) {
|
||
|
||
// Тест DTC не был выполнен в текущем цикле работы
|
||
// dtc_state_error[i] = UDS_dtc_mask_testNotCompletedThisOperationCycle;
|
||
// }
|
||
|
||
// InitThreadAtrStatic(&env->thread.attr, "Diagnostic", env->thread.controlBlock, env->thread.stack,
|
||
// osPriorityNormal);
|
||
}
|
||
|
||
extern lfs_file_t file;
|
||
|
||
uint32_t diagnostic_ClearDiagnosticInformation_14(tDiagnostic *env) {
|
||
|
||
if (osMutexAcquire(env->access, 5000) == osOK) {
|
||
|
||
env->isCleanDTC = true;
|
||
|
||
|
||
// memset(dtc_state_error, 0, sizeof(dtc_state_error));
|
||
/*
|
||
lfs_soff_t lfs_err = lfs_remove(&fs.lfs, "dtc.bin");
|
||
|
||
if (lfs_err == LFS_ERR_OK) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Clean dtc.bin - OK");
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Clean dtc.bin - ERROR");
|
||
}
|
||
*/
|
||
/*
|
||
lfs_soff_t lfs_err = lfs_file_open(&fs.lfs, &file, "dtc.bin", LFS_O_WRONLY);
|
||
|
||
if (lfs_err == LFS_ERR_OK) {
|
||
|
||
int writes = lfs_file_write(&fs.lfs, &file, dtc_state_error, sizeof(dtc_state_error));
|
||
|
||
if (writes != sizeof(dtc_state_error)) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Error write dtc.bin")
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Clean dtc.bin - ERROR");;
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Write dtc.bin - OK");
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Clean dtc.bin - OK");
|
||
}
|
||
|
||
|
||
lfs_err = lfs_file_close(&fs.lfs, &file);
|
||
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Error clear dtc.bin");
|
||
}
|
||
*/
|
||
osMutexRelease(env->access);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Access error diagnostic_ClearDiagnosticInformation_14");
|
||
}
|
||
|
||
|
||
return 0;
|
||
}
|
||
|
||
uint32_t diagnostic_UDS_ReadDTCInformation_19_count(tDiagnostic *env, tDiagnosticDTC *diagnosticDTC) {
|
||
|
||
uint32_t countDTC = 0;
|
||
|
||
if (osMutexAcquire(env->access, 5000) == osOK) {
|
||
|
||
for (uint8_t i = 0; i < COUNT_DTC_CODE_ERROR; ++i) {
|
||
|
||
if (env->isNoBitsDTC) {
|
||
if (dtc_state_FIX_error[i] & (diagnosticDTC->mask)) {
|
||
++countDTC;
|
||
}
|
||
} else {
|
||
if (dtc_state_error[i] & (diagnosticDTC->mask)) {
|
||
++countDTC;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
osMutexRelease(env->access);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Access error diagnostic_ClearDiagnosticInformation_14");
|
||
}
|
||
|
||
|
||
return countDTC;
|
||
}
|
||
|
||
uint32_t diagnostic_UDS_ReadDTCInformation_19_dtc(tDiagnostic *env, tDiagnosticDTC *diagnosticDTC) {
|
||
|
||
uint32_t size = 0;
|
||
|
||
if (osMutexAcquire(env->access, 5000) == osOK) {
|
||
|
||
for (uint8_t i = 0; i < COUNT_DTC_CODE_ERROR; ++i) {
|
||
|
||
if (env->isNoBitsDTC) {
|
||
if (dtc_state_FIX_error[i] & (diagnosticDTC->mask)) {
|
||
diagnosticDTC->dataResponse[size] = dtc_codes[i].DTCHighByte;
|
||
diagnosticDTC->dataResponse[size + 1] = dtc_codes[i].DTCMiddleByte;
|
||
diagnosticDTC->dataResponse[size + 2] = dtc_codes[i].DTCLowByte;
|
||
diagnosticDTC->dataResponse[size + 3] = dtc_state_error[i] & (diagnosticDTC->mask);
|
||
size += 4;
|
||
}
|
||
} else {
|
||
if (dtc_state_error[i] & (diagnosticDTC->mask)) {
|
||
diagnosticDTC->dataResponse[size] = dtc_codes[i].DTCHighByte;
|
||
diagnosticDTC->dataResponse[size + 1] = dtc_codes[i].DTCMiddleByte;
|
||
diagnosticDTC->dataResponse[size + 2] = dtc_codes[i].DTCLowByte;
|
||
diagnosticDTC->dataResponse[size + 3] = dtc_state_error[i] & (diagnosticDTC->mask);
|
||
size += 4;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
osMutexRelease(env->access);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Access error diagnostic_UDS_ReadDTCInformation_19_dtc");
|
||
}
|
||
|
||
return size;
|
||
}
|
||
|
||
|
||
uint32_t diagnostic_UDS_ReadDTCSupportDTC_19_dtc(tDiagnostic *env, tDiagnosticDTC *diagnosticDTC) {
|
||
|
||
uint32_t size = 0;
|
||
|
||
if (osMutexAcquire(env->access, 5000) == osOK) {
|
||
|
||
for (uint8_t i = 0; i < COUNT_DTC_CODE_ERROR; ++i) {
|
||
|
||
diagnosticDTC->dataResponse[size] = dtc_codes[i].DTCHighByte;
|
||
diagnosticDTC->dataResponse[size + 1] = dtc_codes[i].DTCMiddleByte;
|
||
diagnosticDTC->dataResponse[size + 2] = dtc_codes[i].DTCLowByte;
|
||
diagnosticDTC->dataResponse[size + 3] = 0;
|
||
size += 4;
|
||
}
|
||
|
||
osMutexRelease(env->access);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Access error diagnostic_UDS_ReadDTCSupportDTC_19_dtc");
|
||
}
|
||
|
||
return size;
|
||
}
|
||
|
||
|
||
void set_NoBitsDTC(tDiagnostic *env, bool noBitsDTC) {
|
||
if (osMutexAcquire(env->access, 5000) == osOK) {
|
||
|
||
memcpy(dtc_state_FIX_error, dtc_state_error, sizeof(dtc_state_error));
|
||
env->isNoBitsDTC = noBitsDTC;
|
||
|
||
osMutexRelease(env->access);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Access error setBitsDTC");
|
||
}
|
||
}
|
||
|
||
static bool isVINError(char *VIN) {
|
||
if (VIN == NULL) {
|
||
return false; // NULL — не ошибка (ещё нет данных)
|
||
}
|
||
|
||
// Пустой VIN (пробелы) — ещё не собран → НЕ ошибка
|
||
if (memcmp(VIN, " ", 17) == 0) {
|
||
return false; // НЕ ошибка!
|
||
}
|
||
|
||
// Проверка на совпадение с эталоном
|
||
if (memcmp(VIN, statusData.ecu.Vehicle_Identification, 17) == 0) {
|
||
return false; // Валидный - не ошибка
|
||
}
|
||
|
||
// VIN собран, но не совпадает с эталоном - ОШИБКА
|
||
return true;
|
||
}
|
||
|
||
|
||
static void
|
||
setErrorDTC_CAN_VIN(uint8_t *dtc_state_error_model, ccu_candb_error_missing_rx_t *CAN_ERROR_MISSLE, char *VIN,
|
||
CCU_Errors_t *CCU_Errors) {
|
||
bool vin_timeout = CAN_ERROR_MISSLE->VEH_VIN;
|
||
bool vin_error = isVINError(VIN);
|
||
|
||
// DTC = 1 только если:
|
||
// - VIN собран, но невалидный
|
||
// - ИЛИ таймаут (сообщение VIN вообще не приходит)
|
||
if (vin_error || vin_timeout) {
|
||
dtc_state_error_model[DTC_VIN_INVALID_CONFIG] = DTC_TEST_FAILED_CONFIRMED;
|
||
CCU_Errors->CCU_VinRecordErr_Stat = 1;
|
||
} else {
|
||
dtc_state_error_model[DTC_VIN_INVALID_CONFIG] = dtc_state_error[DTC_VIN_INVALID_CONFIG] & (~(DTC_TEST_FAILED));
|
||
CCU_Errors->CCU_VinRecordErr_Stat = 0;
|
||
}
|
||
|
||
}
|
||
|
||
extern volatile bool isCan0BusOff;
|
||
extern volatile uint32_t timeCan0BusOff;
|
||
|
||
static void
|
||
setErrorDTC_CAN(tDiagnostic *env, bool isT15, uint8_t *dtc_state_error_model, ccu_candb_error_missing_rx_t *CAN_ERROR_MISSING, char *VIN,
|
||
CCU_Errors_t *CCU_Errors) {
|
||
|
||
// uint32_t timeCanSpamReceiver = getCanTimeReceived(env->canSpamReceiver, isCan0BusOff, isT15) + 3000;
|
||
uint32_t time = SystemGetMs();
|
||
|
||
if (isCan0BusOff) {
|
||
if (time < timeCan0BusOff) {
|
||
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));
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
if (isT15 == false) {
|
||
return;
|
||
}
|
||
|
||
setErrorDTC_CAN_VIN(dtc_state_error_model, CAN_ERROR_MISSING, VIN, 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;
|
||
} else {
|
||
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;
|
||
} else {
|
||
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;
|
||
} else {
|
||
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;
|
||
} else {
|
||
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;
|
||
} else {
|
||
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;
|
||
} else {
|
||
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;
|
||
} else {
|
||
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;
|
||
} else {
|
||
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;
|
||
} else {
|
||
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;
|
||
} else {
|
||
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) {
|
||
|
||
for (uint8_t i = 0; i < 9; ++i) {
|
||
if (LIN1_ERROR_MISSING[i]) {
|
||
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));
|
||
}
|
||
}
|
||
|
||
for (uint8_t i = 0; i < 6; ++i) {
|
||
if (LIN2_ERROR_MISSING[i]) {
|
||
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));
|
||
}
|
||
}
|
||
|
||
|
||
for (uint8_t i = 0; i < 9; ++i) {
|
||
if (LIN3_ERROR_MISSING[i]) {
|
||
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));
|
||
}
|
||
}
|
||
|
||
for (uint8_t i = 0; i < 7; ++i) {
|
||
if (LIN4_ERROR_MISSING[i]) {
|
||
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));
|
||
}
|
||
}
|
||
|
||
|
||
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;
|
||
} else {
|
||
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;
|
||
} else {
|
||
dtc_state_error_model[DTC_LOST_COMM_DRS_REAR] = dtc_state_error[DTC_LOST_COMM_DRS_REAR] & (~(DTC_TEST_FAILED));
|
||
}
|
||
|
||
}
|
||
|
||
void set_Dtc_state(tDiagnostic *env, bool isT15, 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) {
|
||
|
||
if (osMutexAcquire(env->access, 5000) == osOK) {
|
||
|
||
if (env->isCleanDTC) {
|
||
env->isCleanDTC = false;
|
||
memset(dtc_state_FIX_error, 0, sizeof(dtc_state_FIX_error));
|
||
memset(dtc_state_error, 0, sizeof(dtc_state_error));
|
||
}
|
||
|
||
if (env->isNoBitsDTC == true) {
|
||
osMutexRelease(env->access);
|
||
return;
|
||
}
|
||
|
||
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;
|
||
} else {
|
||
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_CAN(env, isT15, dtc_state_error_model, CAN_ERROR_MISSING, VIN, CCU_Errors);
|
||
|
||
// 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) {
|
||
|
||
bool isDTC_FileWrite = false;
|
||
|
||
#if (LOG_DTC == 1)
|
||
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 ((dtc_state_error[i] & DTC_TEST_CONFIRMED) != (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) {
|
||
failed = true;
|
||
}
|
||
if (dtc_state_error_model[i] & DTC_TEST_CONFIRMED) {
|
||
confirmed = true;
|
||
}
|
||
|
||
LoggerFormatInfo(LOGGER, LOG_SIGN, "DTC: %s (CONFIRMED: %d FAILED: %d)", DTC_Error_Code_Strings[i],
|
||
confirmed, failed)
|
||
#endif
|
||
}
|
||
}
|
||
#if (LOG_DTC == 1)
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "end------------------------------DTC---------------------------------")
|
||
#endif
|
||
|
||
memcpy(dtc_state_error, 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));
|
||
}
|
||
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Write dtc.bin");
|
||
|
||
lfs_soff_t lfs_err = lfs_file_open(&fs.lfs, &file, "dtc.bin", LFS_O_WRONLY | LFS_O_CREAT);
|
||
|
||
if (lfs_err == LFS_ERR_OK) {
|
||
|
||
int writes = lfs_file_write(&fs.lfs, &file, dtc_state_error_model, sizeof(dtc_state_error));
|
||
|
||
if (writes != sizeof(dtc_state_error)) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Error write dtc.bin");
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Write dtc.bin - OK");
|
||
}
|
||
|
||
lfs_err = lfs_file_close(&fs.lfs, &file);
|
||
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Error open (write) dtc.bin");
|
||
}
|
||
|
||
}
|
||
asm("nop");
|
||
}
|
||
|
||
osMutexRelease(env->access);
|
||
} else {
|
||
LoggerErrorStatic(LOGGER, LOG_SIGN, "Access error set_Dtc_state_error");
|
||
}
|
||
}
|
||
|