Добавлена логика 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 "fc7xxx_driver_gpio.h"
#include "candb.h" #include "candb.h"
#include "candb_dbg.h" #include "candb_dbg.h"
#include "CmsisRtosThreadUtils.h"
#include "MainStack.h"
#define LOG_SIGN "INIT" #define LOG_SIGN "INIT"
#define LOGGER logger #define LOGGER logger
@ -37,16 +39,23 @@ static void DMA_TransferCompleteCallbackCan1(void) {
#else #else
volatile bool isCan0BusOff = false; // Recovery
volatile uint32_t timeCan0BusOff = 0; 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) { static void CAN0_ErrorInterrupt_CallBack(uint8_t u8CanIndex, FLEXCAN_ErrorInfoType *pErrorInfo) {
if (pErrorInfo->u32ErrorValue & FLEXCAN_ESR1_BOFFINT_MASK) { if (pErrorInfo->u32ErrorValue & FLEXCAN_ESR1_BOFFINT_MASK) {
timeCan0BusOff = SystemGetMs() + 3000;
isCan0BusOff = true; dtcCan0BusOffActive = true;
dtcCan0BusOffDeadline = SystemGetMs() + 3000u;
FLEXCAN_Stop(u8CanIndex); FLEXCAN_Stop(u8CanIndex);
vCanPort_InitCan0(); vCanPort_InitCan0();
isCan0BusOff = true;
} }
FLEXCAN_ClrErrorInfo(u8CanIndex, pErrorInfo); 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) { static void CAN1_ErrorInterrupt_CallBack(uint8_t u8CanIndex, FLEXCAN_ErrorInfoType *pErrorInfo) {
if (pErrorInfo->u32ErrorValue & FLEXCAN_ESR1_BOFFINT_MASK) { if (pErrorInfo->u32ErrorValue & FLEXCAN_ESR1_BOFFINT_MASK) {
FLEXCAN_Stop(u8CanIndex); FLEXCAN_Stop(u8CanIndex);
vCanPort_InitCan1(); vCanPort_InitCan1();
isCan0BusOff = true;
} }
FLEXCAN_ClrErrorInfo(u8CanIndex, pErrorInfo); FLEXCAN_ClrErrorInfo(u8CanIndex, pErrorInfo);
@ -495,378 +506,147 @@ void CAN3_IRQHandler(void) {
FLEXCAN_IRQHandler(3U); FLEXCAN_IRQHandler(3U);
} }
// ---- Тайминги (UMP-52538, Table 5-2) ------------------------------------
/* #define TBUSOFF1_TICKS 2u // 100 мс при тике 50 мс (min 50, typ 100, max 100)
#if (CAN_DMA_EN == 1) #define TBUSOFF2_TICKS 4u // 200 мс при тике 50 мс (min 200, typ 200, max 500)
#define QUICK_MAX 5u // 5 quick recovery подряд, далее slow
typedef struct { #define HEAL_TICKS 10u // heal-окно 500 мс — согласовать с NAMI
uint32_t u32CanRAM[4]; #define BUSOFF_TICK_MS 50u
} Can_RamType;
extern volatile bool is_Global_T15;
#define size_aRxDataBuf 16
ALIGN(256) Can_RamType g_aRxDataBufCan0[size_aRxDataBuf]; // dma ring buffer size is 256 static _Noreturn void Can0BusOff_Thread(tCan0BusOff *env)
ALIGN(256) Can_RamType g_aRxDataBufCan1[size_aRxDataBuf]; // dma ring buffer size is 256 {
uint8_t quickCount = 0u;
static void DMA_TransferCompleteCallbackCan0(void) { uint8_t waitTicks = 0u;
CanSerialPortFrameIrqRxProcessing(CAN_PORTS.Can0_IO.env, (uint32_t *) &g_aRxDataBufCan0[0]); uint8_t healTicks = 0u;
}
(void)env;
static void DMA_TransferCompleteCallbackCan1(void) {
CanSerialPortFrameIrqRxProcessing(CAN_PORTS.Can1_IO.env, (uint32_t *) &g_aRxDataBufCan1[0]); for (;;) {
} SystemDelayMs(BUSOFF_TICK_MS);
#else
// T15 off: полный сброс стратегии
static void CAN0_ErrorInterrupt_CallBack(uint8_t u8CanIndex, FLEXCAN_ErrorInfoType *pErrorInfo) { if (!is_Global_T15) {
FLEXCAN_ClrErrorInfo(u8CanIndex, pErrorInfo); quickCount = 0u;
PROCESS_UNUSED_VAR(u8CanIndex); waitTicks = 0u;
PROCESS_UNUSED_VAR(pErrorInfo); healTicks = 0u;
} isCan0BusOff = false;
continue;
static void CAN0_RxInterrupt_CallBack(uint8_t u8CanIndex, FLEXCAN_RxMsgType *pRxCfg) { }
CanSerialPortFrameIrqRxProcessingNO_DMA(CAN_PORTS.Can0_IO.env, pRxCfg);
} // Новое bus-off
if (isCan0BusOff) {
static void CAN0_RxFifoInterrupt_CallBack(uint8_t u8CanIndex, FLEXCAN_RxMsgType *pRxCfg) { isCan0BusOff = false;
CanSerialPortFrameIrqRxProcessingNO_DMA(CAN_PORTS.Can0_IO.env, pRxCfg); healTicks = 0u; // heal прерван
}
if (quickCount < QUICK_MAX) {
waitTicks = TBUSOFF1_TICKS; // quick: 100 мс
static void CAN1_ErrorInterrupt_CallBack(uint8_t u8CanIndex, FLEXCAN_ErrorInfoType *pErrorInfo) { quickCount++;
FLEXCAN_ClrErrorInfo(u8CanIndex, pErrorInfo); } else {
PROCESS_UNUSED_VAR(u8CanIndex); waitTicks = TBUSOFF2_TICKS; // slow: 200 мс
PROCESS_UNUSED_VAR(pErrorInfo); }
} continue;
}
static void CAN1_RxInterrupt_CallBack(uint8_t u8CanIndex, FLEXCAN_RxMsgType *pRxCfg) {
CanSerialPortFrameIrqRxProcessingNO_DMA(CAN_PORTS.Can1_IO.env, pRxCfg); // Пауза, затем попытка восстановления
} if (waitTicks > 0u) {
if (--waitTicks == 0u) {
static void CAN1_RxFifoInterrupt_CallBack(uint8_t u8CanIndex, FLEXCAN_RxMsgType *pRxCfg) { vCanPort_InitCan0();
CanSerialPortFrameIrqRxProcessingNO_DMA(CAN_PORTS.Can1_IO.env, pRxCfg); healTicks = HEAL_TICKS;
} }
continue;
#endif }
// Heal: окно прошло без нового bus-off
//static void DMA_ErrorCallback(void) { if (healTicks > 0u) {
// while (1) { if (--healTicks == 0u) {
// __asm("nop"); quickCount = 0u;
// } }
//} }
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")
} else {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Initialization CAN0 - ERROR")
} }
CAN_PORTS.Can0_IO = CanPortFrame_GetIo(&CAN_PORTS.Can0); }
CAN_PORTS.Can1.reInit = false;
result = vCanPort_InitCan1();
if (result) {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Initialization CAN1 - OK") static _Noreturn void Can1BusOff_Thread(tCan0BusOff *env)
} else { {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Initialization CAN1 - ERROR") 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 {
waitTicks = TBUSOFF2_TICKS;
}
continue;
}
// Пауза, затем попытка восстановления
if (waitTicks > 0u) {
if (--waitTicks == 0u) {
vCanPort_InitCan1();
healTicks = HEAL_TICKS;
}
continue;
}
// Heal
if (healTicks > 0u) {
if (--healTicks == 0u) {
quickCount = 0u;
}
}
} }
CAN_PORTS.Can1_IO = CanPortFrame_GetIo(&CAN_PORTS.Can1);
} }
void CAN0_IRQHandler(void) { void Can0BusOff_Init(tCan0BusOff *env, tLoggerInterface *logger) {
FLEXCAN_IRQHandler(0U); 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 CAN1_IRQHandler(void) { void Can1BusOff_Init(tCan1BusOff *env, tLoggerInterface *logger) {
FLEXCAN_IRQHandler(1U); 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 CAN2_IRQHandler(void) {
FLEXCAN_IRQHandler(2U); void Can0BusOff_StartThread(tCan0BusOff *env) {
if (!env->thread.id) {
env->thread.id = osThreadNew((osThreadFunc_t) (Can0BusOff_Thread), (void *) (env), &env->thread.attr);
}
} }
void CAN3_IRQHandler(void) { void Can1BusOff_StartThread(tCan1BusOff *env) {
FLEXCAN_IRQHandler(3U); 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; 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); void CanPorts_Init(tLoggerInterface *logger);
bool vCanPort_InitCan0(); bool vCanPort_InitCan0();
bool vCanPort_InitCan1(); 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 #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"))) tLoggerToSerialPort_stack[384];
uint32_t __attribute__((section(".stack_data"))) tVarsTabDumpObserver_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"))) tLoggerToSerialPort_stack[384];
extern uint32_t __attribute__((section(".stack_data"))) tVarsTabDumpObserver_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) #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 tLoggerToSerialPort_stack_size sizeof(tLoggerToSerialPort_stack)
#define tVarsTabDumpObserver_stack_size sizeof(tVarsTabDumpObserver_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 #endif //HVAC_M7_MAINSTACK_H

View File

@ -614,6 +614,7 @@ void InitWakeupModel(tModelTask *env) {
lfs_file_t file; lfs_file_t file;
volatile bool is_Global_T15 = false;
static _Noreturn void ModelTask_Thread(tModelTask *env) { 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; 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------------------------------------------------ //конец--------------------------------------------------ВХОД МОДЕЛИ CAN------------------------------------------------
//начало-------------------------------------------------ВХОД МОДЕЛИ SlEEP---------------------------------------------- //начало-------------------------------------------------ВХОД МОДЕЛИ SlEEP----------------------------------------------
@ -888,7 +894,7 @@ static _Noreturn void ModelTask_Thread(tModelTask *env) {
//конец--------------------------------------------------ВЫХОД МОДЕЛИ ДЛЯ PWM------------------------------------------- //конец--------------------------------------------------ВЫХОД МОДЕЛИ ДЛЯ PWM-------------------------------------------
//начало-------------------------------------------------ВЫХОД МОДЕЛИ ДЛЯ SlEEP----------------------------------------- //начало-------------------------------------------------ВЫХОД МОДЕЛИ ДЛЯ 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_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_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)); 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===============================================================================================
//==============================================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->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->LIN2_ERROR_MISSING, env->LIN3_ERROR_MISSING, env->LIN4_ERROR_MISSING,
env->LIN5_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 bool dtcCan0BusOffActive; // активен ли bus-off для DTC
extern volatile uint32_t timeCan0BusOff; extern volatile uint32_t dtcCan0BusOffDeadline; // когда снять FAILED
volatile bool isSendingCAN = 0; volatile bool isSendingCAN = 0;
@ -382,22 +383,22 @@ setErrorDTC_CAN(tDiagnostic *env, bool isT15, uint16_t P_BATT, uint8_t *dtc_stat
return; 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) { if (isT15 == false) {
env->tDiagStart = SystemGetMs() + TDiagStart; env->tDiagStart = SystemGetMs() + TDiagStart;
return; 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); setErrorDTC_CAN_VIN(dtc_state_error_model, CAN_ERROR_MISSING, VIN, CCU_Errors);