Index: PersistentAlarm.c =================================================================== diff -u -r75e6d3ffab11ae6ff0521efb9c16d5698402a669 -r192c8f1aa79ad0ef4a50be44a6ba37a8939ac823 --- PersistentAlarm.c (.../PersistentAlarm.c) (revision 75e6d3ffab11ae6ff0521efb9c16d5698402a669) +++ PersistentAlarm.c (.../PersistentAlarm.c) (revision 192c8f1aa79ad0ef4a50be44a6ba37a8939ac823) @@ -8,7 +8,7 @@ * @file PersistentAlarm.c * * @author (last) Dara Navaei -* @date (last) 04-Jan-2022 +* @date (last) 22-Sep-2022 * * @author (original) Quang Nguyen * @date (original) 17-Aug-2020 @@ -26,51 +26,50 @@ // ********** 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. } 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 ********** @@ -106,16 +105,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; } } @@ -207,6 +226,36 @@ /*********************************************************************//** * @brief + * The checkPersistentAlarm function triggers/clears an alarm if an alarm condition + * has persisted/cleared over given time limit. + * @details Inputs: none + * @details Outputs: checks whether an alarm is triggered or an alarm condition is cleared + * @param alarmID ID of alarm to check + * @param isErrorOccured Flag indicates alarm condition is active or not + * @param data alarm data + * @param limit alarm condition limit + * @return TRUE if given alarm is active, FALSE if not + *************************************************************************/ +BOOL checkPersistentAlarm( ALARM_ID_T alarm, BOOL isErrorOccured, F32 data, F32 limit ) +{ + BOOL status = FALSE; + + if ( TRUE == isPersistentAlarmTriggered( alarm, isErrorOccured ) ) + { + SET_ALARM_WITH_2_F32_DATA( alarm, data, limit ); + } + + if ( TRUE == isPersistentAlarmConditionCleared( alarm, isErrorOccured ) ) + { + clearAlarmCondition( alarm ); + status = TRUE; + } + + return status; +} + +/*********************************************************************//** + * @brief * The resetPersistentAlarmTimer function resets the start time for error * condition clear start time and error start time. * @details Inputs: none @@ -220,6 +269,64 @@ 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 errorCount which is the FPGA error count of the sensor group + * @param readCount which is the FPGA read count of the sensor group + * @return none + *************************************************************************/ +void checkFPGAPersistentAlarms( FPGA_PERSISTENT_ALARMS_GROUP_T group, U32 errorCount, U32 readCount ) +{ + if ( group < NUM_OF_FPGA_SENSOR_GROUPS ) + { + FPGA_ERROR_TYPE_T type = NUM_OF_FPGA_ERROR_TYPES; + BOOL isReadPersTrgrd = isFPGAPersistentAlarmTriggered( &fpgaPersistentAlarmGroup[ group ], readCount, FPGA_READ_ERROR ); + BOOL isErroPersTrgrd = isFPGAPersistentAlarmTriggered( &fpgaPersistentAlarmGroup[ group ], errorCount, FPGA_ERROR_ERROR ); + + if ( TRUE == isReadPersTrgrd ) + { + type = FPGA_READ_ERROR; + } + + if ( TRUE == isErroPersTrgrd ) + { + type = FPGA_ERROR_ERROR; + } + + if ( ( TRUE == isReadPersTrgrd ) || ( TRUE == isErroPersTrgrd ) ) + { + 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 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; @@ -235,7 +342,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; } @@ -261,40 +374,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 - } -} - /**@}*/