531 lines
20 KiB
C
531 lines
20 KiB
C
/*
|
|
* timeouts.c
|
|
*
|
|
* Created on: May 29, 2025
|
|
* Author: herli
|
|
*/
|
|
#include <id.h>
|
|
#include "timeouts.h"
|
|
#include "tein_detection.h"
|
|
#include "pre_injection.h"
|
|
#include "can_port.h"
|
|
#include "toothed_wheel.h"
|
|
|
|
#if HAS_PREINJECTION
|
|
#include "pre_injection.h"
|
|
static uint16_t last_PI_tick = 0;
|
|
#else
|
|
static uint16_t last_CAN_msg_1_tick = 0;
|
|
#endif
|
|
|
|
#if defined(T06301)
|
|
#include "ford_immo.h"
|
|
|
|
#endif
|
|
//#include "sync_pulse.c"
|
|
|
|
uint32_t BitStatus = 1024; //si es immo de ford tendria que empezar bloqueada.. a saber si ya funciona en el coche con tanta mierda
|
|
|
|
uint32_t HiddenTimers = 0;
|
|
|
|
static uint16_t last_CAN_msg_2_tick = 0;
|
|
|
|
static uint16_t last_Idle_event_tick = 0;
|
|
|
|
static uint16_t last_ICRPM_event_tick = 0;
|
|
static uint16_t last_CaptorCorrect_event_tick = 0;
|
|
|
|
static uint16_t last_BIP_event_tick = 0;
|
|
|
|
static uint16_t last_TurnOff_event_tick = 0;
|
|
static uint16_t last_CKPSignal_event_tick = 0;
|
|
static uint16_t last_CKPSensor_event_tick = 0;
|
|
static uint16_t last_SV_BIP_InsideTolerance_Timeout = 0;
|
|
|
|
static uint16_t last_NOTIMPLEMENTED_event_tick = 0;
|
|
static uint16_t last_BITZERO_event_tick = 0;
|
|
|
|
static uint16_t last_CAN_msg_empf_1_tick = 0;
|
|
static uint16_t last_CAN_msg_empf_2_tick = 0;
|
|
static uint16_t last_CAN_msg_empf_4_tick = 0;
|
|
static uint16_t last_CAN_msg_empf_3_boot_tick = 0;
|
|
static uint16_t last_sync_pulse_boot_tick = 0;
|
|
|
|
static uint8_t boot_em3_remaining = 0; // how many left to send after the first
|
|
static uint16_t last_boot_em3_tick = 0; // last tick for this timeout
|
|
|
|
static uint16_t last_startup_tick = 0; // last tick for this timeout
|
|
|
|
#if HAS_PREINJECTION
|
|
void Handle_PI_Timeout(void) {
|
|
// Custom action on CAN timeout
|
|
// e.g., trigger a CAN fault routine
|
|
|
|
//si no hay sigo reseteandolo
|
|
if(!active_PI){
|
|
Timeout_ResetByIndex(14, TIM16->CNT); // Reset turnoff timeout
|
|
|
|
}
|
|
|
|
//Timeout_ResetByIndexNoStatus(14, TIM16->CNT); //resetea sin poner a 0 el status
|
|
}
|
|
#else
|
|
void Handle_Can_Timeout_1(void) {
|
|
// Custom action on CAN timeout
|
|
// e.g., trigger a CAN fault routine
|
|
ME = 0.0f;
|
|
}
|
|
#endif
|
|
|
|
void Handle_Can_Timeout_2(void) {
|
|
// Custom action on CAN timeout
|
|
// e.g., trigger a CAN fault routine
|
|
ME = 0.0f;
|
|
}
|
|
void Handle_Idle_Timeout(void) {
|
|
// Custom action on CAN timeout
|
|
// e.g., trigger a CAN fault routine
|
|
|
|
}
|
|
uint8_t rpmoutCount = 0;
|
|
extern volatile uint32_t prev_Difference;
|
|
extern uint8_t hasCapturedTeeth;
|
|
void Handle_IcRPM_Timeout(void) {
|
|
// Handle RPM missing
|
|
/*rpmoutCount++; //500 / 20ms = 25
|
|
if(rpmoutCount > 24){
|
|
RPM = 0; //estas son rpm pal can, pa que no de errores de COM.
|
|
|
|
PHI_AD = 0;
|
|
}else{
|
|
//Timeout_ResetByIndex(3, TIM16->CNT); // Reset rpm timeout
|
|
Timeout_ResetByIndexNoStatus(3, TIM16->CNT); //resetea sin poner a 0 el status
|
|
}*/
|
|
RPM = 0; //estas son rpm pal can, pa que no de errores de COM.
|
|
|
|
PHI_AD = 0;
|
|
hasCapturedTeeth = 0;
|
|
prev_Difference = 0xFFFFFFFF;
|
|
INJ_END();
|
|
|
|
Timeout_StopByIndex(3); // que sapague hasta que vuelva a turular
|
|
|
|
Timeout_ResetByIndex(13, TIM16->CNT); // Reset CKP timeout
|
|
Timeout_StopByIndex(13); // Reset CKP timeout
|
|
|
|
Timeout_ResetByIndex(12, TIM16->CNT); // Reset CKP timeout
|
|
Timeout_StopByIndex(12); // Reset CKP timeout
|
|
|
|
Timeout_ResetByIndex(10, TIM16->CNT); // Reset CKP timeout
|
|
Timeout_StopByIndex(10); // Reset CKP timeout
|
|
FORCE_INJ_END();
|
|
|
|
}
|
|
void Handle_CaptorDefect_Timeout(void) {
|
|
TW_EVAL_MAX_TEETH();
|
|
Timeout_ResetByIndex(4, TIM16->CNT); // Reset turnoff timeout
|
|
}
|
|
|
|
void Handle_TurnOff_Timeout(void) {
|
|
// Handle engine off event
|
|
if(HAL_GPIO_ReadPin(SHUT_OFF_GPIO_Port, SHUT_OFF_Pin) != GPIO_PIN_RESET){ //si esta en alto
|
|
|
|
OnEnd();
|
|
//SYNC_PULSE_TIM_STOP();
|
|
//Timeout_StopByIndex(11);
|
|
//para los de ford se para el can en este msmo momento...
|
|
}else{
|
|
Timeout_ResetByIndex(11, TIM16->CNT); // Reset turnoff timeout
|
|
safetySHUTOFF = 0;
|
|
//forceDC = 0;
|
|
}
|
|
|
|
}
|
|
void Handle_BIP_Timeout(void) {
|
|
// Handle not captured BIP
|
|
TEIN_STATUS_ONFAULT();
|
|
}
|
|
void Handle_CKP_NOSIGNAL_Timeout(void) {
|
|
CKP_PULSE_AVAILABLE = 0;
|
|
}
|
|
void Handle_CKP_SENSOR_Timeout(void) {
|
|
CKP_PULSE_AVAILABLE = 0;
|
|
}
|
|
|
|
void Handle_NOTIMPLEMENTED_Timeout(void) {
|
|
// Handle not implemented
|
|
//T_ein = 950;
|
|
}
|
|
|
|
void Handle_RPM_Low_Timeout(void) {
|
|
if(RPM < CAN_RPM_SEND_ASYNC || safetySHUTOFF){
|
|
can_port_send_msg_def(&MSG_ID_EMPF1);
|
|
}
|
|
Timeout_ResetByIndex(16, TIM16->CNT); // Reset turnoff timeout
|
|
}
|
|
void Handle_EMPF2_TimeoutTick(void)
|
|
{
|
|
if(s_empf2_pending){
|
|
can_port_send_msg_def(&MSG_ID_EMPF2);
|
|
s_empf2_pending = 0;
|
|
}
|
|
Timeout_ResetByIndex(17, TIM16->CNT); // Reset turnoff timeout
|
|
}
|
|
|
|
extern uint8_t startup_finished;
|
|
extern uint8_t count;
|
|
extern uint8_t startup_count;
|
|
extern uint8_t startup_sent_count;
|
|
extern uint8_t eps_fieona_override;
|
|
extern void Fieona_SEND3_set_init(uint8_t u);
|
|
void Handle_Boot_EMPF3_Timeout(void)
|
|
{
|
|
#if defined(T06301)
|
|
if(!startup_finished) {//startup &&
|
|
Set_Timeout_Period_ByIndex(18, 400);
|
|
|
|
/* FOR THE FORD CAN IMMO*/
|
|
if(!eps_fieona_override){
|
|
Fieona_SEND3_set_init(1);
|
|
}
|
|
can_port_send_msg_def(&MSG_ID_EMPF3);
|
|
/* END FORD IMMO*/
|
|
if(startup_count){
|
|
Timeout_ResetByIndex(18, TIM16->CNT); // re-arm for another 40ms
|
|
startup_count--;
|
|
}else{
|
|
startup_finished = 1;
|
|
}
|
|
|
|
}else{
|
|
if(!eps_fieona_override){
|
|
Fieona_SEND3_set_init(0);
|
|
|
|
}
|
|
can_port_send_msg_def(&MSG_ID_EMPF3);
|
|
Timeout_StopByIndex(18); // done
|
|
}
|
|
#else
|
|
can_port_send_msg_def(&MSG_ID_EMPF3);
|
|
if(!startup_finished) {//startup &&
|
|
Set_Timeout_Period_ByIndex(18, 150);
|
|
|
|
startup_sent_count++;
|
|
Timeout_ResetByIndex(18, TIM16->CNT); // re-arm for another 40ms
|
|
|
|
}else{
|
|
Timeout_StopByIndex(18); // re-arm for another 40ms
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
void Handle_EMPF3_BootStart_Timeout(void){
|
|
#if defined(T06301)
|
|
Timeout_ResetByIndex(18, TIM16->CNT); // re-arm for another 40ms
|
|
#else
|
|
Timeout_ResetByIndex(18, TIM16->CNT); // re-arm for another 40ms
|
|
can_port_send_msg_def(&MSG_ID_EMPF1);
|
|
Timeout_ResetByIndex(16, TIM16->CNT); // re-arm for another 40ms
|
|
#endif
|
|
Timeout_StopByIndex(21); // got to stop them because overflow
|
|
|
|
}
|
|
|
|
|
|
uint8_t s_empf4_due = 0;
|
|
int counter = 0;
|
|
#if defined(T06301)
|
|
void Handle_EMPF4_TimeoutTick(void)
|
|
{
|
|
//s_empf4_due = 1;
|
|
can_port_send_msg_def(&MSG_ID_EMPF4);
|
|
uint16_t newtick = last_CAN_msg_empf_4_tick + 500;
|
|
Timeout_ResetByIndex(20, newtick); // deberia mejorarlo bastante esto, en vez de
|
|
FIEONA_advance();
|
|
}
|
|
#endif
|
|
|
|
#if defined(T06301)
|
|
static uint16_t last_immo_unlocked_tick = 0;
|
|
extern uint8_t fieona_unlocked;
|
|
extern uint8_t isCar;
|
|
void Handle_Immo_Timeout(void)
|
|
{
|
|
/*//s_empf4_due = 1;
|
|
can_port_send_msg_def(&MSG_ID_EMPF4);
|
|
uint16_t newtick = last_CAN_msg_empf_4_tick + 500;
|
|
Timeout_ResetByIndex(20, newtick); // deberia mejorarlo bastante esto, en vez de
|
|
FIEONA_advance();*/
|
|
if(fieona_unlocked){
|
|
if(isCar){
|
|
Timeout_ResetByIndex(1, TIM16->CNT);
|
|
//no xse si poner esto afuera, en el banco si que se tendria que volver a bloquear...
|
|
Timeout_SetEnabledByIndex(1,0);
|
|
}
|
|
}
|
|
|
|
Timeout_StopByIndex(1); // deberia mejorarlo bastante esto, en vez de
|
|
|
|
}
|
|
#endif
|
|
|
|
void Handle_startup_Timeout(void){
|
|
startedEngine = 1;
|
|
Timeout_ResetByIndex(0, TIM16->CNT); // Reset turnoff timeout
|
|
Timeout_StopByIndex(0);
|
|
Timeout_ResetByIndex(2, TIM16->CNT); // Reset turnoff timeout
|
|
Timeout_StopByIndex(2);
|
|
}
|
|
void Handle_BITZERO_Timeout(void){
|
|
}
|
|
#if defined(T06301)
|
|
void Handle_SYNC_Pulse_BootStart_Timeout(void){
|
|
if(FORD_SYNC_PULSE_OUT){
|
|
SYNC_PULSE_TIM_START();
|
|
}
|
|
Timeout_StartIfStopped(20, TIM16->CNT); // deberia mejorarlo bastante esto, en vez de
|
|
Timeout_ResetByIndex(16, TIM16->CNT - 50); // Reset turnoff timeout
|
|
Timeout_StopByIndex(22); // got to stop them because overflow
|
|
}
|
|
#endif
|
|
|
|
void Handle_SV_BIP_OutOfTolerance_Timeout(void) {
|
|
// Handle not implemented
|
|
//T_ein = 950;
|
|
}
|
|
/*TimeoutEntry timeout_list[] = {
|
|
{ &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 0), Handle_NOTIMPLEMENTED_Timeout, 0 }, // 10ms
|
|
{ &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 1), Handle_NOTIMPLEMENTED_Timeout, 0 }, // 10ms
|
|
|
|
{ &last_Idle_event_tick, 1000, &BitStatus, (1 << 2), Handle_Idle_Timeout, 1 }, // 100ms
|
|
{ &last_ICRPM_event_tick, 1200, &BitStatus, (1 << 3), Handle_IcRPM_Timeout, 1 }, // 20 ms //si en 20 no captura, abre can error, si en 500 sigue sin capturar, rpm = 0
|
|
{ &last_CaptorCorrect_event_tick, 30000, &BitStatus, (1 << 4), Handle_CaptorDefect_Timeout, 0 }, // 3000ms
|
|
|
|
{ &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 5), Handle_NOTIMPLEMENTED_Timeout, 0 }, // 10ms
|
|
{ &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 6), Handle_NOTIMPLEMENTED_Timeout, 0 }, // 10ms
|
|
{ &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 7), Handle_NOTIMPLEMENTED_Timeout, 0 }, // 10ms
|
|
{ &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 8), Handle_NOTIMPLEMENTED_Timeout, 0 }, // 10ms
|
|
{ &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 9), Handle_NOTIMPLEMENTED_Timeout, 0 }, // 10ms
|
|
|
|
{ &last_BIP_event_tick, 50000, &BitStatus, (1 << 10), Handle_BIP_Timeout, 0 }, // 5000 ms
|
|
{ &last_TurnOff_event_tick, 2500, &BitStatus, (1 << 11), Handle_TurnOff_Timeout, 0 }, // 250ms
|
|
|
|
{ &last_CKPSignal_event_tick, 5000, &BitStatus, (1 << 12), Handle_CKP_NOSIGNAL_Timeout, 0 }, // 10ms
|
|
{ &last_CKPSensor_event_tick, 3000, &BitStatus, (1 << 13), Handle_CKP_SENSOR_Timeout, 0 }, // 10ms, no tendrian que estar started...
|
|
|
|
#if HAS_PREINJECTION
|
|
{ &last_PI_tick, 100, &BitStatus, (1 << 14), Handle_PI_Timeout, 1 }, // 500 ms
|
|
#else
|
|
{ &last_CAN_msg_1_tick, 2500, &BitStatus, (1 << 14), Handle_Can_Timeout_1, 0 }, // 500 ms
|
|
#endif
|
|
|
|
{ &last_CAN_msg_2_tick, 2500, &BitStatus, (1 << 15), Handle_Can_Timeout_2, 0 }, // 500 ms
|
|
|
|
{ &last_CAN_msg_empf_1_tick, 600, &HiddenTimers, (1 << 0), Handle_RPM_Low_Timeout, 1}, // 500 ms
|
|
{ &last_CAN_msg_empf_2_tick, CAN_EMPF2_INSTANT ? 10 : 600, &HiddenTimers, (1 << 1), Handle_EMPF2_TimeoutTick, 0}, // 500 ms
|
|
{ &last_boot_em3_tick, 400, &HiddenTimers, (1 << 2), Handle_Boot_EMPF3_Timeout, 0 },
|
|
{ &last_startup_tick, 1000, &HiddenTimers, (1 << 3), Handle_startup_Timeout, 0 },
|
|
{ &last_CAN_msg_empf_4_tick, 500, &HiddenTimers, (1 << 4), Handle_EMPF4_TimeoutTick, 1}, // 500 ms
|
|
};*/
|
|
TimeoutEntry timeout_list[] = {
|
|
#if defined(T06301)
|
|
{ 0, &last_BITZERO_event_tick, 10, &BitStatus, (1 << 0), 0, Handle_BITZERO_Timeout, 1 }, // 10ms
|
|
{ 1, &last_immo_unlocked_tick, 10000, &BitStatus, (1 << 10), 0, Handle_Immo_Timeout, 0 }, // 1s
|
|
|
|
{ 0, &last_Idle_event_tick, 10, &BitStatus, (1 << 2), 0, Handle_Idle_Timeout, 1 }, // 100ms
|
|
{ 1, &last_ICRPM_event_tick, 1200, &HiddenTimers, (1 << 3), 0, Handle_IcRPM_Timeout, 1 }, // 20 ms //si en 20 no captura, abre can error, si en 500 sigue sin capturar, rpm = 0
|
|
{ 1, &last_CaptorCorrect_event_tick, 30000, &HiddenTimers, (1 << 4), 0, Handle_CaptorDefect_Timeout, 0 }, // 3000ms
|
|
|
|
{ 0, &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 5), 0, Handle_NOTIMPLEMENTED_Timeout, 0 }, // 10ms
|
|
{ 0, &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 6), 0, Handle_NOTIMPLEMENTED_Timeout, 0 }, // 10ms
|
|
{ 0, &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 7), 0, Handle_NOTIMPLEMENTED_Timeout, 0 }, // 100ms
|
|
{ 0, &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 8), 0, Handle_NOTIMPLEMENTED_Timeout, 0 }, // 10ms
|
|
{ 0, &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 9), 0, Handle_NOTIMPLEMENTED_Timeout, 0 }, // 10ms
|
|
|
|
{ 1, &last_BIP_event_tick, 50000, &HiddenTimers, (1 << 10), 0, Handle_BIP_Timeout, 0 }, // 5000 ms
|
|
{ 0, &last_TurnOff_event_tick, 2500, &BitStatus, (1 << 1), 0, Handle_TurnOff_Timeout, 1 }, // 250ms
|
|
|
|
{ 0, &last_CKPSignal_event_tick, 5000, &HiddenTimers, (1 << 12), 0, Handle_CKP_NOSIGNAL_Timeout, 0 }, // 10ms
|
|
{ 1, &last_CKPSensor_event_tick, 3000, &HiddenTimers, (1 << 13), 0, Handle_CKP_SENSOR_Timeout, 0 }, // 10ms, no tendrian que estar started...
|
|
|
|
#if HAS_PREINJECTION
|
|
{ 1, &last_PI_tick, 100, &BitStatus, (1 << 14), 0, Handle_PI_Timeout, 1 }, // 500 ms
|
|
#else
|
|
{ 0, &last_CAN_msg_1_tick, 2500, &HiddenTimers, (1 << 14), 0, Handle_Can_Timeout_1, 0 }, // 500 ms
|
|
#endif
|
|
|
|
{ 1, &last_CAN_msg_2_tick, 50000, &HiddenTimers, (1 << 15), 0, Handle_Can_Timeout_2, 0 }, // 500 ms
|
|
|
|
{ 1, &last_CAN_msg_empf_1_tick, 600, &HiddenTimers, (1 << 0), 0, Handle_RPM_Low_Timeout, 0}, // 500 ms
|
|
{ 1, &last_CAN_msg_empf_2_tick, CAN_EMPF2_INSTANT ? 10 : 600, &HiddenTimers, (1 << 1), 0, Handle_EMPF2_TimeoutTick, 0}, // 500 ms
|
|
{ 1, &last_boot_em3_tick, 100, &HiddenTimers, (1 << 2), 0, Handle_Boot_EMPF3_Timeout, 0 },
|
|
{ 1, &last_startup_tick, 1000, &HiddenTimers, (1 << 3), 0, Handle_startup_Timeout, 0 },
|
|
{ 1, &last_CAN_msg_empf_4_tick, 500, &HiddenTimers, (1 << 4), 0, Handle_EMPF4_TimeoutTick, 0}, // 50 ms
|
|
{ 1, &last_CAN_msg_empf_3_boot_tick, 6200, &HiddenTimers, (1 << 5), 0, Handle_EMPF3_BootStart_Timeout, 1}, // 50 ms
|
|
{ 1, &last_sync_pulse_boot_tick, 950, &HiddenTimers, (1 << 6), 0, Handle_SYNC_Pulse_BootStart_Timeout, 1}, // 50 ms
|
|
#else
|
|
|
|
{ 0, &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 0), 0, Handle_NOTIMPLEMENTED_Timeout, 0 }, // 10ms
|
|
{ 0, &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 1), 0, Handle_NOTIMPLEMENTED_Timeout, 0 }, // 10ms
|
|
|
|
{ 1, &last_Idle_event_tick, 1000, &BitStatus, (1 << 2), 0, Handle_Idle_Timeout, 1 }, // 100ms
|
|
{ 1, &last_ICRPM_event_tick, 1200, &BitStatus, (1 << 3), 0, Handle_IcRPM_Timeout, 1 }, // 20 ms //si en 20 no captura, abre can error, si en 500 sigue sin capturar, rpm = 0
|
|
{ 1, &last_CaptorCorrect_event_tick, 30000, &BitStatus, (1 << 4), 0, Handle_CaptorDefect_Timeout, 0 }, // 3000ms
|
|
|
|
{ 0, &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 5), 0, Handle_NOTIMPLEMENTED_Timeout, 0 }, // 10ms
|
|
{ 0, &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 6), 0, Handle_NOTIMPLEMENTED_Timeout, 0 }, // 10ms
|
|
{ 0, &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 7), 0, Handle_NOTIMPLEMENTED_Timeout, 0 }, // 10ms
|
|
{ 1, &last_SV_BIP_InsideTolerance_Timeout, 65534, &BitStatus, (1 << 8), 0, Handle_SV_BIP_OutOfTolerance_Timeout, 0 }, // 10ms
|
|
{ 0, &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 9), 0, Handle_NOTIMPLEMENTED_Timeout, 0 }, // 10ms
|
|
|
|
{ 1, &last_BIP_event_tick, 50000, &BitStatus, (1 << 10), 0, Handle_BIP_Timeout, 0 }, // 5000 ms
|
|
{ 1, &last_TurnOff_event_tick, 2500, &BitStatus, (1 << 11), 0, Handle_TurnOff_Timeout, 0 }, // 250ms
|
|
|
|
{ 1, &last_CKPSignal_event_tick, 5000, &BitStatus, (1 << 12), 0, Handle_CKP_NOSIGNAL_Timeout, 0 }, // 10ms
|
|
{ 1, &last_CKPSensor_event_tick, 3000, &BitStatus, (1 << 13), 0, Handle_CKP_SENSOR_Timeout, 0 }, // 10ms, no tendrian que estar started...
|
|
|
|
#if HAS_PREINJECTION
|
|
{ 1, &last_PI_tick, 100, &BitStatus, (1 << 14), 0, Handle_PI_Timeout, 1 }, // 500 ms
|
|
#else
|
|
{ 1, &last_CAN_msg_1_tick, 2500, &BitStatus, (1 << 14), 0, Handle_Can_Timeout_1, 0 }, // 500 ms
|
|
#endif
|
|
{ 1, &last_CAN_msg_2_tick, 2500, &BitStatus, (1 << 15), 0, Handle_Can_Timeout_2, 0 }, // 500 ms
|
|
{ 1, &last_CAN_msg_empf_1_tick, 600, &HiddenTimers, (1 << 0), 0, Handle_RPM_Low_Timeout, 0}, // 500 ms
|
|
{ 1, &last_CAN_msg_empf_2_tick, CAN_EMPF2_INSTANT ? 10 : 600, &HiddenTimers, (1 << 1), 0, Handle_EMPF2_TimeoutTick, 0}, // 500 ms
|
|
{ 1, &last_boot_em3_tick, 100, &HiddenTimers, (1 << 2), 0, Handle_Boot_EMPF3_Timeout, 0 },
|
|
{ 1, &last_startup_tick, 1000, &HiddenTimers, (1 << 3), 0, Handle_startup_Timeout, 0 },
|
|
{ 0, &last_NOTIMPLEMENTED_event_tick, 100, &BitStatus, (1 << 4), 0, Handle_NOTIMPLEMENTED_Timeout, 0 }, // 10ms
|
|
#if defined(T06211)
|
|
{ 1, &last_CAN_msg_empf_3_boot_tick, 3500, &HiddenTimers, (1 << 5), 0, Handle_EMPF3_BootStart_Timeout, 1}, // 50 ms
|
|
#else
|
|
{ 1, &last_CAN_msg_empf_3_boot_tick, 75, &HiddenTimers, (1 << 5), 0, Handle_EMPF3_BootStart_Timeout, 1}, // 50 ms
|
|
#endif
|
|
#endif
|
|
|
|
};
|
|
const size_t timeout_list_size = sizeof(timeout_list) / sizeof(timeout_list[0]);
|
|
|
|
uint8_t has_timed_out(uint16_t start, uint16_t duration) {
|
|
uint16_t now = TIM16->CNT;
|
|
return ((uint16_t)(now - start)) > duration;
|
|
}
|
|
|
|
void CheckTimeouts(uint16_t current_time, TimeoutEntry* timeouts) {
|
|
for (size_t i = 0; i < timeout_list_size; ++i) {
|
|
if(!timeouts[i].enabled){continue;}
|
|
if (timeouts[i].started && has_timed_out(*(timeouts[i].last_tick_ptr), timeouts[i].timeout_duration)) {
|
|
*(timeouts[i].status_bit_ptr) |= timeouts[i].bit_mask;
|
|
|
|
// Call the timeout handler if one is defined
|
|
if (timeouts[i].on_timeout != NULL) {
|
|
timeouts[i].on_timeout();
|
|
}
|
|
|
|
} else {
|
|
//*(timeouts[i].status_bit_ptr) &= ~(timeouts[i].bit_mask);
|
|
}
|
|
}
|
|
}
|
|
void Timeout_Reset(uint16_t* tick_ptr, uint16_t new_tick, uint16_t* status_ptr, uint16_t bit_mask) {
|
|
if (tick_ptr) {
|
|
*tick_ptr = new_tick;
|
|
}
|
|
if (status_ptr) {
|
|
*status_ptr &= ~bit_mask; // Clear the sticky timeout bit
|
|
//status |= BIT(n); for inverted
|
|
}
|
|
}
|
|
|
|
void Timeout_ResetByIndex(uint8_t index, uint16_t new_tick) {
|
|
if (index < timeout_list_size) {
|
|
*timeout_list[index].last_tick_ptr = new_tick;
|
|
*timeout_list[index].status_bit_ptr &= ~(timeout_list[index].bit_mask);
|
|
if (!timeout_list[index].started){
|
|
timeout_list[index].started = 1;
|
|
}
|
|
}
|
|
}
|
|
/*void Timeout_ResetByIndex_Compliant(uint8_t index) {
|
|
if (index < timeout_list_size) {
|
|
uint16_t new_tick = timeout_list[index].last_tick_ptr + timeout_list[index].timeout_duration;
|
|
*timeout_list[index].last_tick_ptr = new_tick;
|
|
*timeout_list[index].status_bit_ptr &= ~(timeout_list[index].bit_mask);
|
|
if (!timeout_list[index].started){
|
|
timeout_list[index].started = 1;
|
|
}
|
|
}
|
|
}*/
|
|
void Timeout_ResetByIndexNoStatus(uint8_t index, uint16_t new_tick) {
|
|
if (index < timeout_list_size) {
|
|
*timeout_list[index].last_tick_ptr = new_tick;
|
|
if (!timeout_list[index].started){
|
|
timeout_list[index].started = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Timeout_StopByIndex(uint8_t index){
|
|
if (index < timeout_list_size){
|
|
timeout_list[index].started = 0;
|
|
}
|
|
}
|
|
void Timeout_SetEnabledByIndex(uint8_t index,uint8_t enabled){
|
|
if (index < timeout_list_size){
|
|
timeout_list[index].enabled = enabled;
|
|
}
|
|
}
|
|
void Set_Timeout_Period_ByIndex(uint8_t index, uint16_t period){
|
|
if (index < timeout_list_size){
|
|
timeout_list[index].timeout_duration = period;
|
|
}
|
|
}
|
|
uint16_t* Timeout_GetCanTickPtr(void) {
|
|
return &last_CAN_msg_2_tick;
|
|
}
|
|
uint16_t* Timeout_GetIcRPMTickPtr(void) {
|
|
return &last_ICRPM_event_tick;
|
|
}
|
|
uint16_t* Timeout_GetTurnOffTickPtr(void) {
|
|
return &last_TurnOff_event_tick;
|
|
}
|
|
|
|
void Timeout_CheckAll(uint16_t now) {
|
|
CheckTimeouts(now, timeout_list);
|
|
}
|
|
|
|
bool Timeout_IsStarted(uint8_t index) {
|
|
if (index >= timeout_list_size) return false;
|
|
return timeout_list[index].started != 0;
|
|
}
|
|
void Timeout_StartIfStopped(uint8_t index, uint16_t now) {
|
|
if (index >= timeout_list_size) return;
|
|
if (!timeout_list[index].started) {
|
|
*timeout_list[index].last_tick_ptr = now;
|
|
timeout_list[index].started = 1;
|
|
// do NOT touch status bit here
|
|
}
|
|
}
|
|
|
|
bool Timeout_HasElapsed(uint8_t index, uint16_t now) {
|
|
if (index >= timeout_list_size) return false;
|
|
return has_timed_out(*timeout_list[index].last_tick_ptr,
|
|
timeout_list[index].timeout_duration);
|
|
}
|
|
void Timeout_PollActions(void)
|
|
{
|
|
/*if (s_empf4_due) {
|
|
s_empf4_due = 0;
|
|
|
|
// Now safe: called from "normal" context
|
|
can_port_send_msg_def(&MSG_ID_EMPF4);
|
|
FIEONA_advance();
|
|
}*/
|
|
}
|
|
|
|
/*void Timeout_Stop(uint8_t idx, uint16_t now) {
|
|
if (idx >= timeout_list_size) return;
|
|
timeout_list[idx].started = 0;
|
|
*timeout_list[idx].last_tick_ptr = now; // optional, keeps a reference point
|
|
}*/
|