Index: PersistentAlarm.c
===================================================================
diff -u -r87250a29e916894bc2ee2b6966e7df521a905bc6 -r47562f55e05738340cff996e9b579e90716204db
--- PersistentAlarm.c	(.../PersistentAlarm.c)	(revision 87250a29e916894bc2ee2b6966e7df521a905bc6)
+++ PersistentAlarm.c	(.../PersistentAlarm.c)	(revision 47562f55e05738340cff996e9b579e90716204db)
@@ -30,18 +30,17 @@
 typedef struct
 {
     ALARM_ID_T alarm;                               ///< Alarm id
-    BOOL       isClearable;                         ///< Flag if alarm can be cleared
 
     U32  persistentClearPeriod;                     ///< Persistent count limit before clear alarm
     U32  persistentTriggerPeriod;                   ///< Persistent count limit before trigger alarm
 
-    U32  inRangeStartTime;                          ///< Data in range persistent counter
-    U32  outOfRangeStartTime;                       ///< Data out of range persistent counter
+    U32  errorClearedStartTime;                     ///< Error cleared start time
+    U32  errorOccuredStartTime;                     ///< Error occured start time
 } PERSISTENT_ALARM_DATA_T;
 
 // ********** private data **********
 
-static PERSISTENT_ALARM_DATA_T persistentAlarms[ NUM_OF_PERSISTENT_ALARM ];   ///< Array of persistent alarm structure
+static PERSISTENT_ALARM_DATA_T persistentAlarms[ NUM_OF_ALARM_IDS ];   ///< Array of persistent alarm structure
 
 // ********** private function prototypes **********
 
@@ -51,86 +50,101 @@
  * when the alarm count lower than maximum persistent alarm allowed.
  * @details Inputs: none
  * @details Outputs: PersistentAlarm module initialized
- * @param alarmIndex Persistent alarm index
- * @param alarm Alarm id
- * @param isClearable Flag to indicate alarm is clearable or not
+ * @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 initPersistentAlarm( PERSISTENT_ALARM_T alarmIndex, ALARM_ID_T alarm, BOOL isClearable,
-                          U32 persistentClearPeriod, U32 persistentTriggerPeriod )
+void initPersistentAlarm( ALARM_ID_T alarmId, U32 persistentClearPeriod, U32 persistentTriggerPeriod )
 {
-    if ( alarmIndex < NUM_OF_PERSISTENT_ALARM )
+   if ( alarmId < NUM_OF_ALARM_IDS )
+   {
+       persistentAlarms[ alarmId ].persistentClearPeriod   = persistentClearPeriod;
+       persistentAlarms[ alarmId ].persistentTriggerPeriod = persistentTriggerPeriod;
+       persistentAlarms[ alarmId ].errorClearedStartTime   = 0U;
+       persistentAlarms[ alarmId ].errorOccuredStartTime   = 0U;
+   }
+   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 );
+#endif
+   }
+}
+
+/*********************************************************************//**
+ * @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 isErrorOccured Flag indicates error condition is occuring or not
+ * @return TRUE if error condition persisted over given time limit, FALSE if not
+ *************************************************************************/
+BOOL isPersistentAlarmTriggered( ALARM_ID_T alarmId, BOOL const isErrorOccured )
+{
+    BOOL isAlarmTriggered = FALSE;
+
+    if ( alarmId < NUM_OF_ALARM_IDS )
     {
-        persistentAlarms[ alarmIndex ].alarm                   = alarm;
-        persistentAlarms[ alarmIndex ].isClearable             = isClearable;
-        persistentAlarms[ alarmIndex ].persistentClearPeriod   = persistentClearPeriod;
-        persistentAlarms[ alarmIndex ].persistentTriggerPeriod = persistentTriggerPeriod;
-        persistentAlarms[ alarmIndex ].inRangeStartTime        = 0U;
-        persistentAlarms[ alarmIndex ].outOfRangeStartTime     = 0U;
+        if ( ( TRUE == isErrorOccured ) && ( persistentAlarms[ alarmId ].errorOccuredStartTime != 0 ) )
+        {
+            isAlarmTriggered = didTimeout( persistentAlarms[ alarmId ].errorOccuredStartTime, persistentAlarms[ alarmId ].persistentTriggerPeriod );
+        }
+        else
+        {
+            persistentAlarms[ alarmId ].errorOccuredStartTime = getMSTimerCount();
+        }
     }
     else
     {
 #ifdef _DG_
-        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX, alarmIndex );
+        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, alarmIndex );
+        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX, alarmId );
 #endif
     }
+
+    return isAlarmTriggered;
 }
 
 /*********************************************************************//**
  * @brief
- * The checkPersistentAlarm function check whether data is out of range or
- * not. Then the function set or clear alarm once the persistent counter
- * exceeds the limit.
- * @details Inputs: none
- * @details Outputs: Checks for out of range data and set/clear alarm
- * @param alarmIndex Persistent alarm index
- * @param isOutOfRange Flag indicates data out of range
- * @param data Data to be check for out of range
- * @param limit Upper or lower limit that data exceeded
- * @return none
+ * 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 isErrorOccured Flag indicates error condition is occuring or not
+ * @return TRUE if error condition has been cleared over given time limit, FALSE if not
  *************************************************************************/
-void checkPersistentAlarm( PERSISTENT_ALARM_T const alarmIndex, BOOL const isOutOfRange, F32 const data, F32 const limit )
-{
-    if ( alarmIndex < NUM_OF_PERSISTENT_ALARM )
+BOOL isPersistentAlarmConditionCleared( ALARM_ID_T alarmId, BOOL const isErrorOccured )
+{    BOOL isErrorConditionCleared = FALSE;
+
+    if ( alarmId < NUM_OF_ALARM_IDS )
     {
-        if ( isOutOfRange )
+        if ( ( FALSE == isErrorOccured ) && ( persistentAlarms[ alarmId ].errorClearedStartTime != 0 ) )
         {
-            persistentAlarms[ alarmIndex ].inRangeStartTime = 0;
-            if ( persistentAlarms[ alarmIndex ].outOfRangeStartTime == 0 )
-            {
-                persistentAlarms[ alarmIndex ].outOfRangeStartTime = getMSTimerCount();
-            }
-            if ( didTimeout( persistentAlarms[ alarmIndex ].outOfRangeStartTime, persistentAlarms[ alarmIndex ].persistentTriggerPeriod ) )
-            {
-                SET_ALARM_WITH_2_F32_DATA( persistentAlarms[ alarmIndex ].alarm, data, limit );
-            }
+            isErrorConditionCleared = didTimeout( persistentAlarms[ alarmId ].errorClearedStartTime, persistentAlarms[ alarmId ].persistentClearPeriod );
         }
         else
         {
-            persistentAlarms[ alarmIndex ].outOfRangeStartTime = 0;
-            if ( persistentAlarms[ alarmIndex ].inRangeStartTime == 0 )
-            {
-                persistentAlarms[ alarmIndex ].inRangeStartTime = getMSTimerCount();
-            }
-            BOOL const isInRangePersistent = didTimeout( persistentAlarms[ alarmIndex ].inRangeStartTime, persistentAlarms[ alarmIndex ].persistentClearPeriod );
-            if ( persistentAlarms[ alarmIndex ].isClearable && isInRangePersistent )
-            {
-                clearAlarmCondition( persistentAlarms[ alarmIndex ].alarm );
-            }
+            persistentAlarms[ alarmId ].errorClearedStartTime = getMSTimerCount();
         }
     }
     else
     {
 #ifdef _DG_
-        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX, alarmIndex );
+        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, alarmIndex );
+        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX, alarmId );
 #endif
     }
+
+    return isErrorConditionCleared;
 }
 
 /**@}*/