Index: firmware/App/Services/SystemCommMessages.c
===================================================================
diff -u -r1240b612f790f931825aba86ec37f37eccce9336 -r844f98879b7425c207b58562e623ab960adbc357
--- firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision 1240b612f790f931825aba86ec37f37eccce9336)
+++ firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision 844f98879b7425c207b58562e623ab960adbc357)
@@ -21,8 +21,11 @@
 
 #include "Accel.h"
 #include "AlarmLamp.h"
+#include "Battery.h"
 #include "Buttons.h"
+#include "Compatible.h"
 #include "ConsumableSelfTest.h"
+#include "Fans.h"
 #include "FPGA.h"
 #include "ModeStandby.h"
 #include "ModeTreatmentParams.h"
@@ -32,8 +35,10 @@
 #include "SafetyShutdown.h"
 #include "SystemComm.h"
 #include "SystemCommMessages.h"
+#include "Temperatures.h"
 #include "TreatmentEnd.h"
-#include "TreatmentRecirc.h"
+#include "TreatmentRecirc.h"
+#include "TreatmentStop.h"
 #include "Utilities.h"
 #include "WatchdogMgmt.h"
 
@@ -264,10 +269,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
@@ -570,8 +623,33 @@
     result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_2_UI, ACK_REQUIRED );
 
     return result;
-}
+}
+
+/*********************************************************************//**
+ * @brief
+ * The sendTreatmentPeriodicDataToUI function constructs a treatment periodic
+ * data message to the UI and queues the msg for transmit on the appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: Treatment parameter ranges msg constructed and queued.
+ * @param periodDataPtr treatment log period data record pointer
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL sendTreatmentPeriodicDataToUI( TREATMENT_LOG_DATA_PERIODIC_T * periodDataPtr )
+{
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
 
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_TREATMENT_LOG_PERIODIC_DATA;
+    msg.hdr.payloadLen = sizeof( TREATMENT_LOG_DATA_PERIODIC_T );
+
+    memcpy( payloadPtr, periodDataPtr, sizeof( TREATMENT_LOG_DATA_PERIODIC_T ) );
+
+    // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer
+    return serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_2_UI, ACK_REQUIRED );
+}
+
 /*********************************************************************//**
  * @brief
  * The handlePatientDisconnectionConfirmCmd function handles user confirms
@@ -587,8 +665,10 @@
     {
         signalUserConfirmPatientDisconnection();
     }
-
-    sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    else
+    {
+        sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    }
 }
 
 /*********************************************************************//**
@@ -606,8 +686,10 @@
     {
         signalUserConfirmDisposableRemoval();
     }
-
-    sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    else
+    {
+        sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    }
 }
 
 /*********************************************************************//**
@@ -638,10 +720,12 @@
 {
     if ( 0 == message->hdr.payloadLen )
     {
-        handleTreatmentLogDataRequest();
+        sendTreatmentLogDataToUI();
     }
-
-    sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    else
+    {
+        sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    }
 }
 
 /*********************************************************************//**
@@ -650,6 +734,8 @@
  * for UI and queues the msg for transmit on the appropriate CAN channel.
  * @details Inputs: none
  * @details Outputs: Treatment log data msg constructed and queued.
+ * @param accepted T/F - was treatment log request accepted?
+ * @param reason reason why request was rejected (or zero if accepted)
  * @param logDataPtr treatment log data record pointer
  * @return TRUE if msg successfully queued for transmit, FALSE if not
  *************************************************************************/
@@ -672,9 +758,296 @@
     // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer
     return serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_2_UI, ACK_REQUIRED );
 }
-
+
 /*********************************************************************//**
  * @brief
+ * The handleUIDisinfectRequest function handles a disinfect/flush 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 handleUIDisinfectRequest( MESSAGE_T *message )
+{
+    BOOL result = FALSE;
+
+    if ( message->hdr.payloadLen == sizeof(U32) )
+    {
+        U32 cmd;
+
+        memcpy( &cmd, message->payload, sizeof(U32) );
+
+        if ( 0 == cmd )         // Command 0 = Flush
+        {
+            result = signalUserInitiateFlushMode();
+        }
+        else if ( 1 == cmd )    // Command 1 = Heat disinfect
+        {
+            result = signalUserInitiateHeatDisinfectMode();
+        }
+        else if ( 2 == cmd )   // Command 2 = chemical disinfect
+        {
+            result = signalUserInitiateChemicalDisinfectMode();
+        }
+    }
+
+    sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The sendDisinfectConfirmResponse function constructs a disinfect or flush
+ * confirm user action response to the UI and queues the msg for
+ * transmit on the appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: Disposable removal confirm response msg constructed
+ * and queued.
+ * @param accepted T/F - was disinfect or flush confirm request accepted?
+ * @param reason reason why request was rejected (or zero if accepted)
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL sendDisinfectConfirmResponse( BOOL accepted, U32 reason )
+{
+    return sendUIResponseMsg( MSG_ID_HD_DISINFECT_RESPONSE, accepted, reason );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleSetHDStandbyDisinfectSubmode function handles setting the
+ * standby submode to wait for disisnfect state.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleSetHDStandbyDisinfectSubmodeRequest( MESSAGE_T *message )
+{
+    BOOL result = FALSE;
+
+    // The payload should be 0 in this case because there is mode in this command
+    if ( 0 == message->hdr.payloadLen )
+    {
+        signalInitiateStandbyDisinfectSubmode();
+    }
+
+    sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleSetHDStandbyDisinfectSubmodeResponse function constructs a
+ * standby submode change to wait for disinfect confirm user action response
+ * to the UI and queues the msg for transmit on the appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: Disposable removal confirm response msg constructed
+ * and queued.
+ * @param accepted T/F - was set standby submode confirm request accepted?
+ * @param reason reason why request was rejected (or zero if accepted)
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL handleSetHDStandbyDisinfectSubmodeResponse( BOOL accepted, U32 reason )
+{
+    return sendUIResponseMsg( MSG_ID_HD_SET_STANDBY_DISINFECT_SUB_MODE_RESPONSE, accepted, reason );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleFlushUIStateReadingFromDG function handles the readings of DG
+ * flush mode.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleFlushUIStateReadingFromDG( MESSAGE_T *message )
+{
+    if ( message->hdr.payloadLen == sizeof(MODE_FLUSH_DATA_T) )
+    {
+        MODE_FLUSH_DATA_T payload;
+        DG_DISINFECT_UI_STATES_T uiStates;
+
+        memcpy( &payload, message->payload, sizeof(MODE_FLUSH_DATA_T) );
+
+        uiStates.heatDisinfectUIState = 0;
+        uiStates.chemDisinfectUIState = 0;
+        uiStates.flushUIState         = payload.flushUIState;
+
+        setDGDisinfectsStates( uiStates );
+    }
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleHeatDisinfectUIStateReadingFromDG function handles the readings
+ * of DG heat disinfect mode.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleHeatDisinfectUIStateReadingFromDG( MESSAGE_T *message )
+{
+    if ( message->hdr.payloadLen == sizeof(MODE_HEAT_DISINFECT_DATA_T) )
+    {
+        MODE_HEAT_DISINFECT_DATA_T payload;
+        DG_DISINFECT_UI_STATES_T uiStates;
+
+        memcpy( &payload, message->payload, sizeof(MODE_HEAT_DISINFECT_DATA_T) );
+
+        uiStates.heatDisinfectUIState = payload.heatDisinfectUIState;
+        uiStates.chemDisinfectUIState = 0;
+        uiStates.flushUIState         = 0;
+
+        setDGDisinfectsStates( uiStates );
+    }
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleUIActiveAlarmsListRequest function handles UI active alarms list request.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message a pointer to the message to handle
+ * @return none.
+ *************************************************************************/
+void handleUIActiveAlarmsListRequest( MESSAGE_T *message )
+{
+    if ( 0 == message->hdr.payloadLen )
+    {
+        handleActiveAlarmListRequest();
+    }
+    else
+    {
+        sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    }
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleChemDisinfectUIStateReadingFromDG function handles the readings
+ * of DG chemical disinfect mode.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleChemDisinfectUIStateReadingFromDG( MESSAGE_T *message )
+{
+    if ( message->hdr.payloadLen == sizeof(MODE_CHEMICAL_DISINFECT_DATA_T) )
+    {
+        MODE_CHEMICAL_DISINFECT_DATA_T payload;
+        DG_DISINFECT_UI_STATES_T uiStates;
+
+        memcpy( &payload, message->payload, sizeof(MODE_CHEMICAL_DISINFECT_DATA_T) );
+
+        uiStates.heatDisinfectUIState = 0;
+        uiStates.chemDisinfectUIState = payload.chemDisinfectUIState;
+        uiStates.flushUIState         = 0;
+
+        setDGDisinfectsStates( uiStates );
+    }
+}
+
+/*********************************************************************//**
+ * The sendActiveAlarmsList function constructs a treatment log data message
+ * for UI and queues the msg for transmit on the appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: Treatment log data msg constructed and queued.
+ * @details Outputs: Treatment log data msg constructed and queued.
+ * @param accepted T/F - was treatment log request accepted?
+ * @param alarmList pointer to active alarms list record
+ * @param size the size of active alarms list
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL sendActiveAlarmsList( BOOL accepted, U32 reason, U32 *alarmList, U32 size )
+{
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_ACTIVE_ALARMS_LIST_REQUEST_RESPONSE;
+    msg.hdr.payloadLen = sizeof( BOOL ) + sizeof( U32 ) + size;
+
+    memcpy( payloadPtr, &accepted, sizeof( U32 ) );
+    payloadPtr += sizeof( U32 );
+    memcpy( payloadPtr, &reason, sizeof( U32 ) );
+    payloadPtr += sizeof( U32 );
+    memcpy( payloadPtr, alarmList, size );
+
+    // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer
+    return serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_2_UI, ACK_REQUIRED );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The sendTreatmentLogAlarmEventData function constructs a treatment log
+ * alarm event data message for UI and queues the msg for transmit on the
+ * appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: Treatment log alarm event data msg constructed and queued.
+ * @param alarmID ID of the occurred alarm
+ * @param almData1 data associates with the alarm
+ * @param almData1 data associates with the alarm
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL sendTreatmentLogAlarmEventData( ALARM_ID_T alarmID, ALARM_DATA_T almData1, ALARM_DATA_T almData2 )
+{
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
+    U32 id = (U32)alarmID;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_TREATMENT_LOG_ALARM_EVENT;
+    msg.hdr.payloadLen = sizeof( U32 ) + 2 * sizeof( F32 );
+
+    memcpy( payloadPtr, &id, sizeof( U32 ) );
+    payloadPtr += sizeof( U32 );
+    memcpy( payloadPtr, &almData1.data, sizeof( F32 ) );
+    payloadPtr += sizeof( F32 );
+    memcpy( payloadPtr, &almData2.data, sizeof( F32 ) );
+
+    // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer
+    return serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_2_UI, ACK_REQUIRED );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The sendTreatmentLogEventData function constructs a treatment log parameter
+ * change event data message for UI and queues the msg for transmit on the
+ * appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: Treatment log event data msg constructed and queued.
+ * @param event ID of parameter change event
+ * @param oldValue parameter change event old data value
+ * @param newValue parameter change event new data value
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL sendTreatmentLogEventData( EVENT_ID_T event, F32 oldValue, F32 newValue )
+{
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
+    U32 eventID = (U32)event;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_TREATMENT_LOG_EVENT;
+    msg.hdr.payloadLen = sizeof( U32 ) + 2 * sizeof( F32 );
+
+    memcpy( payloadPtr, &eventID, sizeof( U32 ) );
+    payloadPtr += sizeof( U32 );
+    memcpy( payloadPtr, &oldValue, sizeof( F32 ) );
+    payloadPtr += sizeof( F32 );
+    memcpy( payloadPtr, &newValue, sizeof( F32 ) );
+
+    // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer
+    return serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_2_UI, ACK_REQUIRED );
+}
+
+/*********************************************************************//**
+ * @brief
  * The handleSampleWaterCmd function handles a sample water user action command
  * message from the UI.
  * @details Inputs: none
@@ -691,8 +1064,10 @@
         memcpy( &cmd, &message->payload[0], sizeof( U32 ) );
         signalSampleWaterUserAction( (REQUESTED_SAMPLE_WATER_USER_ACTIONS_T)cmd );
     }
-
-    sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    else
+    {
+        sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    }
 }
 
 /*********************************************************************//**
@@ -727,8 +1102,10 @@
         memcpy( &result, &message->payload[0], sizeof( U32 ) );
         setSampleWaterResult( (BOOL) result );
     }
-
-    sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    else
+    {
+        sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    }
 }
 
 /*********************************************************************//**
@@ -746,8 +1123,10 @@
     {
         signalUserConfirmConsumableInstall();
     }
-
-    sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    else
+    {
+        sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    }
 }
 
 /*********************************************************************//**
@@ -765,8 +1144,10 @@
     {
         signalUserConfirmInstallation();
     }
-
-    sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    else
+    {
+        sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    }
 }
 
 /*********************************************************************//**
@@ -784,8 +1165,10 @@
     {
         signalStartPrime();
     }
-
-    sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    else
+    {
+        sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    }
 }
 
 /*********************************************************************//**
@@ -818,8 +1201,10 @@
     {
         signalUserContinueToTreatment();
     }
-
-    sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    else
+    {
+        sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    }
 }
 
 /*********************************************************************//**
@@ -852,8 +1237,10 @@
     {
         signalUserConfirmPatientConnection();
     }
-
-    sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    else
+    {
+        sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    }
 }
 
 /*********************************************************************//**
@@ -885,8 +1272,10 @@
     {
         signalUserStartTreatment();
     }
-
-    sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    else
+    {
+        sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE );
+    }
 }
 
 /*********************************************************************//**
@@ -1232,6 +1621,92 @@
 
 /*********************************************************************//**
  * @brief
+ * The sendDGStartFlushModeCommand function constructs a DG start/stop
+ * flush mode command message and queues the msg for transmit on the
+ * appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: DG start flush mode command msg constructed and queued.
+ * @param start TRUE indicates start flush mode
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL sendDGStartFlushModeCommand( BOOL start )
+{
+    BOOL result;
+    MESSAGE_T msg;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_DG_START_STOP_FLUSH;
+    msg.hdr.payloadLen = sizeof( BOOL );
+
+    memcpy( msg.payload, &start, sizeof( BOOL ) );
+
+    // 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
+ * The sendDGStartHeatDisinfectModeCommand function constructs a DG start/stop
+ * heat disinfect mode command message and queues the msg for transmit on
+ * the appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: DG start heat disinfect mode command msg constructed
+ * and queued.
+ * @param start TRUE indicates start heat disinfect mode
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL sendDGStartHeatDisinfectModeCommand( BOOL start )
+{
+    BOOL result;
+    MESSAGE_T msg;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_DG_START_STOP_HEAT_DISINFECT;
+    msg.hdr.payloadLen = sizeof( BOOL );
+
+    memcpy( msg.payload, &start, sizeof( BOOL ) );
+
+    // 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
+ * The sendDGStartChemicalDisinfectModeCommand function constructs a DG
+ * start/stop chemical disinfect mode command message and queues the msg
+ * for transmit on the appropriate CAN channel.
+ * @details Inputs: none
+ * @details Outputs: DG start chemical disinfect mode command msg
+ * constructed and queued.
+ * @param start TRUE indicates start chemical disinfect mode
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL sendDGStartChemicalDisinfectModeCommand( BOOL start )
+{
+    BOOL result;
+    MESSAGE_T msg;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_DG_START_STOP_CHEM_DISINFECT;
+    msg.hdr.payloadLen = sizeof( BOOL );
+
+    memcpy( msg.payload, &start, sizeof( BOOL ) );
+
+    // 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
  * The broadcastAccelData function constructs an accelerometer data msg to
  * be broadcast and queues the msg for transmit on the appropriate CAN channel.
  * @details Inputs: none
@@ -2350,6 +2825,114 @@
     return result;
 }
 
+/*********************************************************************//**
+ * @brief
+ * The broadcastDisinfectsData function sends out the disinfects data.
+ * @details Inputs: none
+ * @details Outputs: disinfects data msg constructed and queued
+ * @param disinfectsData which is disinfects msg constructed and queued
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL broadcastDisinfectsData( DISINFECTS_DATA_T *disinfectsData )
+{
+    BOOL result;
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_DISINFECT_STANDBY_DATA;
+    msg.hdr.payloadLen = sizeof( DISINFECTS_DATA_T );
+
+    memcpy( payloadPtr, disinfectsData, sizeof( DISINFECTS_DATA_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 broadcastSwitchesData function sends out switches data.
+ * @details Inputs: none
+ * @details Outputs: switches data msg constructed and queued
+ * @param SWITCHES_DATA_T which is switches msg constructed and queued
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL broadcastSwitchesData( SWITCHES_DATA_T *switchesData )
+{
+    BOOL result;
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
+
+    // create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_SWITCHES_DATA;
+    msg.hdr.payloadLen = sizeof( SWITCHES_DATA_T );
+
+    memcpy( payloadPtr, switchesData, sizeof( SWITCHES_DATA_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 broadcastTemperaturesData function sends out the temperatures data.
+ * @details Inputs: none
+ * @details Outputs: temperatures data msg constructed and queued
+ * @param temperaturesData which is the temperatures msg constructed and queued
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL broadcastTemperaturesData( TEMPERATURES_DATA_T *temperaturesData )
+{
+    BOOL result;
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_TEMPERATURES_DATA;
+    msg.hdr.payloadLen = sizeof( TEMPERATURES_DATA_T );
+
+    memcpy( payloadPtr, temperaturesData, sizeof( TEMPERATURES_DATA_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 broadcastFansData function sends out the fans data.
+ * @details Inputs: none
+ * @details Outputs: fans data msg constructed and queued
+ * @param fansData which is the fans msg constructed and queued
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL broadcastFansData( FANS_DATA_T *fansData )
+{
+    BOOL result;
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_FANS_DATA;
+    msg.hdr.payloadLen = sizeof( FANS_DATA_T );
+
+    memcpy( payloadPtr, fansData, sizeof( FANS_DATA_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;
+}
+
 #ifdef EMC_TEST_BUILD
 BOOL broadcastCANErrorCount( U32 count )
 {
@@ -2469,24 +3052,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
     {
@@ -2599,8 +3171,7 @@
         BOOL passed;
 
         memcpy( &passed, payloadPtr, sizeof( BOOL ) );
-
-        // TODO - handle DG POST  final result
+        signalDGPOSTFinalResult( passed );
     }
     else
     {
@@ -2684,12 +3255,12 @@
  *************************************************************************/
 void handleDGTemperatureData( MESSAGE_T *message )
 {
-    if ( message->hdr.payloadLen == sizeof(DG_TEMPERATURES_T) )
+    if ( message->hdr.payloadLen == sizeof( TEMPERATURE_SENSORS_DATA_T ) )
     {
-        DG_TEMPERATURES_T payload;
-
-        memcpy( &payload, message->payload, sizeof(DG_TEMPERATURES_T) );
-        setDialysateTemperatureReadings( payload.TDi, payload.TRo );
+        TEMPERATURE_SENSORS_DATA_T payload;
+
+        memcpy( &payload, message->payload, sizeof( TEMPERATURE_SENSORS_DATA_T ) );
+        setDialysateTemperatureReadings( payload.inletDialysate, payload.outletRedundant );
     }
     // TODO - what to do if invalid payload length?
     // TODO - how to know if DG stops sending these?
@@ -3466,11 +4037,15 @@
     HD_VERSIONS_T payload;
     U08 *payloadPtr = msg.payload;
 
-    // Populate payload
+    // Get UI version data from this request msg and have it recorded
+    handleUIVersionResponse( message );
+
+    // 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
@@ -3483,6 +4058,136 @@
 
     // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer
     serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_2_UI, ACK_REQUIRED );
+}
+
+/*********************************************************************//**
+ * @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
+ * @details Outputs: message handled, response constructed and queued
+ * for transmit.
+ * @return none
+ *************************************************************************/
+void handleHDSerialNumberRequest( void )
+{
+    MESSAGE_T msg;
+    HD_SYSTEM_RECORD_T system = getHDSystemRecord();
+    U08 *payloadPtr = msg.payload;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_SERIAL_NUMBER;
+
+    // Add 1 byte for null terminator
+    msg.hdr.payloadLen = MAX_TOP_LEVEL_SN_CHARS + 1;
+
+    // Fill message payload
+    memcpy( payloadPtr, &system.topLevelSN, MAX_TOP_LEVEL_SN_CHARS );
+    payloadPtr += MAX_TOP_LEVEL_SN_CHARS;
+    *payloadPtr = 0;
+
+    // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer
+    serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_2_UI, ACK_REQUIRED );
+}
+
+/*********************************************************************//**
+ * @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
+ * @details Outputs: message handled, response constructed and queued for
+ * transmit.
+ * @param message a pointer to the message to handle.
+ * @return none
+ *************************************************************************/
+void handleHDServiceScheduleRequest( MESSAGE_T *message )
+{
+    MESSAGE_T msg;
+    HD_SERVICE_RECORD_T payload = getHDServiceRecord();
+    U08 *payloadPtr = msg.payload;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_SERVICE_SCHEDULE_DATA;
+    msg.hdr.payloadLen = sizeof( U32 ) + sizeof( U32 );
+
+    // Fill message payload
+    memcpy( payloadPtr, &payload.lastServiceEpochDate, sizeof( U32 ) );
+    payloadPtr += sizeof( U32 );
+    memcpy( payloadPtr, &payload.serviceIntervalSeconds, sizeof( U32 ) );
+
+    // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer
+    serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_2_UI, ACK_REQUIRED );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleHDUsageInfoRequest function handles a request for HD
+ * usage information.
+ * @details Inputs: none
+ * @details Outputs: message handled, response constructed and queued for
+ * transmit.
+ * @param message a pointer to the message to handle.
+ * @return none
+ *************************************************************************/
+void handleHDUsageInfoRequest( MESSAGE_T *message )
+{
+    MESSAGE_T msg;
+    U32 payload = getTreatmentTime();
+    U08 *payloadPtr = msg.payload;
+
+    // Create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_HD_USAGE_DATA;
+    msg.hdr.payloadLen = sizeof( U32 );
+
+    // Fill message payload
+    memcpy( payloadPtr, &payload, sizeof( U32 ) );
+
+    // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer
+    serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_2_UI, ACK_REQUIRED );
 }
 
 
@@ -5243,13 +5948,13 @@
  *************************************************************************/
 void handleSetFluidLeakStateOverrideRequest( MESSAGE_T *message )
 {
-    TEST_OVERRIDE_ARRAY_PAYLOAD_T payload;
+    TEST_OVERRIDE_PAYLOAD_T payload;
     BOOL result = FALSE;
 
     // Verify payload length
-    if ( sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) == message->hdr.payloadLen )
+    if ( sizeof( TEST_OVERRIDE_PAYLOAD_T ) == message->hdr.payloadLen )
     {
-        memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) );
+        memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_PAYLOAD_T ) );
         if ( FALSE == payload.reset )
         {
             result = testSetFluidLeakStateOverride( ( FLUID_LEAK_STATES_T)( payload.state.u32 ) );
@@ -5442,8 +6147,232 @@
     sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
 }
 
+/*************************************************************************
+ * @brief
+ * The handleSetSwitchesStatusOverrideRequest function handles a
+ * request to override the status of a switch in HD.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleSetSwitchesStatusOverrideRequest( 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 = testSetSwitchesStatusOverride( payload.index, payload.state.u32 );
+        }
+        else
+        {
+            result = testResetSwitchesStatusOverride( payload.index );
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*************************************************************************
+ * @brief
+ * The handleTestSwitchesPublishIntervalOverrideRequest function handles a
+ * request to override the the switches data publish interval.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestSwitchesPublishIntervalOverrideRequest( 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 = testSetSwitchesDataPublishIntervalOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetSwitchesDataPublishIntervalOverrid();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
 /*********************************************************************//**
  * @brief
+ * The handleBatteryRemainingPercentOverrideRequest function handles a
+ * request to override battery remaining percent.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleBatteryRemainingPercentOverrideRequest( 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 = testSetBatteryRemainingPercentOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetSetBatteryRemainingPercentOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleBloodPrimeVolumeOverrideRequest function handles a request to
+ * override the calculated blood prime volume (in mL).
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleBloodPrimeVolumeOverrideRequest( 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 = testSetBloodPrimeVolumeOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetBloodPrimeVolumeOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleBloodPrimeSafetyVolumeOverrideRequest function handles a request to
+ * override the calculated safety blood prime volume (in mL).
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleBloodPrimeSafetyVolumeOverrideRequest( 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 = testSetBloodPrimeSafetyVolumeOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetBloodPrimeSafetyVolumeOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @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
@@ -6016,13 +6945,46 @@
 
 /*********************************************************************//**
  * @brief
- * The handleTestMonitoredVoltagesSendIntervalOverrideRequest function handles a
- * request to override the monitored HD voltages data publication interval.
+ * The handleTestValvesCurrentOverrideRequest function handles a
+ * request to override HD valves' current.
  * @details Inputs: none
  * @details Outputs: message handled
  * @param message : a pointer to the message to handle
  * @return none
  *************************************************************************/
+void handleTestValvesCurrentOverrideRequest( 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 = testSetValvesCurrentOverride( payload.index, payload.state.f32 );
+        }
+        else
+        {
+            result = testResetValvesCurrentOverride( payload.index );
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestMonitoredVoltagesSendIntervalOverrideRequest function
+ * handles a request to override the monitored HD voltages data
+ * publication interval.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
 void handleTestMonitoredVoltagesSendIntervalOverrideRequest( MESSAGE_T *message )
 {
     TEST_OVERRIDE_PAYLOAD_T payload;
@@ -6048,6 +7010,38 @@
 
 /*********************************************************************//**
  * @brief
+ * The handleTestValvesPositionCountOverrideRequest function handles a
+ * request to override HD valves' position in counts.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestValvesPositionCountOverrideRequest( 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 = testSetValvesPositionCountOverride( payload.index, payload.state.u32 );
+        }
+        else
+        {
+            result = testResetValvesPositionCountOverride( payload.index );
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
  * The handleTestMonitoredVoltageOverrideRequest function handles a
  * request to override the monitored HD voltage override.
  * @details Inputs: none
@@ -6112,6 +7106,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
@@ -6366,4 +7712,131 @@
     sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
 }
 
+/*********************************************************************//**
+ * @brief
+ * The handleTestTemperaturesValueOverrideRequest function handles a
+ * request to override a temperatures sensor's value.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestTemperaturesValueOverrideRequest( 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 = testSetMeasuredTemperatureOverride( payload.index, payload.state.f32 );
+        }
+        else
+        {
+            result = testResetMeasuredTemperatureOverride( payload.index );
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestTemperaturesBroadcastIntervalOverrideRequest function handles a
+ * request to override the temperatures data broadcast interval.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestTemperaturesBroadcastIntervalOverrideRequest( 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 = testSetTemperaturesPublishIntervalOverride( (U32)( payload.state.u32 ) );
+        }
+        else
+        {
+            result = testResetTemperaturesPublishIntervalOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleTestTemperaturesBroadcastIntervalOverrideRequest function handles a
+ * request to override the temperatures data broadcast interval.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestFansBroadcastIntervalOverrideRequest( 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 = testSetFanPublishIntervalOverride( (U32)( payload.state.u32 ) );
+        }
+        else
+        {
+            result = testResetFanPublishIntervalOverride();
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
+/*********************************************************************//**
+ * @brief
+ * The handleFansRPMOverride function handles a request to override a fans RPM value.
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleFansRPMOverride( 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 = testSetFanRPMOverride( payload.index, payload.state.f32 );
+        }
+        else
+        {
+            result = testResetFanRPMOverride( payload.index );
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
 /**@}*/