tasks_shared.c

Go to the documentation of this file.

 
// Standard Library Includes
#include <stdbool.h>
#include <stdint.h>
 
// Framework Includes
#include <define_error_criticality.h>
#include <define_error_flags.h>
#include <define_error_ids.h>
#include <error_handler.h>
#include <error_handler_config.h>
#include <midware_watchdog_manager.h>
#include <midware_watchdog_manager_diag.h>
#include <tasks_config.h>
#include <tasks_shared.h>
#include <tasks_shared_private.h>
 
// Private function prototypes
 
/*
 * The following functions are designed to optimize memory and execution time usage by leveraging
 * static configuration and elimination of dead code at compile-time: the checker code for each
 * channel is only compiled if the corresponding Error ID is configured to 'NOTIFICATION'
 * criticality. It is assumed that in most applications, few or no channels are set to
 * 'NOTIFICATION', resulting in significant potential savings in both hex file size and execution
 * time with higher optimization levels.
 */
static void HandleClockNotificationErrors(void);
static void HandleCpuNotificationErrors(void);
static void HandleMemoryNotificationErrors(void);
static void HandlePowerNotificationErrors(void);
static void HandleWatchdogNotificationErrors(void);
static void HandleEvsysNotificationErrors(void);
 
void T_HandleNotificationErrors(void)
{
    /*
     * For each Error Controller channel configured with 'NOTIFICATION' criticality, clear the error
     * source and channel if set, then report to the Error Handler.
     */
    HandleClockNotificationErrors();
    HandleCpuNotificationErrors();
    HandleMemoryNotificationErrors();
    HandlePowerNotificationErrors();
    HandleWatchdogNotificationErrors();
    HandleEvsysNotificationErrors();
 
    // Go through each error in the notification error log and call the configured callback
    EH_ProcessNotificationLog();
}
 
static void HandleClockNotificationErrors(void)
{
    if (errorIdCritLut[ERRID_CFD0_CH] == NOTIFICATION)
    {
        ReportClearCfd0ChannelError();
    }
 
    if (errorIdCritLut[ERRID_CFD1_CH] == NOTIFICATION)
    {
        ReportClearCfd1ChannelError();
    }
 
    if (errorIdCritLut[ERRID_CFM0_CH] == NOTIFICATION)
    {
        ReportClearCfm0ChannelError();
    }
 
    if (errorIdCritLut[ERRID_CFM1_CH] == NOTIFICATION)
    {
        ReportClearCfm1ChannelError();
    }
}
 
static void HandleCpuNotificationErrors(void)
{
    if (errorIdCritLut[ERRID_BUSERR_CH] == NOTIFICATION)
    {
        ReportClearBuserrChannelError();
    }
 
    if (errorIdCritLut[ERRID_OPC_CH] == NOTIFICATION)
    {
        ReportClearOpcChannelError();
    }
 
    if (errorIdCritLut[ERRID_SPLIM_CH] == NOTIFICATION)
    {
        ReportClearSplimChannelError();
    }
}
 
static void HandleMemoryNotificationErrors(void)
{
 
    if (errorIdCritLut[ERRID_RAM2_CH] == NOTIFICATION)
    {
        ReportClearRam2ChannelError();
    }
 
    if (errorIdCritLut[ERRID_FLASH2_CH] == NOTIFICATION)
    {
        ReportClearFlash2ChannelError();
    }
 
    if (errorIdCritLut[ERRID_RAM1_CH] == NOTIFICATION)
    {
        ReportClearRam1ChannelError();
    }
 
    if (errorIdCritLut[ERRID_FLASH1_CH] == NOTIFICATION)
    {
        ReportClearFlash1ChannelError();
    }
 
    if (errorIdCritLut[ERRID_EEPROM_CH] == NOTIFICATION)
    {
        ReportClearEepromChannelError();
    }
}
 
static void HandlePowerNotificationErrors(void)
{
    if (errorIdCritLut[ERRID_VREGFAIL_CH] == NOTIFICATION)
    {
        ReportClearVregfailChannelError();
    }
 
    if (errorIdCritLut[ERRID_VREGWARN_CH] == NOTIFICATION)
    {
        ReportClearVregwarnChannelError();
    }
}
 
static void HandleWatchdogNotificationErrors(void)
{
    if (errorIdCritLut[ERRID_SWDT_CH] == NOTIFICATION)
    {
        ReportClearSwdtChannelError();
    }
}
 
static void HandleEvsysNotificationErrors(void)
{
    if (errorIdCritLut[ERRID_EVSYS0_CH] == NOTIFICATION)
    {
        ReportClearEvsys0ChannelError();
    }
 
    if (errorIdCritLut[ERRID_EVSYS1_CH] == NOTIFICATION)
    {
        ReportClearEvsys1ChannelError();
    }
}
 
void T_HandleSyncWatchdog(uint32_t newTimeout)
{
    errFlag_t flag = NO_ERROR;
 
    MW_PreClearSwdt(); // Send pre-clear command
 
    // Set the closed window period equal to the new timeout value
    uint32_t newReset = newTimeout + SWDT_OPEN_WINDOW;
    if (newReset < newTimeout) // Test for overflow
    {
        flag = ERROR;
    }
    else
    {
        // Set timeout for the next SWDT period
        flag = MW_SetSwdtResetValue(newReset);
    }
    EH_HandleError(flag, ERRID_SWDT_RESET_VAL);
 
    /* Intentional misra-c2012-2.2/14.3 deviation */
    if (DIAG_PERIODIC_SWDT_COUNT == ENABLED)
    {
        // Verify that the SWDT counter is not stuck
        flag = MW_DiagSwdtCount();
        // Report potential error now to avoid waiting on exiting closed window forever
        EH_HandleError(flag, ERRID_DIAG_SWDT_COUNT);
    }
 
    // Wait until the closed window is over and send clear command within the small open window
    MW_ClearSwdt();
}
 
void T_HandleWatchdog(void)
{
    /* Intentional misra-c2012-2.2/14.3 deviation */
    if (DIAG_PERIODIC_WDT_COUNT == ENABLED)
    {
        // Ensure the WDT counter is running
        errFlag_t flag = MW_DiagWdtCountEnd(); // Assumes MW_DiagWdtCountBegin() has been called
        EH_HandleError(flag, ERRID_DIAG_WDT_COUNT);
    }
 
    MW_ClearWdt(); // Reset the Watchdog
}