Index: firmware/App/Services/SystemCommMessages.c
===================================================================
diff -u -r58f8416a9ff9c68ee34361ac23a46dcf56cfa79e -r2e21b8a4e52e0d1f94389acf424b5033362b63f1
--- firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision 58f8416a9ff9c68ee34361ac23a46dcf56cfa79e)
+++ firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision 2e21b8a4e52e0d1f94389acf424b5033362b63f1)
@@ -23,6 +23,7 @@
 #include "AlarmLamp.h"
 #include "Battery.h"
 #include "Buttons.h"
+#include "Compatible.h"
 #include "ConsumableSelfTest.h"
 #include "FPGA.h"
 #include "ModeStandby.h"
@@ -35,7 +36,8 @@
 #include "SystemComm.h"
 #include "SystemCommMessages.h"
 #include "TreatmentEnd.h"
-#include "TreatmentRecirc.h"
+#include "TreatmentRecirc.h"
+#include "TreatmentStop.h"
 #include "Utilities.h"
 #include "WatchdogMgmt.h"
 
@@ -266,10 +268,58 @@
     msg.payload[ 0 ] = cmd;
 
     // 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_NOT_REQUIRED );
+    result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_2_UI, ACK_REQUIRED );
 
     return result;
-}
+}
+
+/*********************************************************************//**
+ * @brief
+ * The sendUIVersionRequest function constructs a UI version request msg
+ * to the UI and queues the msg for transmit on the appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: UI version request msg constructed and queued.
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL sendUIVersionRequest( void )
+{
+    BOOL result;
+    MESSAGE_T msg;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_UI_VERSION_INFO_REQUEST;
+    msg.hdr.payloadLen = 0;
+
+    // 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 sendDGPOSTResultRequest function constructs a POST result request msg
+ * to the DG and queues the msg for transmit on the appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: DG POST result request msg constructed and queued.
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL sendDGPOSTResultRequest( void )
+{
+    BOOL result;
+    MESSAGE_T msg;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_DG_POST_RESULT_REQUEST;
+    msg.hdr.payloadLen = 0;
+
+    // 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_DG, ACK_REQUIRED );
+
+    return result;
+}
 
 /*********************************************************************//**
  * @brief
@@ -2947,24 +2997,13 @@
  *************************************************************************/
 void handleUIAlarmSilenceRequest( MESSAGE_T *message )
 {
-#ifndef TEMP_UI_ALARM_SILENCE_FIX
     if ( message->hdr.payloadLen == sizeof( U32 ) )
-#else
-    if ( message->hdr.payloadLen == sizeof( U08 ) )
-#endif
     {
         U08 *payloadPtr = message->payload;
-#ifndef TEMP_UI_ALARM_SILENCE_FIX
         U32 cmd;
 
         memcpy( &cmd, payloadPtr, sizeof( U32 ) );
         signalAlarmSilence( (ALARM_SILENCE_CMD_T)cmd );
-#else
-        U08 cmd;
-
-        memcpy( &cmd, payloadPtr, sizeof( U08 ) );
-        signalAlarmSilence( (ALARM_SILENCE_CMD_T)cmd );
-#endif
     }
     else
     {
@@ -3077,8 +3116,7 @@
         BOOL passed;
 
         memcpy( &passed, payloadPtr, sizeof( BOOL ) );
-
-        // TODO - handle DG POST  final result
+        signalDGPOSTFinalResult( passed );
     }
     else
     {
@@ -3943,16 +3981,18 @@
 void handleFWVersionRequest( MESSAGE_T *message )
 {
     MESSAGE_T msg;
-    HD_VERSIONS_T payload;  // TODO - add compatibility data to response
+    HD_VERSIONS_T payload;
     U08 *payloadPtr = msg.payload;
 
-    // TODO - grab UI version data when UI includes it in this message
+    // Get UI version data from this request msg and have it recorded
+    handleUIVersionResponse( message );
 
-    // Populate payload
+    // Populate payload for response
     payload.major = (U08)HD_VERSION_MAJOR;
     payload.minor = (U08)HD_VERSION_MINOR;
     payload.micro = (U08)HD_VERSION_MICRO;
     payload.build = (U16)HD_VERSION_BUILD;
+    payload.compatibilityRev = (U32)SW_COMPATIBILITY_REV;
     getFPGAVersions( &payload.fpgaId, &payload.fpgaMajor, &payload.fpgaMinor, &payload.fpgaLab );
 
     // Create a message record
@@ -3969,6 +4009,27 @@
 
 /*********************************************************************//**
  * @brief
+ * The handleUIVersionResponse function handles a response to request for
+ * UI version information.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message a pointer to the message to handle.
+ * @return none
+ *************************************************************************/
+void handleUIVersionResponse( MESSAGE_T *message )
+{
+    // Get UI version data and have it recorded
+    if ( sizeof(UI_VERSIONS_T) == message->hdr.payloadLen )
+    {
+        UI_VERSIONS_T uiVersion;
+
+        memcpy( &uiVersion, &message->payload[0], sizeof(UI_VERSIONS_T) );
+        signalUIVersion( uiVersion );
+    }
+}
+
+/*********************************************************************//**
+ * @brief
  * The handleHDSerialNumberRequest function handles a request for HD serial
  * number request.
  * @details Inputs: none
@@ -4000,6 +4061,26 @@
 
 /*********************************************************************//**
  * @brief
+ * The handleDGVersionResponse function handles a response for DG f/w version.
+ * @details Inputs: none
+ * @details Outputs: message handled, DG version info recorded.
+ * @param message a pointer to the message to handle.
+ * @return none
+ *************************************************************************/
+void handleDGVersionResponse( MESSAGE_T *message )
+{
+    // Get DG version data from this response msg and have it recorded
+    if ( sizeof(DG_VERSIONS_T) == message->hdr.payloadLen )
+    {
+        DG_VERSIONS_T dgVersion;
+
+        memcpy( &dgVersion, &message->payload[0], sizeof(DG_VERSIONS_T) );
+        signalDGVersion( dgVersion );
+    }
+}
+
+/*********************************************************************//**
+ * @brief
  * The handleHDServiceScheduleRequest function handles a request for HD
  * service information.
  * @details Inputs: none
@@ -6176,6 +6257,70 @@
 
 /*********************************************************************//**
  * @brief
+ * The handleRinsebackVolumeOverrideRequest function handles a request to
+ * override the calculated rinseback volume (in mL).
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleRinsebackVolumeOverrideRequest( 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 = testSetRinsebackVolumeOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetRinsebackVolumeOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleRinsebackSafetyVolumeOverrideRequest function handles a request to
+ * override the calculated safety rinseback volume (in mL).
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleRinsebackSafetyVolumeOverrideRequest( 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 = testSetRinsebackSafetyVolumeOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetRinsebackSafetyVolumeOverride();
+        }
+    }
+
+    // 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
@@ -6909,6 +7054,358 @@
 
 /*********************************************************************//**
  * @brief
+ * The handleTestAlarmStatusSendIntervalOverrideRequest function handles a
+ * request to override the HD alarm status broadcast interval.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestAlarmStatusSendIntervalOverrideRequest( 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 = testSetAlarmStatusPublishIntervalOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetAlarmStatusPublishIntervalOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestTreatmentTimeDataSendIntervalOverrideRequest function handles a
+ * request to override the HD treatment time data broadcast interval.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestTreatmentTimeDataSendIntervalOverrideRequest( 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 = testSetTreatmentTimePublishIntervalOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetTreatmentTimePublishIntervalOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestTreatmentRangesSendIntervalOverrideRequest function handles a
+ * request to override the HD treatment param ranges broadcast interval.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestTreatmentRangesSendIntervalOverrideRequest( 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 = testSetTreatmentParamRangesPublishIntervalOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetTreatmentParamRangesPublishIntervalOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestTreatmentStopDataSendIntervalOverrideRequest function handles a
+ * request to override the HD treatment stop sub-mode data broadcast interval.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestTreatmentStopDataSendIntervalOverrideRequest( 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 = testSetTreatmentStopPublishIntervalOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetTreatmentStopPublishIntervalOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestBloodPrimeDataSendIntervalOverrideRequest function handles a
+ * request to override the HD blood prime sub-mode data broadcast interval.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestBloodPrimeDataSendIntervalOverrideRequest( 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 = testSetBloodPrimePublishIntervalOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetBloodPrimePublishIntervalOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestRinsebackDataSendIntervalOverrideRequest function handles a
+ * request to override the HD rinseback sub-mode data broadcast interval.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestRinsebackDataSendIntervalOverrideRequest( 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 = testSetRinsebackPublishIntervalOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetRinsebackPublishIntervalOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestStandbyModeDataSendIntervalOverrideRequest function handles a
+ * request to override the HD standby mode data broadcast interval.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestStandbyModeDataSendIntervalOverrideRequest( 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 = testSetStandbyModePublishIntervalOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetStandbyModePublishIntervalOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestOpModeDataSendIntervalOverrideRequest function handles a
+ * request to override the HD operation mode data broadcast interval.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestOpModeDataSendIntervalOverrideRequest( 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 = testSetOpModePublishIntervalOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetOpModePublishIntervalOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestPreTreatmentModeDataSendIntervalOverrideRequest function handles a
+ * request to override the HD pre-treatment mode data broadcast interval.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestPreTreatmentModeDataSendIntervalOverrideRequest( 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 = testSetPreTreatmentModePublishIntervalOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetPreTreatmentModePublishIntervalOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestTreatmentModeSendIntervalOverrideRequest function handles a
+ * request to override the HD treatment mode data broadcast interval.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestTreatmentModeSendIntervalOverrideRequest( 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 = testSetTreatmentStatePublishIntervalOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetTreatmentStatePublishIntervalOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestPostTreatmentModeSendIntervalOverrideRequest function handles a
+ * request to override the HD post-treatment mode data broadcast interval.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestPostTreatmentModeSendIntervalOverrideRequest( 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 = testSetPostTreatmentModePublishIntervalOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetPostTreatmentModePublishIntervalOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
  * The handleTestAlarmAudioVolumeOverrideRequest function handles a
  * request to override the alarm audio volume level.
  * @details Inputs: none