Index: firmware/App/Controllers/DGInterface.c
===================================================================
diff -u -ra19a676d1e67bb3e1aca9e9bba49727f9d5f8b38 -r0b87f7e6142dc3710db5c32a0c7c6694343dd717
--- firmware/App/Controllers/DGInterface.c	(.../DGInterface.c)	(revision a19a676d1e67bb3e1aca9e9bba49727f9d5f8b38)
+++ firmware/App/Controllers/DGInterface.c	(.../DGInterface.c)	(revision 0b87f7e6142dc3710db5c32a0c7c6694343dd717)
@@ -15,6 +15,7 @@
  **************************************************************************/
 
 #include "AlarmMgmt.h"
+#include "ModeTreatment.h"
 #include "OperationModes.h"
 #include "SystemCommMessages.h"
 #include "DGInterface.h"
@@ -26,18 +27,37 @@
 
 // ********** private definitions **********
 
-#define START_DG_CMD        TRUE
-#define STOP_DG_CMD         FALSE
+#define START_DG_CMD                        TRUE            ///< .
+#define STOP_DG_CMD                         FALSE           ///< .
 
+#define DRAIN_RESERVOIR_TO_VOLUME_ML        100             ///< Drain reservoir to this volume (in mL) during treatment.
+#define FILL_RESERVOIR_TO_VOLUME_ML         1500            ///< Fill reservoir to this volume (in mL) during treatment.
+
+/// States of the treatment reservoir management state machine.
+typedef enum TreatmentReservoirMgmt_States
+{
+    TREATMENT_RESERVOIR_MGMT_START_STATE = 0,                ///< If DG not already in re-circ mode, try to get it there.
+    TREATMENT_RESERVOIR_MGMT_FLUSH_DG_LINES_STATE,           ///< In DG re-circ, wait for lines to flush - then start draining inactive reservoir.
+    TREATMENT_RESERVOIR_MGMT_DRAIN_RESERVOIR_STATE,          ///< Wait for drain to complete.
+    TREATMENT_RESERVOIR_MGMT_WAIT_TO_FILL_STATE,             ///< Wait to fill inactive reservoir (if appropriate) - then start filling inactive reservoir.
+    TREATMENT_RESERVOIR_MGMT_FILL_RESERVOIR_STATE,           ///< Wait for fill to complete.
+    TREATMENT_RESERVOIR_MGMT_WAIT_FOR_RES_SWITCH_STATE,      ///< Wait for active reservoir to be consumed and switch cmd given - then back to flush DG lines state.
+    NUM_OF_TREATMENT_RESERVOIR_MGMT_STATES                   ///< Number of treatment reservoir mgmt. states.
+} TREATMENT_RESERVOIR_MGMT_STATE_T;
+
 // ********** private data **********
 
 // DG status
 static DG_OP_MODE_T dgCurrentOpMode = DG_MODE_INIT;
+static U32 dgSubMode = 0;
 static BOOL dgStarted = FALSE;
 static BOOL dgStartetSet = FALSE;
 static BOOL dgWaterSampled = FALSE;
 static BOOL dgWaterSampledSet = FALSE;
 
+// state machine states
+static TREATMENT_RESERVOIR_MGMT_STATE_T currentTrtResMgmtState = TREATMENT_RESERVOIR_MGMT_START_STATE;   ///< Current state of treatment mode reservoir management.
+
 // DG sensor data
 static F32 dgPressures[ NUM_OF_DG_PRESSURE_SENSORS ];
 static F32 dgPrimaryTempSet = 0.0;
@@ -71,11 +91,99 @@
  *************************************************************************/
 void initDGInterface( void )
 {
-    // TODO - anything to initialize?
+    currentTrtResMgmtState = TREATMENT_RESERVOIR_MGMT_START_STATE;
 }
 
 /*********************************************************************//**
  * @brief
+ * The execTreatmentReservoirMgmt function executes the state machine for the \n
+ * reservoir management during treatment mode.
+ * @details
+ * Inputs : none
+ * Outputs : DG reservoirs (drains & fills) managed.
+ * @return none
+ *************************************************************************/
+void execTreatmentReservoirMgmt( void )
+{
+    DG_OP_MODE_T dgOpMode = getDGOpMode();  // TODO - the DG mode & sub-mode come as a pair at interval - they MUST be kept together.
+    U32 dgSubMode = getDGSubMode();
+
+    // treatment reservoir mgmt. state machine
+    switch ( currentTrtResMgmtState )
+    {
+        case TREATMENT_RESERVOIR_MGMT_START_STATE:
+            currentTrtResMgmtState = TREATMENT_RESERVOIR_MGMT_FLUSH_DG_LINES_STATE;
+            break;
+
+        case TREATMENT_RESERVOIR_MGMT_FLUSH_DG_LINES_STATE:
+            if ( DG_MODE_CIRC == dgOpMode )
+            {
+                if ( DG_RECIRCULATE_MODE_STATE_RECIRC_WATER == dgSubMode )
+                {
+                    cmdStartDGDrain( DRAIN_RESERVOIR_TO_VOLUME_ML );
+                }
+            }
+            else if ( DG_MODE_DRAI == dgOpMode )
+            {
+                currentTrtResMgmtState = TREATMENT_RESERVOIR_MGMT_DRAIN_RESERVOIR_STATE;
+            }
+            else
+            {
+                // TODO - ???
+            }
+            break;
+
+        case TREATMENT_RESERVOIR_MGMT_DRAIN_RESERVOIR_STATE:
+            if ( DG_MODE_CIRC == dgOpMode )
+            {
+                currentTrtResMgmtState = TREATMENT_RESERVOIR_MGMT_WAIT_TO_FILL_STATE;
+            }
+            break;
+
+        case TREATMENT_RESERVOIR_MGMT_WAIT_TO_FILL_STATE:
+            // delay fill start if we've paused treatment?
+            if ( getTreatmentState() == TREATMENT_DIALYSIS_STATE )
+            {
+                if ( DG_MODE_CIRC == dgOpMode )
+                {
+                    if ( DG_RECIRCULATE_MODE_STATE_RECIRC_WATER == dgSubMode )
+                    {
+                        cmdStartDGFill( FILL_RESERVOIR_TO_VOLUME_ML );
+                    }
+                }
+                else
+                {
+                    // TODO - ???
+                }
+            }
+            if ( DG_MODE_FILL == dgOpMode )
+            {
+                currentTrtResMgmtState = TREATMENT_RESERVOIR_MGMT_FILL_RESERVOIR_STATE;
+            }
+            break;
+
+        case TREATMENT_RESERVOIR_MGMT_FILL_RESERVOIR_STATE:
+            if ( DG_MODE_CIRC == dgOpMode )
+            {
+                currentTrtResMgmtState = TREATMENT_RESERVOIR_MGMT_WAIT_FOR_RES_SWITCH_STATE;
+            }
+            break;
+
+        case TREATMENT_RESERVOIR_MGMT_WAIT_FOR_RES_SWITCH_STATE:
+            // reservoir switch during treatment should only occur in this state (i.e. when DG is ready).
+            // state will reset to start when next reservoir switch is commanded.
+            // TODO - should this state machine determine when to give reservoir switch command?  Or leave to treatment mode?
+            break;
+
+        default:
+            // TODO - s/w fault
+            currentTrtResMgmtState = TREATMENT_RESERVOIR_MGMT_START_STATE;
+            break;
+    }
+}
+
+/*********************************************************************//**
+ * @brief
  * The getDGOpMode function gets the current DG operating mode.
  * @details
  * Inputs : dgCurrentOpMode
@@ -84,9 +192,20 @@
  *************************************************************************/
 DG_OP_MODE_T getDGOpMode( void )
 {
-    DG_OP_MODE_T result = dgCurrentOpMode;
+    return dgCurrentOpMode;
+}
 
-    return result;
+/*********************************************************************//**
+ * @brief
+ * The getDGSubMode function gets the current DG operating sub-mode.
+ * @details
+ * Inputs : dgSubMode
+ * Outputs : none
+ * @return Current DG operating sub-mode.
+ *************************************************************************/
+U32 getDGSubMode( void )
+{
+    return dgSubMode;
 }
 
 /*********************************************************************//**
@@ -171,13 +290,15 @@
  * Inputs : none
  * Outputs : dgCurrentOpMode
  * @param opMode : operating mode reported by DG.
+ * @param subMode : sub-mode (current state) of operating mode reported by DG.
  * @return none
  *************************************************************************/
-void setDGOpMode( U32 opMode )
+void setDGOpMode( U32 opMode, U32 subMode )
 {
     if ( opMode < NUM_OF_DG_MODES )
     {
         dgCurrentOpMode = (DG_OP_MODE_T)opMode;
+        dgSubMode = subMode;
     }
 }
 
@@ -334,6 +455,8 @@
     {
         dgActiveReservoirSet = resID;
         sendDGSwitchReservoirCommand( resID );
+        // reset treatment reservoir mgmt. state machine on reservoir switch
+        currentTrtResMgmtState = TREATMENT_RESERVOIR_MGMT_START_STATE;
     }
     else
     {