Index: PersistentAlarm.c =================================================================== diff -u -r7e186bb97310fb59f525e5399ec7a74711bea571 -r59871c9964559b5137781af9c2eeed6bab18ef73 --- PersistentAlarm.c (.../PersistentAlarm.c) (revision 7e186bb97310fb59f525e5399ec7a74711bea571) +++ PersistentAlarm.c (.../PersistentAlarm.c) (revision 59871c9964559b5137781af9c2eeed6bab18ef73) @@ -1,14 +1,14 @@ /************************************************************************** * -* Copyright (c) 2020-2022 Diality Inc. - All Rights Reserved. +* Copyright (c) 2020-2024 Diality Inc. - All Rights Reserved. * * THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN * WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. * * @file PersistentAlarm.c * -* @author (last) Dara Navaei -* @date (last) 04-Jan-2022 +* @author (last) Sean Nash +* @date (last) 11-Aug-2023 * * @author (original) Quang Nguyen * @date (original) 17-Aug-2020 @@ -26,51 +26,51 @@ // ********** private definitions ********** -#define NUM_OF_FPGA_ALARMS_PER_GROUP 2 -#define FPGA_READ_ALARM_INDEX 0 -#define FPGA_ERROR_ALARM_INDEX 1 +#define NUM_OF_FPGA_ALARMS_PER_GROUP 2 ///< Number of FPGA alarms per group. +#define FPGA_READ_ALARM_INDEX 0 ///< FPGA read alarm index number. +#define FPGA_ERROR_ALARM_INDEX 1 ///< FPGA error alarm index number. /// FPGA persistent alarm types typedef enum { - FPGA_READ_ERROR = 0, - FPGA_ERROR_ERROR, - FPGA_NOT_UPDATING_ERROR, - NUM_OF_FPGA_ERROR_TYPES + FPGA_READ_ERROR = 0, ///< FPGA read error type. + FPGA_ERROR_ERROR, ///< FPGA error error type. + NUM_OF_FPGA_ERROR_TYPES ///< Number of FPGA error types. } FPGA_ERROR_TYPE_T; /// Persistent alarm structure typedef struct { - ALARM_ID_T alarm; ///< Alarm ID - U32 persistentClearPeriod; ///< Persistent count limit before clear alarm - U32 persistentTriggerPeriod; ///< Persistent count limit before trigger alarm - U32 errorClearedStartTime; ///< Error cleared start time - U32 errorOccurredStartTime; ///< Error occurred start time + ALARM_ID_T alarm; ///< Alarm ID. + U32 persistentClearPeriod; ///< Persistent count limit before clear alarm. + U32 persistentTriggerPeriod; ///< Persistent count limit before trigger alarm. + U32 errorClearedStartTime; ///< Error cleared start time. + U32 errorOccurredStartTime; ///< Error occurred start time. + BOOL alarmActive; ///< State of alarm last time alarm checked. } PERSISTENT_ALARM_DATA_T; /// FPGA persistent alarm data structure typedef struct { - U32 fpagErrorClearedStartTime; ///< FPGA error cleared start time - U32 fpgaErrorOccurredStartTime; ///< FPGA error occurred start time - U32 fpgaPreviousCount; ///< FPGA previous read count - BOOL fpgaIsConditionClear; ///< FPGA is persistent condition clear + U32 fpagErrorClearedStartTime; ///< FPGA error cleared start time. + U32 fpgaErrorOccurredStartTime; ///< FPGA error occurred start time. + U32 fpgaPreviousCount; ///< FPGA previous read count. + BOOL fpgaIsConditionClear; ///< FPGA is persistent condition clear. } FPGA_ALARM_DATA_T; /// FPGA persistent alarm structure typedef struct { - ALARM_ID_T fpgaAlarm; ///< FPGA read alarm - U32 fpgaPersistentClearPeriod; ///< FPGA persistent count limit before clear alarm - U32 fpgaPersistentTriggerPeriod; ///< FPGA persistent count limit before trigger alarm - FPGA_ALARM_DATA_T fpgaAlarmData[ NUM_OF_FPGA_ERROR_TYPES ]; + ALARM_ID_T fpgaAlarm; ///< FPGA read alarm. + U32 fpgaPersistentClearPeriod; ///< FPGA persistent count limit before clear alarm. + U32 fpgaPersistentTriggerPeriod; ///< FPGA persistent count limit before trigger alarm. + FPGA_ALARM_DATA_T fpgaAlarmData[ NUM_OF_FPGA_ERROR_TYPES ]; ///< FPGA persistent alarm data. } FPGA_PERSISTENT_ALARM_GROUP_T; // ********** private data ********** -static PERSISTENT_ALARM_DATA_T persistentAlarms[ NUM_OF_ALARM_IDS ]; ///< Array of persistent alarm structure -static FPGA_PERSISTENT_ALARM_GROUP_T fpgaPersistentAlarmGroup[ NUM_OF_FPGA_SENSOR_GROUPS ]; +static PERSISTENT_ALARM_DATA_T persistentAlarms[ NUM_OF_ALARM_IDS ]; ///< Array of persistent alarm structure. +static FPGA_PERSISTENT_ALARM_GROUP_T fpgaPersistentAlarmGroup[ NUM_OF_FPGA_SENSOR_GROUPS ]; ///< FPGA persistent alarm group. // ********** private function prototypes ********** @@ -95,6 +95,7 @@ persistentAlarms[ alarmId ].persistentTriggerPeriod = persistentTriggerPeriod; persistentAlarms[ alarmId ].errorClearedStartTime = 0U; persistentAlarms[ alarmId ].errorOccurredStartTime = 0U; + persistentAlarms[ alarmId ].alarmActive = FALSE; } else { @@ -106,16 +107,36 @@ } } +/*********************************************************************//** + * @brief + * The initFPGAPersistentAlarm function initializes the FPGA persistent alarm + * when the alarm count lower than maximum persistent alarm allowed and the FPGA + * sensor group is less than the maximum allowed sensor group. + * @details Inputs: none + * @details Outputs: fpgaPersistentAlarmGroup + * @param group which is the FPGA persistent alarm group + * @param alarmId Alarm id + * @param persistentClearPeriod Persistent period limit before clear alarm (in ms) + * @param persistentTriggerPeriod Persistent period limit before trigger alarm (in ms) + * @return none + *************************************************************************/ void initFPGAPersistentAlarm( FPGA_PERSISTENT_ALARMS_GROUP_T group, ALARM_ID_T alarmIndex, U32 persistentClearPeriod, U32 persistentTriggerPeriod ) { if ( ( group < NUM_OF_FPGA_SENSOR_GROUPS ) && ( alarmIndex < NUM_OF_ALARM_IDS ) ) { - fpgaPersistentAlarmGroup[ group ].fpgaAlarm = alarmIndex; - fpgaPersistentAlarmGroup[ group ].fpgaPersistentClearPeriod = persistentClearPeriod; - fpgaPersistentAlarmGroup[ group ].fpgaPersistentTriggerPeriod = persistentTriggerPeriod; + fpgaPersistentAlarmGroup[ group ].fpgaAlarm = alarmIndex; + fpgaPersistentAlarmGroup[ group ].fpgaPersistentClearPeriod = persistentClearPeriod; + fpgaPersistentAlarmGroup[ group ].fpgaPersistentTriggerPeriod = persistentTriggerPeriod; - memset( &fpgaPersistentAlarmGroup[ group ].fpgaAlarmData[ FPGA_READ_ALARM_INDEX ], 0x0, sizeof( FPGA_ALARM_DATA_T ) ); - memset( &fpgaPersistentAlarmGroup[ group ].fpgaAlarmData[ FPGA_ERROR_ALARM_INDEX ], 0x0, sizeof( FPGA_ALARM_DATA_T ) ); + fpgaPersistentAlarmGroup[ group ].fpgaAlarmData[ FPGA_READ_ALARM_INDEX ].fpgaIsConditionClear = TRUE; + fpgaPersistentAlarmGroup[ group ].fpgaAlarmData[ FPGA_READ_ALARM_INDEX ].fpagErrorClearedStartTime = 0; + fpgaPersistentAlarmGroup[ group ].fpgaAlarmData[ FPGA_READ_ALARM_INDEX ].fpgaErrorOccurredStartTime = 0; + fpgaPersistentAlarmGroup[ group ].fpgaAlarmData[ FPGA_READ_ALARM_INDEX ].fpgaPreviousCount = 0; + + fpgaPersistentAlarmGroup[ group ].fpgaAlarmData[ FPGA_ERROR_ALARM_INDEX ].fpgaIsConditionClear = TRUE; + fpgaPersistentAlarmGroup[ group ].fpgaAlarmData[ FPGA_ERROR_ALARM_INDEX ].fpagErrorClearedStartTime = 0; + fpgaPersistentAlarmGroup[ group ].fpgaAlarmData[ FPGA_ERROR_ALARM_INDEX ].fpgaErrorOccurredStartTime = 0; + fpgaPersistentAlarmGroup[ group ].fpgaAlarmData[ FPGA_ERROR_ALARM_INDEX ].fpgaPreviousCount = 0; } } @@ -135,6 +156,15 @@ if ( alarmId < NUM_OF_ALARM_IDS ) { + BOOL alarmIsActive = isAlarmActive( alarmId ); + + // Reset persistence if alarm was just cleared + if ( ( FALSE == alarmIsActive ) && ( TRUE == persistentAlarms[ alarmId ].alarmActive ) ) + { + persistentAlarms[ alarmId ].errorOccurredStartTime = 0; + } + persistentAlarms[ alarmId ].alarmActive = alarmIsActive; // remember latest alarm state for next time + // Update start time when error occurs for the first time if ( ( TRUE == isErrorOccurred ) && ( 0 == persistentAlarms[ alarmId ].errorOccurredStartTime ) ) { @@ -196,10 +226,11 @@ else { #ifdef _DG_ - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX, alarmId ); -#else - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX, alarmId ); + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX, alarmId ) #endif +#ifdef _HD_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX, alarmId ) +#endif } return isErrorConditionCleared; @@ -250,6 +281,85 @@ persistentAlarms[ alarmId ].errorClearedStartTime = 0; } +/*********************************************************************//** + * @brief + * The checkFPGAPersistentAlarms function checks the FPGA persistent alarm + * status of the provided FPGA persistent alarm group. + * @details Inputs: fpgaPersistentAlarmGroup + * @details Outputs: fpgaPersistentAlarmGroup + * @param alarmGroup which is the alarm group of the persistent alarm + * (i.e. 2-wire temperature sensor) + * @param readCount which is the FPGA read count of the sensor group + * @return none + *************************************************************************/ +void checkFPGAPersistentAlarms( FPGA_PERSISTENT_ALARMS_GROUP_T group, U32 readCount ) +{ + if ( group < NUM_OF_FPGA_SENSOR_GROUPS ) + { + FPGA_ERROR_TYPE_T type = FPGA_READ_ERROR; + BOOL isReadPersTrgrd = isFPGAPersistentAlarmTriggered( &fpgaPersistentAlarmGroup[ group ], readCount, type ); + + if ( TRUE == isReadPersTrgrd ) + { + SET_ALARM_WITH_2_U32_DATA( fpgaPersistentAlarmGroup[ group ].fpgaAlarm, type, group ) + } + } + else + { +#ifdef _DG_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED, (U32)group ) +#endif +#ifdef _HD_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED, (U32)group ) +#endif + } +} + +/*********************************************************************//** + * @brief + * The checkFPGAPersistentErrorCountAlarm function checks the FPGA persistent + * error count alarm status of the provided FPGA persistent alarm group. + * @details Inputs: fpgaPersistentAlarmGroup + * @details Outputs: none + * @param alarmGroup which is the alarm group of the persistent alarm + * (i.e. 2-wire temperature sensor) + * @param errorCount which is the FPGA error count of the sensor group + * @return none + *************************************************************************/ +void checkFPGAPersistentErrorCountAlarm( FPGA_PERSISTENT_ALARMS_GROUP_T group, U32 errorCount ) +{ + if ( group < NUM_OF_FPGA_SENSOR_GROUPS ) + { + BOOL isErrorPersTrgrd = isFPGAPersistentAlarmTriggered( &fpgaPersistentAlarmGroup[ group ], errorCount, FPGA_ERROR_ERROR ); + + if ( TRUE == isErrorPersTrgrd ) + { + SET_ALARM_WITH_2_U32_DATA( fpgaPersistentAlarmGroup[ group ].fpgaAlarm, FPGA_ERROR_ERROR, group ) + } + } + else + { +#ifdef _DG_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED, (U32)group ) +#endif +#ifdef _HD_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED, (U32)group ) +#endif + } +} + +/*********************************************************************//** + * @brief + * The isFPGAPersistentAlarmTriggered function checks whether persistent alarm + * has been triggered or not. + * @details Inputs: alarmGroup + * @details Outputs: alarmGroup + * @param alarmGroup which is the alarm group of the persistent alarm + * (i.e. 2-wire temperature sensor) + * @param fpgaCount which is the FPGA count of the sensor group + * @param errorType which is the FPGA error type (i.e. read or error count) + * @return TRUE if the persistent alarm is triggered otherwise, FALSE + *************************************************************************/ static BOOL isFPGAPersistentAlarmTriggered( FPGA_PERSISTENT_ALARM_GROUP_T* alarmGroup, U32 fpgaCount, FPGA_ERROR_TYPE_T errorType ) { BOOL isPersistentTriggered = FALSE; @@ -265,7 +375,13 @@ hasErrorOccured = ( alarmGroup->fpgaAlarmData[ errorType ].fpgaPreviousCount != fpgaCount ? TRUE : FALSE ); break; - case FPGA_NOT_UPDATING_ERROR: + default: +#ifdef _DG_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_FPGA_ERROR_GROUP_SELECTED, errorType ) +#endif +#ifdef _HD_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_FPGA_ERROR_GROUP_SELECTED, errorType ) +#endif break; } @@ -291,40 +407,4 @@ return isPersistentTriggered; } -void checkFPGAPersistentAlarms( FPGA_PERSISTENT_ALARMS_GROUP_T group, U32 errorCount, U32 readCount, U32 sensorIndex ) -{ - if ( group < NUM_OF_FPGA_SENSOR_GROUPS ) - { - FPGA_ERROR_TYPE_T type = NUM_OF_FPGA_ERROR_TYPES; - BOOL isPersistenceTrgrd = FALSE; - FPGA_ALARM_DATA_T readData = fpgaPersistentAlarmGroup[ group ].fpgaAlarmData[ FPGA_READ_ERROR ]; - FPGA_ALARM_DATA_T errorData = fpgaPersistentAlarmGroup[ group ].fpgaAlarmData[ FPGA_ERROR_ERROR ]; - - if ( ( readCount == readData.fpgaPreviousCount ) && ( errorCount == errorData.fpgaPreviousCount ) ) - { - type = FPGA_NOT_UPDATING_ERROR; - isPersistenceTrgrd = isFPGAPersistentAlarmTriggered( &fpgaPersistentAlarmGroup[ group ], readCount, FPGA_NOT_UPDATING_ERROR ); - } - else if ( readData.fpgaPreviousCount != readCount ) - { - type = FPGA_READ_ERROR; - isPersistenceTrgrd = isFPGAPersistentAlarmTriggered( &fpgaPersistentAlarmGroup[ group ], readCount, FPGA_READ_ERROR ); - } - else if ( errorData.fpgaPreviousCount != errorCount ) - { - type = FPGA_ERROR_ERROR; - isPersistenceTrgrd = isFPGAPersistentAlarmTriggered( &fpgaPersistentAlarmGroup[ group ], errorCount, FPGA_ERROR_ERROR ); - } - - if ( TRUE == isPersistenceTrgrd ) - { - SET_ALARM_WITH_2_U32_DATA( fpgaPersistentAlarmGroup[ group ].fpgaAlarm, type, sensorIndex ); - } - } - else - { - // TODO software fault - } -} - /**@}*/