tasks_scheduler.c

Go to the documentation of this file.

 
// Standard Library Includes
#include <stdbool.h>
#include <stdint.h>
 
// Framework Includes
#include <define_error_flags.h>
#include <define_error_ids.h>
#include <define_tasks_config.h>
#include <error_handler.h>
#include <midware_clock_manager_diag.h>
#include <midware_error_manager_diag.h>
#include <midware_memory_manager_diag.h>
#include <midware_power_manager_diag.h>
#include <midware_watchdog_manager_diag.h>
#include <tasks_config.h>
#include <tasks_scheduler.h>

#define DIAG_QUEUE_START 0U
 
// Private function wrapper prototype for diagnostic with input parameter
#if (DIAG_PERIODIC_SWDT_EXPIRE == ENABLED)
static errFlag_t RunDiagSwdtExpire(void);
#endif // DIAG_PERIODIC_SWDT_EXPIRE == ENABLED

typedef errFlag_t (*diagFunc_t)(void);

typedef struct
{
    diagFunc_t diagnostic;
    errId_t id;
} diagEntry_t;
 
/* cppcheck-suppress misra-c2012-8.9 */
static const diagEntry_t diagQueue[] = {
    { &MW_DiagRamParity, ERRID_DIAG_PARITY_RAM },
    { &MW_DiagNvmParity, ERRID_DIAG_PARITY_NVM },
    { &MW_DiagRamEcc, ERRID_DIAG_ECC_RAM },
    { &MW_DiagNvmFlashEcc, ERRID_DIAG_ECC_FLASH },
// Optional diagnostics are excluded compile-time depending on configuration
#if (DIAG_PERIODIC_CFM0 == ENABLED)
    { &MW_DiagClockCfm0, ERRID_DIAG_CFM0 },
#endif
#if (DIAG_PERIODIC_CFM1 == ENABLED)
    { &MW_DiagClockCfm1, ERRID_DIAG_CFM1 },
#endif
#if (DIAG_PERIODIC_CFD0 == ENABLED)
    { &MW_DiagClockCfd0Begin, ERRID_DIAG_CFD0 },
#endif
#if (DIAG_PERIODIC_VMON == ENABLED)
    { &MW_DiagVmonOverBegin, ERRID_DIAG_VMON_OVER },
#endif
#if (DIAG_PERIODIC_ECC_EEPROM == ENABLED)
    { &MW_DiagNvmEepromEcc, ERRID_DIAG_ECC_EEPROM },
#endif
#if (DIAG_PERIODIC_SWDT_EXPIRE == ENABLED)
    // Calls a static function since the diagnostic has an input parameter
    { &RunDiagSwdtExpire, ERRID_DIAG_SWDT_EXPIRE },
#endif
#if (DIAG_PERIODIC_ERRCH_SPLIM == ENABLED)
    { &MW_DiagErrorChannelSplim, ERRID_DIAG_ERRCH_SPLIM },
#endif
#if (DIAG_PERIODIC_ERRCH_CFD0 == ENABLED)
    { &MW_DiagErrorChannelCfd0, ERRID_DIAG_ERRCH_CFD0 },
#endif
#if (DIAG_PERIODIC_ERRCH_CFM0 == ENABLED)
    { &MW_DiagErrorChannelCfm0, ERRID_DIAG_ERRCH_CFM0 },
#endif
#if (DIAG_PERIODIC_ERRCH_CFD1 == ENABLED)
    { &MW_DiagErrorChannelCfd1, ERRID_DIAG_ERRCH_CFD1 },
#endif
#if (DIAG_PERIODIC_ERRCH_CFM1 == ENABLED)
    { &MW_DiagErrorChannelCfm1, ERRID_DIAG_ERRCH_CFM1 },
#endif
#if (DIAG_PERIODIC_ERRCH_EEPROM == ENABLED)
    { &MW_DiagErrorChannelEeprom, ERRID_DIAG_ERRCH_EEPROM },
#endif
#if (DIAG_PERIODIC_ERRCH_EVSYS0 == ENABLED)
    { &MW_DiagErrorChannelEvsys0, ERRID_DIAG_ERRCH_EVSYS0 },
#endif
#if (DIAG_PERIODIC_ERRCH_EVSYS1 == ENABLED)
    { &MW_DiagErrorChannelEvsys1, ERRID_DIAG_ERRCH_EVSYS1 },
#endif
#if (DIAG_PERIODIC_CFD1 == ENABLED)
    { &MW_DiagClockCfd1Begin, ERRID_DIAG_CFD1 },
#endif
#if (DIAG_PERIODIC_VMON == ENABLED)
    { &MW_DiagVmonUnderBegin, ERRID_DIAG_VMON_UNDER },
#endif
};
 
void T_RunNextLatentFaultDiag(void)
{
    static uint8_t nextDiagIndex = DIAG_QUEUE_START; // Saves the state between function calls
    const uint8_t queueSize      = sizeof(diagQueue) / sizeof(diagQueue[0U]);
 
    const diagEntry_t nextDiagEntry = diagQueue[nextDiagIndex];
 
    const errFlag_t flag = nextDiagEntry.diagnostic();
    const errId_t id     = nextDiagEntry.id;
    EH_HandleError(flag, id);
 
    nextDiagIndex++;
    if (nextDiagIndex >= queueSize)
    {
        nextDiagIndex = DIAG_QUEUE_START; // Wrap around to the beginning of the queue
    }
}
 
void T_InitiateIdleSleep(void)
{
    return; // TODO: Implement Initiate Idle Sleep API
}
 
// Wrapper for the diagnostic function to allow scheduling despite requiring an input parameter
#if (DIAG_PERIODIC_SWDT_EXPIRE == ENABLED)
static errFlag_t RunDiagSwdtExpire(void)
{
    // Force the SWDT to expire and restart it with a new configured timeout duration
    errFlag_t flag = MW_DiagSwdtExpire(DIAG_PERIODIC_SWDT_RESET_VAL);
    return flag;
}
#endif // DIAG_PERIODIC_SWDT_EXPIRE == ENABLED