Index: firmware/App/Controllers/LoadCell.c
===================================================================
diff -u -r45dcb7966d1996f533eb6ca321637db16535182e -rf5d0c90297a0716e1fb5a5c946436cccd35050e5
--- firmware/App/Controllers/LoadCell.c	(.../LoadCell.c)	(revision 45dcb7966d1996f533eb6ca321637db16535182e)
+++ firmware/App/Controllers/LoadCell.c	(.../LoadCell.c)	(revision f5d0c90297a0716e1fb5a5c946436cccd35050e5)
@@ -288,3 +288,5 @@
 
     return result;
 }
+
+/**@}*/
Index: firmware/App/Controllers/Valves.c
===================================================================
diff -u
--- firmware/App/Controllers/Valves.c	(revision 0)
+++ firmware/App/Controllers/Valves.c	(revision f5d0c90297a0716e1fb5a5c946436cccd35050e5)
@@ -0,0 +1,527 @@
+/**********************************************************************//**
+ *
+ *  Copyright (c) 2020-2020 Diality Inc. - All Rights Reserved.
+ *
+ *  THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN
+ *  WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER.
+ *
+ *  @file Valves.c
+ *
+ *  @date 21-Apr-2020
+ *  @author P. Montazemi
+ *
+ *  @brief Valves source file.
+ *
+ **************************************************************************/
+
+#include "AlarmMgmt.h"
+#include "FPGA.h"
+#include <math.h>
+#include "OperationModes.h"
+#include "stdbool.h"
+#include "SystemCommMessages.h"
+#include "TaskPriority.h"
+#include "Timers.h"
+#include "Valves.h"
+
+/**
+ *  @addtogroup DGValves
+ *  @{
+ */
+
+// ********** private definitions **********
+
+#define DEENERGIZED                                 0                                                               ///< 0 for de-energized valve
+#define ENERGIZED                                   1                                                               ///< 1 for energized valve
+#define ALL_VALVES_DEENERGIZED                      0x0000                                                          ///< 0 in U16 bit field for all valves
+
+#define MAX_VALVE_STATE_MISMATCH_COUNT              3                                                               ///< maximum number of times commanded valves state can fail to match read back valve states in a row.
+
+/// Default publication interval for valves states
+#define VALVES_STATE_PUB_INTERVAL                   ( 500 / TASK_PRIORITY_INTERVAL )                                ///< interval ( ms / task time) at which valves states are published on CAN bus
+
+// ********** private data **********
+
+static U32 valvesStatesPublicationTimerCounter    = 0;                                                              ///< used to schedule valve state publication to CAN bus
+static U16 commandedValvesStates                  = ALL_VALVES_DEENERGIZED;                                         ///< initialize commanded valves states bit field.
+static U32 valveStateMismatchCounter              = 0;                                                              ///< initialize valve state mismatch counter
+
+static OVERRIDE_U32_T valveStates[ NUM_OF_VALVES ];                                                                 ///< Currently commanded valves states
+static OVERRIDE_U32_T valvesStatesPublishInterval = { VALVES_STATE_PUB_INTERVAL, VALVES_STATE_PUB_INTERVAL, 0, 0 }; ///< interval (in ms/task interval) at which to publish valves state to CAN bus
+
+// ********** private function prototypes **********
+
+static BOOL checkValveStateName( VALVES_T valve, VALVE_STATE_NAMES_T valveStateName );                              ///< check validity of requested valve state name for given valve
+static U32 convertValveStateNameToValveState(VALVE_STATE_NAMES_T valveStateName);                                   ///< Convert valve state name to de-/energized valve state
+static U16 fromU32ArrayToU16( OVERRIDE_U32_T array[ NUM_OF_VALVES ] );                                              ///< convert array of U32 to U16 for statesValves preparation
+static void publishValvesStates( void );
+static DATA_GET_PROTOTYPE( U32, getPublishValvesStatesInterval );
+
+/*********************************************************************//**
+ * @brief
+ * The initValves function initializes the Valves module.
+ * @details
+ * Inputs : none
+ * Outputs : Valves module initialized
+ * @return none
+ *************************************************************************/
+void initValves( void )
+{
+    U32 i;
+
+    // initialize commanded valve states
+    for (i = 0; i < NUM_OF_VALVES; i++)
+    {
+        valveStates[ i ].data = DEENERGIZED;
+        valveStates[ i ].ovInitData = DEENERGIZED;
+        valveStates[ i ].ovData = DEENERGIZED;
+        valveStates[ i ].override = OVERRIDE_RESET;
+    }
+    commandedValvesStates = fromU32ArrayToU16( valveStates );
+    setFPGAValveStates( commandedValvesStates ); // initially set all valves to de-energized state via FPGA
+
+    valvesStatesPublicationTimerCounter = 0;  // reset valves states publication timer
+}
+
+/*********************************************************************//**
+ * @brief
+ * The execValves function executes the valves driver.
+ * @details
+ * Inputs : valvesStates, valveStateMismatchCounter
+ * Outputs : valvesStates, valveStateMismatchCounter
+ * @return none
+ *************************************************************************/
+void execValves( void )
+{
+    U16 readValvesStates = getFPGAValveStates(); // get valves states from FPGA
+
+    // verify read back FPGA valve states match last commanded valve states
+    if ( readValvesStates != commandedValvesStates )
+    {
+        valveStateMismatchCounter++; // increment valve state mismatch counter by 1
+        if ( valveStateMismatchCounter > MAX_VALVE_STATE_MISMATCH_COUNT )
+        {
+            activateAlarmNoData( ALARM_ID_VALVE_CONTROL_FAILURE );
+        }
+    }
+    else
+    {
+        valveStateMismatchCounter = 0;
+    }
+
+    // set valves states (via FPGA) to currently commanded states
+    commandedValvesStates = fromU32ArrayToU16( valveStates );
+    setFPGAValveStates( commandedValvesStates );
+
+    // publish valve states on interval
+    publishValvesStates();
+}
+
+/*********************************************************************//**
+ * @brief
+ * The checkValveStateName function checks the validity of requested valve \n
+ * state name for given valve.
+ * @details
+ * Inputs : none
+ * Outputs : none
+ * @param valveID : ID of valve to check a valve state name for.
+ * @param valveStateName : valve state name to check for given valve ID.
+ * @return TRUE if given valveStateName is appropriate for given valve ID, FALSE if not.
+ *************************************************************************/
+static BOOL checkValveStateName( VALVES_T valveID, VALVE_STATE_NAMES_T valveStateName )
+{
+    BOOL result = FALSE; // initialize result flag to FALSE
+
+    switch ( valveStateName )
+    {
+        case VALVE_STATE_OPEN:
+            if ( ( valveID == VPI ) || ( valveID == VBF ) || ( valveID == VSP ) )
+            {
+                result = TRUE;
+            }
+            break;
+
+        case VALVE_STATE_CLOSED:
+            if ( ( valveID == VPI ) || ( valveID == VBF ) || ( valveID == VSP ) )
+            {
+                result = TRUE;
+            }
+            break;
+
+        case VALVE_STATE_OPEN_C_TO_NO:
+            if ( valveID == VPD )
+            {
+                result = TRUE;
+            }
+            break;
+
+        case VALVE_STATE_DRAIN_C_TO_NC:
+            if ( valveID == VPD )
+            {
+                result = TRUE;
+            }
+            break;
+
+        case VALVE_STATE_NOFILL_C_TO_NO:
+            if ( valveID == VPO )
+            {
+                result = TRUE;
+            }
+            break;
+
+        case VALVE_STATE_FILL_C_TO_NC:
+            if ( valveID == VPO )
+            {
+                result = TRUE;
+            }
+            break;
+
+        case VALVE_STATE_DRAIN_C_TO_NO:
+            if ( ( valveID == VDR ) || ( valveID == VRC ) )
+            {
+                result = TRUE;
+            }
+            break;
+
+        case VALVE_STATE_RECIRC_C_TO_NC:
+            if ( ( valveID == VDR ) || ( valveID == VRC ) )
+            {
+                result = TRUE;
+            }
+            break;
+
+        case VALVE_STATE_R1_C_TO_NO:
+            if ( ( valveID == VRO ) || ( valveID == VRI ) )
+            {
+                result = TRUE;
+            }
+            break;
+
+        case VALVE_STATE_R1_C_TO_NC:
+            if ( ( valveID == VRD ) || ( valveID == VRF ) )
+            {
+                result = TRUE;
+            }
+            break;
+
+        case VALVE_STATE_R2_C_TO_NO:
+            if ( ( valveID == VRD ) || ( valveID == VRF ) )
+            {
+                result = TRUE;
+            }
+            break;
+
+        case VALVE_STATE_R2_C_TO_NC:
+            if ( ( valveID == VRO ) || ( valveID == VRI ) )
+            {
+                result = TRUE;
+            }
+            break;
+
+        default:
+            SET_ALARM_WITH_2_U32_DATA( ALARM_ID_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_STATE_NAME, valveStateName )
+            break;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getPublishValveStateInterval function gets the valves states \n
+ * publication interval.
+ * @details
+ * Inputs : valvesStatesPublishInterval
+ * Outputs : none
+ * @return the current valves states publication interval (in task intervals)
+ *************************************************************************/
+U32 getPublishValvesStatesInterval( void )
+{
+    U32 result = valvesStatesPublishInterval.data;
+
+    if ( OVERRIDE_KEY == valvesStatesPublishInterval.override )
+    {
+        result = valvesStatesPublishInterval.ovData;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The fromU32ArrayToU16 function converts an array of U32 valve states \n
+ * to U16 valvesStates that can be passed to FPGA for setting valves.
+ * @details
+ * Inputs : valveStates[]
+ * Outputs : none
+ * @return converted U16 bit field for currently commanded valve states
+ *************************************************************************/
+U16 fromU32ArrayToU16( OVERRIDE_U32_T array[ NUM_OF_VALVES ] )
+{
+    U16 result = ALL_VALVES_DEENERGIZED; // start result flag as all valves de-energized
+    U32 i;
+
+    // flag valves that are currently commanded to be energized
+    for ( i = 0; i < NUM_OF_VALVES; i++)
+    {
+        result |= ( getValveState( i ) == ENERGIZED ? 0x0001 << i : 0 );
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The convertValveStateNameToValveState function converts valve state \n
+ * name to its corresponding de-energized (0) or energized (1) valve state.
+ * @details
+ * Inputs : none
+ * Outputs : none
+ * @param valveStateName : valve state name enumeration to convert to energized/de-energized.
+ * @return converted valve state for given valve state name
+ *************************************************************************/
+U32 convertValveStateNameToValveState( VALVE_STATE_NAMES_T valveStateName )
+{
+    U32 vState = DEENERGIZED; // initialize valve state to de-energized
+
+    switch ( valveStateName )
+    {
+        case VALVE_STATE_OPEN:
+            vState = ENERGIZED;
+            break;
+
+        case VALVE_STATE_CLOSED:
+            vState = DEENERGIZED;
+            break;
+
+        case VALVE_STATE_OPEN_C_TO_NO:
+            vState = DEENERGIZED;
+            break;
+
+        case VALVE_STATE_DRAIN_C_TO_NC:
+            vState = ENERGIZED;
+            break;
+
+        case VALVE_STATE_NOFILL_C_TO_NO:
+            vState = DEENERGIZED;
+            break;
+
+        case VALVE_STATE_FILL_C_TO_NC:
+            vState = ENERGIZED;
+            break;
+
+        case VALVE_STATE_DRAIN_C_TO_NO:
+            vState = DEENERGIZED;
+            break;
+
+        case VALVE_STATE_RECIRC_C_TO_NC:
+            vState = ENERGIZED;
+            break;
+
+        case VALVE_STATE_R1_C_TO_NO:
+            vState = DEENERGIZED;
+            break;
+
+        case VALVE_STATE_R1_C_TO_NC:
+            vState = ENERGIZED;
+            break;
+
+        case VALVE_STATE_R2_C_TO_NO:
+            vState = DEENERGIZED;
+            break;
+
+        case VALVE_STATE_R2_C_TO_NC:
+            vState = ENERGIZED;
+            break;
+
+        default:
+            SET_ALARM_WITH_2_U32_DATA( ALARM_ID_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_STATE_NAME, valveStateName )
+            break;
+    }
+
+    return vState;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The setValveState function sets the valve state for given valve.
+ * @details
+ * Inputs : none
+ * Outputs : none
+ * @param valveID : ID of valve to set state for.
+ * @param valveStateName : Name of valve state to set given valve to.
+ * @return TRUE if new valve state is set for given valve ID, FALSE if not.
+ *************************************************************************/
+BOOL setValveState( VALVES_T valveID, VALVE_STATE_NAMES_T valveStateName )
+{
+    BOOL result = FALSE; // initialize result flag to FALSE
+
+    if ( checkValveStateName ( valveID, valveStateName ) )
+    {
+        valveStates[ valveID ].data = convertValveStateNameToValveState( valveStateName );
+        result = TRUE;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getValveState function gets the current valve state for given valve.
+ * @details
+ * Inputs : valveStates[]
+ * Outputs : none
+ * @param valveID : ID of valve to get state for.
+ * @return the current valve state for given valve
+ *************************************************************************/
+U32 getValveState( U32 valveID )
+{
+    U32 valveState = DEENERGIZED;
+
+    if ( valveID < NUM_OF_VALVES )
+    {
+        if ( OVERRIDE_KEY == valveStates[ valveID ].override )
+        {
+            valveState = valveStates[ valveID ].ovData;
+        }
+        else
+        {
+            valveState = valveStates[ valveID ].data;
+        }
+    }
+    else
+    {
+        SET_ALARM_WITH_2_U32_DATA( ALARM_ID_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_ID, valveID )
+    }
+
+    return valveState;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The publishValvesStates function publishes DG valves states at the \n
+ * set interval.
+ * @details
+ * Inputs : valvesStatesPublicationTimerCounter
+ * Outputs : DG valves states are published to CAN bus on interval.
+ * @return none
+ *************************************************************************/
+static void publishValvesStates( void )
+{
+    // publish valve state on interval
+    if ( ++valvesStatesPublicationTimerCounter >= getPublishValvesStatesInterval() )
+    {
+        broadcastValvesStates( getFPGAValveStates() );
+        valvesStatesPublicationTimerCounter = 0;
+    }
+}
+
+/*************************************************************************
+ *                       TEST SUPPORT FUNCTIONS
+ *************************************************************************/
+
+
+/*********************************************************************//**
+ * @brief
+ * The testSetValvesStatesPublishIntervalOverride function overrides the \n
+ * valves states publish interval.
+ * @details
+ * Inputs : none
+ * Outputs : valvesStatesPublishInterval
+ * @param value : override valves states publish interval with (in ms)
+ * @return TRUE if override successful, FALSE if not
+ *************************************************************************/
+BOOL testSetValvesStatesPublishIntervalOverride( U32 value )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        U32 intvl = value / TASK_PRIORITY_INTERVAL;
+
+        result = TRUE;
+        valvesStatesPublishInterval.ovData = intvl;
+        valvesStatesPublishInterval.override = OVERRIDE_KEY;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testResetValvesStatesPublishIntervalOverride function resets the override \n
+ * of the valves states publish interval.
+ * @details
+ * Inputs : none
+ * Outputs : valvesStatesPublishInterval
+ * @return TRUE if override reset successful, FALSE if not
+ *************************************************************************/
+BOOL testResetValvesStatesPublishIntervalOverride( void )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        result = TRUE;
+        valvesStatesPublishInterval.override = OVERRIDE_RESET;
+        valvesStatesPublishInterval.ovData = valvesStatesPublishInterval.ovInitData;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testSetValveStateOverride function overrides the value of the \n
+ * specified valve with a given value.
+ * Inputs : none
+ * Outputs : valves[]
+ * @param valveID : ID of valve to override for
+ * @param value : override value for the given valve ID
+ * @return TRUE if override successful, FALSE if not
+ *************************************************************************/
+BOOL testSetValveStateOverride( U32 valveID, U32 value )
+{
+    BOOL result = FALSE;
+
+    if ( valveID < NUM_OF_VALVES )
+    {
+        if ( TRUE == isTestingActivated() )
+        {
+            result = TRUE;
+            valveStates[ valveID ].ovData = value;
+            valveStates[ valveID ].override = OVERRIDE_KEY;
+        }
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testResetValveStateOverride function resets the override of the \n
+ * specified valve.
+ * @details
+ * Inputs : none
+ * Outputs : valves[]
+ * @param valveID : ID of valve to reset override state for
+ * @return TRUE if override successful, FALSE if not
+ *************************************************************************/
+BOOL testResetValveStateOverride( U32 valveID )
+{
+    BOOL result = FALSE;
+
+    if ( valveID < NUM_OF_VALVES )
+    {
+        if ( TRUE == isTestingActivated() )
+        {
+            result = TRUE;
+            valveStates[ valveID ].override = OVERRIDE_RESET;
+            valveStates[ valveID ].ovData = valveStates[ valveID ].ovInitData;
+        }
+    }
+
+    return result;
+}
+
+/**@}*/
Index: firmware/App/Controllers/Valves.h
===================================================================
diff -u
--- firmware/App/Controllers/Valves.h	(revision 0)
+++ firmware/App/Controllers/Valves.h	(revision f5d0c90297a0716e1fb5a5c946436cccd35050e5)
@@ -0,0 +1,85 @@
+/**************************************************************************
+ *
+ *  Copyright (c) 2020-2020 Diality Inc. - All Rights Reserved.
+ *
+ *  THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN
+ *  WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER.
+ *
+ *  @file Valves.h
+ *
+ *  @date 21-Apr-2020
+ *  @author P. Montazemi
+ *
+ *  @brief Valves header file.
+ *
+ **************************************************************************/
+
+#ifndef __VALVES_H__
+#define __VALVES_H__
+
+#include "DGCommon.h"
+
+/**
+ *  @defgroup Valves Valves
+ *  @brief Valves driver module.
+ *  Controls valves.
+ *
+ *  @addtogroup Valves
+ *  @{
+ */
+
+// ********** public definitions **********
+
+/// Enumeration of available valve state names per valve type (from SA and DG SRS documents)
+typedef enum ValveStateNames
+{
+    VALVE_STATE_OPEN = 0,       ///< Open valve state, used only for VPi, VBf, and VSP
+    VALVE_STATE_CLOSED,         ///< Closed valve state, used only for VPi, VBf, and VSP
+    VALVE_STATE_OPEN_C_TO_NO,   ///< Open Common to Normally Open valve state, used only for VPd
+    VALVE_STATE_DRAIN_C_TO_NC,  ///< Drain Common to Normally Closed valve state, used only for VPd
+    VALVE_STATE_NOFILL_C_TO_NO, ///< No Fill Common to Normally Open valve state, used only for VPo
+    VALVE_STATE_FILL_C_TO_NC,   ///< Fill Common to Normally Closed valve state, used only for VPo
+    VALVE_STATE_DRAIN_C_TO_NO,  ///< Drain Common to Normally Open valve state, used only for VDr and VRc
+    VALVE_STATE_RECIRC_C_TO_NC, ///< Recirculate Common to Normally Closed valve state, used only for VDr and VRc
+    VALVE_STATE_R1_C_TO_NO,     ///< Reservoir 1 Common to Normally Open valve state, used only for VRo and VRi
+    VALVE_STATE_R1_C_TO_NC,     ///< Reservoir 1 Common to Normally Closed valve state, used only for VRd and VRf
+    VALVE_STATE_R2_C_TO_NO,     ///< Reservoir 2 Common to Normally Open valve state, used only for VRd and VRf
+    VALVE_STATE_R2_C_TO_NC,     ///< Reservoir 2 Common to Normally Closed valve state, used only for VRo and VRi
+    NUM_OF_VALVE_STATES         ///< number of valve states
+} VALVE_STATE_NAMES_T;
+
+/// Enumeration of valves
+typedef enum Valves
+{
+    VRF = 0,          ///< Valve Reservoir Fill
+    VRI,              ///< Valve Reservoir Inlet
+    VRD,              ///< Valve Reservoir Drain
+    VRO,              ///< Valve Reservoir Outlet
+    VPO,              ///< Valve Pressure Outlet
+    VBF,              ///< Valve Bypass Filter
+    VRC,              ///< Valve Recirculate
+    VDR,              ///< Valve Drain
+    VPI,              ///< Valve Pressure inlet
+    VSP,              ///< Valve Sampling Port
+    VR1,              ///< Valve Reservoir 1 (spare for now including DG FPGA, as valve is of passive air relief type)
+    VR2,              ///< Valve Reservoir 2 (spare for now including DG FPGA, as valve is of passive air relief type)
+    VPD,              ///< Valve Production Drain
+    NUM_OF_VALVES     ///< Number of valves
+} VALVES_T;
+
+// ********** public function prototypes **********
+
+void initValves( void );                                              // initialize the valves driver
+void execValves( void );                                              // execute the valves driver
+
+BOOL setValveState( VALVES_T valve, VALVE_STATE_NAMES_T valveState );      // set valve's state to valveState
+DATA_ARRAY_GET_PROTOTYPE( U32, getValveState, valveID );              // get valve state for given valve
+
+BOOL testSetValvesStatesPublishIntervalOverride( U32 value );
+BOOL testResetValvesStatesPublishIntervalOverride( void );
+BOOL testSetValveStateOverride( U32 valve, U32 state );
+BOOL testResetValveStateOverride( U32 valveID );
+
+/**@}*/
+
+#endif /* __VALVES_H__ */
Index: firmware/App/Services/AlarmMgmt.h
===================================================================
diff -u -r2496e9225fa1b2c627d625def02515a0f0dd5793 -rf5d0c90297a0716e1fb5a5c946436cccd35050e5
--- firmware/App/Services/AlarmMgmt.h	(.../AlarmMgmt.h)	(revision 2496e9225fa1b2c627d625def02515a0f0dd5793)
+++ firmware/App/Services/AlarmMgmt.h	(.../AlarmMgmt.h)	(revision f5d0c90297a0716e1fb5a5c946436cccd35050e5)
@@ -129,6 +129,8 @@
     SW_FAULT_ID_HEATERS_SELF_TEST_INVALID_STATE,
     SW_FAULT_ID_HEATERS_PRIMARY_HEATER_EXEC_INVALID_STATE,
     SW_FAULT_ID_HEATERS_TRIMMER_HEATER_EXEC_INVALID_STATE,
+    SW_FAULT_ID_VALVES_INVALID_VALVE_STATE_NAME,
+    SW_FAULT_ID_VALVES_INVALID_VALVE_ID,
     NUM_OF_SW_FAULT_IDS
 } SW_FAULT_ID_T;
 
Index: firmware/App/Services/FPGA.c
===================================================================
diff -u -ra721c4feab8c89880314070d56224e28d502ac5e -rf5d0c90297a0716e1fb5a5c946436cccd35050e5
--- firmware/App/Services/FPGA.c	(.../FPGA.c)	(revision a721c4feab8c89880314070d56224e28d502ac5e)
+++ firmware/App/Services/FPGA.c	(.../FPGA.c)	(revision f5d0c90297a0716e1fb5a5c946436cccd35050e5)
@@ -210,7 +210,6 @@
     memset( &fpgaHeader, 0, sizeof(FPGA_HEADER_T) );
     memset( &fpgaSensorReadings, 0, sizeof(DG_FPGA_SENSORS_T) );
     memset( &fpgaActuatorSetPoints, 0, sizeof(FPGA_ACTUATORS_T) );
-    fpgaActuatorSetPoints.fpgaValveStates = 0x015F;  // TODO - temporary init per Blaine while testing - remove later.
 
     // initialize fpga comm buffers
     memset( &fpgaWriteCmdBuffer, 0, FPGA_WRITE_CMD_BUFFER_LEN );
Index: firmware/App/Services/SystemCommMessages.c
===================================================================
diff -u -rd611d220407c97b46a047455e6a91600662df227 -rf5d0c90297a0716e1fb5a5c946436cccd35050e5
--- firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision d611d220407c97b46a047455e6a91600662df227)
+++ firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision f5d0c90297a0716e1fb5a5c946436cccd35050e5)
@@ -31,6 +31,7 @@
 #include "RTC.h"
 #include "SystemComm.h"
 #include "Utilities.h"
+#include "Valves.h"
 #include "WatchdogMgmt.h"
 #include "SystemCommMessages.h"
 
@@ -419,6 +420,35 @@
 
 /*************************************************************************
  * @brief
+ * The broadcastValvesStates function sends out DG valves states.
+ * @details
+ * Inputs : none
+ * Outputs : Valves states msg constructed and queued
+ * @param valvesStates : valves states
+ * refer to setFPGAValveStates function in FPGA.c for details
+ * @return TRUE if msg successfully queued for transmit, FALSE if not
+ *************************************************************************/
+BOOL broadcastValvesStates( U16 valvesStates )
+{
+    BOOL result;
+    MESSAGE_T msg;
+    U08 *payloadPtr = msg.payload;
+
+    // create a message record
+    blankMessage( &msg );
+    msg.hdr.msgID = MSG_ID_DG_VALVES_STATES;
+    msg.hdr.payloadLen = sizeof( U16 );
+
+    memcpy( payloadPtr, &valvesStates, sizeof( U16 ) );
+
+    // 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_DG_BROADCAST, ACK_NOT_REQUIRED );
+
+    return result;
+}
+
+/*************************************************************************
+ * @brief
  * The broadcastROPumpData function sends out RO pump data.
  * @details
  * Inputs : none
Index: firmware/App/Services/SystemCommMessages.h
===================================================================
diff -u -r00c9d70ee1398f0c6db39a011220f830db92cfd3 -rf5d0c90297a0716e1fb5a5c946436cccd35050e5
--- firmware/App/Services/SystemCommMessages.h	(.../SystemCommMessages.h)	(revision 00c9d70ee1398f0c6db39a011220f830db92cfd3)
+++ firmware/App/Services/SystemCommMessages.h	(.../SystemCommMessages.h)	(revision f5d0c90297a0716e1fb5a5c946436cccd35050e5)
@@ -41,6 +41,9 @@
 // MSG_ID_LOAD_CELL_READINGS
 BOOL broadcastLoadCellData( F32 loadCellA1, F32 loadCellA2, F32 loadCellB1, F32 loadCellB2 );
 
+// MSG_ID_DG_VALVES_STATES
+BOOL broadcastValvesStates( U16 valvesStates );
+
 // MSG_ID_RO_PUMP_DATA
 BOOL broadcastROPumpData( U32 tgtPressure, F32 measFlow, F32 setPWM );
 
Index: firmware/App/Tasks/TaskPriority.c
===================================================================
diff -u -rfdaea534d10067404de9bd14b91b2a81d0a7e5ef -rf5d0c90297a0716e1fb5a5c946436cccd35050e5
--- firmware/App/Tasks/TaskPriority.c	(.../TaskPriority.c)	(revision fdaea534d10067404de9bd14b91b2a81d0a7e5ef)
+++ firmware/App/Tasks/TaskPriority.c	(.../TaskPriority.c)	(revision f5d0c90297a0716e1fb5a5c946436cccd35050e5)
@@ -22,9 +22,9 @@
 #include "LoadCell.h"
 #include "Pressures.h"
 #include "ROPump.h"
+#include "TaskPriority.h"
 #include "TemperatureSensors.h"
 #include "WatchdogMgmt.h"
-#include "TaskPriority.h"
 
 /*************************************************************************
  * @brief taskPriority
@@ -45,9 +45,12 @@
     // monitor pressures
     execPressures();
 
-    // load cells monitor
+    // monitor load cells
     execLoadCell();
 
+    // control valves
+    execValves();
+
     // monitor RO pump
     execROPumpMonitor();
 
@@ -64,6 +67,6 @@
     checkInWithWatchdogMgmt( TASK_PRIORITY );
 
     // toggle GPIO to indicate priority task has executed
-//    gioToggleBit( gioPORTB, 3 );
+    //gioToggleBit( gioPORTB, 3 );
 }
 
Index: firmware/source/sys_main.c
===================================================================
diff -u -r45dcb7966d1996f533eb6ca321637db16535182e -rf5d0c90297a0716e1fb5a5c946436cccd35050e5
--- firmware/source/sys_main.c	(.../sys_main.c)	(revision 45dcb7966d1996f533eb6ca321637db16535182e)
+++ firmware/source/sys_main.c	(.../sys_main.c)	(revision f5d0c90297a0716e1fb5a5c946436cccd35050e5)
@@ -80,6 +80,7 @@
 #include "TaskBG.h"
 #include "TemperatureSensors.h"
 #include "Timers.h"
+#include "Valves.h"
 #include "WatchdogMgmt.h"
 
 static void initProcessor( void );
@@ -167,6 +168,7 @@
     initInternalADC();
     initPressures();
     initLoadCell();
+    initValves();
     initHeaters();
     initTemperatureSensors();
     initROPump();