Index: PersistentAlarm.c
===================================================================
diff -u -rf74fbf44ae7855cb229e39278481cb9f57d6bcd8 -r75e6d3ffab11ae6ff0521efb9c16d5698402a669
--- PersistentAlarm.c	(.../PersistentAlarm.c)	(revision f74fbf44ae7855cb229e39278481cb9f57d6bcd8)
+++ PersistentAlarm.c	(.../PersistentAlarm.c)	(revision 75e6d3ffab11ae6ff0521efb9c16d5698402a669)
@@ -30,10 +30,19 @@
 #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
@@ -55,7 +64,7 @@
     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_ALARMS_PER_GROUP ];
+    FPGA_ALARM_DATA_T fpgaAlarmData[ NUM_OF_FPGA_ERROR_TYPES ];
 } FPGA_PERSISTENT_ALARM_GROUP_T;
 
 // ********** private data **********
@@ -65,7 +74,7 @@
 
 // ********** private function prototypes **********
 
-static BOOL isFPGAPersistentAlarmTriggered( FPGA_PERSISTENT_ALARM_GROUP_T* alarmGroup, U32 readOrErrorIndex, U32 fpgaCount, BOOL isThisErrorCount );
+static BOOL isFPGAPersistentAlarmTriggered( FPGA_PERSISTENT_ALARM_GROUP_T* alarmGroup, U32 fpgaCount, FPGA_ERROR_TYPE_T errorType );
 
 /*********************************************************************//**
  * @brief
@@ -211,38 +220,43 @@
     persistentAlarms[ alarmId ].errorClearedStartTime  = 0;
 }
 
-static BOOL isFPGAPersistentAlarmTriggered( FPGA_PERSISTENT_ALARM_GROUP_T* alarmGroup, U32 readOrErrorIndex, U32 fpgaCount, BOOL isThisErrorCount )
+static BOOL isFPGAPersistentAlarmTriggered( FPGA_PERSISTENT_ALARM_GROUP_T* alarmGroup, U32 fpgaCount, FPGA_ERROR_TYPE_T errorType )
 {
     BOOL isPersistentTriggered = FALSE;
     BOOL hasErrorOccured       = FALSE;
 
-    if ( TRUE == isThisErrorCount )
+    switch ( errorType )
     {
-        hasErrorOccured = ( alarmGroup->fpgaAlarmData[ readOrErrorIndex ].fpgaPreviousCount != fpgaCount ? TRUE : FALSE );
+        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;
     }
-    else
-    {
-        hasErrorOccured = ( fpgaCount == alarmGroup->fpgaAlarmData[ readOrErrorIndex ].fpgaPreviousCount ? TRUE : FALSE );
-    }
 
     if ( TRUE == hasErrorOccured )
     {
-        if ( TRUE == alarmGroup->fpgaAlarmData[ readOrErrorIndex ].fpgaIsConditionClear )
+        if ( TRUE == alarmGroup->fpgaAlarmData[ errorType ].fpgaIsConditionClear )
         {
-            alarmGroup->fpgaAlarmData[ readOrErrorIndex ].fpgaIsConditionClear       = FALSE;
-            alarmGroup->fpgaAlarmData[ readOrErrorIndex ].fpgaErrorOccurredStartTime = getMSTimerCount();
+            alarmGroup->fpgaAlarmData[ errorType ].fpgaIsConditionClear       = FALSE;
+            alarmGroup->fpgaAlarmData[ errorType ].fpgaErrorOccurredStartTime = getMSTimerCount();
         }
-        else if ( TRUE == didTimeout( alarmGroup->fpgaAlarmData[ readOrErrorIndex ].fpgaErrorOccurredStartTime, alarmGroup->fpgaPersistentTriggerPeriod ) )
+        else if ( TRUE == didTimeout( alarmGroup->fpgaAlarmData[ errorType ].fpgaErrorOccurredStartTime, alarmGroup->fpgaPersistentTriggerPeriod ) )
         {
             isPersistentTriggered = TRUE;
         }
     }
     else
     {
-        alarmGroup->fpgaAlarmData[ readOrErrorIndex ].fpgaIsConditionClear = TRUE;
+        alarmGroup->fpgaAlarmData[ errorType ].fpgaIsConditionClear = TRUE;
     }
 
-    alarmGroup->fpgaAlarmData[ readOrErrorIndex ].fpgaPreviousCount = fpgaCount;
+    alarmGroup->fpgaAlarmData[ errorType ].fpgaPreviousCount = fpgaCount;
 
     return isPersistentTriggered;
 }
@@ -251,58 +265,31 @@
 {
     if ( group < NUM_OF_FPGA_SENSOR_GROUPS )
     {
-        BOOL isErrorPersistentTriggered = FALSE;
-        FPGA_ALARM_DATA_T readData      = fpgaPersistentAlarmGroup[ group ].fpgaAlarmData[ FPGA_READ_ALARM_INDEX ];
-        FPGA_ALARM_DATA_T errorData     = fpgaPersistentAlarmGroup[ group ].fpgaAlarmData[ FPGA_ERROR_ALARM_INDEX ];
-        BOOL isReadPersistentTriggered  = isFPGAPersistentAlarmTriggered( &fpgaPersistentAlarmGroup[ group ], FPGA_READ_ALARM_INDEX, readCount, FALSE );
+        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 ( readData.fpgaPreviousCount != readCount )
+        if ( ( readCount == readData.fpgaPreviousCount ) && ( errorCount == errorData.fpgaPreviousCount ) )
         {
-            isErrorPersistentTriggered = isFPGAPersistentAlarmTriggered( &fpgaPersistentAlarmGroup[ group ], FPGA_ERROR_ALARM_INDEX, errorCount, TRUE );
+            type               = FPGA_NOT_UPDATING_ERROR;
+            isPersistenceTrgrd = isFPGAPersistentAlarmTriggered( &fpgaPersistentAlarmGroup[ group ], readCount, FPGA_NOT_UPDATING_ERROR );
         }
-
-        if ( ( TRUE == isReadPersistentTriggered ) || ( TRUE == isErrorPersistentTriggered ) )
+        else if ( readData.fpgaPreviousCount != readCount )
         {
-            SET_ALARM_WITH_1_U32_DATA( fpgaPersistentAlarmGroup[ group ].fpgaAlarm, sensorIndex );
+            type               = FPGA_READ_ERROR;
+            isPersistenceTrgrd = isFPGAPersistentAlarmTriggered( &fpgaPersistentAlarmGroup[ group ], readCount, FPGA_READ_ERROR );
         }
-
-        /*if ( readCount == readData.fpgaPreviousCount )
+        else if ( errorData.fpgaPreviousCount != errorCount )
         {
-            if ( TRUE == readData.fpgaIsConditionClear )
-            {
-                readData.fpgaErrorOccurredStartTime = getMSTimerCount();
-                readData.fpgaIsConditionClear       = FALSE;
-            }
-            else if ( TRUE == didTimeout( readData.fpgaErrorOccurredStartTime, readData.fpgaPersistentTriggerPeriod ) )
-            {
-                SET_ALARM_WITH_1_U32_DATA( fpgaPersistentAlarmGroup[ group ].fpgaAlarm, sensorIndex );
-            }
+            type               = FPGA_ERROR_ERROR;
+            isPersistenceTrgrd = isFPGAPersistentAlarmTriggered( &fpgaPersistentAlarmGroup[ group ], errorCount, FPGA_ERROR_ERROR );
         }
-        else
-        {
-            readData.fpgaIsConditionClear = TRUE;
-        }
 
-        if ( errorCount == errorData.fpgaPreviousCount )
+        if ( TRUE == isPersistenceTrgrd )
         {
-            if ( TRUE == errorData.fpgaIsConditionClear )
-            {
-                errorData.fpgaErrorOccurredStartTime = getMSTimerCount();
-                errorData.fpgaIsConditionClear       = FALSE;
-            }
-            else if ( TRUE == didTimeout( errorData.fpgaErrorOccurredStartTime, errorData.fpgaPersistentTriggerPeriod ) )
-            {
-                SET_ALARM_WITH_1_U32_DATA( fpgaPersistentAlarmGroup[ group ].fpgaAlarm, sensorIndex );
-            }
+            SET_ALARM_WITH_2_U32_DATA( fpgaPersistentAlarmGroup[ group ].fpgaAlarm, type, sensorIndex );
         }
-        else
-        {
-            errorData.fpgaIsConditionClear = TRUE;
-        }
-
-        readData.fpgaPreviousCount  = readCount;
-        errorData.fpgaPreviousCount = errorCount;*/
-
     }
     else
     {