Index: PersistentAlarm.c
===================================================================
diff -u -r19785148b28639c3d1fc09f403901c8c756753a3 -r0f1d0c443daee3e30ae823711e85f3410bbf49fe
--- PersistentAlarm.c	(.../PersistentAlarm.c)	(revision 19785148b28639c3d1fc09f403901c8c756753a3)
+++ PersistentAlarm.c	(.../PersistentAlarm.c)	(revision 0f1d0c443daee3e30ae823711e85f3410bbf49fe)
@@ -1,22 +1,23 @@
 /**************************************************************************
 *
-* Copyright (c) 2019-2020 Diality Inc. - All Rights Reserved.
+* Copyright (c) 2019-2021 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) Quang Nguyen
-* @date (last) 12-Aug-2020
+* @author (last) Sean Nash
+* @date (last) 01-Dec-2020
 *
 * @author (original) Quang Nguyen
-* @date (original) 12-Aug-2020
+* @date (original) 17-Aug-2020
 *
 ***************************************************************************/
 
 #include "AlarmMgmt.h"
 #include "PersistentAlarm.h"
+#include "Timers.h"
 
 /**
  *  @addtogroup PersistentAlarm
@@ -31,11 +32,11 @@
     ALARM_ID_T alarm;                               ///< Alarm id
     BOOL       isClearable;                         ///< Flag if alarm can be cleared
 
-    U32  persistentClearCount;                      ///< Persistent count limit before clear alarm
-    U32  persistentTriggerCount;                    ///< Persistent count limit before trigger alarm
+    U32  persistentClearPeriod;                     ///< Persistent count limit before clear alarm
+    U32  persistentTriggerPeriod;                   ///< Persistent count limit before trigger alarm
 
-    U32  inRangeCounter;                            ///< Data in range persistent counter
-    U32  outOfRangeCounter;                         ///< Data out of range persistent counter
+    U32  inRangeStartTime;                          ///< Data in range persistent counter
+    U32  outOfRangeStartTime;                       ///< Data out of range persistent counter
 } PERSISTENT_ALARM_DATA_T;
 
 // ********** private data **********
@@ -48,27 +49,26 @@
  * @brief
  * The initPersistentAlarm function initializes the PersistentAlarm module
  * when the alarm count lower than maximum persistent alarm allowed.
- * @details
- * Inputs : none
- * Outputs : PersistentAlarm module initialized
+ * @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 persistentClearCount Persistent count limit before clear alarm
- * @param persistentTriggerCount Persistent count limit before trigger alarm
+ * @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,
-                          F32 persistentClearCount, F32 persistentTriggerCount )
+                          U32 persistentClearPeriod, U32 persistentTriggerPeriod )
 {
     if ( alarmIndex < NUM_OF_PERSISTENT_ALARM )
     {
-        persistentAlarms[ alarmIndex ].alarm                  = alarm;
-        persistentAlarms[ alarmIndex ].isClearable            = isClearable;
-        persistentAlarms[ alarmIndex ].persistentClearCount   = persistentClearCount;
-        persistentAlarms[ alarmIndex ].persistentTriggerCount = persistentTriggerCount;
-        persistentAlarms[ alarmIndex ].inRangeCounter         = 0U;
-        persistentAlarms[ alarmIndex ].outOfRangeCounter      = 0U;
+        persistentAlarms[ alarmIndex ].alarm                   = alarm;
+        persistentAlarms[ alarmIndex ].isClearable             = isClearable;
+        persistentAlarms[ alarmIndex ].persistentClearPeriod   = persistentClearPeriod;
+        persistentAlarms[ alarmIndex ].persistentTriggerPeriod = persistentTriggerPeriod;
+        persistentAlarms[ alarmIndex ].inRangeStartTime        = 0U;
+        persistentAlarms[ alarmIndex ].outOfRangeStartTime     = 0U;
     }
     else
     {
@@ -85,32 +85,38 @@
  * 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
- * Outputs : Checks for out of range data and set/clear alarm
+ * @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
  *************************************************************************/
-void checkPersistentAlarm( PERSISTENT_ALARM_T const alarmIndex, BOOL const isOutOfRange, F32 const data )
+void checkPersistentAlarm( PERSISTENT_ALARM_T const alarmIndex, BOOL const isOutOfRange, F32 const data, F32 const limit )
 {
     if ( alarmIndex < NUM_OF_PERSISTENT_ALARM )
     {
         if ( isOutOfRange )
         {
-            ++persistentAlarms[ alarmIndex ].outOfRangeCounter;
-            persistentAlarms[ alarmIndex ].inRangeCounter = 0;
-            if ( persistentAlarms[ alarmIndex ].outOfRangeCounter > persistentAlarms[ alarmIndex ].persistentTriggerCount )
+            persistentAlarms[ alarmIndex ].inRangeStartTime = 0;
+            if ( persistentAlarms[ alarmIndex ].outOfRangeStartTime == 0 )
             {
-                SET_ALARM_WITH_1_F32_DATA( persistentAlarms[ alarmIndex ].alarm, data );
+                persistentAlarms[ alarmIndex ].outOfRangeStartTime = getMSTimerCount();
             }
+            if ( didTimeout( persistentAlarms[ alarmIndex ].outOfRangeStartTime, persistentAlarms[ alarmIndex ].persistentTriggerPeriod ) )
+            {
+                SET_ALARM_WITH_2_F32_DATA( persistentAlarms[ alarmIndex ].alarm, data, limit );
+            }
         }
         else
         {
-            ++persistentAlarms[ alarmIndex ].inRangeCounter;
-            persistentAlarms[ alarmIndex ].outOfRangeCounter = 0;
-            BOOL const isInRangePersistent = persistentAlarms[ alarmIndex ].inRangeCounter > persistentAlarms[ alarmIndex ].persistentClearCount;
+            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 )
             {
                 clearAlarm( persistentAlarms[ alarmIndex ].alarm );