Index: firmware/App/Modes/ModeTreatment.c
===================================================================
diff -u -r9c833ef5623ce842267e284d958820ac0dc3a7fc -r1275f9e92eb1ab0cd1b321c0c8eb940524e22117
--- firmware/App/Modes/ModeTreatment.c	(.../ModeTreatment.c)	(revision 9c833ef5623ce842267e284d958820ac0dc3a7fc)
+++ firmware/App/Modes/ModeTreatment.c	(.../ModeTreatment.c)	(revision 1275f9e92eb1ab0cd1b321c0c8eb940524e22117)
@@ -30,6 +30,8 @@
 #include "StateTxBloodPrime.h"
 #include "StateTxDialysis.h"
 #include "StateTxPaused.h"
+#include "StateTxRecirc.h"
+#include "StateTxRinseback.h"
 //#include "Switches.h"
 #include "TaskGeneral.h"
 #include "Timers.h"
@@ -91,9 +93,13 @@
 static BOOL resumeTreatmentAlarmResponseRequest;                ///< Flag indicates user has requested treatment resume.
 static BOOL initiateRinsebackAlarmResponseRequest;              ///< Flag indicates user has requested rinseback.
 static BOOL endTreatmentAlarmResponseRequest;                   ///< Flag indicates user has requested treatment end.
+static BOOL initiateTempBreakALarmReponseRequest;               ///< Flag indicates user has requested temporary break.
 static BOOL endTreatmentRequest;                                ///< Flag indicates user has requested end of treatment from rinseback workflow.
 static BOOL bloodPrimeToDialysisRequest;                        ///< Flag indicates blood prime has completed and time to start dialysis.
 static BOOL resumeBlockedByAlarm;                               ///< Flag indicates an alarm has blocked resume of this treatment.
+static BOOL rinsebackToRecircRequest;                           ///< Flag indicates rinseback sub-mode has requested transition to Re-circulate.
+static BOOL recirculateToBloodPrimeRequest;                     ///< Flag indicates re-circulate sub-mode has requested transition to Treatment Blood prime.
+static BOOL recircAllowed;                                      ///< Flag indicates re-circulate allowed only if user selects temp break option.
 
 static U32  treatmentStartTimeStamp;                            ///< Treatment start timestamp for logging purpose.
 static U32  treatmentEndTimeStamp;                              ///< Treatment end timestamp for logging purpose.
@@ -131,6 +137,7 @@
     treatmentCompleted = FALSE;
     rinsebackDone = FALSE;
     resumeBlockedByAlarm = FALSE;
+    recircAllowed = FALSE;
 
     treatmentTimePublishInterval.data = TREATMENT_TIME_DATA_PUB_INTERVAL;
     treatmentTimePublishInterval.ovData = TREATMENT_TIME_DATA_PUB_INTERVAL;
@@ -185,8 +192,8 @@
         initBloodPrime();
         initDialysis();
         initTreatmentPaused();
-//        initRinseback();
-//        initTreatmentRecirc();
+        initRinseback();
+        initTreatmentRecirc();
 //        initTreatmentEnd();
         initFluidBolus();
 
@@ -266,6 +273,20 @@
 
 /*********************************************************************//**
  * @brief
+ * The isRecircAllowed function determines whether the recirculation is
+ * allowed or not. Only allowed in temporary break option
+ * seen an alarm that prevents resumption.
+ * @details \b Inputs: recircAllowed
+ * @details \b Outputs: none
+ * @return isRecircAllowed
+ *************************************************************************/
+BOOL isRecircAllowed( void )
+{
+    return recircAllowed;
+}
+
+/*********************************************************************//**
+ * @brief
  * The getTreatmentTimeRemainingSecs function determines the number of seconds
  * remaining in the treatment.
  * @details \b Inputs: presTreatmentTimeSecs, treatmentTimeMS
@@ -349,6 +370,35 @@
 
 /*********************************************************************//**
  * @brief
+ * The setRinsebackIsCompleted function sets that flag indicating whether a
+ * rinseback has been completed.  Call this function with TRUE when rinseback
+ * operation is completed.  Call this function with FALSE at start of blood
+ * prime operation.
+ * @details Inputs: none
+ * @details Outputs: rinsebackDone
+ * @param flag TRUE if rinseback has been completed, FALSE if not
+ * @return none
+ *************************************************************************/
+void setRinsebackIsCompleted( BOOL flag )
+{
+    rinsebackDone = flag;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getRinsebackIsCompleted function determines whether a rinseback has been
+ * completed (indicating blood-side circuit should be primarily saline or online fluid).
+ * @details Inputs: rinsebackDone
+ * @details Outputs: none
+ * @return rinsebackDone
+ *************************************************************************/
+BOOL getRinsebackIsCompleted( void )
+{
+    return rinsebackDone;
+}
+
+/*********************************************************************//**
+ * @brief
  * The signalAlarmActionToTreatmentMode function executes the given alarm action
  * as appropriate while in Treatment Mode.
  * @details \b Alarm: ALARM_ID_TD_SOFTWARE_FAULT if invalid alarm action given.
@@ -381,6 +431,10 @@
             // Nothing to be done here
             break;
 
+        case ALARM_ACTION_TEMPORARY_BREAK:
+            initiateTempBreakALarmReponseRequest = TRUE;
+            break;
+
         default:
             SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_TREATMENT_INVALID_ALARM_ACTION, (U32)action )
             break;
@@ -415,6 +469,32 @@
 
 /*********************************************************************//**
  * @brief
+ * The signalGoToBloodPrime function signals that user wants to return
+ * to treatment blood prime from recirculate workflow.
+ * @details Inputs: none
+ * @details Outputs:
+ * @return none
+ *************************************************************************/
+void signalGoToBloodPrime( void )
+{
+    recirculateToBloodPrimeRequest = TRUE;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The signalRinsebackToRecirc function signals that user wants to continue
+ * on to re-circulate portion of rinseback workflow.
+ * @details Inputs: none
+ * @details Outputs: rinsebackToRecircRequest
+ * @return none
+ *************************************************************************/
+void signalRinsebackToRecirc( void )
+{
+    rinsebackToRecircRequest = TRUE;
+}
+
+/*********************************************************************//**
+ * @brief
  * The execTreatmentMode function executes the Treatment Mode state machine.
  * @details \b Alarm: ALARM_ID_TD_TREATMENT_PED_BY_USER if user presses
  * the  button
@@ -585,6 +665,9 @@
         // Handle signals from blood prime sub-mode
         if ( TRUE == bloodPrimeToDialysisRequest )
         {
+            F32 rinsebackVolume_L = getDeliveredRinsebackVolume() / (F32)ML_PER_LITER;
+            F32 addToUFVolume = getTreatmentParameterF32( TREATMENT_PARAM_UF_VOLUME ) + rinsebackVolume_L;
+
             lastTreatmentTimeStamp = getMSTimerCount();
             // Kick dialysis sub-mode off
             setDialysisBloodPumpFlowRate( getTreatmentParameterU32( TREATMENT_PARAM_BLOOD_FLOW ) );
@@ -594,6 +677,15 @@
 //            {
 //                sendTreatmentLogEventData( UF_START_RESUME_EVENT, 0.0, presUFRate );
 //            }
+
+            // Add only if rinseback is completed
+            if ( TRUE == getRinsebackIsCompleted() )
+            {
+                // Add rinseback volume to UF volume (fluid in circuit goes back to the patient when we resume treatment)
+                setTreatmentParameterF32( TREATMENT_PARAM_UF_VOLUME, addToUFVolume );
+                setRinsebackIsCompleted( FALSE );
+            }
+
             transitionToDialysis();
 //            // To update partial blood pump occlusion baseline - start of treatment
 //            signalBloodPumpPressureOcclBaseline();
@@ -686,18 +778,28 @@
         }
         signalInitiatePressureStabilization( USE_NORMAL_STABILIZATION_PERIOD );
     }
-    // If user requests rinseback, go to rinseback
-//    else if ( TRUE == initiateRinsebackAlarmResponseRequest )
-//    {
-//        transitionToRinseback();
-//        result = TREATMENT_RINSEBACK_STATE;
-//    }
+    // If user requests temp break, go to rinseback and then recirc
+    else if ( TRUE == initiateTempBreakALarmReponseRequest )
+    {
+        initiateTempBreakALarmReponseRequest = FALSE;
+        recircAllowed = TRUE;
+        transitionToRinseback();
+        result = TREATMENT_RINSEBACK_STATE;
+    }
+    // If user requests blood return & end treatemnt, go to rinseback only and end treat
+    else if ( TRUE == initiateRinsebackAlarmResponseRequest )
+    {
+        initiateRinsebackAlarmResponseRequest = FALSE;
+        recircAllowed = FALSE;
+        transitionToRinseback();
+        result = TREATMENT_RINSEBACK_STATE;
+    }
     // If user requests treatment end, end treatment
-//    else if ( TRUE == endTreatmentAlarmResponseRequest )
-//    {
-//        sendLastTreatmentPeriodicData = TRUE;
-//        requestNewOperationMode( MODE_POST );
-//    }
+    else if ( TRUE == endTreatmentAlarmResponseRequest )
+    {
+        //sendLastTreatmentPeriodicData = TRUE;
+        requestNewOperationMode( MODE_POST );
+    }
     // Otherwise execute state machine for treatment paused sub-mode
     else
     {
@@ -723,89 +825,76 @@
  * The handleTreatmentRinsebackState function executes the rinseback state of the
  * Treatment Mode state machine.
  * @details \b Inputs: endTreatmentAlarmResponseRequest, resumeTreatmentAlarmResponseRequest,
- * rinsebackToRecircRequest, rinsebackTopedRequest, endTreatmentRequest
+ * rinsebackToRecircRequest
  * @details \b Outputs: treatment rinseback sub-mode executed, sendLastTreatmentPeriodicData
  * @return next treatment mode state
  *************************************************************************/
 static TREATMENT_STATE_T handleTreatmentRinsebackState( void )
 {
     TREATMENT_STATE_T result = TREATMENT_RINSEBACK_STATE;
 
-//    // If user requests treatment end, end treatment
-//    if ( TRUE == endTreatmentAlarmResponseRequest )
-//    {
-//        sendLastTreatmentPeriodicData = TRUE;
-//        requestNewOperationMode( MODE_POST );
-//    }
-//    // Otherwise execute state machine for treatment rinseback sub-mode
-//    else
-//    {
-//        // If user requests resumption of treatment, resume rinseback
-//        if ( TRUE == resumeTreatmentAlarmResponseRequest )
-//        {
-//            resumeTreatmentAlarmResponseRequest = FALSE;
-//            signalRinsebackAlarmResumeUserAction();
-//        }
-//        // Execute treatment rinseback sub-mode
-//        execRinseback();
-//    }
-//
-//    // Handle signals from rinseback sub-mode
-//    if ( TRUE == rinsebackToRecircRequest )
-//    {
-//        transitionToTreatmentRecirc();
-//        result = TREATMENT_RECIRC_STATE;
-//    }
-//    else if ( TRUE == rinsebackTopedRequest )
-//    {
-//        transitionToTreatment();
-//        result = TREATMENT_PAUSED_STATE;
-//    }
-//    else if ( TRUE == endTreatmentRequest )
-//    {
-//        requestNewOperationMode( MODE_POST );
-//    }
+    // If user requests treatment end, end treatment
+    if ( TRUE == endTreatmentAlarmResponseRequest )
+    {
+        //sendLastTreatmentPeriodicData = TRUE;
+        requestNewOperationMode( MODE_POST );
+    }
+    else
+    {
+        // Forward alarm resume action to rinseback sub-mode as a rinseback specific resume
+        if ( TRUE == resumeTreatmentAlarmResponseRequest )
+        {
+            resumeTreatmentAlarmResponseRequest = FALSE;
+            signalRinsebackAlarmResumeUserAction();
+        }
 
+        // Execute treatment rinseback sub-mode
+        execRinseback();
+    }
+
+    // Handle signals from rinseback sub-mode
+    if ( TRUE == rinsebackToRecircRequest )
+    {
+        transitionToTreatmentRecirc();
+        result = TREATMENT_RECIRC_STATE;
+    }
+
     return result;
 }
 
 /*********************************************************************//**
  * @brief
  * The handleTreatmentRecircState function executes the re-circulate state of the
  * Treatment Mode state machine.
- * @details \b Inputs: endTreatmentAlarmResponseRequest, rinsebackTopedRequest,
- * endTreatmentRequest
+ * @details \b Inputs: endTreatmentAlarmResponseRequest, recirculateToBloodPrimeRequest
  * @details \b Outputs: sendLastTreatmentPeriodicData
  * @return next treatment mode state
  *************************************************************************/
 static TREATMENT_STATE_T handleTreatmentRecircState( void )
 {
     TREATMENT_STATE_T result = TREATMENT_RECIRC_STATE;
 
-//    // If user requests treatment end, end treatment
-//    if ( TRUE == endTreatmentAlarmResponseRequest )
-//    {
-//        sendLastTreatmentPeriodicData = TRUE;
-//        requestNewOperationMode( MODE_POST );
-//    }
-//    else
-//    {
-//        // Execute treatment re-circ sub-mode
-//        execTreatmentRecirc();
-//    }
-//
-//    // Handle signals from treatment re-circ sub-mode
-//    if ( TRUE == rinsebackTopedRequest )
-//    {
-//        Dialysis();
-//        transitionToTreatment();
-//        result = TREATMENT__STATE;
-//    }
-//    else if ( TRUE == endTreatmentRequest )
-//    {
-//        requestNewOperationMode( MODE_POST );
-//    }
+    // If user requests treatment end, end treatment
+    if ( TRUE == endTreatmentAlarmResponseRequest )
+    {
+        //sendLastTreatmentPeriodicData = TRUE;
+        // Stop dialysate generation
+        cmdStopGenerateDialysate();
+        requestNewOperationMode( MODE_POST );
+    }
+    else
+    {
+        // Execute treatment re-circ sub-mode
+        execTreatmentRecirc();
+    }
 
+    // Back to blood prime when user requests resume treatment
+    if ( TRUE == recirculateToBloodPrimeRequest )
+    {
+        transitionToBloodPrime();
+        result = TREATMENT_BLOOD_PRIME_STATE;
+    }
+
     return result;
 }
 
@@ -910,8 +999,8 @@
         payload.dialysisState = getDialysisState();
         payload.isoUFState = 0;
         payload.txPausedState = getCurrentTreatmentPausedState();
-        payload.rinsebackState = 0; // getCurrentRinsebackState();
-        payload.txRecircState = 0; // getCurrentTreatmentRecircState();
+        payload.rinsebackState = getCurrentRinsebackState();
+        payload.txRecircState = getCurrentTreatmentRecircState();
         payload.txEndState = 0; // getCurrentTreatmentEndState();
         payload.txFluidBolusState = getCurrentFluidBolusState();
         payload.txHepState = 0; //
@@ -1095,11 +1184,11 @@
  *************************************************************************/
 static void resetSignalFlags( void )
 {
-//    rinsebackTopedRequest = FALSE;
     endTreatmentRequest = FALSE;
-//    rinsebackToRecircRequest = FALSE;
+    rinsebackToRecircRequest = FALSE;
     bloodPrimeToDialysisRequest = FALSE;
 //    treatmentEndToRinsebackRequest = FALSE;
+    recirculateToBloodPrimeRequest = FALSE;
 }
 
 /*********************************************************************//**
@@ -1114,6 +1203,7 @@
     resumeTreatmentAlarmResponseRequest = FALSE;
     initiateRinsebackAlarmResponseRequest = FALSE;
     endTreatmentAlarmResponseRequest = FALSE;
+    initiateTempBreakALarmReponseRequest = FALSE;
 }
 
 /*********************************************************************//**