Index: firmware/App/Controllers/LoadCell.c
===================================================================
diff -u -rebbb1f85550a1f9b8f946655f7b2b63f76fbf67d -rfa8d55ab4d5371d943b5dce113a22652899bd061
--- firmware/App/Controllers/LoadCell.c	(.../LoadCell.c)	(revision ebbb1f85550a1f9b8f946655f7b2b63f76fbf67d)
+++ firmware/App/Controllers/LoadCell.c	(.../LoadCell.c)	(revision fa8d55ab4d5371d943b5dce113a22652899bd061)
@@ -36,7 +36,6 @@
 #define LOAD_CELL_REPORT_PERIOD         (100 / TASK_PRIORITY_INTERVAL)                  ///< Broadcast load cell values message every 100 ms.
 /// Conversion factor from ADC counts to grams.
 static const F32 ADC2GRAM = (0.0894 * 1.1338);
-#define LOAD_CELL_ZERO_OFFSET           -1500.0                                         ///< Zero offset (in grams).  TODO - right now, this is empty reservoir weight.
 #define LOAD_CELL_FILTER_ALPHA          0.05                                            ///< Alpha factor for the alpha filter used on load cell readings.
 
 #define SIZE_OF_SMALL_LOAD_CELL_AVG     100                                             ///< Small load cell moving average has 100 raw samples @ 10ms intervals (1-second).
@@ -45,17 +44,17 @@
 /// Load cell data structure.
 typedef struct
 {
-    U32 rawReading;                                                 ///< Latest raw load cell reading
-    OVERRIDE_F32_T weight;                                          ///< Latest load cell weight
+    U32 rawReading;                                                 ///< Latest raw load cell reading.
+    OVERRIDE_F32_T weight;                                          ///< Latest load cell weight.
     F32 autoCalOffset;                                              ///< Load cell auto-calibration offset
 
-    F32 smallFilterReadings[ SIZE_OF_SMALL_LOAD_CELL_AVG ];         ///< Load cell samples for small load cell moving average
-    F32 smallFilterTotal;                                           ///< Small filter rolling total - used to calc small load cell moving average
-    F32 smallFilteredWeight;                                        ///< Load cell small filtered (100 100Hz raw sample) weight
+    F32 smallFilterReadings[ SIZE_OF_SMALL_LOAD_CELL_AVG ];         ///< Load cell samples for small load cell moving average.
+    F32 smallFilterTotal;                                           ///< Small filter rolling total - used to calc small load cell moving average.
+    F32 smallFilteredWeight;                                        ///< Load cell small filtered (100 100Hz raw sample) weight.
 
-    F32 largeFilterReadings[ SIZE_OF_LARGE_LOAD_CELL_AVG ];         ///< Load cell samples for large load cell moving average
-    F32 largeFilterTotal;                                           ///< Large filter rolling total - used to calc small load cell moving average
-    F32 largeFilteredWeight;                                        ///< Load cell large filtered (40 10Hz filtered sample) weight
+    F32 largeFilterReadings[ SIZE_OF_LARGE_LOAD_CELL_AVG ];         ///< Load cell samples for large load cell moving average.
+    F32 largeFilterTotal;                                           ///< Large filter rolling total - used to calc small load cell moving average.
+    F32 largeFilteredWeight;                                        ///< Load cell large filtered (40 10Hz filtered sample) weight.
 } LOADCELL_T;
 
 // ********** private data **********
@@ -70,8 +69,6 @@
 static U32 largeReadingsIdx;                                                            ///< Index for next sample in load cell large rolling average sample array.
 static DG_LOAD_CELLS_CAL_RECORD_T loadCellsCalRecord;                                   ///< Load cells calibration record.
 
-// TODO - gain and offset for load cells should be read from NV Data calibration record.
-
 // ********** private function prototypes **********
 
 static U32 getLoadCellDataPublishInterval( void );
@@ -147,14 +144,35 @@
 
     // update sums for load cell average calculations
     loadcells[ LOAD_CELL_RESERVOIR_1_PRIMARY ].rawReading = getFPGALoadCellA1();
-    loadcells[ LOAD_CELL_RESERVOIR_1_BACKUP ].rawReading = getFPGALoadCellA2();
+    loadcells[ LOAD_CELL_RESERVOIR_1_BACKUP ].rawReading  = getFPGALoadCellA2();
     loadcells[ LOAD_CELL_RESERVOIR_2_PRIMARY ].rawReading = getFPGALoadCellB1();
-    loadcells[ LOAD_CELL_RESERVOIR_2_BACKUP ].rawReading = getFPGALoadCellB2();
+    loadcells[ LOAD_CELL_RESERVOIR_2_BACKUP ].rawReading  = getFPGALoadCellB2();
 
+    // Check if a new calibration is available
+    if ( isNewCalibrationRecordAvailable() == TRUE )
+    {
+        // Get the new calibration data and check its validity
+        processCalibrationData();
+
+        // Zero the current tare values when new calibration data is available
+        loadcells[ LOAD_CELL_RESERVOIR_1_PRIMARY ].autoCalOffset = 0.0;
+        loadcells[ LOAD_CELL_RESERVOIR_1_BACKUP ].autoCalOffset  = 0.0;
+        loadcells[ LOAD_CELL_RESERVOIR_2_PRIMARY ].autoCalOffset = 0.0;
+        loadcells[ LOAD_CELL_RESERVOIR_2_BACKUP ].autoCalOffset  = 0.0;
+    }
+
     // Rolling average of last 100 raw samples in small filter
     for ( ii = 0; ii < NUM_OF_LOAD_CELLS; ++ii )
     {
-        loadcells[ ii ].weight.data = (F32)loadcells[ ii ].rawReading * ADC2GRAM + LOAD_CELL_ZERO_OFFSET - loadcells[ ii ].autoCalOffset;
+        loadcells[ ii ].weight.data = (F32)loadcells[ ii ].rawReading * ADC2GRAM;
+        // Apply the calibration factors to the data.
+        // load_cell_weight = fourth_order_coeff * (load_cell^4) + third_order_coeff * (load_cell^3) + second_order_coeff * (load_cell^2) + gain * load_cell + offset
+        loadcells[ ii ].weight.data = pow(loadcells[ ii ].weight.data, 4) * loadCellsCalRecord.loadCells[ (CAL_DATA_DG_LOAD_CELLS_T)ii ].fourthOrderCoeff +
+                                      pow(loadcells[ ii ].weight.data, 3) * loadCellsCalRecord.loadCells[ (CAL_DATA_DG_LOAD_CELLS_T)ii ].thirdOrderCoeff  +
+                                      pow(loadcells[ ii ].weight.data, 2) * loadCellsCalRecord.loadCells[ (CAL_DATA_DG_LOAD_CELLS_T)ii ].secondOrderCoeff +
+                                          loadcells[ ii ].weight.data     * loadCellsCalRecord.loadCells[ (CAL_DATA_DG_LOAD_CELLS_T)ii ].gain +
+                                          loadCellsCalRecord.loadCells[ (CAL_DATA_DG_LOAD_CELLS_T)ii ].offset;
+        loadcells[ ii ].weight.data = loadcells[ ii ].weight.data - loadcells[ ii ].autoCalOffset;
 
         // Update small filter with new weight sample
         loadcells[ ii ].smallFilterTotal -= loadcells[ ii ].smallFilterReadings[ smallReadingsIdx ];