HVAC_M7
/
HVAC_M7_MONO
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

В систему диагностики добавлен таймаут CAN

This commit is contained in:
cfif 2026-09-02 10:04:16 +03:00
parent dde9f47594
commit 415b9b9d7b
5 changed files with 44 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
MODULES/HVAC_M7_CAN_SPAM/CanSpamReceiver.c
View File

@ -263,18 +263,34 @@ static void set_CanSpamReceiver(tCanSpamReceiver *env, uint32_t recid) {
}
uint32_t getCanTimeReceived(tCanSpamReceiver *env) {
uint32_t time = 0;
if (osMutexAcquire(env->access, 5000) == osOK) {
time = env->canTimeReceived;
osMutexRelease(env->access);
} else {
LoggerErrorStatic(LOGGER, LOG_SIGN, "Access error getCanTimeReceived");
}
return time;
}
static void ListenCanSpamReceiver(tCanSpamReceiver *env) {
uint16_t recv = env->ioCanFrame->receive(env->ioCanFrame->env, PROTOCOL_CAN_RAW, (uint8_t *) &env->canFrame, 1,
1000);
if (recv == 0) {
return;
}
if (osMutexAcquire(env->access, 5000) == osOK) {
env->canTimeReceived = SystemGetMs();
uint32_t id = env->canFrame.standard_id;
if (env->canFrame.id_type == FLEXCAN_ID_EXT) {

4
MODULES/HVAC_M7_CAN_SPAM/CanSpamReceiver.h
View File

@ -53,6 +53,8 @@ typedef struct {
osMutexId_t access;
can_rx_message_type canFrame;
uint32_t canTimeReceived;
char SET_HVAC_VIN[17];
bool getVIN0;
bool getVIN1;
@ -97,4 +99,6 @@ bool get_CanSpamReceiverUDS(tCanSpamReceiver *env, char *VIN, func_update_func u
bool get_is_NoNull_CanSpam_BCM_PowerTrain_Receiver(tCanSpamReceiver *env);
uint32_t getCanTimeReceived(tCanSpamReceiver *env);
#endif //HVAC_CAN_SPAM_RECEIVER_H

3
MODULES/HVAC_M7_DebugTesting/MainModesArbiter_InitStage.c
View File

@ -228,8 +228,6 @@ static void Mma_InitSubSystems(tMma *env) {
&env->serialPorts->cliVirtualPortOut_Io);
CommandLine_StartThread(&env->cli);
Diagnostic_Init(&env->Diagnostic, &env->slog.logger);
CanSerialPortFrameXcpInit(
&env->CanSerialPortFrameXCP,
&env->canPorts->Can1_IO,
@ -261,6 +259,7 @@ static void Mma_InitSubSystems(tMma *env) {
&env->slog.logger);
CanSpamDebugTransmitter_StartThread(&env->canSpamDebugTransmitter);
Diagnostic_Init(&env->Diagnostic, &env->canSpamReceiver, &env->slog.logger);
tLinData *linData4 = Lin4_Init(GetLin123CallbackHandler);
Lin_4_Init(&env->linTaskSensor4, linData4, &env->linPorts->lin4_Io, &env->slog.logger);

32
MODULES/HVAC_M7_StatusData/DiagnosticTask.c
View File

@ -146,10 +146,10 @@ const char *DTC_Error_Code_Strings[COUNT_DTC_CODE_ERROR] = {
};
#endif
void Diagnostic_Init(tDiagnostic *env, tLoggerInterface *logger) {
void Diagnostic_Init(tDiagnostic *env, tCanSpamReceiver *canSpamReceiver, tLoggerInterface *logger) {
env->logger = logger;
env->canSpamReceiver = canSpamReceiver;
env->access = osMutexNew(NULL);
@ -354,68 +354,72 @@ setErrorDTC_CAN_VIN(uint8_t *dtc_state_error_model, ccu_candb_error_missing_rx_t
}
static void setErrorDTC_CAN(uint8_t *dtc_state_error_model, ccu_candb_error_missing_rx_t *CAN_ERROR_MISSLE) {
if (CAN_ERROR_MISSLE->EMS_Veh) {
static void setErrorDTC_CAN(tDiagnostic *env, uint8_t *dtc_state_error_model, ccu_candb_error_missing_rx_t *CAN_ERROR_MISSLE) {
uint32_t timeCanSpamReceiver = getCanTimeReceived(env->canSpamReceiver) + 3000;
uint32_t time = SystemGetMs();
if ((CAN_ERROR_MISSLE->EMS_Veh) || (time > timeCanSpamReceiver)) {
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));
}
if (CAN_ERROR_MISSLE->ESC_04) {
if ((CAN_ERROR_MISSLE->ESC_04) || (time > timeCanSpamReceiver)) {
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));
}
if (CAN_ERROR_MISSLE->BCM_Powertrain) {
if ((CAN_ERROR_MISSLE->BCM_Powertrain) || (time > timeCanSpamReceiver)) {
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));
}
if (CAN_ERROR_MISSLE->EMS_HVC_Req_Msg) {
if ((CAN_ERROR_MISSLE->EMS_HVC_Req_Msg) || (time > timeCanSpamReceiver)) {
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));
}
if (CAN_ERROR_MISSLE->DMFR_Msg1) {
if ((CAN_ERROR_MISSLE->DMFR_Msg1) || (time > timeCanSpamReceiver)) {
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));
}
if (CAN_ERROR_MISSLE->DMFL_Msg1) {
if ((CAN_ERROR_MISSLE->DMFL_Msg1) || (time > timeCanSpamReceiver)) {
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));
}
if (CAN_ERROR_MISSLE->SMFL_status) {
if ((CAN_ERROR_MISSLE->SMFL_status) || (time > timeCanSpamReceiver)) {
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));
}
if (CAN_ERROR_MISSLE->SMFR_status) {
if ((CAN_ERROR_MISSLE->SMFR_status) || (time > timeCanSpamReceiver)) {
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));
}
if (CAN_ERROR_MISSLE->SMRL_status) {
if ((CAN_ERROR_MISSLE->SMRL_status) || (time > timeCanSpamReceiver)) {
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));
}
if (CAN_ERROR_MISSLE->SMRR_status) {
if ((CAN_ERROR_MISSLE->SMRR_status) || (time > timeCanSpamReceiver)) {
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] =
@ -446,7 +450,7 @@ void set_Dtc_state(tDiagnostic *env, CCU_Errors_t *CCU_Errors,
}
setErrorDTC_CAN_VIN(dtc_state_error_model, CAN_ERROR_MISSLE, VIN, CCU_Errors);
setErrorDTC_CAN(dtc_state_error_model, CAN_ERROR_MISSLE);
setErrorDTC_CAN(env, dtc_state_error_model, CAN_ERROR_MISSLE);
if (memcmp(dtc_state_error, dtc_state_error_model, sizeof(dtc_state_error)) != 0) {

5
MODULES/HVAC_M7_StatusData/DiagnosticTask.h
View File

@ -8,6 +8,7 @@
#include <cmsis_os.h>
#include "LoggerInterface.h"
#include "ccu_candb-binutil.h"
#include "CanSpamReceiver.h"
#include "lfs.h"
#define LOG_DTC 1
@ -25,13 +26,15 @@ typedef struct {
osMutexId_t access;
tLoggerInterface *logger;
tCanSpamReceiver *canSpamReceiver;
bool isNoBitsDTC;
bool isCleanDTC;
} tDiagnostic;
void Diagnostic_Init(tDiagnostic *env, tLoggerInterface *logger);
void Diagnostic_Init(tDiagnostic *env, tCanSpamReceiver *canSpamReceiver, tLoggerInterface *logger);
void set_NoBitsDTC(tDiagnostic *env, bool noBitsDTC);
void set_Dtc_state(tDiagnostic *env, 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);