Index: firmware/App/Services/SystemCommMessages.c
===================================================================
diff -u -r27f3db92495948d4c1192421c1b0c20338c4a034 -rba15d3e6250e8cd3cd3ef39cb64a93f91c3caba2
--- firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision 27f3db92495948d4c1192421c1b0c20338c4a034)
+++ firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision ba15d3e6250e8cd3cd3ef39cb64a93f91c3caba2)
@@ -37,7 +37,7 @@
 #include "TreatmentEnd.h"
 #include "TreatmentRecirc.h"
 #include "Utilities.h"
-#include "Valves.h"
+#include "Valves.h"
 #include "WatchdogMgmt.h"
 
 /**
@@ -433,6 +433,38 @@
     return result;
 }
 
+/*********************************************************************//**
+ * @brief
+ * The sendHeparinCommandResponse function constructs a Heparin command response
+ * to the UI and queues the msg for transmit on the
+ * appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: Heparin command response msg constructed and queued.
+ * @param accepted flag indicating whether request was accepted
+ * @param rejReason rejection reason code
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL sendHeparinCommandResponse( U32 accepted, U32 rejReason )
+{
+    BOOL result;
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_HEPARIN_PAUSE_RESUME_RESPONSE;
+    msg.hdr.payloadLen = sizeof( U32 ) * 2;
+
+    memcpy( payloadPtr, &accepted, sizeof( U32 ) );
+    payloadPtr += sizeof( U32 );
+    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 sendTreatmentParamsRangesToUI function constructs a treatment parameter
@@ -1021,6 +1053,62 @@
     result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_BROADCAST, ACK_NOT_REQUIRED );
 
     return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The broadcastSyringePumpData function constructs a syringe pump data
+ * msg to be broadcast and queues the msg for transmit on the appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: syringe pump data msg constructed and queued.
+ * @param data syringe pump data record
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL broadcastSyringePumpData( SYRINGE_PUMP_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_SYRINGE_PUMP_DATA;
+    msg.hdr.payloadLen = sizeof( SYRINGE_PUMP_DATA_PAYLOAD_T );
+
+    memcpy( payloadPtr, &data, sizeof( SYRINGE_PUMP_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 broadcastHeparinData function constructs a Heparin data message
+ * to be broadcast and queues the msg for transmit on the appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: Heparin data msg constructed and queued.
+ * @param data Heparin data record
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL broadcastHeparinData( F32 volume )
+{
+    BOOL result;
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_HEPARIN_DATA_BROADCAST;
+    msg.hdr.payloadLen = sizeof( F32 );
+
+    memcpy( payloadPtr, &volume, sizeof( F32 ) );
+
+    // 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;
 }
 
 /*********************************************************************//**
@@ -1405,10 +1493,39 @@
 
 /***********************************************************************//**
  * @brief
- * The broadcastAirTrapData function constructs an HD air trap data msg to \n
+ * The broadcastFluidLeakState function constructs an HD fluid leak state msg to \n
+ * be broadcasted and queues the msg for transmit on the appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: fluid leak state msg constructed and queued
+ * @param state fluid leak state
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL broadcastFluidLeakState( FLUID_LEAK_STATES_T state )
+{
+    BOOL result;
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
+    U32 leakState = (U32)state;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_FLUID_LEAK_STATE;
+    msg.hdr.payloadLen = sizeof( U32 );
+
+    memcpy( payloadPtr, &leakState, 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 broadcastPrimeData function constructs a prime data msg to \n
  * be broadcast and queues the msg for transmit on the appropriate CAN channel.
  * @details Inputs: none
- * @details Outputs: air trap data msg constructed and queued
+ * @details Outputs: prime data msg constructed and queued
  * @param primeDataPtr prime data record pointer
  * @return TRUE if msg successfully queued for transmit, FALSE if not
  *************************************************************************/
@@ -1631,8 +1748,6 @@
         memcpy( &payload, message->payload, sizeof(LOAD_CELL_READINGS_PAYLOAD_T) );
         setNewLoadCellReadings( payload.res1PrimaryLoadCell, payload.res1BackupLoadCell, payload.res2PrimaryLoadCell, payload.res2BackupLoadCell );
     }
-    // TODO - what to do if invalid payload length?
-    // TODO - how to know if DG stops sending these?
 }
 
 /*********************************************************************//**
@@ -1675,7 +1790,6 @@
         memcpy( &payload, message->payload, sizeof(DG_RO_PUMP_DATA_PAYLOAD_T) );
         setDGROPumpData( payload.setPtPSI, payload.measFlowRateMlMin );
     }
-    // TODO - what to do if invalid payload length?
 }
 
 /*********************************************************************//**
@@ -1696,7 +1810,6 @@
          memcpy( &payload, message->payload, sizeof(DG_DRAIN_PUMP_DATA_PAYLOAD_T) );
          setDGDrainPumpData( payload.setPtRPM );
      }
-     // TODO - what to do if invalid payload length?
 }
 
 /*********************************************************************//**
@@ -1717,7 +1830,6 @@
          memcpy( &payload, message->payload, sizeof(DG_PRESSURES_DATA_PAYLOAD_T) );
          setDGPressures( payload.roInPSI, payload.roOutPSI, payload.drainInPSI, payload.drainOutPSI );
      }
-     // TODO - what to do if invalid payload length?
 }
 
 /*********************************************************************//**
@@ -1738,7 +1850,6 @@
          memcpy( &payload, message->payload, sizeof(DG_RESERVOIRS_DATA_PAYLOAD_T) );
          setDGReservoirsData( (DG_RESERVOIR_ID_T)payload.resID, payload.setFillToVolumeMl, payload.setDrainToVolumeMl );
      }
-     // TODO - what to do if invalid payload length?
 }
 
 /*********************************************************************//**
@@ -1809,14 +1920,14 @@
 
 /*********************************************************************//**
  * @brief
- * The handleUIStartTreatmentMsg function handles a treatment start/cancel
+ * The handleInitiateTreatmentRequest function handles a treatment initiate/cancel
  * message from the UI.
  * @details Inputs: none
  * @details Outputs: message handled
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-void handleUIStartTreatmentMsg( MESSAGE_T *message )
+void handleInitiateTreatmentRequest( MESSAGE_T *message )
 {
     BOOL result = FALSE;
 
@@ -1826,17 +1937,13 @@
 
         memcpy( &cmd, message->payload, sizeof(U32) );
 
-        if ( 0 == cmd )         // Initiate treatment (go to treatment params mode)
+        if ( 0 == cmd )         // Cancel treatment (return from aborted treatment params mode)
         {
-            result = signalUserStartingTreatment();
-        }
-        else if ( 1 == cmd )    // Cancel treatment (return from aborted treatment params mode)
-        {
             result = signalUserCancelTreatment();
         }
-        else if ( 2 == cmd )    // Start treatment
+        else if ( 1 == cmd )    // Initiate treatment (go to treatment params mode)
         {
-            result = signalUserBeginningTreatment();
+            result = signalUserStartingTreatment();
         }
     }
 
@@ -1845,6 +1952,27 @@
 
 /*********************************************************************//**
  * @brief
+ * The handleStartTreatmentRequest function handles a treatment start
+ * message from the UI.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleStartTreatmentRequest( MESSAGE_T *message )
+{
+    BOOL result = FALSE;
+
+    if ( 0 == message->hdr.payloadLen )
+    {
+        result = signalUserBeginningTreatment();
+    }
+
+    sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, result );
+}
+
+/*********************************************************************//**
+ * @brief
  * The sendTreatmentStartResponseMsg function constructs a treatment start
  * request response message to the UI and queues the msg for transmit on
  * the appropriate CAN channel.
@@ -1937,12 +2065,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;
@@ -1953,7 +2081,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 );
 
@@ -2153,6 +2281,31 @@
 
 /*********************************************************************//**
  * @brief
+ * The handleHeparinCommandRequest function handles a Heparin command
+ * request message from the UI.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleHeparinCommandRequest( MESSAGE_T *message )
+{
+    if ( sizeof( U32 ) == message->hdr.payloadLen )
+    {
+        U32 payload;
+
+        memcpy( &payload, &message->payload[0], sizeof( U32 ) );
+
+        userHeparinRequest( (HEPARIN_CMD_T)payload );
+    }
+    else
+    {
+        sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    }
+}
+
+/*********************************************************************//**
+ * @brief
  * The handleSalineBolusRequest function handles a saline bolus request
  * message from the UI.
  * @details Inputs: none
@@ -3343,7 +3496,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
         {
@@ -3375,7 +3528,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
         {
@@ -3407,7 +3560,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
         {
@@ -4119,12 +4272,12 @@
     BOOL result = FALSE;
 
     // Verify payload length
-    if ( sizeof(TEST_OVERRIDE_ARRAY_PAYLOAD_T) == message->hdr.payloadLen )
+    if ( sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) == message->hdr.payloadLen )
     {
-        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_ARRAY_PAYLOAD_T) );
+        memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) );
         if ( FALSE == payload.reset )
         {
-            result = testSetAirTrapLevelOverride( (AIR_TRAP_LEVEL_SENSORS_T)payload.index, (AIR_TRAP_LEVELS_T)(payload.state.u32) );
+            result = testSetAirTrapLevelOverride( (AIR_TRAP_LEVEL_SENSORS_T)payload.index, (AIR_TRAP_LEVELS_T)( payload.state.u32 ) );
         }
         else
         {
@@ -4138,6 +4291,70 @@
 
 /*********************************************************************//**
  * @brief
+ * The handleSetFluidLeakBroadcastIntervalOverrideRequest function handles a
+ * request to override the fluid leak state broadcast interval.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleSetFluidLeakBroadcastIntervalOverrideRequest( 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 = testSetFluidLeakStatePublishIntervalOverride( (U32)( payload.state.u32 ) );
+        }
+        else
+        {
+            result = testResetFluidLeakStatePublishIntervalOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleSetFluidLeakStateDetectorOverrideRequest function handles a request to
+ * override the fluid leak detector state.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleSetFluidLeakStateDetectorOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_ARRAY_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // Verify payload length
+    if ( sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) );
+        if ( FALSE == payload.reset )
+        {
+            result = testSetFluidLeakStateOverride( ( FLUID_LEAK_STATES_T)( payload.state.u32 ) );
+        }
+        else
+        {
+            result = testResetFluidLeakStateOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
  * The handleHDSoftwareResetRequest function handles a request to reset the
  * HD firmware processor.
  * @details Inputs: none
@@ -4282,4 +4499,253 @@
     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 );
+}
+
 /**@}*/