Index: firmware/App/Services/SystemCommMessages.c
===================================================================
diff -u -r1240b612f790f931825aba86ec37f37eccce9336 -r91aa11a47f3b3c744cbbfd9e9c1bd240263aa1bd
--- firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision 1240b612f790f931825aba86ec37f37eccce9336)
+++ firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision 91aa11a47f3b3c744cbbfd9e9c1bd240263aa1bd)
@@ -672,6 +672,176 @@
     // 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 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 );
+    }
+}
 
 /*********************************************************************//**
  * @brief
@@ -1232,6 +1402,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 +2606,33 @@
     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_STANDBY_STATE;
+    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;
+}
+
 #ifdef EMC_TEST_BUILD
 BOOL broadcastCANErrorCount( U32 count )
 {
@@ -5243,13 +5526,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 ) );
@@ -6016,13 +6299,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 +6364,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