Index: firmware/App/Modes/SelfTests.c
===================================================================
diff -u -r9055124b17389e04131b44c00915c33c72db3ae6 -r197d80dce4d78c253ef16a970f52d84cea4158cc
--- firmware/App/Modes/SelfTests.c	(.../SelfTests.c)	(revision 9055124b17389e04131b44c00915c33c72db3ae6)
+++ firmware/App/Modes/SelfTests.c	(.../SelfTests.c)	(revision 197d80dce4d78c253ef16a970f52d84cea4158cc)
@@ -811,10 +811,6 @@
     {
         state = DRY_SELF_TESTS_OCCLUSION_SENSORS_STATE;
     }
-    else
-    {
-        activateAlarmNoData( ALARM_ID_INSTALL_NEW_CARTRIDGE );
-    }
 
     return state;
 }
Index: firmware/App/Services/SystemCommMessages.c
===================================================================
diff -u -r9055124b17389e04131b44c00915c33c72db3ae6 -r197d80dce4d78c253ef16a970f52d84cea4158cc
--- firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision 9055124b17389e04131b44c00915c33c72db3ae6)
+++ firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision 197d80dce4d78c253ef16a970f52d84cea4158cc)
@@ -28,13 +28,16 @@
 #include "ModePreTreat.h"
 #include "ModeStandby.h"
 #include "ModeTreatment.h"
-#include "ModeTreatmentParams.h"
-#include "PresOccl.h"
+#include "ModeTreatmentParams.h"
+#include "OperationModes.h"
+#include "PresOccl.h"
 #include "RTC.h"
 #include "SampleWater.h"
 #include "SafetyShutdown.h"
 #include "SystemComm.h"
-#include "SystemCommMessages.h"
+#include "SystemCommMessages.h"
+#include "TreatmentEnd.h"
+#include "TreatmentRecirc.h"
 #include "Utilities.h"
 #include "Valves.h"
 #include "WatchdogMgmt.h"
@@ -398,8 +401,8 @@
     result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_2_UI, ACK_REQUIRED );
 
     return result;
-}
-
+}
+
 /*********************************************************************//**
  * @brief
  * The sendChangeBloodDialysateRateChangeResponse function constructs a change
@@ -1327,7 +1330,7 @@
     result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_BROADCAST, ACK_NOT_REQUIRED );
 
     return result;
-}
+}
 
 /*********************************************************************//**
  * @brief
@@ -1482,28 +1485,19 @@
  * be broadcast and queues the msg for transmit on the appropriate CAN channel.
  * @details Inputs: none
  * @details Outputs: treatment state msg constructed and queued
- * @param subMode Current state (sub-mode) of treatment
- * @param uFState Current state of ultrafiltration
- * @param salineBolusState 1=saline bolus in progress, 0=not, 2=max bolus volume reached
+ * @param payload Record with treatment state data
  * @return TRUE if msg successfully queued for transmit, FALSE if not
  *************************************************************************/
-BOOL broadcastTreatmentState( U32 subMode, U32 uFState, U32 salineBolusState )
+BOOL broadcastTreatmentState( TREATMENT_STATE_DATA_T payload )
 {
     BOOL result;
     MESSAGE_T msg;
     U08 *payloadPtr = msg.payload;
-    TREATMENT_STATE_DATA_T payload;
 
-    // Create a message record
     blankMessage( &msg );
     msg.hdr.msgID = MSG_ID_TREATMENT_STATE;
     msg.hdr.payloadLen = sizeof( TREATMENT_STATE_DATA_T );
 
-    payload.treatmentSubMode = subMode;
-    payload.uFState = uFState;
-    payload.salineBolusState = salineBolusState;
-    payload.heparinState = 0;  // TODO - add this later
-
     memcpy( payloadPtr, &payload, sizeof( TREATMENT_STATE_DATA_T ) );
 
     // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer
@@ -1653,6 +1647,124 @@
 
 /***********************************************************************//**
  * @brief
+ * The broadcastTreatmentStopData function constructs a treatment stop data msg to
+ * be broadcast and queues the msg for transmit on the appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: treatment stop data msg constructed and queued
+ * @param timeout treatment stop timeout (in sec)
+ * @param countdown treatment stop timeout count down (in sec)
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL broadcastTreatmentStopData(  U32 timeout, U32 countdown  )
+{
+    BOOL result;
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_TREATMENT_STOP_TIMER_DATA;
+    msg.hdr.payloadLen = sizeof( U32 ) + sizeof( U32 );
+
+    memcpy( payloadPtr, &timeout, sizeof( U32 ) );
+    payloadPtr += sizeof( U32 );
+    memcpy( payloadPtr, &countdown, sizeof( U32 ) );
+
+    // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer
+    result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_BROADCAST, ACK_NOT_REQUIRED );
+
+    return result;
+}
+
+/***********************************************************************//**
+ * @brief
+ * The broadcastRinsebackData function constructs a rinseback data msg to
+ * be broadcast and queues the msg for transmit on the appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: rinseback data msg constructed and queued
+ * @param data rinseback data record
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL broadcastRinsebackData( RINSEBACK_DATA_PAYLOAD_T data )
+{
+    BOOL result;
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_RINSEBACK_PROGRESS;
+    msg.hdr.payloadLen = sizeof( RINSEBACK_DATA_PAYLOAD_T );
+
+    memcpy( payloadPtr, &data, sizeof( RINSEBACK_DATA_PAYLOAD_T ) );
+
+    // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer
+    result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_BROADCAST, ACK_NOT_REQUIRED );
+
+    return result;
+}
+
+/***********************************************************************//**
+ * @brief
+ * The broadcastRecircData function constructs a treatment re-circ data msg to
+ * be broadcast and queues the msg for transmit on the appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: treatment re-circ data msg constructed and queued
+ * @param timeout re-circulation timeout (in sec)
+ * @param countdown re-circulation timeout count down (in sec)
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL broadcastRecircData( U32 timeout, U32 countdown )
+{
+    BOOL result;
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_RECIRC_PROGRESS;
+    msg.hdr.payloadLen = sizeof( U32 ) + sizeof( U32 );
+
+    memcpy( payloadPtr, &timeout, sizeof( U32 ) );
+    payloadPtr += sizeof( U32 );
+    memcpy( payloadPtr, &countdown, sizeof( U32 ) );
+
+    // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer
+    result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_BROADCAST, ACK_NOT_REQUIRED );
+
+    return result;
+}
+
+/***********************************************************************//**
+ * @brief
+ * The broadcastBloodPrimeData function constructs a blood prime data msg to
+ * be broadcast and queues the msg for transmit on the appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: blood prime data msg constructed and queued
+ * @param data blood prime data record
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL broadcastBloodPrimeData( BLOOD_PRIME_DATA_PAYLOAD_T data )
+{
+    BOOL result;
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_BLOOD_PRIME_PROGRESS;
+    msg.hdr.payloadLen = sizeof( BLOOD_PRIME_DATA_PAYLOAD_T );
+
+    memcpy( payloadPtr, &data, sizeof( BLOOD_PRIME_DATA_PAYLOAD_T ) );
+
+    // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer
+    result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_BROADCAST, ACK_NOT_REQUIRED );
+
+    return result;
+}
+
+/***********************************************************************//**
+ * @brief
  * The broadcastAirTrapData function constructs an HD air trap data msg to \n
  * be broadcast and queues the msg for transmit on the appropriate CAN channel.
  * @details Inputs: none
@@ -1899,7 +2011,7 @@
 
         memcpy( &cmd, payloadPtr, sizeof( U32 ) );
 
-        signalAlarmSilence( cmd );
+        signalAlarmSilence( (ALARM_SILENCE_CMD_T)cmd );
     }
     else
     {
@@ -2259,12 +2371,12 @@
  * response to the UI and queues the msg for transmit on the appropriate CAN channel.
  * @details Inputs: none
  * @details Outputs: Treatment parameters response msg constructed and queued.
- * @param rejected T/F - are settings rejected?
+ * @param accepted T/F - are settings accepted?
  * @param rejectReasons reasons each parameter was rejected (if not accepted)
  * @param byteLength number of bytes that array of reject reasons takes
  * @return TRUE if msg successfully queued for transmit, FALSE if not
  *************************************************************************/
-BOOL sendTreatmentParametersResponseMsg( BOOL rejected, U08 *rejectReasons, U32 byteLength )
+BOOL sendTreatmentParametersResponseMsg( BOOL accepted, U08 *rejectReasons, U32 byteLength )
 {
     BOOL result;
     MESSAGE_T msg;
@@ -2275,7 +2387,7 @@
     msg.hdr.msgID = MSG_ID_HD_NEW_TREATMENT_PARAMS_RESPONSE;
     msg.hdr.payloadLen = sizeof( BOOL ) + byteLength;
 
-    memcpy( payloadPtr, &rejected, sizeof( BOOL ) );
+    memcpy( payloadPtr, &accepted, sizeof( BOOL ) );
     payloadPtr += sizeof( BOOL );
     memcpy( payloadPtr, rejectReasons, byteLength );
 
@@ -2419,7 +2531,7 @@
         sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
     }
 }
-
+
 /*********************************************************************//**
  * @brief
  * The handleChangeBloodDialysateRateChangeRequest function handles a blood
@@ -2540,9 +2652,10 @@
  * @param accepted T/F - was saline bolus request accepted?
  * @param rejReason reason why request was rejected (or zero if accepted)
  * @param bolusVol volume (in mL) currently set for saline bolus
+ * @param bolusState current state of saline bolus
  * @return TRUE if msg successfully queued for transmit, FALSE if not
  *************************************************************************/
-BOOL sendSalineBolusResponse( BOOL accepted, U32 rejReason, U32 bolusVol )
+BOOL sendSalineBolusResponse( BOOL accepted, U32 rejReason, U32 bolusVol, U32 bolusState )
 {
     BOOL result;
     MESSAGE_T msg;
@@ -2551,19 +2664,191 @@
     // Create a message record
     blankMessage( &msg );
     msg.hdr.msgID = MSG_ID_USER_SALINE_BOLUS_RESPONSE;
-    msg.hdr.payloadLen = sizeof( BOOL ) + sizeof( U32 ) + sizeof( U32 );
+    msg.hdr.payloadLen = sizeof( BOOL ) + sizeof( U32 ) + sizeof( U32 ) + sizeof( U32 );
 
     memcpy( payloadPtr, &accepted, sizeof( BOOL ) );
     payloadPtr += sizeof( BOOL );
     memcpy( payloadPtr, &rejReason, sizeof( U32 ) );
     payloadPtr += sizeof( U32 );
     memcpy( payloadPtr, &bolusVol, sizeof( U32 ) );
+    payloadPtr += sizeof( U32 );
+    memcpy( payloadPtr, &bolusState, sizeof( U32 ) );
 
     // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer
     result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_2_UI, ACK_REQUIRED );
 
     return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handlRinsebackCmd function handles a rinseback user action command
+ * message from the UI.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handlRinsebackCmd( MESSAGE_T *message )
+{
+    if ( sizeof(U32) == message->hdr.payloadLen )
+    {
+        U32 cmd;
+
+        memcpy( &cmd, &message->payload[0], sizeof(U32) );
+
+        signalRinsebackUserAction( (REQUESTED_RINSEBACK_USER_ACTIONS_T)cmd );
+    }
+    else
+    {
+        sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    }
+}
+
+/*********************************************************************//**
+ * @brief
+ * The sendRinsebackCmdResponse function constructs a rinseback user action
+ * response to the UI and queues the msg for transmit on the appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: Rinseback command response msg constructed and queued.
+ * @param accepted T/F - was rinseback user action accepted?
+ * @param rejReason reason why action was rejected (or zero if accepted)
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL sendRinsebackCmdResponse( BOOL accepted, U32 rejReason )
+{
+    BOOL result;
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_RINSEBACK_CMD_RESPONSE;
+    msg.hdr.payloadLen = sizeof( BOOL ) + sizeof( U32 );
+
+    memcpy( payloadPtr, &accepted, sizeof( BOOL ) );
+    payloadPtr += sizeof( BOOL );
+    memcpy( payloadPtr, &rejReason, sizeof( U32 ) );
+
+    // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer
+    result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_2_UI, ACK_REQUIRED );
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTreatmentRecircCmd function handles a treatment re-circ user action command
+ * message from the UI.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTreatmentRecircCmd( MESSAGE_T *message )
+{
+    if ( sizeof(U32) == message->hdr.payloadLen )
+    {
+        U32 cmd;
+
+        memcpy( &cmd, &message->payload[0], sizeof(U32) );
+
+        signalTreatmentRecircUserAction( (REQUESTED_TREATMENT_RECIRC_USER_ACTIONS_T)cmd );
+    }
+    else
+    {
+        sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    }
+}
+
+/*********************************************************************//**
+ * @brief
+ * The sendTreatmentRecircCmdResponse function constructs a treatment re-circulation
+ * user action response to the UI and queues the msg for transmit on the appropriate
+ * CAN channel.
+ * @details Inputs: none
+ * @details Outputs: Treatment re-circ command response msg constructed and queued.
+ * @param accepted T/F - was re-circ user action accepted?
+ * @param rejReason reason why action was rejected (or zero if accepted)
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL sendTreatmentRecircCmdResponse( BOOL accepted, U32 rejReason )
+{
+    BOOL result;
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_RECIRC_CMD_RESPONSE;
+    msg.hdr.payloadLen = sizeof( BOOL ) + sizeof( U32 );
+
+    memcpy( payloadPtr, &accepted, sizeof( BOOL ) );
+    payloadPtr += sizeof( BOOL );
+    memcpy( payloadPtr, &rejReason, sizeof( U32 ) );
+
+    // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer
+    result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_2_UI, ACK_REQUIRED );
+
+    return result;
 }
+
+/*********************************************************************//**
+ * @brief
+ * The handleTreatmentEndCmd function handles a treatment end user action command
+ * message from the UI.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTreatmentEndCmd( MESSAGE_T *message )
+{
+    if ( sizeof(U32) == message->hdr.payloadLen )
+    {
+        U32 cmd;
+
+        memcpy( &cmd, &message->payload[0], sizeof(U32) );
+
+        signalTreatmentEndUserAction( (REQUESTED_TREATMENT_END_USER_ACTIONS_T)cmd );
+    }
+    else
+    {
+        sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    }
+}
+
+/*********************************************************************//**
+ * @brief
+ * The sendTreatmentEndCmdResponse function constructs a treatment end
+ * user action response to the UI and queues the msg for transmit on the
+ * appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: Treatment end command response msg constructed and queued.
+ * @param accepted T/F - was user action accepted?
+ * @param rejReason reason why action was rejected (or zero if accepted)
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL sendTreatmentEndCmdResponse( BOOL accepted, U32 rejReason )
+{
+    BOOL result;
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_TX_END_CMD_RESPONSE;
+    msg.hdr.payloadLen = sizeof( BOOL ) + sizeof( U32 );
+
+    memcpy( payloadPtr, &accepted, sizeof( BOOL ) );
+    payloadPtr += sizeof( BOOL );
+    memcpy( payloadPtr, &rejReason, sizeof( U32 ) );
+
+    // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer
+    result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_2_UI, ACK_REQUIRED );
+
+    return result;
+}
 
 /*********************************************************************//**
  * @brief
@@ -3521,7 +3806,7 @@
         memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
         if ( FALSE == payload.reset )
         {
-            result = testSetBloodPumpOcclusionOverride( payload.state.f32 );
+            result = testSetBloodPumpOcclusionOverride( payload.state.u32 );
         }
         else
         {
@@ -3553,7 +3838,7 @@
         memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
         if ( FALSE == payload.reset )
         {
-            result = testSetDialInPumpOcclusionOverride( payload.state.f32 );
+            result = testSetDialInPumpOcclusionOverride( payload.state.u32 );
         }
         else
         {
@@ -3585,7 +3870,7 @@
         memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
         if ( FALSE == payload.reset )
         {
-            result = testSetDialOutPumpOcclusionOverride( payload.state.f32 );
+            result = testSetDialOutPumpOcclusionOverride( payload.state.u32 );
         }
         else
         {
@@ -3919,6 +4204,31 @@
     sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
 }
 
+/*********************************************************************//**
+ * @brief
+ * The handleTestTreatmentTimeRemainingOverrideRequest function handles a treatment
+ * time remaining override request message.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestTreatmentTimeRemainingOverrideRequest( MESSAGE_T *message )
+{
+    U32  payload;
+    BOOL result = FALSE;
+
+    // Verify payload length
+    if ( sizeof(U32) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(U32) );
+        result = testSetTreatmentTimeRemainingOverride( payload );
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
 /*********************************************************************//**
  * @brief
  * The handleTestHDSafetyShutdownOverrideRequest function handles a
@@ -4049,84 +4359,6 @@
 
 /*********************************************************************//**
  * @brief
- * The handleSetAccelCalibration function handles a request to set
- * accelerometer calibration factors.
- * @details Inputs: none
- * @details Outputs: message handled
- * @param message a pointer to the message to handle
- * @return none
- *************************************************************************/
-void handleSetAccelCalibration( MESSAGE_T *message )
-{
-    BOOL result = FALSE;
-
-    // Verify payload length
-    if ( message->hdr.payloadLen == sizeof(ACCEL_CAL_PAYLOAD_T) )
-    {
-        ACCEL_CAL_PAYLOAD_T payload;
-
-        memcpy( &payload, message->payload, sizeof(ACCEL_CAL_PAYLOAD_T) );
-        result = setAccelCalibration( payload.xOffset, payload.yOffset, payload.zOffset );
-    }
-
-    // Respond to request
-    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
-}
-
-/*********************************************************************//**
- * @brief
- * The handleSetBloodFlowCalibration function handles a request to set
- * blood flow calibration factors.
- * @details Inputs: none
- * @details Outputs: message handled
- * @param message a pointer to the message to handle
- * @return none
- *************************************************************************/
-void handleSetBloodFlowCalibration( MESSAGE_T *message )
-{
-    BOOL result = FALSE;
-
-    // Verify payload length
-    if ( message->hdr.payloadLen == sizeof(LINEAR_F32_CAL_PAYLOAD_T) )
-    {
-        LINEAR_F32_CAL_PAYLOAD_T payload;
-
-        memcpy( &payload, message->payload, sizeof(LINEAR_F32_CAL_PAYLOAD_T) );
-        result = setBloodFlowCalibration( payload.gain, payload.offset );
-    }
-
-    // Respond to request
-    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
-}
-
-/*********************************************************************//**
- * @brief
- * The handleSetDialysateFlowCalibration function handles a request to set
- * dialysate flow calibration factors.
- * @details Inputs: none
- * @details Outputs: message handled
- * @param message a pointer to the message to handle
- * @return none
- *************************************************************************/
-void handleSetDialysateFlowCalibration( MESSAGE_T *message )
-{
-    BOOL result = FALSE;
-
-    // Verify payload length
-    if ( message->hdr.payloadLen == sizeof(LINEAR_F32_CAL_PAYLOAD_T) )
-    {
-        LINEAR_F32_CAL_PAYLOAD_T payload;
-
-        memcpy( &payload, message->payload, sizeof(LINEAR_F32_CAL_PAYLOAD_T) );
-        result = setDialInFlowCalibration( payload.gain, payload.offset );
-    }
-
-    // Respond to request
-    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
-}
-
-/*********************************************************************//**
- * @brief
  * The handleTestSetTreatmentParameter function handles a request to set
  * a specific treatment parameter value.
  * @details Inputs: none
@@ -4401,9 +4633,8 @@
  * @brief
  * The handleTestBloodPumpHomeRequest function handles a request to home
  * the blood pump.
- * @details
- * Inputs : none
- * Outputs : message handled
+ * @details Inputs: none
+ * @details Outputs: message handled
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
@@ -4424,9 +4655,8 @@
  * @brief
  * The handleTestDialInPumpHomeRequest function handles a request to home
  * the dialysate inlet pump.
- * @details
- * Inputs : none
- * Outputs : message handled
+ * @details Inputs: none
+ * @details Outputs: message handled
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
@@ -4447,9 +4677,8 @@
  * @brief
  * The handleTestDialOutPumpHomeRequest function handles a request to home
  * the dialysate outlet pump.
- * @details
- * Inputs : none
- * Outputs : message handled
+ * @details Inputs: none
+ * @details Outputs: message handled
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
@@ -4470,9 +4699,8 @@
  * @brief
  * The handleTestSuperClearAlarmsRequest function handles a request to clear
  * all active alarms.
- * @details
- * Inputs : none
- * Outputs : message handled
+ * @details Inputs: none
+ * @details Outputs: message handled
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
@@ -4486,12 +4714,284 @@
 
         memcpy( &key, message->payload, sizeof(U32) );
         result = testClearAllAlarms( key );
+    }
 
-        result = TRUE;
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestSetOpModeRequest function handles a request to set the
+ * HD operation mode.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestSetOpModeRequest( MESSAGE_T *message )
+{
+    BOOL result = FALSE;
+
+    if ( message->hdr.payloadLen == sizeof(U32) )
+    {
+        U32 mode;
+
+        memcpy( &mode, message->payload, sizeof(U32) );
+        result = testSetOperationMode( (HD_OP_MODE_T)mode );
     }
 
     // Respond to request
     sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
 }
 
+/*********************************************************************//**
+ * @brief
+ * The handleTestSyringePumpDataBroadcastIntervalOverrideRequest function handles a
+ * request to override the syringe pump data broadcast interval.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestSyringePumpDataBroadcastIntervalOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // Verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( FALSE == payload.reset )
+        {
+            result = testSetSyringePumpDataPublishIntervalOverride( (U32)(payload.state.u32) );
+        }
+        else
+        {
+            result = testResetSyringePumpDataPublishIntervalOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestSyringePumpOperationRequest function handles a
+ * request to initiate a syringe pump operation.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestSyringePumpOperationRequest( MESSAGE_T *message )
+{
+    BOOL result = FALSE;
+
+    if ( message->hdr.payloadLen == sizeof(SYRINGE_PUMP_OP_PAYLOAD_T) )
+    {
+        SYRINGE_PUMP_OP_PAYLOAD_T payload;
+
+        memcpy( &payload, message->payload, sizeof(SYRINGE_PUMP_OP_PAYLOAD_T) );
+        result = testSyringePumpOperationRequest( payload );
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestSyringePumpMeasuredRateOverrideRequest function handles a
+ * request to override the syringe pump measured rate.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestSyringePumpMeasuredRateOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // Verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( FALSE == payload.reset )
+        {
+            result = testSetSyringePumpMeasuredRateOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetSyringePumpMeasuredRateOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestSyringePumpMeasuredForceOverrideRequest function handles a
+ * request to override the syringe pump measured force analog signal.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestSyringePumpMeasuredForceOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // Verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( FALSE == payload.reset )
+        {
+            result = testSetSyringePumpMeasuredForceOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetSyringePumpMeasuredForceOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestSyringePumpMeasuredSyringeDetectOverrideRequest function handles a
+ * request to override the syringe pump syringe detected analog signal.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestSyringePumpMeasuredSyringeDetectOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // Verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( FALSE == payload.reset )
+        {
+            result = testSetSyringePumpMeasuredSyringeDetectOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetSyringePumpMeasuredSyringeDetectOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestSyringePumpMeasuredHomeOverrideRequest function handles a
+ * request to override the syringe pump measured home analog signal.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestSyringePumpMeasuredHomeOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // Verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( FALSE == payload.reset )
+        {
+            result = testSetSyringePumpMeasuredHomeOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetSyringePumpMeasuredHomeOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestSyringePumpMeasuredPositionOverrideRequest function handles a
+ * request to override the syringe pump measured position.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestSyringePumpMeasuredPositionOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // Verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( FALSE == payload.reset )
+        {
+            result = testSetSyringePumpMeasuredPositionOverride( (S32)(payload.state.u32) );
+        }
+        else
+        {
+            result = testResetSyringePumpMeasuredPositionOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestSyringePumpMeasuredVolumeOverrideRequest function handles a
+ * request to override the syringe pump measured volume delivered.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestSyringePumpMeasuredVolumeOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // Verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( FALSE == payload.reset )
+        {
+            result = testSetSyringePumpMeasuredVolumeOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetSyringePumpMeasuredVolumeOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
 /**@}*/