Добавлена логика BusOff (не доделана)

This commit is contained in:
cfif 2026-10-05 15:03:04 +03:00
parent 74953a6f47
commit d84ba19920
6 changed files with 211 additions and 383 deletions

View File

@ -7,6 +7,8 @@
#include "fc7xxx_driver_gpio.h"
#include "candb.h"
#include "candb_dbg.h"
#include "CmsisRtosThreadUtils.h"
#include "MainStack.h"
#define LOG_SIGN "INIT"
#define LOGGER logger
@ -37,16 +39,23 @@ static void DMA_TransferCompleteCallbackCan1(void) {
#else
volatile bool isCan0BusOff = false;
volatile uint32_t timeCan0BusOff = 0;
// Recovery
volatile bool isCan0BusOff = false; // для Can0BusOff_Thread
// DTC
volatile bool dtcCan0BusOffActive = false; // активен ли bus-off для DTC
volatile uint32_t dtcCan0BusOffDeadline = 0; // когда снять FAILED
static void CAN0_ErrorInterrupt_CallBack(uint8_t u8CanIndex, FLEXCAN_ErrorInfoType *pErrorInfo) {
if (pErrorInfo->u32ErrorValue & FLEXCAN_ESR1_BOFFINT_MASK) {
timeCan0BusOff = SystemGetMs() + 3000;
isCan0BusOff = true;
dtcCan0BusOffActive = true;
dtcCan0BusOffDeadline = SystemGetMs() + 3000u;
FLEXCAN_Stop(u8CanIndex);
vCanPort_InitCan0();
isCan0BusOff = true;
}
FLEXCAN_ClrErrorInfo(u8CanIndex, pErrorInfo);
@ -63,12 +72,14 @@ static void CAN0_RxFifoInterrupt_CallBack(uint8_t u8CanIndex, FLEXCAN_RxMsgType
}
volatile bool isCan1BusOff = false;
static void CAN1_ErrorInterrupt_CallBack(uint8_t u8CanIndex, FLEXCAN_ErrorInfoType *pErrorInfo) {
if (pErrorInfo->u32ErrorValue & FLEXCAN_ESR1_BOFFINT_MASK) {
FLEXCAN_Stop(u8CanIndex);
vCanPort_InitCan1();
isCan0BusOff = true;
}
FLEXCAN_ClrErrorInfo(u8CanIndex, pErrorInfo);
@ -495,378 +506,147 @@ void CAN3_IRQHandler(void) {
FLEXCAN_IRQHandler(3U);
}
// ---- Тайминги (UMP-52538, Table 5-2) ------------------------------------
#define TBUSOFF1_TICKS 2u // 100 мс при тике 50 мс (min 50, typ 100, max 100)
#define TBUSOFF2_TICKS 4u // 200 мс при тике 50 мс (min 200, typ 200, max 500)
#define QUICK_MAX 5u // 5 quick recovery подряд, далее slow
#define HEAL_TICKS 10u // heal-окно 500 мс — согласовать с NAMI
#define BUSOFF_TICK_MS 50u
/*
#if (CAN_DMA_EN == 1)
extern volatile bool is_Global_T15;
typedef struct {
uint32_t u32CanRAM[4];
} Can_RamType;
static _Noreturn void Can0BusOff_Thread(tCan0BusOff *env)
{
uint8_t quickCount = 0u;
uint8_t waitTicks = 0u;
uint8_t healTicks = 0u;
#define size_aRxDataBuf 16
ALIGN(256) Can_RamType g_aRxDataBufCan0[size_aRxDataBuf]; // dma ring buffer size is 256
ALIGN(256) Can_RamType g_aRxDataBufCan1[size_aRxDataBuf]; // dma ring buffer size is 256
(void)env;
static void DMA_TransferCompleteCallbackCan0(void) {
CanSerialPortFrameIrqRxProcessing(CAN_PORTS.Can0_IO.env, (uint32_t *) &g_aRxDataBufCan0[0]);
for (;;) {
SystemDelayMs(BUSOFF_TICK_MS);
// T15 off: полный сброс стратегии
if (!is_Global_T15) {
quickCount = 0u;
waitTicks = 0u;
healTicks = 0u;
isCan0BusOff = false;
continue;
}
static void DMA_TransferCompleteCallbackCan1(void) {
CanSerialPortFrameIrqRxProcessing(CAN_PORTS.Can1_IO.env, (uint32_t *) &g_aRxDataBufCan1[0]);
}
#else
// Новое bus-off
if (isCan0BusOff) {
isCan0BusOff = false;
healTicks = 0u; // heal прерван
static void CAN0_ErrorInterrupt_CallBack(uint8_t u8CanIndex, FLEXCAN_ErrorInfoType *pErrorInfo) {
FLEXCAN_ClrErrorInfo(u8CanIndex, pErrorInfo);
PROCESS_UNUSED_VAR(u8CanIndex);
PROCESS_UNUSED_VAR(pErrorInfo);
}
static void CAN0_RxInterrupt_CallBack(uint8_t u8CanIndex, FLEXCAN_RxMsgType *pRxCfg) {
CanSerialPortFrameIrqRxProcessingNO_DMA(CAN_PORTS.Can0_IO.env, pRxCfg);
}
static void CAN0_RxFifoInterrupt_CallBack(uint8_t u8CanIndex, FLEXCAN_RxMsgType *pRxCfg) {
CanSerialPortFrameIrqRxProcessingNO_DMA(CAN_PORTS.Can0_IO.env, pRxCfg);
}
static void CAN1_ErrorInterrupt_CallBack(uint8_t u8CanIndex, FLEXCAN_ErrorInfoType *pErrorInfo) {
FLEXCAN_ClrErrorInfo(u8CanIndex, pErrorInfo);
PROCESS_UNUSED_VAR(u8CanIndex);
PROCESS_UNUSED_VAR(pErrorInfo);
}
static void CAN1_RxInterrupt_CallBack(uint8_t u8CanIndex, FLEXCAN_RxMsgType *pRxCfg) {
CanSerialPortFrameIrqRxProcessingNO_DMA(CAN_PORTS.Can1_IO.env, pRxCfg);
}
static void CAN1_RxFifoInterrupt_CallBack(uint8_t u8CanIndex, FLEXCAN_RxMsgType *pRxCfg) {
CanSerialPortFrameIrqRxProcessingNO_DMA(CAN_PORTS.Can1_IO.env, pRxCfg);
}
#endif
//static void DMA_ErrorCallback(void) {
// while (1) {
// __asm("nop");
// }
//}
static void vCanPort_InitCAN0RxTxPin() {
PORT_InitType tInitStruct = {0U};
GPIO_InitType tGpioInitStruct = {0};
// CAN0_STB
// PortC 30: MUX = GPIO output
tInitStruct.u32PortPins = PORT_PIN_30;
tInitStruct.uPortPinMux.u32PortPinMode = PORT_GPIO_MODE;
PORT_InitPins(PORT_C, &tInitStruct);
tGpioInitStruct.u32GpioPins = PORT_PIN_30;
tGpioInitStruct.ePinDirection = GPIO_OUT;
tGpioInitStruct.ePinLevel = GPIO_LOW;
GPIO_InitPins(GPIO_C, &tGpioInitStruct);
// Port C2: MUX = ALT3, CAN0_RX
tInitStruct.u32PortPins = PORT_PIN_2;
tInitStruct.uPortPinMux.u32PortPinMode = PORTC_2_FLEXCAN0_RX;
tInitStruct.bPullEn = FALSE;
tInitStruct.ePullSel = PORT_PULL_UP;
PORT_InitPins(PORT_C, &tInitStruct);
tGpioInitStruct.u32GpioPins = PORT_PIN_2;
tGpioInitStruct.ePinDirection = GPIO_IN;
GPIO_InitPins((GPIO_InstanceType) PORT_C, &tGpioInitStruct);
// Port C3: MUX = ALT3, CAN0_TX
tInitStruct.u32PortPins = PORT_PIN_3;
tInitStruct.uPortPinMux.u32PortPinMode = PORTC_3_FLEXCAN0_TX;
PORT_InitPins(PORT_C, &tInitStruct);
tGpioInitStruct.u32GpioPins = PORT_PIN_3;
tGpioInitStruct.ePinDirection = GPIO_OUT;
tGpioInitStruct.ePinLevel = GPIO_HIGH;
GPIO_InitPins(GPIO_C, &tGpioInitStruct);
}
#define countIdCanHardSoftFilterCan0 31
const FilterTo_FLEXCAN_RxMbFilterType IdCanHardSoftFilterCan0[countIdCanHardSoftFilterCan0] = {
{FLEXCAN_ID_STD, Diag_To_CCU_CANID, 0x7FF, PROTOCOL_CAN_UDS},
{FLEXCAN_ID_STD, Diag_Functional_CANID, 0x7FF, PROTOCOL_CAN_UDS},
{FLEXCAN_ID_STD, EMS_Veh_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, BCM_Powertrain_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, EMS_Veh_02_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, BCM_EEM_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, DMFR_Msg1_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, DMFL_Msg1_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, TM_Stat_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, TM_CP_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, HVC_CCU_Status_Msg_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, BCM_VEH_STATE_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, EMS_HVC_Req_Msg_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, HVC_Err_Status_Msg_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, BCM_CLIMATIC_DATA_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, VCU_CCU_Req_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, ESC_08_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, SMFL_status_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, SMFR_status_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, SMRL_status_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, SMRR_status_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, SDM_Cmd_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, VEH_VIN_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, OCUFL_MSG_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, OCUFR_MSG_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, OCURL_MSG_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, OCURR_MSG_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, DW_STATE_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, FIU_CCU1_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, FIU_CCU2_CANID, 0x7FF, PROTOCOL_CAN_RAW},
{FLEXCAN_ID_STD, FIU_CCU3_CANID, 0x7FF, PROTOCOL_CAN_RAW}
};
#if (CAN_DMA_EN == 1)
#define countIdCanFilterFifoCan0 7
const FLEXCAN_RxMbFilterType IdCanFilterFifoCan0[countIdCanFilterFifoCan0] = {
{FLEXCAN_ID_STD, 0x100, 0x7FF},
{FLEXCAN_ID_STD, 0x200, 0x7FF},
{FLEXCAN_ID_STD, 0x300, 0x7FF},
{FLEXCAN_ID_STD, 0x400, 0x7FF},
{FLEXCAN_ID_STD, 0x500, 0x7FF},
{FLEXCAN_ID_STD, Diag_To_CCU_CANID, 0x7FF},
{FLEXCAN_ID_STD, Diag_Functional_CANID, 0x7FF}
};
#endif
#define countIdCanHardSoftFilterCan1 2
const FilterTo_FLEXCAN_RxMbFilterType IdCanHardSoftFilterCan1[countIdCanHardSoftFilterCan1] = {
{FLEXCAN_ID_STD, Diag_To_CCU_CANID, 0x7FF, PROTOCOL_CAN_UDS},
{FLEXCAN_ID_STD, Diag_Functional_CANID, 0x7FF, PROTOCOL_CAN_UDS},
// {FLEXCAN_ID_STD, XCP_CCU_RX_CANID, 0x7FF, PROTOCOL_CAN_XCP},
// {FLEXCAN_ID_STD, dbg_Cmd_Act_Information_CANID, 0x7FF, PROTOCOL_CAN_RAW}
};
#if (CAN_DMA_EN == 1)
#define countIdCanFilterFifoCan1 7
const FLEXCAN_RxMbFilterType IdCanFilterFifoCan1[countIdCanFilterFifoCan1] = {
// {FLEXCAN_ID_STD, 0, 0}
{FLEXCAN_ID_STD, 0x100, 0x7FF},
{FLEXCAN_ID_STD, 0x200, 0x7FF},
{FLEXCAN_ID_STD, 0x300, 0x7FF},
{FLEXCAN_ID_STD, 0x400, 0x7FF},
{FLEXCAN_ID_STD, 0x500, 0x7FF},
{FLEXCAN_ID_STD, Diag_To_CCU_CANID, 0x7FF},
{FLEXCAN_ID_STD, Diag_Functional_CANID, 0x7FF}
};
#endif
static bool vCanPort_InitCan0() {
vCanPort_InitCAN0RxTxPin();
#if (CAN_DMA_EN == 1)
bool result = vCanSerialPortFrameDMAInit(
&CAN_PORTS.Can0,
FLEXCAN0,
0, // CAN0 = 0 ... CAN3 = 3
FlexCAN0_IRQn, // // FlexCAN0_IRQn ... FlexCAN3_IRQn
0xFF,
DMA_CHANNEL_0,
DMA_REQ_FLEXCAN0,
(uint8_t *) &g_aRxDataBufCan0[0],
size_aRxDataBuf,
IdCanHardSoftFilterCan0,
countIdCanHardSoftFilterCan0,
IdCanFilterFifoCan0,
countIdCanFilterFifoCan0,
DMA0_IRQn,
0xFF,
DMA0_IRQn,
FLEXCAN_BAUD_500K,
FLEXCAN_ID_STD,
0x55,
NULL,
NULL,
NULL,
NULL,
DMA_TransferCompleteCallbackCan0,
NULL
);
#else
bool result = vCanSerialPortFrameMbInit(
&CAN_PORTS.Can0,
FLEXCAN0,
0, // CAN0 = 0 ... CAN3 = 3
FlexCAN0_IRQn, // // FlexCAN0_IRQn ... FlexCAN3_IRQn
0xFF,
IdCanHardSoftFilterCan0,
countIdCanHardSoftFilterCan0,
FLEXCAN_BAUD_500K,
FLEXCAN_ID_STD,
0x55,
CAN0_ErrorInterrupt_CallBack,
CAN0_RxInterrupt_CallBack,
CAN0_RxFifoInterrupt_CallBack,
NULL
);
#endif
return result;
}
static void vCanPort_InitCAN1RxTxPin() {
PORT_InitType tInitStruct = {0U};
GPIO_InitType tGpioInitStruct = {0};
// CAN1_STB
// PortD 28: MUX = GPIO output
tInitStruct.u32PortPins = PORT_PIN_28;
tInitStruct.uPortPinMux.u32PortPinMode = PORT_GPIO_MODE;
PORT_InitPins(PORT_D, &tInitStruct);
tGpioInitStruct.u32GpioPins = PORT_PIN_28;
tGpioInitStruct.ePinDirection = GPIO_OUT;
tGpioInitStruct.ePinLevel = GPIO_LOW;
GPIO_InitPins(GPIO_D, &tGpioInitStruct);
// PortA 12: MUX = ALT3, CAN1_RX
tInitStruct.u32PortPins = PORT_PIN_12;
tInitStruct.uPortPinMux.u32PortPinMode = PORTA_12_FLEXCAN1_RX;
tInitStruct.bPullEn = FALSE;
tInitStruct.ePullSel = PORT_PULL_UP;
PORT_InitPins(PORT_A, &tInitStruct);
tGpioInitStruct.u32GpioPins = PORT_PIN_12;
tGpioInitStruct.ePinDirection = GPIO_IN;
GPIO_InitPins((GPIO_InstanceType) PORT_A, &tGpioInitStruct);
// PortA 13: MUX = ALT4, CAN1_TX
tInitStruct.u32PortPins = PORT_PIN_13;
tInitStruct.uPortPinMux.u32PortPinMode = PORTA_13_FLEXCAN1_TX;
PORT_InitPins(PORT_A, &tInitStruct);
tGpioInitStruct.u32GpioPins = PORT_PIN_13;
tGpioInitStruct.ePinDirection = GPIO_OUT;
tGpioInitStruct.ePinLevel = GPIO_HIGH;
GPIO_InitPins(GPIO_A, &tGpioInitStruct);
}
static bool vCanPort_InitCan1() {
vCanPort_InitCAN1RxTxPin();
#if (CAN_DMA_EN == 1)
bool result = vCanSerialPortFrameDMAInit(
&CAN_PORTS.Can1,
FLEXCAN1,
1, // CAN0 = 0 ... CAN3 = 3
FlexCAN1_IRQn, // // FlexCAN0_IRQn ... FlexCAN3_IRQn
0xFF,
DMA_CHANNEL_1,
DMA_REQ_FLEXCAN1,
(uint8_t *) &g_aRxDataBufCan1[0],
size_aRxDataBuf,
IdCanHardSoftFilterCan1,
countIdCanHardSoftFilterCan1,
IdCanFilterFifoCan1,
countIdCanFilterFifoCan1,
DMA1_IRQn,
0xFF,
DMA1_IRQn,
FLEXCAN_BAUD_500K,
FLEXCAN_ID_STD,
0x55,
NULL,
NULL,
NULL,
NULL,
DMA_TransferCompleteCallbackCan1,
NULL
);
#else
bool result = vCanSerialPortFrameMbInit(
&CAN_PORTS.Can1,
FLEXCAN1,
1, // CAN0 = 0 ... CAN3 = 3
FlexCAN1_IRQn, // // FlexCAN0_IRQn ... FlexCAN3_IRQn
0xFF,
IdCanHardSoftFilterCan1,
countIdCanHardSoftFilterCan1,
FLEXCAN_BAUD_500K,
FLEXCAN_ID_STD,
0x55,
CAN1_ErrorInterrupt_CallBack,
CAN1_RxInterrupt_CallBack,
CAN1_RxFifoInterrupt_CallBack,
NULL
);
#endif
return result;
}
void CanPorts_Init(tLoggerInterface *logger) {
CAN_PORTS.Can0.reInit = false;
bool result = vCanPort_InitCan0();
if (result) {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Initialization CAN0 - OK")
if (quickCount < QUICK_MAX) {
waitTicks = TBUSOFF1_TICKS; // quick: 100 мс
quickCount++;
} else {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Initialization CAN0 - ERROR")
waitTicks = TBUSOFF2_TICKS; // slow: 200 мс
}
continue;
}
CAN_PORTS.Can0_IO = CanPortFrame_GetIo(&CAN_PORTS.Can0);
CAN_PORTS.Can1.reInit = false;
// Пауза, затем попытка восстановления
if (waitTicks > 0u) {
if (--waitTicks == 0u) {
vCanPort_InitCan0();
healTicks = HEAL_TICKS;
}
continue;
}
result = vCanPort_InitCan1();
if (result) {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Initialization CAN1 - OK")
// Heal: окно прошло без нового bus-off
if (healTicks > 0u) {
if (--healTicks == 0u) {
quickCount = 0u;
}
}
}
}
static _Noreturn void Can1BusOff_Thread(tCan0BusOff *env)
{
uint8_t quickCount = 0u;
uint8_t waitTicks = 0u;
uint8_t healTicks = 0u;
(void)env;
for (;;) {
SystemDelayMs(BUSOFF_TICK_MS);
// T15 off
if (!is_Global_T15) {
quickCount = 0u;
waitTicks = 0u;
healTicks = 0u;
isCan1BusOff = false;
continue;
}
// Новое bus-off
if (isCan1BusOff) {
isCan1BusOff = false;
healTicks = 0u;
if (quickCount < QUICK_MAX) {
waitTicks = TBUSOFF1_TICKS;
quickCount++;
} else {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Initialization CAN1 - ERROR")
waitTicks = TBUSOFF2_TICKS;
}
CAN_PORTS.Can1_IO = CanPortFrame_GetIo(&CAN_PORTS.Can1);
continue;
}
void CAN0_IRQHandler(void) {
FLEXCAN_IRQHandler(0U);
// Пауза, затем попытка восстановления
if (waitTicks > 0u) {
if (--waitTicks == 0u) {
vCanPort_InitCan1();
healTicks = HEAL_TICKS;
}
continue;
}
void CAN1_IRQHandler(void) {
FLEXCAN_IRQHandler(1U);
// Heal
if (healTicks > 0u) {
if (--healTicks == 0u) {
quickCount = 0u;
}
}
}
}
void CAN2_IRQHandler(void) {
FLEXCAN_IRQHandler(2U);
void Can0BusOff_Init(tCan0BusOff *env, tLoggerInterface *logger) {
env->logger = logger;
env->thread.stack = tCan0BusOff_stack;
InitThreadAtr(&env->thread.attr,"Can0BusOff",&env->thread.controlBlock,sizeof(env->thread.controlBlock),env->thread.stack,tCan0BusOff_stack_size,osPriorityNormal);
env->thread.id = 0;
}
void CAN3_IRQHandler(void) {
FLEXCAN_IRQHandler(3U);
void Can1BusOff_Init(tCan1BusOff *env, tLoggerInterface *logger) {
env->logger = logger;
env->thread.stack = tCan1BusOff_stack;
InitThreadAtr(&env->thread.attr,"Can1BusOff",&env->thread.controlBlock,sizeof(env->thread.controlBlock),env->thread.stack,tCan1BusOff_stack_size,osPriorityNormal);
env->thread.id = 0;
}
void Can0BusOff_StartThread(tCan0BusOff *env) {
if (!env->thread.id) {
env->thread.id = osThreadNew((osThreadFunc_t) (Can0BusOff_Thread), (void *) (env), &env->thread.attr);
}
}
void Can1BusOff_StartThread(tCan1BusOff *env) {
if (!env->thread.id) {
env->thread.id = osThreadNew((osThreadFunc_t) (Can1BusOff_Thread), (void *) (env), &env->thread.attr);
}
}
*/

View File

@ -30,8 +30,41 @@ typedef struct {
extern tCanPorts CAN_PORTS;
typedef struct {
tLoggerInterface *logger;
struct {
osThreadId_t id;
//uint32_t stack[384];
uint32_t *stack;
StaticTask_t controlBlock;
osThreadAttr_t attr;
} thread;
} tCan0BusOff;
typedef struct {
tLoggerInterface *logger;
struct {
osThreadId_t id;
//uint32_t stack[384];
uint32_t *stack;
StaticTask_t controlBlock;
osThreadAttr_t attr;
} thread;
} tCan1BusOff;
void CanPorts_Init(tLoggerInterface *logger);
bool vCanPort_InitCan0();
bool vCanPort_InitCan1();
void Can0BusOff_Init(tCan0BusOff *env, tLoggerInterface *logger);
void Can1BusOff_Init(tCan1BusOff *env, tLoggerInterface *logger);
void Can0BusOff_StartThread(tCan0BusOff *env);
void Can1BusOff_StartThread(tCan1BusOff *env);
#endif //SMART_COMPONENTS_CANPORTS_H

View File

@ -26,3 +26,6 @@ uint32_t tModelTask_stack[1024];
uint32_t __attribute__((section(".stack_data"))) tLoggerToSerialPort_stack[384];
uint32_t __attribute__((section(".stack_data"))) tVarsTabDumpObserver_stack[384];
uint32_t __attribute__((section(".stack_data"))) tCan0BusOff_stack[384];
uint32_t __attribute__((section(".stack_data"))) tCan1BusOff_stack[384];

View File

@ -33,6 +33,9 @@ extern uint32_t tModelTask_stack[1024];
extern uint32_t __attribute__((section(".stack_data"))) tLoggerToSerialPort_stack[384];
extern uint32_t __attribute__((section(".stack_data"))) tVarsTabDumpObserver_stack[384];
extern uint32_t __attribute__((section(".stack_data"))) tCan0BusOff_stack[384];
extern uint32_t __attribute__((section(".stack_data"))) tCan1BusOff_stack[384];
#define tCanSpamDebugReceiver_stack_size sizeof(tCanSpamDebugReceiver_stack)
@ -56,5 +59,7 @@ extern uint32_t __attribute__((section(".stack_data"))) tVarsTabDumpObserver_sta
#define tLoggerToSerialPort_stack_size sizeof(tLoggerToSerialPort_stack)
#define tVarsTabDumpObserver_stack_size sizeof(tVarsTabDumpObserver_stack)
#define tCan0BusOff_stack_size sizeof(tCan0BusOff_stack)
#define tCan1BusOff_stack_size sizeof(tCan1BusOff_stack)
#endif //HVAC_M7_MAINSTACK_H

View File

@ -614,6 +614,7 @@ void InitWakeupModel(tModelTask *env) {
lfs_file_t file;
volatile bool is_Global_T15 = false;
static _Noreturn void ModelTask_Thread(tModelTask *env) {
@ -688,7 +689,12 @@ 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;
bool isT15 = rtDW.CCUCAN_BCM_VEH_STATE_model.BCM_T15_Stat;
if (rtDW.CCUCAN_BCM_VEH_STATE_model.BCM_T15_Stat) {
is_Global_T15 = true;
} else {
is_Global_T15 = false;
}
//конец--------------------------------------------------ВХОД МОДЕЛИ CAN------------------------------------------------
//начало-------------------------------------------------ВХОД МОДЕЛИ SlEEP----------------------------------------------
@ -888,7 +894,7 @@ static _Noreturn void ModelTask_Thread(tModelTask *env) {
//конец--------------------------------------------------ВЫХОД МОДЕЛИ ДЛЯ PWM-------------------------------------------
//начало-------------------------------------------------ВЫХОД МОДЕЛИ ДЛЯ SlEEP-----------------------------------------
if (isT15) {
if (is_Global_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));
@ -906,7 +912,7 @@ static _Noreturn void ModelTask_Thread(tModelTask *env) {
//==============================================DTC===============================================================================================
//==============================================DTC===============================================================================================
set_Dtc_state(env->diagnostic, isT15, PBATT_CHECK_16, &env->ccu_candb_tx.CCU_Errors, env->dtc_state_error,
set_Dtc_state(env->diagnostic, is_Global_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);

View File

@ -355,8 +355,9 @@ setErrorDTC_CAN_VIN(uint8_t *dtc_state_error_model, ccu_candb_error_missing_rx_t
}
extern volatile bool isCan0BusOff;
extern volatile uint32_t timeCan0BusOff;
extern volatile bool dtcCan0BusOffActive; // активен ли bus-off для DTC
extern volatile uint32_t dtcCan0BusOffDeadline; // когда снять FAILED
volatile bool isSendingCAN = 0;
@ -382,22 +383,22 @@ setErrorDTC_CAN(tDiagnostic *env, bool isT15, uint16_t P_BATT, uint8_t *dtc_stat
return;
}
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));
}
env->tDiagStart = SystemGetMs() + TDiagStart;
return;
}
if (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;
} else {
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(dtc_state_error_model, CAN_ERROR_MISSING, VIN, CCU_Errors);