Index: firmware/App/Services/SystemCommMessages.c
===================================================================
diff -u -r7665e7b142961a50c5e77c44877247366a374526 -rd6c75118f4e5792b40b744a0b29e44c78368a469
--- firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision 7665e7b142961a50c5e77c44877247366a374526)
+++ firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision d6c75118f4e5792b40b744a0b29e44c78368a469)
@@ -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;
 }
 
 /*********************************************************************//**
@@ -1778,8 +1866,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?
 }
 
 /*********************************************************************//**
@@ -1822,7 +1908,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?
 }
 
 /*********************************************************************//**
@@ -1843,7 +1928,6 @@
          memcpy( &payload, message->payload, sizeof(DG_DRAIN_PUMP_DATA_PAYLOAD_T) );
          setDGDrainPumpData( payload.setPtRPM );
      }
-     // TODO - what to do if invalid payload length?
 }
 
 /*********************************************************************//**
@@ -1864,7 +1948,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?
 }
 
 /*********************************************************************//**
@@ -1885,7 +1968,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?
 }
 
 /*********************************************************************//**
@@ -1956,14 +2038,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;
 
@@ -1973,17 +2055,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();
         }
     }
 
@@ -1992,6 +2070,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.
@@ -2084,12 +2183,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;
@@ -2100,7 +2199,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 );
 
@@ -2300,6 +2399,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
@@ -3490,7 +3614,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
         {
@@ -3522,7 +3646,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
         {
@@ -3554,7 +3678,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
         {
@@ -4553,6 +4677,95 @@
 }
 
 /*********************************************************************//**
+ * @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 handleSetHDSystemRecord function handles a request to set the HD
 * system data record.
@@ -4612,6 +4825,70 @@
 }
 
 /*********************************************************************//**
+ * @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 handleGetHDServiceRecord function handles a request to get the HD
 * service data record.
@@ -4639,6 +4916,38 @@
 }
 
 /*********************************************************************//**
+ * @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 handleSetHDServiceRecord function handles a request to set the HD
 * service data record.
@@ -4670,4 +4979,68 @@
     sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, status );
 }
 
+/*********************************************************************//**
+ * @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 );
+}
+
 /**@}*/