Index: PersistentAlarm.c =================================================================== diff -u -rc9b16409a91c7d6943dad4400ae1858433f5adf5 -r9512aac6feeb1379d6d425361fa78d58f75c86f6 --- PersistentAlarm.c (.../PersistentAlarm.c) (revision c9b16409a91c7d6943dad4400ae1858433f5adf5) +++ PersistentAlarm.c (.../PersistentAlarm.c) (revision 9512aac6feeb1379d6d425361fa78d58f75c86f6) @@ -42,10 +42,10 @@ 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. + U32 persistentClearPeriod_ms; ///< Persistent time limit before clear alarm (in ms). + U32 persistentTriggerPeriod_ms; ///< Persistent time limit before trigger alarm (in ms). + U32 errorClearedStartTime; ///< Error cleared start time stamp. + U32 errorOccurredStartTime; ///< Error occurred start time stamp. BOOL alarmActive; ///< State of alarm last time alarm checked. } PERSISTENT_ALARM_DATA_T; @@ -62,8 +62,8 @@ 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. + U32 fpgaPersistentClearPeriod_ms; ///< FPGA persistent time limit before clear alarm (in ms). + U32 fpgaPersistentTriggerPeriod_ms; ///< FPGA persistent time limit before trigger alarm (in ms). FPGA_ALARM_DATA_T fpgaAlarmData[ NUM_OF_FPGA_ERROR_TYPES ]; ///< FPGA persistent alarm data. } FPGA_PERSISTENT_ALARM_GROUP_T; @@ -78,77 +78,80 @@ /*********************************************************************//** * @brief - * The initPersistentAlarm function initializes the PersistentAlarm module - * when the alarm count lower than maximum persistent alarm allowed. - * @details Inputs: none - * @details Outputs: PersistentAlarm module initialized - * @param alarmId Alarm id - * @param persistentClearPeriod Persistent period limit before clear alarm (in ms) - * @param persistentTriggerPeriod Persistent period limit before trigger alarm (in ms) + * The initPersistentAlarm function initializes a given persistent alarm. + * @details \b Alarm: ALARM_ID_XX_SOFTWARE_FAULT if given persistent alarm is invalid. + * @details \b Inputs: none + * @details \b Outputs: persistentAlarms[] + * @param alarmId ID of alarm to initialize persistence for + * @param persistentClearPeriod Persistent period for clearing alarm condition (in ms) + * @param persistentTriggerPeriod Persistent period for triggering alarm (in ms) * @return none *************************************************************************/ void initPersistentAlarm( ALARM_ID_T alarmId, U32 persistentClearPeriod, U32 persistentTriggerPeriod ) { if ( alarmId < NUM_OF_ALARM_IDS ) { - persistentAlarms[ alarmId ].persistentClearPeriod = persistentClearPeriod; - persistentAlarms[ alarmId ].persistentTriggerPeriod = persistentTriggerPeriod; + persistentAlarms[ alarmId ].persistentClearPeriod_ms = persistentClearPeriod; + persistentAlarms[ alarmId ].persistentTriggerPeriod_ms = persistentTriggerPeriod; persistentAlarms[ alarmId ].errorClearedStartTime = 0U; persistentAlarms[ alarmId ].errorOccurredStartTime = 0U; persistentAlarms[ alarmId ].alarmActive = FALSE; } else { +#ifdef _TD_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX1, alarmId ); +#endif #ifdef _DD_ SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX1, alarmId ); -#else - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX1, alarmId ); #endif +#ifdef _RO_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX1, alarmId ); +#endif } } /*********************************************************************//** * @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) + * The initFPGAPersistentAlarm function initializes a given FPGA persistent alarm. + * @details \b Inputs: none + * @details \b Outputs: fpgaPersistentAlarmGroup + * @param group ID of FPGA persistent alarm group to initialize + * @param alarmId ID of alarm to associate with the given FPGA persistent alarm group + * @param persistentClearPeriod Persistent period for clearing alarm (in ms) + * @param persistentTriggerPeriod Persistent period for triggering 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 ].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; -// } + if ( ( group < NUM_OF_FPGA_SENSOR_GROUPS ) && ( alarmIndex < NUM_OF_ALARM_IDS ) ) + { + fpgaPersistentAlarmGroup[ group ].fpgaAlarm = alarmIndex; + fpgaPersistentAlarmGroup[ group ].fpgaPersistentClearPeriod_ms = persistentClearPeriod; + fpgaPersistentAlarmGroup[ group ].fpgaPersistentTriggerPeriod_ms = persistentTriggerPeriod; + + 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; + } } /*********************************************************************//** * @brief * The isPersistentAlarmTriggered function checks if the error condition has - * persisted for given time limit. - * @details Inputs: persistentAlarms[] - * @details Outputs: none - * @param alarmId Alarm id - * @param isErrorOccurred Flag indicates error condition is occurring or not - * @return TRUE if error condition persisted over given time limit, FALSE if not + * persisted long enough to meet its trigger persistence time. + * @details \b Alarm: ALARM_ID_XX_SOFTWARE_FAULT if given alarm ID is invalid. + * @details \b Inputs: persistentAlarms[] + * @details \b Outputs: none + * @param alarmId ID of alarm to check persistence for + * @param isErrorOccurred has alarm criteria otherwise been met (T/F) + * @return TRUE if error condition has persisted long enough to be triggered, FALSE if not *************************************************************************/ BOOL isPersistentAlarmTriggered( ALARM_ID_T alarmId, BOOL const isErrorOccurred ) { @@ -173,7 +176,7 @@ if ( TRUE == isErrorOccurred ) { - isAlarmTriggered = didTimeout( persistentAlarms[ alarmId ].errorOccurredStartTime, persistentAlarms[ alarmId ].persistentTriggerPeriod ); + isAlarmTriggered = didTimeout( persistentAlarms[ alarmId ].errorOccurredStartTime, persistentAlarms[ alarmId ].persistentTriggerPeriod_ms ); } else { @@ -182,11 +185,15 @@ } else { +#ifdef _TD_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX2, alarmId ); +#endif #ifdef _DD_ SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX2, alarmId ); -#else - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX2, alarmId ); #endif +#ifdef _RO_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX2, alarmId ); +#endif } return isAlarmTriggered; @@ -195,12 +202,13 @@ /*********************************************************************//** * @brief * The isPersistentAlarmConditionCleared function checks if the error condition has - * been cleared for given time limit. - * @details Inputs: persistentAlarms[] - * @details Outputs: none - * @param alarmId Alarm id - * @param isErrorOccurred Flag indicates error condition is occurring or not - * @return TRUE if error condition has been cleared over given time limit, FALSE if not + * been cleared long enough to clear the alarm condition. + * @details \b Alarm: ALARM_ID_XX_SOFTWARE_FAULT if given alarm ID is invalid. + * @details \b Inputs: persistentAlarms[] + * @details \b Outputs: persistentAlarms[] + * @param alarmId AD of alarm to check clear persistence for + * @param isErrorOccurred Flag indicates whether error condition is occurring or not + * @return TRUE if error condition has been cleared long enough to clear the condition, FALSE if not *************************************************************************/ BOOL isPersistentAlarmConditionCleared( ALARM_ID_T alarmId, BOOL const isErrorOccurred ) { @@ -216,7 +224,7 @@ if ( FALSE == isErrorOccurred ) { - isErrorConditionCleared = didTimeout( persistentAlarms[ alarmId ].errorClearedStartTime, persistentAlarms[ alarmId ].persistentClearPeriod ); + isErrorConditionCleared = didTimeout( persistentAlarms[ alarmId ].errorClearedStartTime, persistentAlarms[ alarmId ].persistentClearPeriod_ms ); } else { @@ -225,11 +233,14 @@ } else { +#ifdef _TD_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX3, alarmId ) +#endif #ifdef _DD_ SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX3, alarmId ) #endif -#ifdef _TD_ - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX3, alarmId ) +#ifdef _RO_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX3, alarmId ) #endif } @@ -238,20 +249,20 @@ /*********************************************************************//** * @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 + * The checkPersistentAlarm function triggers or clears an alarm if an alarm condition + * has persisted or been cleared long enough to meet the persistence time. + * @details \b Alarm: given alarm is triggered if trigger persistence period elapsed + * @details \b Alarm: given alarm condition is cleared if clear persistence period elapsed + * @details \b Inputs: none + * @details \b Outputs: checks whether an alarm is triggered or an alarm condition is cleared + * @param alarmID ID of alarm to check persistence for + * @param isErrorOccured Flag indicates whether 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 + * @return none *************************************************************************/ -BOOL checkPersistentAlarm( ALARM_ID_T alarm, BOOL isErrorOccured, F32 data, F32 limit ) +void 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 ); @@ -260,19 +271,15 @@ 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 - * @details Outputs: reset condition clear start time and error occur start time - * @param alarmId Alarm id of the alarm to reset timer + * The resetPersistentAlarmTimer function resets the timing for a given alarm. + * @details \b Inputs: none + * @details \b Outputs: persistentAlarms[] + * @param alarmId ID of alarm to reset persistence for * @return none *************************************************************************/ void resetPersistentAlarmTimer( ALARM_ID_T alarmId ) @@ -283,13 +290,15 @@ /*********************************************************************//** * @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 + * The checkFPGAPersistentAlarms function checks the FPGA persistent + * read count of the provided FPGA persistent sensor group. + * @details \b Alarm: Alarm associated with given FPGA alarm group triggered + * if given sensor has not been read since last check. + * @details \b Alarm: ALARM_ID_XX_SOFTWARE_FAULT if given FPGA sensor group is invalid. + * @details \b Inputs: fpgaPersistentAlarmGroup + * @details \b Outputs: fpgaPersistentAlarmGroup + * @param alarmGroup ID of FPGA sensor group to check + * @param readCount Current read count reported by FPGA * @return none *************************************************************************/ void checkFPGAPersistentAlarms( FPGA_PERSISTENT_ALARMS_GROUP_T group, U32 readCount ) @@ -306,24 +315,29 @@ } else { +#ifdef _TD_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED1, (U32)group ) +#endif #ifdef _DD_ SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED1, (U32)group ) #endif -#ifdef _TD_ - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED1, (U32)group ) +#ifdef _RO_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED1, (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 + * error count of the provided FPGA persistent sensor group. + * @details \b Alarm: Alarm associated with given FPGA alarm group triggered + * if error count changes or read count does not change since last read. + * @details \b Alarm: ALARM_ID_XX_SOFTWARE_FAULT if given FPGA alarm group is invalid. + * @details \b Inputs: fpgaPersistentAlarmGroup + * @details \b Outputs: none + * @param alarmGroup ID of FPGA sensor group to check counts for + * @param errorCount Current error count reported by FPGA * @return none *************************************************************************/ void checkFPGAPersistentErrorCountAlarm( FPGA_PERSISTENT_ALARMS_GROUP_T group, U32 errorCount ) @@ -339,26 +353,29 @@ } else { +#ifdef _TD_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED2, (U32)group ) +#endif #ifdef _DD_ SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED2, (U32)group ) #endif -#ifdef _TD_ - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED2, (U32)group ) +#ifdef _RO_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED2, (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 + * The isFPGAPersistentAlarmTriggered function checks whether a given FPGA sensor + * group has stopped reading or reported a new error (depending on given error type). + * @details \b Alarm: ALARM_ID_TD_SOFTWARE_FAULT if given FPGA error type is invalid. + * @details \b Inputs: none + * @details \b Outputs: none + * @param alarmGroup ID of FPGA sensor group to report error status for + * @param fpgaCount Current error or read count for FPGA sensor group + * @param errorType The type of error status being requested (error or failure to read) + * @return TRUE if the given error type is detected, otherwise FALSE *************************************************************************/ static BOOL isFPGAPersistentAlarmTriggered( FPGA_PERSISTENT_ALARM_GROUP_T* alarmGroup, U32 fpgaCount, FPGA_ERROR_TYPE_T errorType ) { @@ -376,11 +393,14 @@ break; default: +#ifdef _TD_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED3, errorType ) +#endif #ifdef _DD_ SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED3, errorType ) #endif -#ifdef _TD_ - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED3, errorType ) +#ifdef _RO_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED3, errorType ) #endif break; } @@ -392,7 +412,7 @@ alarmGroup->fpgaAlarmData[ errorType ].fpgaIsConditionClear = FALSE; alarmGroup->fpgaAlarmData[ errorType ].fpgaErrorOccurredStartTime = getMSTimerCount(); } - else if ( TRUE == didTimeout( alarmGroup->fpgaAlarmData[ errorType ].fpgaErrorOccurredStartTime, alarmGroup->fpgaPersistentTriggerPeriod ) ) + else if ( TRUE == didTimeout( alarmGroup->fpgaAlarmData[ errorType ].fpgaErrorOccurredStartTime, alarmGroup->fpgaPersistentTriggerPeriod_ms ) ) { isPersistentTriggered = TRUE; }