Index: firmware/App/Modes/Dialysis.c
===================================================================
diff -u -r4fdd94336f97f71d0ba2918260125ecb46d52e75 -r0ffe96d360a99601ac79a1185556eac7b0e7e2a1
--- firmware/App/Modes/Dialysis.c	(.../Dialysis.c)	(revision 4fdd94336f97f71d0ba2918260125ecb46d52e75)
+++ firmware/App/Modes/Dialysis.c	(.../Dialysis.c)	(revision 0ffe96d360a99601ac79a1185556eac7b0e7e2a1)
@@ -65,6 +65,8 @@
 static F32 resCurrVolume[ NUM_OF_DG_RESERVOIRS ];       ///< Reservoir current volume.
 static F32 resLastVolume[ NUM_OF_DG_RESERVOIRS ];       ///< Reservoir previous volume.
 static F32 measUFVolumeFromPriorReservoirs;             ///< Current total ultrafiltration volume from previous reservoirs in current treatment.
+static F32 lcLastStartWeight[NUM_OF_LOAD_CELLS];        ///< Load Cell Last Starting Weight for drift test
+static F32 lcLastFinalWeight[NUM_OF_LOAD_CELLS];        ///< Load Cell Last Final Weight for drift test
 
 static U32 uFTimeMS;                                    ///< Current elapsed ultrafiltration time (in ms).  Used for calculating UF reference volume.
 static U32 lastUFTimeStamp;                             ///< HD timer value when we last took stock of ultrafiltration time (so we can determine how much time has elapsed since).
@@ -106,7 +108,7 @@
 static void updateUFVolumes( void );
 
 static void publishSalineBolusData( void );
-static void checkLoadCellsStablePrimaryBackupDriftOutOfRange( DG_RESERVOIR_ID_T reservoirID, BOOL reservoirFull );
+static void checkLoadCellsStablePrimaryBackupDriftOutOfRange( DG_RESERVOIR_ID_T reservoirID, BOOL reservoirFinal );
 
 /*********************************************************************//**
  * @brief
@@ -119,6 +121,8 @@
  *************************************************************************/
 void initDialysis( void )
 {
+    U16 i;
+
     currentDialysisState = DIALYSIS_START_STATE;
     currentUFState = UF_START_STATE;
     currentSalineBolusState = SALINE_BOLUS_STATE_IDLE;
@@ -143,6 +147,11 @@
     uFAccuracyCheckTimerCtr = 0;
     lastUFVolumeChecked = 0.0;
 
+    for (i=0; i<NUM_OF_LOAD_CELLS; i++)
+    {
+        lcLastStartWeight[i] = LOAD_CELL_ILLEGAL_WEIGHT_VALUE;
+        lcLastFinalWeight[i] = LOAD_CELL_ILLEGAL_WEIGHT_VALUE;
+    }
     resetSalineBolus();
 }
 
@@ -1137,7 +1146,7 @@
     resStartVolume[ reservoirID ] = resVolume;
     resFinalVolume[ reservoirID ] = resVolume;
 
-    checkLoadCellsStablePrimaryBackupDriftOutOfRange( reservoirID, false );
+    checkLoadCellsStablePrimaryBackupDriftOutOfRange( reservoirID, FALSE );
 }
 
 /*********************************************************************//**
@@ -1176,7 +1185,7 @@
     resFinalVolume[ inactiveRes ] = resVolume;
     measUFVolumeFromPriorReservoirs += ( resFinalVolume[ inactiveRes ] - resStartVolume[ inactiveRes ] );
 
-    checkLoadCellsStablePrimaryBackupDriftOutOfRange( inactiveRes, true );
+    checkLoadCellsStablePrimaryBackupDriftOutOfRange( inactiveRes, TRUE );
 }
 
 /*********************************************************************//**
@@ -1219,98 +1228,61 @@
  * @details Inputs: none
  * @details Outputs: none
  * @param reservoirID which is the reservoir ID that is range checked
- * @param reservoirFull is the reservoir status full or empty
+ * @param reservoirFinal is the reservoir status final or start
  * @return none
  *************************************************************************/
-static void checkLoadCellsStablePrimaryBackupDriftOutOfRange( DG_RESERVOIR_ID_T reservoirID, BOOL reservoirFull )
+static void checkLoadCellsStablePrimaryBackupDriftOutOfRange( DG_RESERVOIR_ID_T reservoirID, BOOL reservoirFinal )
 {
-    static F32 lastEmptyWeight[NUM_OF_LOAD_CELLS] = { LOAD_CELL_ILLEGAL_WEIGHT_VALUE,
-                                                      LOAD_CELL_ILLEGAL_WEIGHT_VALUE,
-                                                      LOAD_CELL_ILLEGAL_WEIGHT_VALUE,
-                                                      LOAD_CELL_ILLEGAL_WEIGHT_VALUE };
-    static F32 lastFullWeight[NUM_OF_LOAD_CELLS]  = { LOAD_CELL_ILLEGAL_WEIGHT_VALUE,
-                                                      LOAD_CELL_ILLEGAL_WEIGHT_VALUE,
-                                                      LOAD_CELL_ILLEGAL_WEIGHT_VALUE,
-                                                      LOAD_CELL_ILLEGAL_WEIGHT_VALUE };
     F32 loadCellPrimaryWeight, loadCellBackupWeight;
     F32 loadCellPreviousDrift, loadCellCurrentDrift;
     F32 driftDiff = 0.0;
+    U16 lcPrimaryIndex, lcBackupIndex;
 
-    if ( reservoirID == DG_RESERVOIR_1 )
+    if ( DG_RESERVOIR_1 == reservoirID )
     {
-        // Reservoir 1
-        loadCellPrimaryWeight = getReservoirWeightLargeFilter( DG_RESERVOIR_1 );
-        loadCellBackupWeight  = getReservoirBackupWeightLargeFilter( DG_RESERVOIR_1 );
-        loadCellCurrentDrift = fabs( loadCellPrimaryWeight - loadCellBackupWeight );
+        lcPrimaryIndex = LOAD_CELL_RESERVOIR_1_PRIMARY;
+        lcBackupIndex = LOAD_CELL_RESERVOIR_1_BACKUP;
+    }
+    else
+    {
+        lcPrimaryIndex = LOAD_CELL_RESERVOIR_2_PRIMARY;
+        lcBackupIndex = LOAD_CELL_RESERVOIR_2_BACKUP;
+    }
 
-        if ( reservoirFull )
+    loadCellPrimaryWeight = getReservoirWeightLargeFilter( reservoirID );
+    loadCellBackupWeight  = getReservoirBackupWeightLargeFilter( reservoirID );
+    loadCellCurrentDrift = fabs( loadCellPrimaryWeight - loadCellBackupWeight );
+
+    if ( TRUE == reservoirFinal )
+    {
+        if ( lcLastFinalWeight[lcPrimaryIndex] > (LOAD_CELL_ILLEGAL_WEIGHT_VALUE + 1) )
         {
-            if ( lastFullWeight[LOAD_CELL_RESERVOIR_1_PRIMARY] > (LOAD_CELL_ILLEGAL_WEIGHT_VALUE + 1) )
-            {
-                // Weight has been previously saved, ok to test
-                loadCellPreviousDrift = fabs( lastFullWeight[LOAD_CELL_RESERVOIR_1_PRIMARY] -
-                                              lastFullWeight[LOAD_CELL_RESERVOIR_1_BACKUP] );
-                driftDiff = fabs ( loadCellCurrentDrift - loadCellPreviousDrift );
-            }
-            // Save latest reading for next test time
-            lastFullWeight[LOAD_CELL_RESERVOIR_1_PRIMARY] = loadCellPrimaryWeight;
-            lastFullWeight[LOAD_CELL_RESERVOIR_1_BACKUP]  = loadCellBackupWeight;
+            // Weight has been previously saved, ok to test
+            loadCellPreviousDrift = lcLastFinalWeight[lcPrimaryIndex] - lcLastFinalWeight[lcBackupIndex];
+            driftDiff = fabs ( loadCellCurrentDrift - loadCellPreviousDrift );
         }
-        else
-        {
-            if ( lastEmptyWeight[LOAD_CELL_RESERVOIR_1_PRIMARY] > (LOAD_CELL_ILLEGAL_WEIGHT_VALUE + 1) )
-            {
-                // Weight has been previously saved, ok to test
-                loadCellPreviousDrift = fabs( lastEmptyWeight[LOAD_CELL_RESERVOIR_1_PRIMARY] -
-                                              lastEmptyWeight[LOAD_CELL_RESERVOIR_1_BACKUP] );
-                driftDiff = fabs ( loadCellCurrentDrift - loadCellPreviousDrift );
-            }
-            // Save latest reading for next test time
-            lastEmptyWeight[LOAD_CELL_RESERVOIR_1_PRIMARY] = loadCellPrimaryWeight;
-            lastEmptyWeight[LOAD_CELL_RESERVOIR_1_BACKUP]  = loadCellBackupWeight;
-        }
+        // Save latest reading for next test time
+        lcLastFinalWeight[lcPrimaryIndex] = loadCellPrimaryWeight;
+        lcLastFinalWeight[lcBackupIndex]  = loadCellBackupWeight;
     }
     else
     {
-        // Reservoir 2
-        loadCellPrimaryWeight = getReservoirWeightLargeFilter( DG_RESERVOIR_2 );
-        loadCellBackupWeight  = getReservoirBackupWeightLargeFilter( DG_RESERVOIR_2 );
-        loadCellCurrentDrift = fabs( loadCellPrimaryWeight - loadCellBackupWeight );
-
-        if ( reservoirFull )
+        if ( lcLastStartWeight[lcPrimaryIndex] > (LOAD_CELL_ILLEGAL_WEIGHT_VALUE + 1) )
         {
-            if ( lastFullWeight[LOAD_CELL_RESERVOIR_2_PRIMARY] > (LOAD_CELL_ILLEGAL_WEIGHT_VALUE + 1) )
-            {
-                // Weight has been previously saved, ok to test
-                loadCellPreviousDrift = fabs( lastFullWeight[LOAD_CELL_RESERVOIR_2_PRIMARY] -
-                                              lastFullWeight[LOAD_CELL_RESERVOIR_2_BACKUP] );
-                driftDiff = fabs ( loadCellCurrentDrift - loadCellPreviousDrift );
-            }
-            // Save latest reading for next test time
-            lastFullWeight[LOAD_CELL_RESERVOIR_2_PRIMARY] = loadCellPrimaryWeight;
-            lastFullWeight[LOAD_CELL_RESERVOIR_2_BACKUP]  = loadCellBackupWeight;
+            // Weight has been previously saved, ok to test
+            loadCellPreviousDrift = lcLastStartWeight[lcPrimaryIndex] - lcLastStartWeight[lcBackupIndex];
+            driftDiff = fabs ( loadCellCurrentDrift - loadCellPreviousDrift );
         }
-        else
-        {
-            if ( lastEmptyWeight[LOAD_CELL_RESERVOIR_2_PRIMARY] > (LOAD_CELL_ILLEGAL_WEIGHT_VALUE + 1) )
-            {
-                // Weight has been previously saved, ok to test
-                loadCellPreviousDrift = fabs( lastEmptyWeight[LOAD_CELL_RESERVOIR_2_PRIMARY] -
-                                              lastEmptyWeight[LOAD_CELL_RESERVOIR_2_BACKUP] );
-                driftDiff = fabs ( loadCellCurrentDrift - loadCellPreviousDrift );
-            }
-            // Save latest reading for next test time
-            lastEmptyWeight[LOAD_CELL_RESERVOIR_2_PRIMARY] = loadCellPrimaryWeight;
-            lastEmptyWeight[LOAD_CELL_RESERVOIR_2_BACKUP]  = loadCellBackupWeight;
-        }
+        // Save latest reading for next test time
+        lcLastStartWeight[lcPrimaryIndex] = loadCellPrimaryWeight;
+        lcLastStartWeight[lcBackupIndex]  = loadCellBackupWeight;
     }
 
-    // TODO How does this alarm get cleared?
+    // Check for drift out of range
     if ( driftDiff > LOAD_CELL_PRIMARY_BACKUP_MAX_ALLOWED_DRIFT_GRAMS )
     {
         SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_LOAD_CELL_PRIMARY_BACKUP_DRIFT_OUT_OF_RANGE, loadCellCurrentDrift, loadCellPreviousDrift )
     }
-
 }