832 lines
37 KiB
C
832 lines
37 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_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,
|
||
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, tCanSpamReceiver *canSpamReceiver, tLoggerInterface *logger) {
|
||
|
||
env->logger = logger;
|
||
env->canSpamReceiver = canSpamReceiver;
|
||
env->access = osMutexNew(NULL);
|
||
env->tDiagStart = TDiagStart;
|
||
|
||
|
||
env->state.CCU_Errors = CCU_Errors;
|
||
env->state.dtc_state_error_model = dtc_state_error;
|
||
env->state.VIN = VIN;
|
||
env->state.CAN_ERROR_MISSING = CAN_ERROR_MISSING;
|
||
env->state.CAN_TIME_MISSING = CAN_TIME_MISSING;
|
||
env->state.LIN1_ERROR_MISSING = LIN1_ERROR_MISSING;
|
||
env->state.LIN2_ERROR_MISSING = LIN2_ERROR_MISSING;
|
||
env->state.LIN3_ERROR_MISSING = LIN3_ERROR_MISSING;
|
||
env->state.LIN4_ERROR_MISSING = LIN4_ERROR_MISSING;
|
||
env->state.LIN5_ERROR_MISSING = LIN5_ERROR_MISSING;
|
||
|
||
|
||
// 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 dtcCan0BusOffActive; // активен ли bus-off для DTC
|
||
extern volatile uint32_t dtcCan0BusOffDeadline; // когда снять FAILED
|
||
|
||
|
||
|
||
|
||
static void
|
||
setErrorDTC_CAN(tDiagnostic *env) {
|
||
|
||
|
||
uint32_t time = SystemGetMs();
|
||
|
||
if (env->tDiagStart > time) {
|
||
return;
|
||
}
|
||
|
||
if ((env->state.P_BATT < V_DIAG_LOW) || (env->state.P_BATT > V_DIAG_HIGH)) {
|
||
env->tDiagStart = SystemGetMs() + TDiagStart;
|
||
return;
|
||
}
|
||
|
||
if (env->state.isT15 == false) {
|
||
env->tDiagStart = SystemGetMs() + TDiagStart;
|
||
return;
|
||
}
|
||
|
||
if (dtcCan0BusOffActive) {
|
||
if (time < dtcCan0BusOffDeadline) {
|
||
env->state.dtc_state_error_model[DTC_BODY_CAN_BUS_OFF] = DTC_TEST_FAILED_CONFIRMED;
|
||
} else {
|
||
env->state.dtc_state_error_model[DTC_BODY_CAN_BUS_OFF] = dtc_state_error[DTC_BODY_CAN_BUS_OFF] & (~(DTC_TEST_FAILED));
|
||
dtcCan0BusOffActive = false; // ← окно закрыто
|
||
}
|
||
|
||
env->tDiagStart = SystemGetMs() + TDiagStart;
|
||
return;
|
||
}
|
||
|
||
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 - CGW
|
||
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 {
|
||
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 - CGW
|
||
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 {
|
||
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 ((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 {
|
||
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 ((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 {
|
||
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 ((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 {
|
||
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 ((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 {
|
||
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 ((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 {
|
||
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 ((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 {
|
||
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 ((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 {
|
||
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 ((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 {
|
||
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));
|
||
}
|
||
|
||
// U22A187 (TMCP) 0x24C - OK
|
||
if (env->state.CAN_ERROR_MISSING->TM_CP) {
|
||
env->state.dtc_state_error_model[DTC_LOST_COMM_TRUNK_CCPF_CCPR] = DTC_TEST_FAILED_CONFIRMED;
|
||
} else {
|
||
env->state.dtc_state_error_model[DTC_LOST_COMM_TRUNK_CCPF_CCPR] =
|
||
dtc_state_error[DTC_LOST_COMM_TRUNK_CCPF_CCPR] & (~(DTC_TEST_FAILED));
|
||
}
|
||
|
||
// 0xE2A287 (CGW) - OK
|
||
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.CAN_ERROR_MISSING->ESC_04) && (env->state.CAN_ERROR_MISSING->ESC_08)) {
|
||
env->state.dtc_state_error_model[DTC_LOST_COMM_CGW] = DTC_TEST_FAILED_CONFIRMED;
|
||
} else {
|
||
env->state.dtc_state_error_model[DTC_LOST_COMM_CGW] =
|
||
dtc_state_error[DTC_LOST_COMM_CGW] & (~(DTC_TEST_FAILED));
|
||
}
|
||
|
||
|
||
}
|
||
|
||
|
||
static bool dtcDebounce(DtcDebounce *d, bool cond, uint32_t now_ms)
|
||
{
|
||
if (!cond) {
|
||
d->active = false;
|
||
return false;
|
||
}
|
||
if (!d->active) {
|
||
d->active = true;
|
||
d->since_ms = now_ms;
|
||
return false; // в этом цикле 0 мс
|
||
}
|
||
return (uint32_t)(now_ms - d->since_ms) >= DTC_CONFIRM_DELAY_MS;
|
||
}
|
||
|
||
// raw == 0 -> ошибки нет, пишем 0, таймер сбрасывается
|
||
// raw != 0, <4 c -> пишем raw (pending, как раньше)
|
||
// raw != 0, >=4 c непрерыв -> пишем DTC_TEST_FAILED_CONFIRMED
|
||
|
||
static void setDtcWithDebounce(tDiagnostic *env, uint8_t index, uint8_t raw,
|
||
DtcDebounce *d, uint32_t now_ms) {
|
||
if (raw > 0) {
|
||
env->state.dtc_state_error_model[index] = dtc_state_error[index] | DTC_TEST_FAILED;
|
||
} else {
|
||
env->state.dtc_state_error_model[index] = dtc_state_error[index] & (~(DTC_TEST_FAILED));
|
||
}
|
||
|
||
if (dtcDebounce(d, raw != 0, now_ms)) {
|
||
env->state.dtc_state_error_model[index] = DTC_TEST_FAILED_CONFIRMED;
|
||
}
|
||
}
|
||
|
||
static void
|
||
setErrorDTC_LIN(tDiagnostic *env) {
|
||
|
||
for (uint8_t i = 0; i < 9; ++i) {
|
||
if (env->state.LIN1_ERROR_MISSING[i]) {
|
||
env->state.dtc_state_error_model[i + 93] = DTC_TEST_FAILED_CONFIRMED;
|
||
} else {
|
||
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 (env->state.LIN2_ERROR_MISSING[i]) {
|
||
env->state.dtc_state_error_model[i + 102] = DTC_TEST_FAILED_CONFIRMED;
|
||
} else {
|
||
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 (env->state.LIN3_ERROR_MISSING[i]) {
|
||
env->state.dtc_state_error_model[i + 109] = DTC_TEST_FAILED_CONFIRMED;
|
||
} else {
|
||
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 (env->state.LIN4_ERROR_MISSING[i]) {
|
||
// env->state.dtc_state_error_model[i + 117] = DTC_TEST_FAILED_CONFIRMED;
|
||
// } else {
|
||
// env->state.dtc_state_error_model[i + 117] = dtc_state_error[i + 117] & (~(DTC_TEST_FAILED));
|
||
// }
|
||
// }
|
||
|
||
// AirQS
|
||
if (env->state.LIN4_ERROR_MISSING[0]) {
|
||
env->state.dtc_state_error_model[DTC_LOST_COMM_AIR_QUALITY_SENSOR] = DTC_TEST_FAILED_CONFIRMED;
|
||
} else {
|
||
env->state.dtc_state_error_model[DTC_LOST_COMM_AIR_QUALITY_SENSOR] = dtc_state_error[DTC_LOST_COMM_AIR_QUALITY_SENSOR] & (~(DTC_TEST_FAILED));
|
||
}
|
||
|
||
// Aroma_Stat
|
||
if (env->state.LIN4_ERROR_MISSING[1]) {
|
||
env->state.dtc_state_error_model[DTC_LOST_COMM_AROMATIZATION] = DTC_TEST_FAILED_CONFIRMED;
|
||
} else {
|
||
env->state.dtc_state_error_model[DTC_LOST_COMM_AROMATIZATION] = dtc_state_error[DTC_LOST_COMM_AROMATIZATION] & (~(DTC_TEST_FAILED));
|
||
}
|
||
|
||
// Ionizer
|
||
if (env->state.LIN4_ERROR_MISSING[2]) {
|
||
env->state.dtc_state_error_model[DTC_LOST_COMM_IONIZER] = DTC_TEST_FAILED_CONFIRMED;
|
||
} else {
|
||
env->state.dtc_state_error_model[DTC_LOST_COMM_IONIZER] = dtc_state_error[DTC_LOST_COMM_IONIZER] & (~(DTC_TEST_FAILED));
|
||
}
|
||
|
||
|
||
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 {
|
||
env->state.dtc_state_error_model[DTC_LOST_COMM_DRS_FRONT] = dtc_state_error[DTC_LOST_COMM_DRS_FRONT] & (~(DTC_TEST_FAILED));
|
||
}
|
||
|
||
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 {
|
||
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));
|
||
|
||
setDtcWithDebounce(env, DTC_AROMATIZATION_OPEN,
|
||
env->state.d_DTC_AROMATIZATION_OPEN,
|
||
&env->state.dtc_aux_debounce[DEB_AROMA_OPEN], env->state.now_ms);
|
||
|
||
setDtcWithDebounce(env, DTC_AROMATIZATION_SHORT_GND,
|
||
env->state.d_DTC_AROMATIZATION_SHORT_GND,
|
||
&env->state.dtc_aux_debounce[DEB_AROMA_SHORT_GND], env->state.now_ms);
|
||
|
||
setDtcWithDebounce(env, DTC_AROMATIZATION_MALFUNCTION,
|
||
env->state.d_DTC_AROMATIZATION_MALFUNCTION,
|
||
&env->state.dtc_aux_debounce[DEB_AROMA_MALFUNCTION], env->state.now_ms);
|
||
|
||
}
|
||
|
||
|
||
setDtcWithDebounce(env, DTC_IONIZER_OPEN,
|
||
env->state.d_DTC_IONIZER_OPEN,
|
||
&env->state.dtc_aux_debounce[DEB_IONIZER_OPEN], env->state.now_ms);
|
||
|
||
setDtcWithDebounce(env, DTC_IONIZER_SHORT_GND,
|
||
env->state.d_DTC_IONIZER_SHORT_GND,
|
||
&env->state.dtc_aux_debounce[DEB_IONIZER_SHORT_GND], env->state.now_ms);
|
||
|
||
setDtcWithDebounce(env, DTC_IONIZER_MALFUNCTION,
|
||
env->state.d_DTC_IONIZER_MALFUNCTION,
|
||
&env->state.dtc_aux_debounce[DEB_IONIZER_MALFUNCTION], env->state.now_ms);
|
||
|
||
|
||
|
||
setDtcWithDebounce(env, DTC_AIR_QUALITY_SENSOR_OPEN,
|
||
env->state.d_DTC_AIR_QUALITY_SENSOR_OPEN,
|
||
&env->state.dtc_aux_debounce[DEB_AQS_OPEN], env->state.now_ms);
|
||
|
||
setDtcWithDebounce(env, DTC_AIR_QUALITY_SENSOR_SHORT_GND,
|
||
env->state.d_DTC_AIR_QUALITY_SENSOR_SHORT_GND,
|
||
&env->state.dtc_aux_debounce[DEB_AQS_SHORT_GND], env->state.now_ms);
|
||
|
||
setDtcWithDebounce(env, DTC_AIR_QUALITY_SENSOR_MALFUNCTION,
|
||
env->state.d_DTC_AIR_QUALITY_SENSOR_MALFUNCTION,
|
||
&env->state.dtc_aux_debounce[DEB_AQS_MALFUNCTION], env->state.now_ms);
|
||
|
||
|
||
|
||
setDtcWithDebounce(env, DTC_DRS_FRONT_ZONE_MALFUNCTION,
|
||
env->state.d_DTC_DRS_FRONT_ZONE_MALFUNCTION,
|
||
&env->state.dtc_aux_debounce[DEB_DRS_FRONT_ZONE], env->state.now_ms);
|
||
|
||
setDtcWithDebounce(env, DTC_DRS_REAR_ZONE_MALFUNCTION,
|
||
env->state.d_DTC_DRS_REAR_ZONE_MALFUNCTION,
|
||
&env->state.dtc_aux_debounce[DEB_DRS_REAR_ZONE], env->state.now_ms);
|
||
|
||
// Только в электричке
|
||
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;
|
||
|
||
}
|
||
|
||
// raw > 60 || raw > 180 -> ошибки нет, пишем 0, таймер сбрасывается
|
||
// raw < 60 || raw < 180, <4 c -> пишем raw (pending, как раньше)
|
||
// raw < 60 || raw < 180, >=4 c непрерыв -> пишем DTC_TEST_FAILED_CONFIRMED
|
||
|
||
static void setDtcWithDebounce_V(tDiagnostic *env, uint8_t index, uint8_t raw,
|
||
DtcDebounce *d, uint32_t now_ms) {
|
||
|
||
if ((raw < 60) || (raw > 180)) {
|
||
env->state.dtc_state_error_model[index] = dtc_state_error[index] | DTC_TEST_FAILED;
|
||
} else {
|
||
env->state.dtc_state_error_model[index] = dtc_state_error[index] & (~(DTC_TEST_FAILED));
|
||
}
|
||
|
||
if (dtcDebounce(d, ((raw < 60) || (raw > 180)), now_ms)) {
|
||
env->state.dtc_state_error_model[index] = DTC_TEST_FAILED_CONFIRMED;
|
||
}
|
||
}
|
||
|
||
|
||
bool set_Dtc_state(tDiagnostic *env) {
|
||
|
||
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));
|
||
memset(env->state.dtc_state_error_model, 0, COUNT_DTC_CODE_ERROR);
|
||
|
||
osMutexRelease(env->access);
|
||
return true;
|
||
}
|
||
|
||
if (env->isNoBitsDTC == true) {
|
||
|
||
osMutexRelease(env->access);
|
||
return false;
|
||
}
|
||
|
||
// начало--------------От модели-------------------------------------------------------
|
||
for (uint8_t i = 3; i < 37; ++i) {
|
||
if (env->state.dtc_state_error_model[i]) {
|
||
env->state.dtc_state_error_model[i] = DTC_TEST_FAILED_CONFIRMED;
|
||
} else {
|
||
env->state.dtc_state_error_model[i] = dtc_state_error[i] & (~(DTC_TEST_FAILED));
|
||
}
|
||
}
|
||
|
||
for (uint8_t i = 50; i < 79; ++i) {
|
||
if (env->state.dtc_state_error_model[i]) {
|
||
env->state.dtc_state_error_model[i] = DTC_TEST_FAILED_CONFIRMED;
|
||
} else {
|
||
env->state.dtc_state_error_model[i] = dtc_state_error[i] & (~(DTC_TEST_FAILED));
|
||
}
|
||
}
|
||
// конец--------------От модели-------------------------------------------------------
|
||
|
||
setErrorDTC_LIN(env);
|
||
setErrorDTC_CAN(env);
|
||
|
||
setDtcWithDebounce_V(env, DTC_CCU_POWER_SUPPLY_VOLTAGE_OUT_OF_RANGE,
|
||
env->state.P_BATT,
|
||
&env->state.dtc_aux_debounce[DEB_IONIZER_OPEN], env->state.now_ms);
|
||
|
||
setDtcWithDebounce_V(env, DTC_IGNITION_VOLTAGE_OUT_OF_RANGE,
|
||
env->state.P_IGN,
|
||
&env->state.dtc_aux_debounce[DEB_IONIZER_OPEN], env->state.now_ms);
|
||
|
||
if (memcmp(dtc_state_error, env->state.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 (env->state.dtc_state_error_model[i]) {
|
||
|
||
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 (env->state.dtc_state_error_model[i] & DTC_TEST_FAILED) {
|
||
failed = true;
|
||
}
|
||
if (env->state.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, env->state.dtc_state_error_model, sizeof(dtc_state_error));
|
||
|
||
if (isDTC_FileWrite) {
|
||
|
||
for (uint8_t i = 0; i < COUNT_DTC_CODE_ERROR; ++i) {
|
||
env->state.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, env->state.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");
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|