tasks_interrupts.c

Go to the documentation of this file.

 
// Standard Library Includes
#include <stdbool.h>
 
// Framework Includes
#include <define_error_flags.h>
#include <define_error_ids.h>
#include <define_tasks_config.h>
#include <error_handler.h>
#include <midware_checksum_manager.h>
#include <midware_clock_manager.h>
#include <midware_error_manager.h>
#include <midware_memory_manager.h>
#include <midware_power_manager.h>
#include <midware_power_manager_diag.h>
#include <midware_watchdog_manager.h>
#include <tasks_config.h>
#include <tasks_interrupts.h>
 
// Private function prototypes
static void ReportEndOvervoltageDiag(void);
static void ReportEndUndervoltageDiag(void);
static void ReportClearVregfailErrors(void);
static void ReportClearVregwarnErrors(void);
static errCh_t FindSetErrorChannel(void);
static void HandleErrorChVregfail(void);
static void HandleErrorChBuserr(void);
static void HandleErrorChRam2(void);
static void HandleErrorChFlash2(void);
static void HandleErrorChOpc(void);
static void HandleErrorChSplim(void);
static void HandleErrorChRam1(void);
static void HandleErrorChFlash1(void);
static void HandleErrorChVregwarn(void);
static void HandleErrorChCdf0(void);
static void HandleErrorChCfd1(void);
static void HandleErrorChCfm0(void);
static void HandleErrorChCfm1(void);
static void HandleErrorChSwdt(void);
static void HandleErrorChEeprom(void);
static void HandleErrorChEvsys0(void);
static void HandleErrorChEvsys1(void);
 
void T_HandleNmiInterrupt(void)
{
    errFlag_t busFlag   = NO_ERROR;
    errFlag_t splimFlag = NO_ERROR;
    errFlag_t opcFlag   = NO_ERROR;
    busFlag = MW_GetClearBusError();
    EH_HandleError(busFlag, ERRID_BUSERR_BUSERR);
    const bool notBusError = (busFlag == NO_ERROR);
 
    splimFlag = MW_GetClearRamStackError();
    EH_HandleError(splimFlag, ERRID_SPLIM_CH); // Report channel ID when channel only has one source
    const bool notSplimError = (splimFlag == NO_ERROR);
 
    opcFlag = MW_GetClearCpuOpcodeError();
    EH_HandleError(opcFlag, ERRID_OPC_OPC);
    const bool notOpcError = (opcFlag == NO_ERROR);
 
    const bool unkownErrorSource = (notBusError && notSplimError && notOpcError);
    if (unkownErrorSource)
    {
        EH_HandleError(ERROR, ERRID_NMI_UNKNOWN);
    }
 
    // Report one last error in case none of the former reports resulted in a device reset
    EH_HandleError(ERROR, ERRID_NMI);
 
    /*
     * An NMI should always lead to a device reset. If the Error IDs have been configured to their
     * correct criticality, the device should already have transitioned into a Safe State before
     * reaching this point. However, as a safety mechanism, the function will halt further execution
     * and wait for one of the device timeout mechanisms to trigger a device reset.
     */
    while (FOREVER)
    {
    }
}
 
void T_HandleBodInterrupt(void)
{
    errFlag_t flag = MW_GetClearVlmError();
 
    EH_HandleError(flag, ERRID_BOD_VLM);
}
 
void T_HandleClockInterrupt(void)
{
    errFlag_t flag = NO_ERROR;
 
    // The CFM Done flags are cleared without further action
    MW_ClearClockCfmDoneFlags();
 
    flag = MW_GetClearClockCfd0Error();
    EH_HandleError(flag, ERRID_CFD0_CH);
 
    flag = MW_GetClearClockCfd1Error();
    EH_HandleError(flag, ERRID_CFD1_CH);
 
    flag = MW_GetClearClockCfm0Error();
    EH_HandleError(flag, ERRID_CFM0_CH);
 
    flag = MW_GetClearClockCfm1Error();
    EH_HandleError(flag, ERRID_CFM1_CH);
 
    /*
     * To prevent double reporting of errors, the error channel connected to the source must be
     * cleared. It is assumed that all sources are correctly cleared in this function and clearing
     * the channel will succeed. For this reason, the returned error flag is always discarded.
     * However, should the clearing fail due to a hardware fault, the redundant error channel
     * interrupt handler or the notification error handler Task will report this error.
     */
    (void)MW_ClearErrorChannel(ERRCH_CFD0); // CFD0 error source
    (void)MW_ClearErrorChannel(ERRCH_CFD1); // CFD1 error source
    (void)MW_ClearErrorChannel(ERRCH_CFM0); // CFM0 error source
    (void)MW_ClearErrorChannel(ERRCH_CFM1); // CFM1 error source
}
 
void T_HandlePowerInterrupt(void)
{
    // Only compile diagnostic code if VMON diagnostics are enabled
#if (DIAG_PERIODIC_VMON == ENABLED)
    if (MW_IsDiagVmonOverDone()) // Check if diagnostic completion caused the interrupt
    {
        ReportEndOvervoltageDiag();
        /* cppcheck-suppress misra-c2012-15.5 */
        return; // True error flag interrupts are handled by calling the function again
    }
 
    if (MW_IsDiagVmonUnderDone()) // Check if diagnostic completion caused the interrupt
    {
        ReportEndUndervoltageDiag();
        /* cppcheck-suppress misra-c2012-15.5 */
        return; // True error flag interrupts are handled by calling the function again
    }
#endif // DIAG_PERIODIC_VMON == ENABLED
 
    ReportClearVregfailErrors();
    ReportClearVregwarnErrors();
 
    /*
     * To prevent double reporting of errors, the error channel connected to the source must be
     * cleared. It is assumed that all sources are correctly cleared in this function and clearing
     * the channel will succeed. For this reason, the returned error flag is always discarded.
     * However, should the clearing fail due to a hardware fault, the redundant error channel
     * interrupt handler or the notification error handler Task will report this error.
     */
    (void)MW_ClearErrorChannel(ERRCH_VREGFAIL); // VOV and VUV sources
    (void)MW_ClearErrorChannel(ERRCH_VREGWARN); // VDENTER, VDEXIT, VERR, VSLP, VDIS, SERR sources
}
 
void T_HandleSwdtInterrupt(void)
{
    errFlag_t flag = NO_ERROR;
 
    // Check each interrupt source and handle the error
    flag = MW_GetSwdtPreclearError();
    EH_HandleError(flag, ERRID_SWDT_BADPC);
 
    flag = MW_GetSwdtClearError();
    EH_HandleError(flag, ERRID_SWDT_BADC);
 
    flag = MW_GetSwdtUnexpectedCmdError();
    EH_HandleError(flag, ERRID_SWDT_UC);
 
    flag = MW_GetSwdtCounterExpiredError();
    EH_HandleError(flag, ERRID_SWDT_EXP);
 
    MW_ClearSwdtErrors(); // The error flags cannot be cleared individually in hardware
 
    /*
     * To prevent double reporting of errors, the error channel connected to the source must be
     * cleared. It is assumed that all sources are correctly cleared in this function and clearing
     * the channel will succeed. For this reason, the returned error flag is always discarded.
     * However, should the clearing fail due to a hardware fault, the redundant error channel
     * interrupt handler or the notification error handler Task will report this error.
     */
    (void)MW_ClearErrorChannel(ERRCH_SWDT);
}
 
void T_HandleNvmInterrupt(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_GetClearNvmFlashEcc1Error();
    EH_HandleError(flag, ERRID_FLASH1_CH);
 
    flag = MW_GetClearNvmFlashEcc2Error();
    EH_HandleError(flag, ERRID_FLASH2_ECC2);
 
    flag = MW_GetClearNvmEepromEcc1Error();
    EH_HandleError(flag, ERRID_EEPROM_ECC1);
 
    flag = MW_GetClearNvmEepromEcc2Error();
    EH_HandleError(flag, ERRID_EEPROM_ECC2);
 
    flag = MW_GetClearNvmEccCompError();
    EH_HandleError(flag, ERRID_FLASH2_COMP);
 
    flag = MW_GetClearNvmParityError();
    EH_HandleError(flag, ERRID_NVM_PARITY);
 
    /*
     * To prevent double reporting of errors, the error channel connected to the source must be
     * cleared. It is assumed that all sources are correctly cleared in this function and clearing
     * the channel will succeed. For this reason, the returned error flag is always discarded.
     * However, should the clearing fail due to a hardware fault, the redundant error channel
     * interrupt handler or the notification error handler Task will report this error.
     */
    (void)MW_ClearErrorChannel(ERRCH_FLASH1); // Flash ECC1 error source
    (void)MW_ClearErrorChannel(ERRCH_FLASH2); // Flash ECC2 and COMP error sources
    (void)MW_ClearErrorChannel(ERRCH_EEPROM); // EEPROM ECC1 and ECC2 error sources
}
 
void T_HandleRamInterrupt(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_GetClearRamEcc1Error();
    EH_HandleError(flag, ERRID_RAM1_CH); // Report channel ID due to singular source
 
    flag = MW_GetClearRamEcc2Error();
    EH_HandleError(flag, ERRID_RAM2_ECC2);
 
    flag = MW_GetClearRamEccCompError();
    EH_HandleError(flag, ERRID_RAM2_COMP);
 
    flag = MW_GetClearRamParityError();
    EH_HandleError(flag, ERRID_RAM_PARITY);
 
    /*
     * To prevent double reporting of errors, the error channel connected to the source must be
     * cleared. It is assumed that all sources are correctly cleared in this function and clearing
     * the channel will succeed. For this reason, the returned error flag is always discarded.
     * However, should the clearing fail due to a hardware fault, the redundant error channel
     * interrupt handler or the notification error handler Task will report this error.
     */
    (void)MW_ClearErrorChannel(ERRCH_RAM1); // RAM ECC1 error source
    (void)MW_ClearErrorChannel(ERRCH_RAM2); // RAM ECC2 and COMP error sources
}
 
void T_HandleCrcInterrupt(void)
{
    // Assumes no further action is required after clearing the PERIOD bit
    MW_ClearCrcPeriodInterrupt();
 
    // If the CRCSCAN is done, check whether an error was detected
    errFlag_t flag = MW_GetClearCrcDoneError();
    EH_HandleError(flag, ERRID_CRC_FLASH);
}
 
void T_HandleBadInterrupt(void)
{
    // Always report interrupt requests without an ISR as an error
    EH_HandleError(ERROR, ERRID_BAD_IRQ);
}
 
void T_HandleErrorChInterrupt(void)
{
    // Lookup table for quickly facilitating which private function to call for which channel
    static void (*channelHandler[ERRCH_MAX])(void)
        = { [ERRCH_VREGFAIL] = &HandleErrorChVregfail, [ERRCH_BUSERR] = &HandleErrorChBuserr,
            [ERRCH_RAM2] = &HandleErrorChRam2,         [ERRCH_FLASH2] = &HandleErrorChFlash2,
            [ERRCH_OPC] = &HandleErrorChOpc,           [ERRCH_SPLIM] = &HandleErrorChSplim,
            [ERRCH_RAM1] = &HandleErrorChRam1,         [ERRCH_FLASH1] = &HandleErrorChFlash1,
            [ERRCH_VREGWARN] = &HandleErrorChVregwarn, [ERRCH_CFD0] = &HandleErrorChCdf0,
            [ERRCH_CFD1] = &HandleErrorChCfd1,         [ERRCH_CFM0] = &HandleErrorChCfm0,
            [ERRCH_CFM1] = &HandleErrorChCfm1,         [ERRCH_SWDT] = &HandleErrorChSwdt,
            [ERRCH_EEPROM] = &HandleErrorChEeprom,     [ERRCH_EVSYS0] = &HandleErrorChEvsys0,
            [ERRCH_EVSYS1] = &HandleErrorChEvsys1 };
 
    /*
     * Returns the first set error channel, starting from the lowest numbered channel in the errCh_t
     * enum. This may handle channels set to NOTIFICATION before those set to NON_CRITICAL,
     * requiring multiple executions to clear the interrupt source. In practice, simultaneously set
     * error channels are rare, and higher priority channels are placed in lower enum values.
     */
    const errCh_t setChannel = FindSetErrorChannel();
 
    // Call channel specific handler or skip if no channel is set
    if (setChannel < ERRCH_MAX)
    {
        // Check and report all error channel sources before clearing it
        void (*setChannelHandler)(void) = channelHandler[setChannel];
        setChannelHandler();
    }
}
 
// Completes the VMON Overvoltage diagnostic and reports the result
static void ReportEndOvervoltageDiag(void)
{
    errFlag_t flag = MW_DiagVmonOverEnd(); // Read the result of the diag
    EH_HandleError(flag, ERRID_DIAG_VMON_OVER);
}
 
// Completes the VMON Undervoltage diagnostic and reports the result
static void ReportEndUndervoltageDiag(void)
{
    errFlag_t flag = MW_DiagVmonUnderEnd(); // Read the result of the diag
    EH_HandleError(flag, ERRID_DIAG_VMON_UNDER);
}
 
// Checks, clears and reports all SLPCTRL error flags connected to the VREGFAIL error channel
static void ReportClearVregfailErrors(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_GetClearVmonOverError();
    EH_HandleError(flag, ERRID_VREGFAIL_VOV);
 
    flag = MW_GetClearVmonUnderError();
    EH_HandleError(flag, ERRID_VREGFAIL_VUV);
}
 
// Checks, clears and reports all SLPCTRL error flags connected to the VREGWARN error channel
static void ReportClearVregwarnErrors(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_GetClearVmonDiagEntryError();
    EH_HandleError(flag, ERRID_VREGWARN_VDENTER);
 
    flag = MW_GetClearVmonDiagExitError();
    EH_HandleError(flag, ERRID_VREGWARN_VDEXIT);
 
    flag = MW_GetClearVmonInternalError();
    EH_HandleError(flag, ERRID_VREGWARN_VERR);
 
    flag = MW_GetClearVmonSleepEntryError();
    EH_HandleError(flag, ERRID_VREGWARN_VSLP);
 
    flag = MW_GetClearVmonDisabledError();
    EH_HandleError(flag, ERRID_VREGWARN_VDIS);
 
    flag = MW_GetClearSleepError();
    EH_HandleError(flag, ERRID_VREGWARN_SERR);
}
 
// Returns the first channel with an error, or ERRCH_MAX if none is found
static errCh_t FindSetErrorChannel(void)
{
    errCh_t channel = ERRCH_VREGFAIL; // First channel in enum
 
    while (channel < ERRCH_MAX)
    {
        errFlag_t flag = MW_GetErrorChannel(channel);
 
        // First set channel is found, break and return
        if (flag == ERROR)
        {
            break;
        }
 
        /* Intentional misra-c2012-10.1 deviation */
        channel++;
    }
 
    return channel;
}
 
// Checks, clears and reports error sources and clears error channel
static void HandleErrorChVregfail(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_GetClearVmonOverError();
    EH_HandleError(flag, ERRID_VREGFAIL_VOV);
 
    flag = MW_GetClearVmonUnderError();
    EH_HandleError(flag, ERRID_VREGFAIL_VUV);
 
    // The channel can only be cleared after all error sources are cleared
    flag = MW_ClearErrorChannel(ERRCH_VREGFAIL);
    EH_HandleError(flag, ERRID_VREGFAIL_CH); // In case the channel was not cleared
}
 
// Checks, clears and reports error sources and clears error channel
static void HandleErrorChBuserr(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_GetClearBusError();
    EH_HandleError(flag, ERRID_BUSERR_BUSERR);
 
    // Check and report if the bus error was due to a RAM or NVM bus parity error
    if (flag == ERROR)
    {
        flag = MW_GetClearRamParityError();
        EH_HandleError(flag, ERRID_RAM_PARITY);
 
        flag = MW_GetClearNvmParityError();
        EH_HandleError(flag, ERRID_NVM_PARITY);
    }
 
    flag = MW_GetClearCpuDataParityError();
    EH_HandleError(flag, ERRID_BUSERR_PARITYD);
 
    // The channel can only be cleared after all error sources are cleared
    flag = MW_ClearErrorChannel(ERRCH_BUSERR);
    EH_HandleError(flag, ERRID_BUSERR_CH); // In case the channel was not cleared
}
 
// Checks, clears and reports error sources and clears error channel
static void HandleErrorChRam2(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_GetClearRamEcc2Error();
    EH_HandleError(flag, ERRID_RAM2_ECC2);
 
    flag = MW_GetClearRamEccCompError();
    EH_HandleError(flag, ERRID_RAM2_COMP);
 
    // The channel can only be cleared after all error sources are cleared
    flag = MW_ClearErrorChannel(ERRCH_RAM2);
    EH_HandleError(flag, ERRID_RAM2_CH); // In case the channel was not cleared
}
 
// Checks, clears and reports error sources and clears error channel
static void HandleErrorChFlash2(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_GetClearNvmFlashEcc2Error();
    EH_HandleError(flag, ERRID_FLASH2_ECC2);
 
    flag = MW_GetClearNvmEccCompError();
    EH_HandleError(flag, ERRID_FLASH2_COMP);
 
    // The channel can only be cleared after all error sources are cleared
    flag = MW_ClearErrorChannel(ERRCH_FLASH2);
    EH_HandleError(flag, ERRID_FLASH2_CH); // In case the channel was not cleared
}
 
// Checks, clears and reports error sources and clears error channel
static void HandleErrorChOpc(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_GetClearCpuOpcodeError();
    EH_HandleError(flag, ERRID_OPC_OPC);
 
    flag = MW_GetClearCpuInstrParityError();
    EH_HandleError(flag, ERRID_OPC_PARITYI);
 
    // The channel can only be cleared after all error sources are cleared
    flag = MW_ClearErrorChannel(ERRCH_OPC);
    EH_HandleError(flag, ERRID_OPC_CH); // In case the channel was not cleared
}
 
// Checks, clears and reports error sources and clears error channel
static void HandleErrorChSplim(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_GetClearRamStackError();
    EH_HandleError(flag, ERRID_SPLIM_CH); // Report channel ID due to singular source
 
    // The channel can only be cleared after all error sources are cleared
    flag = MW_ClearErrorChannel(ERRCH_SPLIM);
    EH_HandleError(flag, ERRID_SPLIM_CH); // In case the channel was not cleared
}
 
// Checks, clears and reports error sources and clears error channel
static void HandleErrorChRam1(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_GetClearRamEcc1Error();
    EH_HandleError(flag, ERRID_RAM1_CH); // Report channel ID due to singular source
 
    // The channel can only be cleared after all error sources are cleared
    flag = MW_ClearErrorChannel(ERRCH_RAM1);
    EH_HandleError(flag, ERRID_RAM1_CH); // In case the channel was not cleared
}
 
// Checks, clears and reports error sources and clears error channel
static void HandleErrorChFlash1(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_GetClearNvmFlashEcc1Error();
    EH_HandleError(flag, ERRID_FLASH1_CH); // Report channel ID due to singular source
 
    // The channel can only be cleared after all error sources are cleared
    flag = MW_ClearErrorChannel(ERRCH_FLASH1);
    EH_HandleError(flag, ERRID_FLASH1_CH); // In case the channel was not cleared
}
 
// Checks, clears and reports error sources and clears error channel
static void HandleErrorChVregwarn(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_GetClearVmonDiagEntryError();
    EH_HandleError(flag, ERRID_VREGWARN_VDENTER);
 
    flag = MW_GetClearVmonDiagExitError();
    EH_HandleError(flag, ERRID_VREGWARN_VDEXIT);
 
    flag = MW_GetClearVmonInternalError();
    EH_HandleError(flag, ERRID_VREGWARN_VERR);
 
    flag = MW_GetClearVmonSleepEntryError();
    EH_HandleError(flag, ERRID_VREGWARN_VSLP);
 
    flag = MW_GetClearVmonDisabledError();
    EH_HandleError(flag, ERRID_VREGWARN_VDIS);
 
    flag = MW_GetClearSleepError();
    EH_HandleError(flag, ERRID_VREGWARN_SERR);
 
    // The channel can only be cleared after all error sources are cleared
    flag = MW_ClearErrorChannel(ERRCH_VREGWARN);
    EH_HandleError(flag, ERRID_VREGWARN_CH); // In case the channel was not cleared
}
 
// Checks, clears and reports error sources and clears error channel
static void HandleErrorChCdf0(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_GetClearClockCfd0Error();
    EH_HandleError(flag, ERRID_CFD0_CH); // Report channel ID due to singular source
 
    // The channel can only be cleared after all error sources are cleared
    flag = MW_ClearErrorChannel(ERRCH_CFD0);
    EH_HandleError(flag, ERRID_CFD0_CH); // In case the channel was not cleared
}
 
// Checks, clears and reports error sources and clears error channel
static void HandleErrorChCfd1(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_GetClearClockCfd1Error();
    EH_HandleError(flag, ERRID_CFD1_CH); // Report channel ID due to singular source
 
    // The channel can only be cleared after all error sources are cleared
    flag = MW_ClearErrorChannel(ERRCH_CFD1);
    EH_HandleError(flag, ERRID_CFD1_CH); // In case the channel was not cleared
}
 
// Checks, clears and reports error sources and clears error channel
static void HandleErrorChCfm0(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_GetClearClockCfm0Error();
    EH_HandleError(flag, ERRID_CFM0_CH); // Report channel ID due to singular source
 
    // The channel can only be cleared after all error sources are cleared
    flag = MW_ClearErrorChannel(ERRCH_CFM0);
    EH_HandleError(flag, ERRID_CFM0_CH); // In case the channel was not cleared
}
 
// Checks, clears and reports error sources and clears error channel
static void HandleErrorChCfm1(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_GetClearClockCfm1Error();
    EH_HandleError(flag, ERRID_CFM1_CH); // Report channel ID due to singular source
 
    // The channel can only be cleared after all error sources are cleared
    flag = MW_ClearErrorChannel(ERRCH_CFM1);
    EH_HandleError(flag, ERRID_CFM1_CH); // In case the channel was not cleared
}
 
// Checks, clears and reports error sources and clears error channel
static void HandleErrorChSwdt(void)
{
    errFlag_t flag = MW_GetSwdtPreclearError();
    EH_HandleError(flag, ERRID_SWDT_BADPC);
 
    flag = MW_GetSwdtClearError();
    EH_HandleError(flag, ERRID_SWDT_BADC);
 
    flag = MW_GetSwdtUnexpectedCmdError();
    EH_HandleError(flag, ERRID_SWDT_UC);
 
    flag = MW_GetSwdtCounterExpiredError();
    EH_HandleError(flag, ERRID_SWDT_EXP);
 
    MW_ClearSwdtErrors(); // The error flags cannot be cleared individually in hardware
 
    // The channel can only be cleared after all error sources are cleared
    flag = MW_ClearErrorChannel(ERRCH_SWDT);
    EH_HandleError(flag, ERRID_SWDT_CH); // In case the channel was not cleared
}
 
// Checks, clears and reports error sources and clears error channel
static void HandleErrorChEeprom(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_GetClearNvmEepromEcc1Error();
    EH_HandleError(flag, ERRID_EEPROM_ECC1);
 
    flag = MW_GetClearNvmEepromEcc2Error();
    EH_HandleError(flag, ERRID_EEPROM_ECC2);
 
    // The channel can only be cleared after all error sources are cleared
    flag = MW_ClearErrorChannel(ERRCH_EEPROM);
    EH_HandleError(flag, ERRID_EEPROM_CH); // In case the channel was not cleared
}
 
/*
 * Clear and report the error channel directly, without attempting to clear the source,
 * as it is unknown. When the event type is a "pulse", the source will be automatically
 * cleared unless there is an error. For a "level" event type, it is assumed that the
 * channel and the source is cleared in the error handler callback.
 */
static void HandleErrorChEvsys0(void)
{
    EH_HandleError(ERROR, ERRID_EVSYS0_CH);
    errFlag_t flag = MW_ClearErrorChannel(ERRCH_EVSYS0);
    EH_HandleError(flag, ERRID_EVSYS0_CLEAR); // In case the channel was not cleared
}
 
/*
 * Clear and report the error channel directly, without attempting to clear the source,
 * as it is unknown. When the event type is a "pulse", the source will be automatically
 * cleared unless there is an error. For a "level" event type, it is assumed that the
 * channel and the source is cleared in the error handler callback.
 */
static void HandleErrorChEvsys1(void)
{
    EH_HandleError(ERROR, ERRID_EVSYS1_CH);
    errFlag_t flag = MW_ClearErrorChannel(ERRCH_EVSYS1);
    EH_HandleError(flag, ERRID_EVSYS1_CLEAR); // In case the channel was not cleared
}