Index: PersistentAlarm.c =================================================================== diff -u -r54a9bd09d6714d7faaa186959988a75ef3b83557 -r7e186bb97310fb59f525e5399ec7a74711bea571 --- PersistentAlarm.c (.../PersistentAlarm.c) (revision 54a9bd09d6714d7faaa186959988a75ef3b83557) +++ PersistentAlarm.c (.../PersistentAlarm.c) (revision 7e186bb97310fb59f525e5399ec7a74711bea571) @@ -26,24 +26,56 @@ // ********** private definitions ********** +#define NUM_OF_FPGA_ALARMS_PER_GROUP 2 +#define FPGA_READ_ALARM_INDEX 0 +#define FPGA_ERROR_ALARM_INDEX 1 + +/// FPGA persistent alarm types +typedef enum +{ + FPGA_READ_ERROR = 0, + FPGA_ERROR_ERROR, + FPGA_NOT_UPDATING_ERROR, + NUM_OF_FPGA_ERROR_TYPES +} FPGA_ERROR_TYPE_T; + /// Persistent alarm structure typedef struct { - ALARM_ID_T alarm; ///< Alarm id + 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; - U32 persistentClearPeriod; ///< Persistent count limit before clear alarm - U32 persistentTriggerPeriod; ///< Persistent count limit before trigger alarm +/// 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 +} FPGA_ALARM_DATA_T; - U32 errorClearedStartTime; ///< Error cleared start time - U32 errorOccurredStartTime; ///< Error occurred start time -} PERSISTENT_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 ]; +} 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 ]; // ********** private function prototypes ********** +static BOOL isFPGAPersistentAlarmTriggered( FPGA_PERSISTENT_ALARM_GROUP_T* alarmGroup, U32 fpgaCount, FPGA_ERROR_TYPE_T errorType ); + /*********************************************************************//** * @brief * The initPersistentAlarm function initializes the PersistentAlarm module @@ -74,6 +106,19 @@ } } +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; + + 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 ) ); + } +} + /*********************************************************************//** * @brief * The isPersistentAlarmTriggered function checks if the error condition has @@ -91,7 +136,7 @@ if ( alarmId < NUM_OF_ALARM_IDS ) { // Update start time when error occurs for the first time - if ( ( TRUE == isErrorOccurred ) && ( persistentAlarms[ alarmId ].errorOccurredStartTime == 0 ) ) + if ( ( TRUE == isErrorOccurred ) && ( 0 == persistentAlarms[ alarmId ].errorOccurredStartTime ) ) { persistentAlarms[ alarmId ].errorOccurredStartTime = getMSTimerCount(); } @@ -162,6 +207,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 @@ -172,7 +247,84 @@ void resetPersistentAlarmTimer( ALARM_ID_T alarmId ) { persistentAlarms[ alarmId ].errorOccurredStartTime = 0; - persistentAlarms[ alarmId ].errorClearedStartTime = 0; + persistentAlarms[ alarmId ].errorClearedStartTime = 0; } +static BOOL isFPGAPersistentAlarmTriggered( FPGA_PERSISTENT_ALARM_GROUP_T* alarmGroup, U32 fpgaCount, FPGA_ERROR_TYPE_T errorType ) +{ + BOOL isPersistentTriggered = FALSE; + BOOL hasErrorOccured = FALSE; + + switch ( errorType ) + { + case FPGA_READ_ERROR: + hasErrorOccured = ( fpgaCount == alarmGroup->fpgaAlarmData[ errorType ].fpgaPreviousCount ? TRUE : FALSE ); + break; + + case FPGA_ERROR_ERROR: + hasErrorOccured = ( alarmGroup->fpgaAlarmData[ errorType ].fpgaPreviousCount != fpgaCount ? TRUE : FALSE ); + break; + + case FPGA_NOT_UPDATING_ERROR: + break; + } + + if ( TRUE == hasErrorOccured ) + { + if ( TRUE == alarmGroup->fpgaAlarmData[ errorType ].fpgaIsConditionClear ) + { + alarmGroup->fpgaAlarmData[ errorType ].fpgaIsConditionClear = FALSE; + alarmGroup->fpgaAlarmData[ errorType ].fpgaErrorOccurredStartTime = getMSTimerCount(); + } + else if ( TRUE == didTimeout( alarmGroup->fpgaAlarmData[ errorType ].fpgaErrorOccurredStartTime, alarmGroup->fpgaPersistentTriggerPeriod ) ) + { + isPersistentTriggered = TRUE; + } + } + else + { + alarmGroup->fpgaAlarmData[ errorType ].fpgaIsConditionClear = TRUE; + } + + alarmGroup->fpgaAlarmData[ errorType ].fpgaPreviousCount = fpgaCount; + + 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 + } +} + /**@}*/