Изменена работа с DTC

MODULES/HVAC_M7_CAN_SPAM/CanSpamReceiver.c

@@ -16,7 +16,7 @@
 typedef struct {
     uint32_t can_id;
     FrameMonitor_t *monitor;
-    uint8_t *error_flag;
+    uint8_t *error_flag_missing;
     uint32_t *time_flag;
 } CAN_MonitorEntry_t;
 
@@ -152,15 +152,15 @@ void CanSpamReceiver_Init(tCanSpamReceiver *env,
 static void CheckAllCANMonitors(void) {
     uint32_t current_time = SystemGetMs();
 
-    for (uint32_t i = 0; i < CAN_MONITOR_COUNT; i++) {
+    for (uint32_t i = 0; i < CAN_MONITOR_COUNT; ++i) {
         FrameMonitor_t *mon = g_can_monitors[i].monitor;
 
         // Проверяем таймаут
         uint32_t diff = current_time - mon->last_cycle;
-        uint8_t error = (diff > mon->timeout_cycle) ? 1 : 0;
+        uint8_t error_missing = (diff > mon->timeout_cycle) ? 1 : 0;
 
         // Сохраняем ошибку
-        *(g_can_monitors[i].error_flag) = error;
+        *(g_can_monitors[i].error_flag_missing) = error_missing;
 
         // Сохраняем время
         *(g_can_monitors[i].time_flag) = mon->last_cycle;
@@ -316,7 +316,7 @@ static void set_CanSpamReceiver(tCanSpamReceiver *env, uint32_t recid) {
 
 }
 
-uint32_t getCanTimeReceived(tCanSpamReceiver *env) {
+uint32_t getCanTimeReceived(tCanSpamReceiver *env, bool isCan0BusOff, bool isT15) {
 
     uint32_t time = 0;
 
@@ -335,10 +335,10 @@ uint32_t getCanTimeReceived(tCanSpamReceiver *env) {
 static void ListenCanSpamReceiver(tCanSpamReceiver *env) {
 
     uint16_t recv = env->ioCanFrame->receive(env->ioCanFrame->env, PROTOCOL_CAN_RAW, (uint8_t *) &env->canFrame, 1,
-                                             1000);
+                                             3000);
-    if (recv == 0) {
+//    if (recv == 0) {
-        return;
+//        return;
-    }
+//    }
 
     if (osMutexAcquire(env->access, 5000) == osOK) {
 
@@ -384,8 +384,8 @@ bool get_is_NoNull_CanSpam_BCM_PowerTrain_Receiver(tCanSpamReceiver *env) {
     return false;
 }
 
-void get_CanSpamReceiver(tCanSpamReceiver *env, char *VIN, ccu_candb_error_missing_rx_t *CAN_ERROR_MISSLE,
+void get_CanSpamReceiver(tCanSpamReceiver *env, char *VIN, ccu_candb_error_missing_rx_t *CAN_ERROR_MISSING,
-                         ccu_candb_time_missing_rx_t *CAN_TIME_MISSLE) {
+                         ccu_candb_time_missing_rx_t *CAN_TIME_MISSING) {
 
     osStatus_t status = osOK;
 
@@ -394,37 +394,20 @@ void get_CanSpamReceiver(tCanSpamReceiver *env, char *VIN, ccu_candb_error_missi
 
     uint32_t countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_error_missing_rx);
     if (countQueue_ccu_candb_rx == 0) {
-        status = osMessageQueueGet(env->ccu_candb_error_missing_rx, CAN_ERROR_MISSLE, 0, 0U);
+        status = osMessageQueueGet(env->ccu_candb_error_missing_rx, CAN_ERROR_MISSING, 0, 0U);
     }
 
     countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_time_missing_rx);
     if (countQueue_ccu_candb_rx == 0) {
-        status = osMessageQueueGet(env->ccu_candb_time_missing_rx, CAN_TIME_MISSLE, 0, 0U);
+        status = osMessageQueueGet(env->ccu_candb_time_missing_rx, CAN_TIME_MISSING, 0, 0U);
     }
 
     //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
-
-    countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_TM_CP);
-    if (countQueue_ccu_candb_rx == 0) {
-        status = osMessageQueueGet(env->ccu_candb_rx_TM_CP, &rtDW.TM_CP_model, 0, 0U);
-    }
-
     memset(&rtDW.FIU_CCU1_MODEL, 0, sizeof(rtDW.FIU_CCU1_MODEL));
     memset(&rtDW.FIU_CCU2_MODEL, 0, sizeof(rtDW.FIU_CCU2_MODEL));
     memset(&rtDW.FIU_CCU3_MODEL, 0, sizeof(rtDW.FIU_CCU3_MODEL));
 
-
-    countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_BCM_EEM);
-    if (countQueue_ccu_candb_rx == 0) {
-//cfif        status = osMessageQueueGet(env->ccu_candb_rx_BCM_EEM, &rtDW., 0, 0U);
-    }
-
-    countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_EMS_Veh_02);
-    if (countQueue_ccu_candb_rx == 0) {
-//cfif        status = osMessageQueueGet(env->ccu_candb_rx_EMS_Veh_02, &rtDW., 0, 0U);
-    }
-
     countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_FIU_CCU1);
     if (countQueue_ccu_candb_rx == 0) {
         status = osMessageQueueGet(env->ccu_candb_rx_FIU_CCU1, &rtDW.FIU_CCU1_MODEL, 0, 0U);
@@ -440,6 +423,67 @@ void get_CanSpamReceiver(tCanSpamReceiver *env, char *VIN, ccu_candb_error_missi
         status = osMessageQueueGet(env->ccu_candb_rx_FIU_CCU3, &rtDW.FIU_CCU3_MODEL, 0, 0U);
     }
 
+
+    if (CAN_ERROR_MISSING->TM_CP) {
+        memset(&rtDW.TM_CP_model, 0, sizeof(rtDW.TM_CP_model));
+    }
+
+    if (CAN_ERROR_MISSING->BCM_EEM) {
+//cfif        memset(&rtDW.TM_CP_model, 0, sizeof(rtDW.TM_CP_model));
+    }
+
+    if (CAN_ERROR_MISSING->EMS_Veh_02) {
+//cfif        memset(&rtDW.TM_CP_model, 0, sizeof(rtDW.TM_CP_model));
+    }
+
+    if (CAN_ERROR_MISSING->BCM_Powertrain) {
+        memset(&rtDW.CCUCAN_BCM_Powertrain_model, 0, sizeof(rtDW.CCUCAN_BCM_Powertrain_model));
+    }
+
+    if (CAN_ERROR_MISSING->BCM_CLIMATIC_DATA) {
+        memset(&rtDW.CCUCAN_BCM_Climatic_model, 0, sizeof(rtDW.CCUCAN_BCM_Climatic_model));
+    }
+
+    if (CAN_ERROR_MISSING->EMS_Veh) {
+        memset(&rtDW.CCUCAN_EMS_Veh_model, 0, sizeof(rtDW.CCUCAN_EMS_Veh_model));
+    }
+
+    if (CAN_ERROR_MISSING->ESC_04) {
+        memset(&rtDW.CCUCAN_ESC_04_model, 0, sizeof(rtDW.CCUCAN_ESC_04_model));
+    }
+
+    if (CAN_ERROR_MISSING->BCM_VEH_STATE) {
+        memset(&rtDW.CCUCAN_BCM_VEH_STATE_model, 0, sizeof(rtDW.CCUCAN_BCM_VEH_STATE_model));
+    }
+
+    if (CAN_ERROR_MISSING->EMS_HVC_Req_Msg) {
+        memset(&rtDW.CCUCAN_EMS_HVC_REQ_MSG_MODEL, 0, sizeof(rtDW.CCUCAN_EMS_HVC_REQ_MSG_MODEL));
+    }
+
+    if (CAN_ERROR_MISSING->HVC_Err_Status_Msg) {
+        memset(&rtDW.HVC_ERR_STATUS_MSG_MODEL, 0, sizeof(rtDW.HVC_ERR_STATUS_MSG_MODEL));
+    }
+
+
+
+
+
+
+    countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_TM_CP);
+    if (countQueue_ccu_candb_rx == 0) {
+        status = osMessageQueueGet(env->ccu_candb_rx_TM_CP, &rtDW.TM_CP_model, 0, 0U);
+    }
+
+    countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_BCM_EEM);
+    if (countQueue_ccu_candb_rx == 0) {
+//cfif        status = osMessageQueueGet(env->ccu_candb_rx_BCM_EEM, &rtDW., 0, 0U);
+    }
+
+    countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_EMS_Veh_02);
+    if (countQueue_ccu_candb_rx == 0) {
+//cfif        status = osMessageQueueGet(env->ccu_candb_rx_EMS_Veh_02, &rtDW., 0, 0U);
+    }
+
     countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_BCM_Powertrain);
     if (countQueue_ccu_candb_rx == 0) {
         status = osMessageQueueGet(env->ccu_candb_rx_BCM_Powertrain, &rtDW.CCUCAN_BCM_Powertrain_model, 0, 0U);

MODULES/HVAC_M7_CAN_SPAM/CanSpamReceiver.h

@@ -96,13 +96,14 @@ void CanSpamReceiver_Init(tCanSpamReceiver *env, tSerialPortFrameIO *ioCanFrame,
 
 void CanSpamReceiver_StartThread(tCanSpamReceiver *env);
 
-void get_CanSpamReceiver(tCanSpamReceiver *env, char *VIN,  ccu_candb_error_missing_rx_t *CAN_ERROR_MISSLE,  ccu_candb_time_missing_rx_t *CAN_TIME_MISSLE);
+void get_CanSpamReceiver(tCanSpamReceiver *env, char *VIN, ccu_candb_error_missing_rx_t *CAN_ERROR_MISSING,
+                         ccu_candb_time_missing_rx_t *CAN_TIME_MISSING);
 
 bool get_CanSpamReceiverUDS(tCanSpamReceiver *env, char *VIN, func_update_func update_func, void *update_func_env,
                             uint32_t timeout, uint32_t count);
 
 bool get_is_NoNull_CanSpam_BCM_PowerTrain_Receiver(tCanSpamReceiver *env);
 
-uint32_t getCanTimeReceived(tCanSpamReceiver *env);
+uint32_t getCanTimeReceived(tCanSpamReceiver *env, bool isCan0BusOff, bool isT15);
 
 #endif //HVAC_CAN_SPAM_RECEIVER_H

MODULES/HVAC_M7_MODEL/HVAC_model_private.h

@@ -3,9 +3,9 @@
  *
  * Code generated for Simulink model 'HVAC_model'.
  *
- * Model version                  : 1.1628
+ * Model version                  : 1.1658
  * Simulink Coder version         : 24.1 (R2024a) 19-Nov-2023
- * C/C++ source code generated on : Mon Sep 28 10:54:48 2026
+ * C/C++ source code generated on : Fri Oct  2 10:22:10 2026
  *
  * Target selection: ert.tlc
  * Embedded hardware selection: ARM Compatible->ARM Cortex-M
@@ -95,24 +95,27 @@ extern uint8_t look2_iu8bu8s16lu64n32_binlcse(uint8_t u0, uint8_t u1, const
   maxIndex[], uint32_t stride);
 extern uint8_t look1_iu16lu64n48tu8_binlcse(uint16_t u0, const uint16_t bp0[],
   const uint8_t table[], uint32_t maxIndex);
-extern int16_t look1_iu16tdIs16_binlcs(uint16_t u0, const uint16_t bp0[], const
-  double table[], uint32_t maxIndex);
-extern double look2_binlx(double u0, double u1, const double bp0[], const double
-  bp1[], const double table[], const uint32_t maxIndex[], uint32_t stride);
-extern int16_t look1_iu16lu64n48ts16Ds32_binlcs(uint16_t u0, const uint16_t bp0[],
-  const int16_t table[], uint32_t maxIndex);
 extern int16_t look1_iu16bs16lu64n32ts16Ds32_binlcs(uint16_t u0, const int16_t
   bp0[], const int16_t table[], uint32_t maxIndex);
+extern int16_t look1_iu16lu64n48ts16Ds32_binlcs(uint16_t u0, const uint16_t bp0[],
+  const int16_t table[], uint32_t maxIndex);
+extern int16_t look2_bs16ts16Dddd_binlc(double u0, double u1, const int16_t bp0[],
+  const int16_t bp1[], const int16_t table[], const uint32_t maxIndex[],
+  uint32_t stride);
+extern uint16_t look1_iu8bu16lu64n32tu16_binlcse(uint8_t u0, const uint16_t bp0[],
+  const uint16_t table[], uint32_t maxIndex);
 extern int16_t look1_iu16lu64n48Ds32Is16_binlcs(uint16_t u0, const uint16_t bp0[],
   const uint16_t table[], uint32_t maxIndex);
+extern uint16_t look1_iu16lu64n48_binlcse(uint16_t u0, const uint16_t bp0[],
+  const uint16_t table[], uint32_t maxIndex);
 extern uint16_t look1_is16lu64n32tu16_binlcse(int16_t u0, const int16_t bp0[],
   const uint16_t table[], uint32_t maxIndex);
 extern double look1_bs16ts16DdId_binlc(double u0, const int16_t bp0[], const
   int16_t table[], uint32_t maxIndex);
-extern uint8_t look1_iu8lu64n56_binlcse(uint8_t u0, const uint8_t bp0[], const
-  uint8_t table[], uint32_t maxIndex);
 extern double look1_iu16td_binlc(uint16_t u0, const uint16_t bp0[], const double
   table[], uint32_t maxIndex);
+extern uint8_t look1_iu8lu64n56_binlcse(uint8_t u0, const uint8_t bp0[], const
+  uint8_t table[], uint32_t maxIndex);
 extern uint32_t plook_u32s16_bincka(int16_t u_7, const int16_t bp[], uint32_t
   maxIndex);
 extern int32_t div_nzp_s32_round(int32_t numerator, int32_t denominator);
@@ -371,6 +374,7 @@ extern void u_p(int16_t rtu_amb_raw, int16_t rtu_lvl, uint8_t *rty_out, const
 extern void u_g2(int16_t rtu_amb_raw, int16_t rtu_lvl, uint8_t
                  *rty_riseperminute, const double *rtd_AMB_store, double
                  *rtd_KEEP_RISING_UNTIL_LIMIT);
+extern void IfActionSubsystem2(int16_t *rty_Out1);
 extern void IfActionSubsystem(int8_t *rty_Out1, double *rtd_ErrorHomming_private,
   double *rtd_Start_timer_n, int8_t *rtd_stepSig_private);
 extern void MATLABFunction_Init(DW_MATLABFunction *localDW);

MODULES/HVAC_M7_MODEL/HVAC_model_types.h

@@ -3,9 +3,9 @@
  *
  * Code generated for Simulink model 'HVAC_model'.
  *
- * Model version                  : 1.1628
+ * Model version                  : 1.1658
  * Simulink Coder version         : 24.1 (R2024a) 19-Nov-2023
- * C/C++ source code generated on : Mon Sep 28 10:54:48 2026
+ * C/C++ source code generated on : Fri Oct  2 10:22:10 2026
  *
  * Target selection: ert.tlc
  * Embedded hardware selection: ARM Compatible->ARM Cortex-M
@@ -1278,6 +1278,70 @@ typedef struct {
 
 #endif
 
+#ifndef DEFINED_TYPEDEF_FOR_DMFR_Msg1_Bus_
+#define DEFINED_TYPEDEF_FOR_DMFR_Msg1_Bus_
+
+typedef struct {
+  uint8_t DMFR_WarningInd;
+  uint8_t DMFR_DoorLockState;
+  uint8_t DMFR_DoorAjarState;
+  uint8_t DMFR_DoorAjarFault_Stat;
+  uint8_t DMFR_MirrorHeating_Status;
+  uint8_t DMFR_WindowFullyClosed_Stat;
+  uint8_t DMFR_IntDoorHandle_Req;
+  uint8_t DMFR_IntDoorLockSw_Cmd;
+  uint8_t DMFR_ShortDrop_Stat;
+  uint8_t DMFR_Comm_Req;
+  uint8_t DMFR_DoorMovement_Stat;
+  uint8_t DMFR_DoorDirection_Stat;
+  uint8_t DMFR_Antipinch_Stat;
+  uint8_t DMFR_BSDLed_Stat;
+  uint8_t DMFR_DoorCloseSw_Req;
+  uint8_t DMFR_TurnInd_Stat;
+} DMFR_Msg1_Bus;
+
+#endif
+
+#ifndef DEFINED_TYPEDEF_FOR_DMFL_Msg1_Bus_
+#define DEFINED_TYPEDEF_FOR_DMFL_Msg1_Bus_
+
+typedef struct {
+  uint8_t DMFL_KeyCylinder_Req;
+  uint8_t DMFL_WarningInd;
+  uint8_t DMFL_DoorLockState;
+  uint8_t DMFL_DoorAjarState;
+  uint8_t DMFL_ChildLockCentralTab_Stat;
+  uint8_t DMFL_DoorCloseSw_Req;
+  uint8_t DMFL_MirrorHeating_Status;
+  uint8_t DMFL_IntDoorHandle_Req;
+  uint8_t DMFL_ChildLock_RLwindow_Stat;
+  uint8_t DMFL_ChildLockRLTab_Stat;
+  uint8_t DMFL_IntDoorLockSw_Cmd;
+  uint8_t DMFL_ChildLockRRTab_Stat;
+  uint8_t DMFL_FRWindow_Cmd;
+  uint8_t DMFL_RLWindow_Cmd;
+  uint8_t DMFL_RightMirrorTilt_Cmd;
+  uint8_t DMFL_RRWindow_Cmd;
+  uint8_t DMFL_RightMirrorAdjust_Cmd;
+  uint8_t DMFL_RightMirrorFold_Cmd;
+  uint8_t DMFL_WindowFullyClosed_Stat;
+  uint8_t DMFL_Comm_Req;
+  uint8_t DMFL_ChildLock_Stat;
+  uint8_t DMFL_DoorMovement_Stat;
+  uint8_t DMFL_Antipinch_Stat;
+  uint8_t DMFL_DoorDirection_Stat;
+  uint8_t DMFL_BSDLed_Stat;
+  uint8_t DMFL_DoorAjarFault_Stat;
+  uint8_t DMFL_ShortDrop_Stat;
+  uint8_t DMFL_TurnInd_Stat;
+  uint8_t DMFL_ChildLock_RRwindow_Stat;
+  uint8_t DMFL_RearWindowCurtain_Req;
+  uint8_t DMFL_ChildLock_RLdoor_Stat;
+  uint8_t DMFL_ChildLock_RRdoor_Stat;
+} DMFL_Msg1_Bus;
+
+#endif
+
 #ifndef DEFINED_TYPEDEF_FOR_CmdBusADCData_
 #define DEFINED_TYPEDEF_FOR_CmdBusADCData_
 
@@ -1356,6 +1420,31 @@ typedef struct {
 
 #endif
 
+#ifndef DEFINED_TYPEDEF_FOR_DW_STATE_Bus_
+#define DEFINED_TYPEDEF_FOR_DW_STATE_Bus_
+
+typedef struct {
+  uint8_t DW_Display_Stat;
+  uint8_t DW_MediaPower_Stat;
+  uint8_t DW_Display_Req;
+  uint8_t DW_Glass_Stat;
+  uint8_t DW_AntiPinchFlag_Stat;
+  uint8_t DW_CurrentVideoSigSrc_Stat;
+  uint8_t DW_DisplayPosition_Stat;
+  uint8_t DW_GlassPosition_Stat;
+  uint8_t DW_MovingDisplay_Stat;
+  uint8_t DW_MovingGlass_Stat;
+  uint8_t DW_DisplayDimmingMode_Stat;
+  uint8_t DW_DetectedMMSSrc_Stat;
+  uint8_t DW_DetectedCAMSrc_Stat;
+  uint8_t DW_DetectedHDMI1Src_Stat;
+  uint8_t DW_DetectedHDMI2Src_Stat;
+  uint8_t DW_DetectedHDMISockSrc_Stat;
+  uint8_t DW_DisplayBrightness_Stat_ro;
+} DW_STATE_Bus;
+
+#endif
+
 #ifndef DEFINED_TYPEDEF_FOR_CmdCAN_FIU_CCU2_Bus_
 #define DEFINED_TYPEDEF_FOR_CmdCAN_FIU_CCU2_Bus_
 

MODULES/HVAC_M7_MODEL/Model_Task.c

@@ -905,7 +905,7 @@ static _Noreturn void ModelTask_Thread(tModelTask *env) {
             //==============================================DTC===============================================================================================
 
             if (SystemGetMs() > timeDTC) {
-                set_Dtc_state(env->diagnostic, &env->ccu_candb_tx.CCU_Errors, env->dtc_state_error,
+                set_Dtc_state(env->diagnostic, isT15, &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);

MODULES/HVAC_M7_StatusData/DiagnosticTask.c

@@ -358,9 +358,10 @@ extern volatile bool isCan0BusOff;
 extern volatile uint32_t timeCan0BusOff;
 
 static void
-setErrorDTC_CAN(tDiagnostic *env, uint8_t *dtc_state_error_model, ccu_candb_error_missing_rx_t *CAN_ERROR_MISSLE) {
+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) + 3000;
+//    uint32_t timeCanSpamReceiver = getCanTimeReceived(env->canSpamReceiver, isCan0BusOff, isT15) + 3000;
     uint32_t time = SystemGetMs();
 
     if (isCan0BusOff) {
@@ -369,34 +370,40 @@ setErrorDTC_CAN(tDiagnostic *env, uint8_t *dtc_state_error_model, ccu_candb_erro
         } 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_MISSLE->EMS_HVC_Req_Msg) || (CAN_ERROR_MISSLE->EMS_Veh) || (CAN_ERROR_MISSLE->EMS_Veh_02) ||
+    if ((CAN_ERROR_MISSING->EMS_HVC_Req_Msg) || (CAN_ERROR_MISSING->EMS_Veh) || (CAN_ERROR_MISSING->EMS_Veh_02)) {
-        (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));
     }
 
     // U012287 (ESP)- 0x100 OR 0x3C1 - OK
-    if ((CAN_ERROR_MISSLE->ESC_04) || (CAN_ERROR_MISSLE->ESC_08) || (time > timeCanSpamReceiver)) {
+    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_MISSLE->BCM_CLIMATIC_DATA) || (CAN_ERROR_MISSLE->BCM_EEM) || (CAN_ERROR_MISSLE->BCM_Powertrain) ||
+    if ((CAN_ERROR_MISSING->BCM_CLIMATIC_DATA) || (CAN_ERROR_MISSING->BCM_EEM) || (CAN_ERROR_MISSING->BCM_Powertrain) ||
-        (CAN_ERROR_MISSLE->BCM_VEH_STATE) || (CAN_ERROR_MISSLE->VEH_VIN) || (time > timeCanSpamReceiver)) {
+        (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_MISSLE->HVC_CCU_Status_Msg) || (CAN_ERROR_MISSLE->HVC_Err_Status_Msg) ||
+    if ((CAN_ERROR_MISSING->HVC_CCU_Status_Msg) || (CAN_ERROR_MISSING->HVC_Err_Status_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] =
@@ -404,7 +411,7 @@ setErrorDTC_CAN(tDiagnostic *env, uint8_t *dtc_state_error_model, ccu_candb_erro
     }
 
     // U019987 (DMFL) - 0x244 - OK
-    if ((CAN_ERROR_MISSLE->DMFR_Msg1) || (time > timeCanSpamReceiver)) {
+    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] =
@@ -412,7 +419,7 @@ setErrorDTC_CAN(tDiagnostic *env, uint8_t *dtc_state_error_model, ccu_candb_erro
     }
 
     // U020087 (DMFR) - 0x243 - OK
-    if ((CAN_ERROR_MISSLE->DMFL_Msg1) || (time > timeCanSpamReceiver)) {
+    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] =
@@ -420,7 +427,7 @@ setErrorDTC_CAN(tDiagnostic *env, uint8_t *dtc_state_error_model, ccu_candb_erro
     }
 
     // U020887 (SMFL) 0x4D0 OR 0x521 - OK
-    if ((CAN_ERROR_MISSLE->SMFL_status) || (CAN_ERROR_MISSLE->OCUFL_MSG) || (time > timeCanSpamReceiver)) {
+    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] =
@@ -428,7 +435,7 @@ setErrorDTC_CAN(tDiagnostic *env, uint8_t *dtc_state_error_model, ccu_candb_erro
     }
 
     // U020987 (SMFR) 0x4D1 OR 0x522 - OK
-    if ((CAN_ERROR_MISSLE->SMFR_status) || (CAN_ERROR_MISSLE->OCUFR_MSG) || (time > timeCanSpamReceiver)) {
+    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] =
@@ -436,7 +443,7 @@ setErrorDTC_CAN(tDiagnostic *env, uint8_t *dtc_state_error_model, ccu_candb_erro
     }
 
     // U021087 (SMRL) 0x4D2 OR 0x523 - OK
-    if ((CAN_ERROR_MISSLE->SMRL_status) || (CAN_ERROR_MISSLE->OCURL_MSG) || (time > timeCanSpamReceiver)) {
+    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] =
@@ -444,7 +451,7 @@ setErrorDTC_CAN(tDiagnostic *env, uint8_t *dtc_state_error_model, ccu_candb_erro
     }
 
     // U021187 (SMRR) 0x4D3 OR 0x524 - OK
-    if ((CAN_ERROR_MISSLE->SMRR_status) || (CAN_ERROR_MISSLE->OCURR_MSG) || (time > timeCanSpamReceiver)) {
+    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] =
@@ -506,7 +513,7 @@ setErrorDTC_LIN(uint8_t *dtc_state_error_model, const uint8_t *LIN1_ERROR_MISSIN
 
 }
 
-void set_Dtc_state(tDiagnostic *env, CCU_Errors_t *CCU_Errors,
+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,
@@ -535,10 +542,9 @@ void set_Dtc_state(tDiagnostic *env, CCU_Errors_t *CCU_Errors,
 
             setErrorDTC_LIN(dtc_state_error_model, LIN1_ERROR_MISSING, LIN2_ERROR_MISSING, LIN3_ERROR_MISSING,
                             LIN4_ERROR_MISSING, LIN5_ERROR_MISSING);
-            setErrorDTC_CAN_VIN(dtc_state_error_model, CAN_ERROR_MISSING, VIN, CCU_Errors);
 
             // Если не было изначально сообщений
-            setErrorDTC_CAN(env, dtc_state_error_model, CAN_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;

MODULES/HVAC_M7_StatusData/DiagnosticTask.h

@@ -36,7 +36,7 @@ typedef struct {
 
 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,
+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_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,