Index: firmware/App/Controllers/AirTrap.c
===================================================================
diff -u -r563f516a81cb41290008f93b33e7cf5e121717db -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Controllers/AirTrap.c	(.../AirTrap.c)	(revision 563f516a81cb41290008f93b33e7cf5e121717db)
+++ firmware/App/Controllers/AirTrap.c	(.../AirTrap.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -83,7 +83,6 @@
 static AIR_TRAP_STATE_T handleAirTrapValveClosedState( void );
 static AIR_TRAP_STATE_T handleAirTrapValveOpenState( void );
 static void publishAirTrapData( void );
-static U32  getPublishAirTrapDataInterval( void );
 
 /*********************************************************************//**
  * @brief
@@ -375,11 +374,7 @@
 
     if ( sensor < NUM_OF_AIR_TRAP_LEVEL_SENSORS )
     {
-        result = (AIR_TRAP_LEVELS_T)airTrapLevels[ sensor ].data;
-        if ( OVERRIDE_KEY == airTrapLevels[ sensor ].override )
-        {
-            result = (AIR_TRAP_LEVELS_T)airTrapLevels[ sensor ].ovData;
-        }
+        result = (AIR_TRAP_LEVELS_T)getU32OverrideValue( &airTrapLevels[ sensor ] );
     }
     else
     {
@@ -392,26 +387,6 @@
 
 /*********************************************************************//**
  * @brief
- * The getPublishAirTrapDataInterval function gets the air trap data
- * publication interval.
- * @details Inputs: airTrapDataPublishInterval
- * @details Outputs: none
- * @return the current air trap data publication interval (in task intervals).
- *************************************************************************/
-static U32  getPublishAirTrapDataInterval( void )
-{
-    U32 result = airTrapDataPublishInterval.data;
-
-    if ( OVERRIDE_KEY == airTrapDataPublishInterval.override )
-    {
-        result = airTrapDataPublishInterval.ovData;
-    }
-
-    return result;
-}
-
-/*********************************************************************//**
- * @brief
  * The publishAirTrapData function publishes air trap data at the set interval.
  * @details Inputs: airTrapLevels[]
  * @details Outputs: if broadcast is due, send air trap data
@@ -420,7 +395,7 @@
 static void publishAirTrapData( void )
 {
     // Publish air trap data on interval
-    if ( ++airTrapDataPublicationTimerCounter >= getPublishAirTrapDataInterval() )
+    if ( ++airTrapDataPublicationTimerCounter >= getU32OverrideValue( &airTrapDataPublishInterval ) )
     {
         AIR_TRAP_LEVELS_T lowLevel = getAirTrapLevel( AIR_TRAP_LEVEL_SENSOR_LOWER );
         AIR_TRAP_LEVELS_T highLevel = getAirTrapLevel( AIR_TRAP_LEVEL_SENSOR_UPPER );
Index: firmware/App/Controllers/BloodFlow.c
===================================================================
diff -u -rd27dcf1fbbc9651636f211028917a1c0702bb56a -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Controllers/BloodFlow.c	(.../BloodFlow.c)	(revision d27dcf1fbbc9651636f211028917a1c0702bb56a)
+++ firmware/App/Controllers/BloodFlow.c	(.../BloodFlow.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -236,7 +236,6 @@
 static void checkBloodPumpFlowAgainstSpeed( void );
 static void checkBloodPumpMCCurrent( void );
 static void checkBloodFlowSensorSignalStrength( void );
-static U32  getPublishBloodFlowDataInterval( void );
 
 /*********************************************************************//**
  * @brief
@@ -778,33 +777,13 @@
 
 /*********************************************************************//**
  * @brief
- * The getPublishBloodFlowDataInterval function gets the blood flow data
- * publication interval.
- * @details Inputs: bloodFlowDataPublishInterval
- * @details Outputs: none
- * @return the current blood flow data publication interval (in task intervals).
- *************************************************************************/
-U32 getPublishBloodFlowDataInterval( void )
-{
-    U32 result = bloodFlowDataPublishInterval.data;
-
-    if ( OVERRIDE_KEY == bloodFlowDataPublishInterval.override )
-    {
-        result = bloodFlowDataPublishInterval.ovData;
-    }
-
-    return result;
-}
-
-/*********************************************************************//**
- * @brief
  * The getMeasuredBloodFlowRate function gets the measured blood flow
  * rate.
  * @details Inputs: measuredBloodFlowRate
  * @details Outputs: none
  * @return the current blood flow rate (in mL/min).
  *************************************************************************/
-F32  getMeasuredBloodFlowRate( void )
+F32 getMeasuredBloodFlowRate( void )
 {
     F32 result = measuredBloodFlowRate.data;
 
@@ -844,7 +823,7 @@
  * @details Outputs: none
  * @return the current blood flow rate (in mL/min).
  *************************************************************************/
-F32  getMeasuredBloodPumpRotorSpeed( void )
+F32 getMeasuredBloodPumpRotorSpeed( void )
 {
     F32 result = bloodPumpRotorSpeedRPM.data;
 
@@ -864,7 +843,7 @@
  * @details Outputs: none
  * @return the current blood flow rate (in mL/min).
  *************************************************************************/
-F32  getMeasuredBloodPumpSpeed( void )
+F32 getMeasuredBloodPumpSpeed( void )
 {
     F32 result = bloodPumpSpeedRPM.data;
 
@@ -884,7 +863,7 @@
  * @details Outputs: none
  * @return the current blood pump speed (in RPM).
  *************************************************************************/
-F32  getMeasuredBloodPumpMCSpeed( void )
+F32 getMeasuredBloodPumpMCSpeed( void )
 {
     F32 result = adcBloodPumpMCSpeedRPM.data;
 
@@ -904,7 +883,7 @@
  * @details Outputs: none
  * @return the current blood pump current (in mA).
  *************************************************************************/
-F32  getMeasuredBloodPumpMCCurrent( void )
+F32 getMeasuredBloodPumpMCCurrent( void )
 {
     F32 result = adcBloodPumpMCCurrentmA.data;
 
@@ -928,7 +907,7 @@
 static void publishBloodFlowData( void )
 {
     // Publish blood flow data on interval
-    if ( ++bloodFlowDataPublicationTimerCounter >= getPublishBloodFlowDataInterval() )
+    if ( ++bloodFlowDataPublicationTimerCounter >= getU32OverrideValue( &bloodFlowDataPublishInterval ) )
     {
         BLOOD_PUMP_STATUS_PAYLOAD_T payload;
 
Index: firmware/App/Controllers/BloodLeak.c
===================================================================
diff -u -reb9e7f219b519e0ce02d00296ceb986f642b38fe -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Controllers/BloodLeak.c	(.../BloodLeak.c)	(revision eb9e7f219b519e0ce02d00296ceb986f642b38fe)
+++ firmware/App/Controllers/BloodLeak.c	(.../BloodLeak.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -65,7 +65,6 @@
 static BLOOD_LEAK_STATES_T handleBloodLeakNormalState( void );
 
 static void publishBloodLeakData( void );
-static U32  getPublishBloodLeakDataInterval( void );
 
 /*********************************************************************//**
  * @brief
@@ -318,26 +317,6 @@
 
 /*********************************************************************//**
  * @brief
- * The getPublishBloodLeakDataInterval function gets the blood leak data
- * publication interval.
- * @details Inputs: bloodLeakDataPublishInterval
- * @details Outputs: none
- * @return the current blood leak data publication interval (in task intervals).
- *************************************************************************/
-static U32  getPublishBloodLeakDataInterval( void )
-{
-    U32 result = bloodLeakDataPublishInterval.data;
-
-    if ( OVERRIDE_KEY == bloodLeakDataPublishInterval.override )
-    {
-        result = bloodLeakDataPublishInterval.ovData;
-    }
-
-    return result;
-}
-
-/*********************************************************************//**
- * @brief
  * The publishBloodLeakData function publishes blood leak data at the set interval.
  * @details Inputs: bloodLeakStatus, bloodLeakState
  * @details Outputs: if broadcast is due, send blood leak data
@@ -346,7 +325,7 @@
 static void publishBloodLeakData( void )
 {
     // Publish blood leak data on interval
-    if ( ++bloodLeakDataPublicationTimerCounter >= getPublishBloodLeakDataInterval() )
+    if ( ++bloodLeakDataPublicationTimerCounter >= getU32OverrideValue( &bloodLeakDataPublishInterval ) )
     {
         BLOOD_LEAK_STATUS_T status = getBloodLeakStatus();
 
Index: firmware/App/Controllers/Bubble.c
===================================================================
diff -u -r953879c2319ea70007bfc303422155dd162d87e5 -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Controllers/Bubble.c	(.../Bubble.c)	(revision 953879c2319ea70007bfc303422155dd162d87e5)
+++ firmware/App/Controllers/Bubble.c	(.../Bubble.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -60,7 +60,6 @@
 static BUBBLE_STATES_T handleBubbleSelfTestState( BUBBLES_T );
 
 static void publishBubblesData( void );
-static U32  getPublishBubblesDataInterval( void );
 
 /*********************************************************************//**
  * @brief
@@ -318,26 +317,6 @@
 
 /*********************************************************************//**
  * @brief
- * The getPublishBubblesDataInterval function gets the air bubbles data
- * publication interval.
- * @details Inputs: bubblesDataPublishInterval
- * @details Outputs: none
- * @return the current air bubbles data publication interval (in task intervals).
- *************************************************************************/
-static U32 getPublishBubblesDataInterval( void )
-{
-    U32 result = bubblesDataPublishInterval.data;
-
-    if ( OVERRIDE_KEY == bubblesDataPublishInterval.override )
-    {
-        result = bubblesDataPublishInterval.ovData;
-    }
-
-    return result;
-}
-
-/*********************************************************************//**
- * @brief
  * The publishBubblesData function publishes air bubble detectors data at
  * the set interval.
  * @details Inputs: status, bubblesState
@@ -347,7 +326,7 @@
 static void publishBubblesData( void )
 {
     // Publish air bubble detectors data on interval
-    if ( ++bubblesDataPublicationTimerCounter >= getPublishBubblesDataInterval() )
+    if ( ++bubblesDataPublicationTimerCounter >= getU32OverrideValue( &bubblesDataPublishInterval ) )
     {
         BUBBLE_STATUS_T statusADA = getBubbleStatus( ADA );
         BUBBLE_STATUS_T statusADV = getBubbleStatus( ADV );
Index: firmware/App/Controllers/DialInFlow.c
===================================================================
diff -u -rd27dcf1fbbc9651636f211028917a1c0702bb56a -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Controllers/DialInFlow.c	(.../DialInFlow.c)	(revision d27dcf1fbbc9651636f211028917a1c0702bb56a)
+++ firmware/App/Controllers/DialInFlow.c	(.../DialInFlow.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -234,7 +234,6 @@
 static void checkDialInPumpFlowAgainstSpeed( void );
 static void checkDialInPumpMCCurrent( void );
 static void checkDialInFlowSensorSignalStrength( void );
-static U32  getPublishDialInFlowDataInterval( void );
 
 /*********************************************************************//**
  * @brief
@@ -740,26 +739,6 @@
 
 /*********************************************************************//**
  * @brief
- * The getPublishDialInFlowDataInterval function gets the dialIn flow data
- * publication interval.
- * @details Inputs: dialInFlowDataPublishInterval
- * @details Outputs: none
- * @return the current dialIn flow data publication interval (in task intervals).
- *************************************************************************/
-U32 getPublishDialInFlowDataInterval( void )
-{
-    U32 result = dialInFlowDataPublishInterval.data;
-
-    if ( OVERRIDE_KEY == dialInFlowDataPublishInterval.override )
-    {
-        result = dialInFlowDataPublishInterval.ovData;
-    }
-
-    return result;
-}
-
-/*********************************************************************//**
- * @brief
  * The getTargetDialInFlowRate function gets the current target dialIn flow
  * rate.
  * @details Inputs: targetDialInFlowRate
@@ -916,7 +895,7 @@
 static void publishDialInFlowData( void )
 {
     // Publish dialIn flow data on interval
-    if ( ++dialInFlowDataPublicationTimerCounter >= getPublishDialInFlowDataInterval() )
+    if ( ++dialInFlowDataPublicationTimerCounter >= getU32OverrideValue( &dialInFlowDataPublishInterval ) )
     {
         DIALIN_PUMP_STATUS_PAYLOAD_T payload;
 
Index: firmware/App/Controllers/DialOutFlow.c
===================================================================
diff -u -rd27dcf1fbbc9651636f211028917a1c0702bb56a -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Controllers/DialOutFlow.c	(.../DialOutFlow.c)	(revision d27dcf1fbbc9651636f211028917a1c0702bb56a)
+++ firmware/App/Controllers/DialOutFlow.c	(.../DialOutFlow.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -202,8 +202,6 @@
 static void checkDialOutPumpSpeeds( void );
 static void checkDialOutPumpMCCurrent( void );
 
-static U32  getPublishDialOutDataInterval( void );
-
 /*********************************************************************//**
  * @brief
  * The initDialOutFlow function initializes the DialOutFlow module.
@@ -710,7 +708,7 @@
 static void publishDialOutFlowData( void )
 {
     // Publish dialysate outlet pump and UF volume data on interval
-    if ( ++dialOutFlowDataPublicationTimerCounter >= getPublishDialOutDataInterval() )
+    if ( ++dialOutFlowDataPublicationTimerCounter >= getU32OverrideValue( &dialOutDataPublishInterval ) )
     {
         DIAL_OUT_FLOW_DATA_T dialOutBroadCastVariables;
 
@@ -995,26 +993,6 @@
 
 /*********************************************************************//**
  * @brief
- * The getPublishDialOutFlowDataInterval function gets the dialysate out flow
- * data publication interval.
- * @details Inputs: dialOutDataPublishInterval
- * @details Outputs: none
- * @return the current dialysate out flow data publication interval (in ms).
- *************************************************************************/
-static U32 getPublishDialOutDataInterval( void )
-{
-    U32 result = dialOutDataPublishInterval.data;
-
-    if ( OVERRIDE_KEY == dialOutDataPublishInterval.override )
-    {
-        result = dialOutDataPublishInterval.ovData;
-    }
-
-    return result;
-}
-
-/*********************************************************************//**
- * @brief
  * The getTotalTargetDialOutUFVolumeInMl function gets the target UF volume.
  * @details Inputs: referenceUFVolumeInMl
  * @details Outputs: none
Index: firmware/App/Controllers/FluidLeak.c
===================================================================
diff -u -reb9e7f219b519e0ce02d00296ceb986f642b38fe -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Controllers/FluidLeak.c	(.../FluidLeak.c)	(revision eb9e7f219b519e0ce02d00296ceb986f642b38fe)
+++ firmware/App/Controllers/FluidLeak.c	(.../FluidLeak.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -43,7 +43,6 @@
 // ********** private function prototypes **********
 
 static void publishFluidLeakState( void );
-static U32  getPublishFluidLeakStateInterval( void );
 
 /*********************************************************************//**
  * @brief
@@ -121,26 +120,6 @@
 
 /*********************************************************************//**
  * @brief
- * The getPublishFluidLeakStateInterval function gets the fluid leak state
- * publication interval.
- * @details Inputs: fluidLeakStatePublishInterval
- * @details Outputs: none
- * @return the current fluid leak state publication interval (in task intervals).
- *************************************************************************/
-static U32  getPublishFluidLeakStateInterval( void )
-{
-    U32 result = fluidLeakStatePublishInterval.data;
-
-    if ( OVERRIDE_KEY == fluidLeakStatePublishInterval.override )
-    {
-        result = fluidLeakStatePublishInterval.ovData;
-    }
-
-    return result;
-}
-
-/*********************************************************************//**
- * @brief
  * The publishFluidLeakState function publishes fluid leak state at the set interval.
  * @details Inputs: fluidLeakState
  * @details Outputs: if broadcast is due, send fluid leak state
@@ -149,7 +128,7 @@
 static void publishFluidLeakState( void )
 {
     // Publish fluid leak state on interval
-    if ( ++fluidLeakStatePublicationTimerCounter >= getPublishFluidLeakStateInterval() )
+    if ( ++fluidLeakStatePublicationTimerCounter >= getU32OverrideValue( &fluidLeakStatePublishInterval ) )
     {
         FLUID_LEAK_STATES_T state = getFluidLeakState();
 
Index: firmware/App/Controllers/PresOccl.c
===================================================================
diff -u -r7611b3a8e323b688441c88f56aa114d292efd4e1 -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Controllers/PresOccl.c	(.../PresOccl.c)	(revision 7611b3a8e323b688441c88f56aa114d292efd4e1)
+++ firmware/App/Controllers/PresOccl.c	(.../PresOccl.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -131,7 +131,6 @@
 static void checkVenousPressureInRange( void );
 static void checkOcclusions( void );
 static void publishPresOcclData( void );
-static U32  getPublishPresOcclDataInterval( void );
 
 /*********************************************************************//**
  * @brief
@@ -621,26 +620,6 @@
 
 /*********************************************************************//**
  * @brief
- * The getPublishPresOcclDataInterval function gets the pressure/occlusion data
- * publication interval.
- * @details Inputs: presOcclDataPublishInterval
- * @details Outputs: none
- * @return the current pressure/occlusion data publication interval (in task intervals).
- *************************************************************************/
-static U32 getPublishPresOcclDataInterval( void )
-{
-    U32 result = presOcclDataPublishInterval.data;
-
-    if ( OVERRIDE_KEY == presOcclDataPublishInterval.override )
-    {
-        result = presOcclDataPublishInterval.ovData;
-    }
-
-    return result;
-}
-
-/*********************************************************************//**
- * @brief
  * The getMeasuredArterialPressure function gets the current arterial pressure.
  * @details Inputs: arterialPressure
  * @details Outputs: none
@@ -748,7 +727,7 @@
 static void publishPresOcclData( void )
 {
     // Publish pressure/occlusion data on interval
-    if ( ++presOcclDataPublicationTimerCounter >= getPublishPresOcclDataInterval() )
+    if ( ++presOcclDataPublicationTimerCounter >= getU32OverrideValue( &presOcclDataPublishInterval ) )
     {
         PRESSURE_OCCLUSION_DATA_T data;
 
Index: firmware/App/Controllers/SyringePump.c
===================================================================
diff -u -r87d883239d8367b92840cade0802dc36d9c83d80 -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Controllers/SyringePump.c	(.../SyringePump.c)	(revision 87d883239d8367b92840cade0802dc36d9c83d80)
+++ firmware/App/Controllers/SyringePump.c	(.../SyringePump.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -221,7 +221,6 @@
 
 static void resetSyringePumpRequestFlags( void );
 static void execSyringePumpMonitor( void );
-static U32 getPublishSyringePumpDataInterval( void );
 static S32 getSyringePumpPosition( void );
 static F32 getSyringePumpMeasRate( void );
 static F32 getSyringePumpSyringeDetectorV( void );
@@ -619,26 +618,6 @@
 
 /*********************************************************************//**
  * @brief
- * The getPublishSyringePumpDataInterval function gets the syringe pump data
- * publication interval.
- * @details Inputs: syringePumpDataPublishInterval
- * @details Outputs: none
- * @return the current syringe pump data publication interval (in task intervals).
- *************************************************************************/
-static U32 getPublishSyringePumpDataInterval( void )
-{
-    U32 result = syringePumpDataPublishInterval.data;
-
-    if ( OVERRIDE_KEY == syringePumpDataPublishInterval.override )
-    {
-        result = syringePumpDataPublishInterval.ovData;
-    }
-
-    return result;
-}
-
-/*********************************************************************//**
- * @brief
  * The getSyringePumpVolumeDelivered function gets the current syringe pump
  * volume delivered.
  * @details Inputs: syringePumpVolumeDelivered
@@ -1788,7 +1767,7 @@
 static void publishSyringePumpData( void )
 {
     // Publish syringe pump data on interval
-    if ( ++syringePumpDataPublicationTimerCounter >= getPublishSyringePumpDataInterval() )
+    if ( ++syringePumpDataPublicationTimerCounter >= getU32OverrideValue( &syringePumpDataPublishInterval ) )
     {
         SYRINGE_PUMP_DATA_PAYLOAD_T data;
 
Index: firmware/App/Controllers/Valves.c
===================================================================
diff -u -r953879c2319ea70007bfc303422155dd162d87e5 -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Controllers/Valves.c	(.../Valves.c)	(revision 953879c2319ea70007bfc303422155dd162d87e5)
+++ firmware/App/Controllers/Valves.c	(.../Valves.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -240,7 +240,6 @@
 static void setFPGAValveSetPoint( VALVE_T valve, S16 position, BOOL enableCurrentRelaxation );
 static void convertAndMonitorValvesCurrent( void );
 static void getAndMonitorValvesCurrentPosition( void );
-static U32  getPublishValvesDataInterval( void );
 static void publishValvesData( VALVE_T valve );
 static void setValveNextStep( VALVE_T valve, U32 stepChange );
 
@@ -1186,26 +1185,6 @@
 
 /*********************************************************************//**
  * @brief
- * The getPublishValvesDataInterval function gets the valves data publish
- * interval.
- * @details Inputs: valvesDataPublishInterval
- * @details Outputs: none
- * @return data publish time interval
- *************************************************************************/
-U32 getPublishValvesDataInterval( void )
-{
-    U32 result = valvesDataPublishInterval.data;
-
-    if ( OVERRIDE_KEY == valvesDataPublishInterval.override )
-    {
-        result = valvesDataPublishInterval.ovData;
-    }
-
-    return result;
-}
-
-/*********************************************************************//**
- * @brief
  * The publishValvesData function publishes the data of the valves at the
  * specified time interval.
  * @details Inputs: valvesStatus
@@ -1216,7 +1195,7 @@
 static void publishValvesData( VALVE_T valve )
 {
     // Check the counter
-    if ( ++valvesStatus[ valve ].dataPublishCounter >= getPublishValvesDataInterval() )
+    if ( ++valvesStatus[ valve ].dataPublishCounter >= getU32OverrideValue( &valvesDataPublishInterval ) )
     {
         HD_VALVE_DATA_T valveData;
         valveData.valveID      = (U32)valve;
Index: firmware/App/Controllers/Voltages.c
===================================================================
diff -u -r40b37059da0ecd27dc9beb48614f6f3869d18732 -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Controllers/Voltages.c	(.../Voltages.c)	(revision 40b37059da0ecd27dc9beb48614f6f3869d18732)
+++ firmware/App/Controllers/Voltages.c	(.../Voltages.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -93,7 +93,6 @@
 static VOLTAGES_STATE_T handleVoltagesMonitorState( void );
 static void checkVoltageRanges( void );
 static void publishVoltagesData( void );
-static U32  getPublishVoltagesDataInterval( void );
 
 /*********************************************************************//**
  * @brief
@@ -238,26 +237,6 @@
 
 /*********************************************************************//**
  * @brief
- * The getPublishVoltagesDataInterval function gets the voltages monitor data
- * publication interval.
- * @details Inputs: voltagesDataPublishInterval
- * @details Outputs: none
- * @return the current voltage monitor data publication interval (in task intervals).
- *************************************************************************/
-static U32 getPublishVoltagesDataInterval( void )
-{
-    U32 result = voltagesDataPublishInterval.data;
-
-    if ( OVERRIDE_KEY == voltagesDataPublishInterval.override )
-    {
-        result = voltagesDataPublishInterval.ovData;
-    }
-
-    return result;
-}
-
-/*********************************************************************//**
- * @brief
  * The getMonitoredLineLevel function gets the current voltage or current
  * level for a given signal.
  * @details Inputs: voltages[]
@@ -297,7 +276,7 @@
 static void publishVoltagesData( void )
 {
     // Publish voltages monitor data on interval
-    if ( ++voltagesDataPublicationTimerCounter >= getPublishVoltagesDataInterval() )
+    if ( ++voltagesDataPublicationTimerCounter >= getU32OverrideValue( &voltagesDataPublishInterval ) )
     {
         VOLTAGES_DATA_PAYLOAD_T data;
 
Index: firmware/App/Modes/ModePostTreat.c
===================================================================
diff -u -r5bf62ff1373f2e9eea858244a97167323bff33f8 -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Modes/ModePostTreat.c	(.../ModePostTreat.c)	(revision 5bf62ff1373f2e9eea858244a97167323bff33f8)
+++ firmware/App/Modes/ModePostTreat.c	(.../ModePostTreat.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -70,6 +70,8 @@
 static HD_POST_TREATMENT_STATE_T currentPostTreatmentState;         ///< Current state of post-treatment mode state machine.
 static DRAIN_STATE_T currentDrainReservoirState;                    ///< Current drain reservoir state.
 static U32 postTreatmentPublishTimerCounter;                        ///< Timer counter used to schedule post-treatment data broadcast.
+/// Interval (in task intervals) at which to publish post-treatment mode data to CAN bus.
+static OVERRIDE_U32_T postTreatmentModePublishInterval = { POST_TREATMENT_DATA_PUB_INTERVAL, POST_TREATMENT_DATA_PUB_INTERVAL, POST_TREATMENT_DATA_PUB_INTERVAL, 0 };
 
 static TREATMENT_LOG_DATA_PAYLOAD_T treatmentLogData;               ///< Treatment parameters record for logging.
 
@@ -171,7 +173,7 @@
             break;
     }
 
-    if ( ++postTreatmentPublishTimerCounter >= POST_TREATMENT_DATA_PUB_INTERVAL )
+    if ( ++postTreatmentPublishTimerCounter >= getU32OverrideValue( &postTreatmentModePublishInterval ) )
     {
         broadcastPostTreatmentState( currentPostTreatmentState );
         postTreatmentPublishTimerCounter = 0;
@@ -552,4 +554,57 @@
     return state;
 }
 
+
+/*************************************************************************
+ *                       TEST SUPPORT FUNCTIONS
+ *************************************************************************/
+
+
+/*********************************************************************//**
+ * @brief
+ * The testSetPostTreatmentModePublishIntervalOverride function sets the override of the
+ * post-treatment mode data publication interval.
+ * @details Inputs: none
+ * @details Outputs: postTreatmentModePublishInterval
+ * @param ms milliseconds between post-treatment mode broadcasts
+ * @return TRUE if override set successful, FALSE if not
+ *************************************************************************/
+BOOL testSetPostTreatmentModePublishIntervalOverride( U32 ms )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        U32 intvl = ms / TASK_GENERAL_INTERVAL;
+
+        result = TRUE;
+        postTreatmentModePublishInterval.ovData = intvl;
+        postTreatmentModePublishInterval.override = OVERRIDE_KEY;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testResetPostTreatmentModePublishIntervalOverride function resets the override of the
+ * post-treatment mode data publication interval.
+ * @details Inputs: none
+ * @details Outputs: postTreatmentModePublishInterval
+ * @return TRUE if override reset successful, FALSE if not
+ *************************************************************************/
+BOOL testResetPostTreatmentModePublishIntervalOverride( void )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        result = TRUE;
+        postTreatmentModePublishInterval.override = OVERRIDE_RESET;
+        postTreatmentModePublishInterval.ovData = postTreatmentModePublishInterval.ovInitData;
+    }
+
+    return result;
+}
+
 /**@}*/
Index: firmware/App/Modes/ModePostTreat.h
===================================================================
diff -u -r368e2fde80a5cc108f61c021830c684e05fb62d5 -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Modes/ModePostTreat.h	(.../ModePostTreat.h)	(revision 368e2fde80a5cc108f61c021830c684e05fb62d5)
+++ firmware/App/Modes/ModePostTreat.h	(.../ModePostTreat.h)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -88,6 +88,9 @@
 void signalUserConfirmDisposableRemoval( void );
 void signalAlarmActionToPostTreatmentMode( ALARM_ACTION_T action ); // Execute alarm action as appropriate for post-treatment mode
 
+BOOL testSetPostTreatmentModePublishIntervalOverride( U32 ms );
+BOOL testResetPostTreatmentModePublishIntervalOverride( void );
+
 /**@}*/
 
 #endif
Index: firmware/App/Modes/ModePreTreat.c
===================================================================
diff -u -rc9df9f42e294adae397a57bf83c2a67fa831b164 -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Modes/ModePreTreat.c	(.../ModePreTreat.c)	(revision c9df9f42e294adae397a57bf83c2a67fa831b164)
+++ firmware/App/Modes/ModePreTreat.c	(.../ModePreTreat.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -78,6 +78,8 @@
 
 static HD_PRE_TREATMENT_MODE_STATE_T currentPreTreatmentState;          ///< Current state of pre-treatment mode state machine.
 static U32 preTreatmentPublishTimerCounter;                             ///< Pre-treatment data broadcast timer counter used to schedule when to transmit data.
+/// Interval (in task intervals) at which to publish pre-treatment mode data to CAN bus.
+static OVERRIDE_U32_T preTreatmentModePublishInterval = { PRE_TREATMENT_DATA_PUB_INTERVAL, PRE_TREATMENT_DATA_PUB_INTERVAL, PRE_TREATMENT_DATA_PUB_INTERVAL, 0 };
 static U32 submodeCompleteTransitionTimeCounter;                        ///< Sub-mode completed transition wait time counter.
 
 static PRE_TREATMENT_RESERVOIR_MGMT_STATE_T currentReservoirMgmtState;  ///< Current pre-treatment reservoir management state.
@@ -415,7 +417,7 @@
 static void publishPreTreatmentState( void )
 {
     // Broadcast treatment time and state data at interval
-    if ( ++preTreatmentPublishTimerCounter >= PRE_TREATMENT_DATA_PUB_INTERVAL )
+    if ( ++preTreatmentPublishTimerCounter >= getU32OverrideValue( &preTreatmentModePublishInterval ) )
     {
         PRE_TREATMENT_STATE_DATA_T preTreatmentData;
 
@@ -1043,4 +1045,57 @@
     return state;
 }
 
+
+/*************************************************************************
+ *                       TEST SUPPORT FUNCTIONS
+ *************************************************************************/
+
+
+/*********************************************************************//**
+ * @brief
+ * The testSetPreTreatmentModePublishIntervalOverride function sets the override of the
+ * pre-treatment mode data publication interval.
+ * @details Inputs: none
+ * @details Outputs: preTreatmentModePublishInterval
+ * @param ms milliseconds between pre-treatment mode broadcasts
+ * @return TRUE if override set successful, FALSE if not
+ *************************************************************************/
+BOOL testSetPreTreatmentModePublishIntervalOverride( U32 ms )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        U32 intvl = ms / TASK_GENERAL_INTERVAL;
+
+        result = TRUE;
+        preTreatmentModePublishInterval.ovData = intvl;
+        preTreatmentModePublishInterval.override = OVERRIDE_KEY;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testResetPreTreatmentModePublishIntervalOverride function resets the override of the
+ * pre-treatment mode data publication interval.
+ * @details Inputs: none
+ * @details Outputs: preTreatmentModePublishInterval
+ * @return TRUE if override reset successful, FALSE if not
+ *************************************************************************/
+BOOL testResetPreTreatmentModePublishIntervalOverride( void )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        result = TRUE;
+        preTreatmentModePublishInterval.override = OVERRIDE_RESET;
+        preTreatmentModePublishInterval.ovData = preTreatmentModePublishInterval.ovInitData;
+    }
+
+    return result;
+}
+
 /**@}*/
Index: firmware/App/Modes/ModePreTreat.h
===================================================================
diff -u -rbb114842e73659f097bb8b8ec0d670bfa4f8cb73 -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Modes/ModePreTreat.h	(.../ModePreTreat.h)	(revision bb114842e73659f097bb8b8ec0d670bfa4f8cb73)
+++ firmware/App/Modes/ModePreTreat.h	(.../ModePreTreat.h)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -62,6 +62,9 @@
 
 BOOL getReservoirFillStatus( DG_RESERVOIR_ID_T reservoirID );
 
+BOOL testSetPreTreatmentModePublishIntervalOverride( U32 ms );
+BOOL testResetPreTreatmentModePublishIntervalOverride( void );
+
 /**@}*/
 
 #endif
Index: firmware/App/Modes/ModeStandby.c
===================================================================
diff -u -r8e50cc04fb92d9b4ee9045e445ca8451abe951ab -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Modes/ModeStandby.c	(.../ModeStandby.c)	(revision 8e50cc04fb92d9b4ee9045e445ca8451abe951ab)
+++ firmware/App/Modes/ModeStandby.c	(.../ModeStandby.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -31,6 +31,7 @@
 #include "OperationModes.h"
 #include "SystemComm.h"
 #include "SystemCommMessages.h"
+#include "TaskGeneral.h"
 #ifdef EMC_TEST_BUILD     // TODO - test code
 #include "FPGA.h"
 #endif
@@ -42,19 +43,27 @@
 
 // ********** private definitions **********
 
+#define DISINFECTS_DATA_PUB_INTERVAL          ( 1 * MS_PER_SECOND / TASK_GENERAL_INTERVAL )    ///< Disinfects data publish interval in counts.
+
 // ********** private data **********
 
 static HD_STANDBY_STATE_T currentStandbyState;                      ///< Current state (sub-mode) of standby mode.
 
 static BOOL treatStartReqReceived = FALSE;                          ///< Flag indicates user has requested initiation of a treatment
 
+static U32 dataPublishCounter = 0;                                  ///< Disinfects data publish counter.
+/// Interval (in task intervals) at which to publish standby mode data to CAN bus.
+static OVERRIDE_U32_T standbyModePublishInterval = { DISINFECTS_DATA_PUB_INTERVAL, DISINFECTS_DATA_PUB_INTERVAL, DISINFECTS_DATA_PUB_INTERVAL, 0 };
+
 // ********** private function prototypes **********
 
 static HD_STANDBY_STATE_T handleStandbyWait4TreatmentState( void );
 static HD_STANDBY_STATE_T handleStandbyDGFlushState( void );
 static HD_STANDBY_STATE_T handleStandbyDGHeatDisinfectState( void );
 static HD_STANDBY_STATE_T handleStandbyDGChemDisinfectState( void );
 
+static void publishDisinfectData( void );
+
 /*********************************************************************//**
  * @brief
  * The initStandbyMode function initializes the Standby Mode module.
@@ -353,4 +362,74 @@
     // Alarm actions not handled in Standby mode
 }
 
+/*********************************************************************//**
+ * @brief
+ * The publishDisinfectData function publishes disinfects data at
+ * the set interval.
+ * @details Inputs: dataPublishCounter
+ * @details Outputs: dataPublishCounter
+ * @return: none
+ *************************************************************************/
+static void publishDisinfectData( void )
+{
+    if ( ++dataPublishCounter > getU32OverrideValue( &standbyModePublishInterval ) )
+    {
+        dataPublishCounter = 0;
+        // TODO - merge function code from Dara's branch
+    }
+}
+
+
+/*************************************************************************
+ *                       TEST SUPPORT FUNCTIONS
+ *************************************************************************/
+
+
+/*********************************************************************//**
+ * @brief
+ * The testSetStandbyModePublishIntervalOverride function sets the override of the
+ * standby mode data publication interval.
+ * @details Inputs: none
+ * @details Outputs: standbyModePublishInterval
+ * @param ms milliseconds between standby mode broadcasts
+ * @return TRUE if override set successful, FALSE if not
+ *************************************************************************/
+BOOL testSetStandbyModePublishIntervalOverride( U32 ms )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        U32 intvl = ms / TASK_GENERAL_INTERVAL;
+
+        result = TRUE;
+        standbyModePublishInterval.ovData = intvl;
+        standbyModePublishInterval.override = OVERRIDE_KEY;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testResetStandbyModePublishIntervalOverride function resets the override of the
+ * standby mode data publication interval.
+ * @details Inputs: none
+ * @details Outputs: standbyModePublishInterval
+ * @return TRUE if override reset successful, FALSE if not
+ *************************************************************************/
+BOOL testResetStandbyModePublishIntervalOverride( void )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        result = TRUE;
+        standbyModePublishInterval.override = OVERRIDE_RESET;
+        standbyModePublishInterval.ovData = standbyModePublishInterval.ovInitData;
+    }
+
+    return result;
+}
+
 /**@}*/
Index: firmware/App/Modes/ModeStandby.h
===================================================================
diff -u -rbb114842e73659f097bb8b8ec0d670bfa4f8cb73 -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Modes/ModeStandby.h	(.../ModeStandby.h)	(revision bb114842e73659f097bb8b8ec0d670bfa4f8cb73)
+++ firmware/App/Modes/ModeStandby.h	(.../ModeStandby.h)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -38,6 +38,9 @@
 BOOL signalUserInitiateTreatment( void );                       // User has initiated a treatment - go to treatment parameters mode
 void signalAlarmActionToStandbyMode( ALARM_ACTION_T action );   // Execute alarm action as appropriate for Standby mode
 
+BOOL testSetStandbyModePublishIntervalOverride( U32 ms );
+BOOL testResetStandbyModePublishIntervalOverride( void );
+
 /**@}*/
 
 #endif
Index: firmware/App/Modes/ModeTreatment.c
===================================================================
diff -u -rc65ad0538ff99c3e13d7d7866ac15e38a1ef6002 -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Modes/ModeTreatment.c	(.../ModeTreatment.c)	(revision c65ad0538ff99c3e13d7d7866ac15e38a1ef6002)
+++ firmware/App/Modes/ModeTreatment.c	(.../ModeTreatment.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -119,9 +119,6 @@
 static TREATMENT_STATE_T handleTreatmentRinsebackState( void );
 static TREATMENT_STATE_T handleTreatmentRecircState( void );
 static TREATMENT_STATE_T handleTreatmentEndState( void );
-static U32 getPublishTreatmentTimeInterval( void );
-static U32 getPublishTreatmentStateInterval( void );
-static U32 getPublishTreatmentParamRangesInterval( void );
 
 /*********************************************************************//**
  * @brief
@@ -1155,7 +1152,7 @@
     // Update treatment time stats and broadcast - end treatment if time
     elapsedTreatmentTimeInSecs = CALC_ELAPSED_TREAT_TIME_IN_SECS();
     // Broadcast treatment time data at interval
-    if ( ++treatmentTimeBroadcastTimerCtr >= getPublishTreatmentTimeInterval() )
+    if ( ++treatmentTimeBroadcastTimerCtr >= getU32OverrideValue( &treatmentTimePublishInterval ) )
     {
         if ( isTreatmentCompleted() != TRUE )
         {
@@ -1170,7 +1167,7 @@
         treatmentTimeBroadcastTimerCtr = 0;
     }
     // Broadcast treatment state data at interval
-    if ( ++treatmentStateBroadcastTimerCtr >= getPublishTreatmentStateInterval() )
+    if ( ++treatmentStateBroadcastTimerCtr >= getU32OverrideValue( &treatmentStatePublishInterval ) )
     {
         TREATMENT_STATE_DATA_T payload;
 
@@ -1192,66 +1189,6 @@
 
 /*********************************************************************//**
  * @brief
- * The getPublishTreatmentTimeInterval function gets the treatment time data
- * publication interval.
- * @details Inputs: treatmentTimePublishInterval
- * @details Outputs: none
- * @return the current treatment time data publication interval (in task intervals).
- *************************************************************************/
-static U32 getPublishTreatmentTimeInterval( void )
-{
-    U32 result = treatmentTimePublishInterval.data;
-
-    if ( OVERRIDE_KEY == treatmentTimePublishInterval.override )
-    {
-        result = treatmentTimePublishInterval.ovData;
-    }
-
-    return result;
-}
-
-/*********************************************************************//**
- * @brief
- * The getPublishTreatmentStateInterval function gets the treatment state data
- * publication interval.
- * @details Inputs: treatmentStatePublishInterval
- * @details Outputs: none
- * @return the current treatment state data publication interval (in task intervals).
- *************************************************************************/
-static U32 getPublishTreatmentStateInterval( void )
-{
-    U32 result = treatmentStatePublishInterval.data;
-
-    if ( OVERRIDE_KEY == treatmentStatePublishInterval.override )
-    {
-        result = treatmentStatePublishInterval.ovData;
-    }
-
-    return result;
-}
-
-/*********************************************************************//**
- * @brief
- * The getPublishTreatmentParamRangesInterval function gets the treatment param
- * range data publication interval.
- * @details Inputs: treatmentParamRangesPublishInterval
- * @details Outputs: none
- * @return the current treatment param range data publication interval (in task intervals).
- *************************************************************************/
-static U32 getPublishTreatmentParamRangesInterval( void )
-{
-    U32 result = treatmentParamRangesPublishInterval.data;
-
-    if ( OVERRIDE_KEY == treatmentParamRangesPublishInterval.override )
-    {
-        result = treatmentParamRangesPublishInterval.ovData;
-    }
-
-    return result;
-}
-
-/*********************************************************************//**
- * @brief
  * The broadcastTreatmentSettingsRanges function computes and broadcasts
  * updated treatment parameter ranges that the user may change during treatment.
  * It is assumed that prescription settings have already been set prior to calling
@@ -1262,7 +1199,7 @@
  *************************************************************************/
 static void broadcastTreatmentSettingsRanges( void )
 {
-    if ( ++treatmentParamsRangesBroadcastTimerCtr >= getPublishTreatmentParamRangesInterval() )
+    if ( ++treatmentParamsRangesBroadcastTimerCtr >= getU32OverrideValue( &treatmentParamRangesPublishInterval ) )
     {
         // Compute minimum treatment duration
         U32 presTime = ( presTreatmentTimeSecs / SEC_PER_MIN );
Index: firmware/App/Modes/OperationModes.c
===================================================================
diff -u -r158b4394cb66d4585bbcef39471193a7396709c6 -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Modes/OperationModes.c	(.../OperationModes.c)	(revision 158b4394cb66d4585bbcef39471193a7396709c6)
+++ firmware/App/Modes/OperationModes.c	(.../OperationModes.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -38,7 +38,7 @@
 // ********** private data **********
 
 /// HD operation mode broadcast interval (in task interval/sec).
-static const U32 BROADCAST_HD_OP_MODE_INTERVAL = ( 250 / TASK_GENERAL_INTERVAL );
+#define BROADCAST_HD_OP_MODE_INTERVAL    ( 250 / TASK_GENERAL_INTERVAL )
 
 // ********** private data **********
 
@@ -47,6 +47,8 @@
 static HD_OP_MODE_T currentMode = MODE_INIT;                ///< Current operation mode.
 static U32 currentSubMode = 0;                              ///< The currently active state of the active mode.
 static U32 broadcastModeIntervalCtr = 11;                   ///< Interval counter used to determine when to broadcast operation mode.  Initialize to 11 to stagger broadcast.
+/// Interval (in task intervals) at which to publish operation mode data to CAN bus.
+static OVERRIDE_U32_T opModePublishInterval = { BROADCAST_HD_OP_MODE_INTERVAL, BROADCAST_HD_OP_MODE_INTERVAL, BROADCAST_HD_OP_MODE_INTERVAL, 0 };
 
 /// This matrix determines legal transitions from one mode to another
 static const HD_OP_MODE_T MODE_TRANSITION_TABLE[ NUM_OF_MODES - 1 ][ NUM_OF_MODES - 1 ] = {
@@ -358,7 +360,7 @@
  *************************************************************************/
 static void broadcastOperationMode( void )
 {
-    if ( ++broadcastModeIntervalCtr >= BROADCAST_HD_OP_MODE_INTERVAL )
+    if ( ++broadcastModeIntervalCtr >= getU32OverrideValue( &opModePublishInterval ) )
     {
         broadcastModeIntervalCtr = 0;
         broadcastHDOperationMode( (U32)currentMode, currentSubMode );
@@ -399,4 +401,51 @@
     return result;
 }
 
+/*********************************************************************//**
+ * @brief
+ * The testSetOpModePublishIntervalOverride function sets the override of the
+ * operation mode publication interval.
+ * @details Inputs: none
+ * @details Outputs: opModePublishInterval
+ * @param ms milliseconds between operation mode broadcasts
+ * @return TRUE if override set successful, FALSE if not
+ *************************************************************************/
+BOOL testSetOpModePublishIntervalOverride( U32 ms )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        U32 intvl = ms / TASK_GENERAL_INTERVAL;
+
+        result = TRUE;
+        opModePublishInterval.ovData = intvl;
+        opModePublishInterval.override = OVERRIDE_KEY;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testResetOpModePublishIntervalOverride function resets the override of the
+ * operation mode data publication interval.
+ * @details Inputs: none
+ * @details Outputs: opModePublishInterval
+ * @return TRUE if override reset successful, FALSE if not
+ *************************************************************************/
+BOOL testResetOpModePublishIntervalOverride( void )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        result = TRUE;
+        opModePublishInterval.override = OVERRIDE_RESET;
+        opModePublishInterval.ovData = opModePublishInterval.ovInitData;
+    }
+
+    return result;
+}
+
 /**@}*/
Index: firmware/App/Modes/OperationModes.h
===================================================================
diff -u -r158b4394cb66d4585bbcef39471193a7396709c6 -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Modes/OperationModes.h	(.../OperationModes.h)	(revision 158b4394cb66d4585bbcef39471193a7396709c6)
+++ firmware/App/Modes/OperationModes.h	(.../OperationModes.h)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -41,6 +41,8 @@
 void initiateAlarmAction( ALARM_ACTION_T action );                  // Initiate an alarm or alarm recovery action according to current op mode
 
 BOOL testSetOperationMode( HD_OP_MODE_T newMode );                  // Force transition to a given mode (if allowed)
+BOOL testSetOpModePublishIntervalOverride( U32 ms );
+BOOL testResetOpModePublishIntervalOverride( void );
 
 /**@}*/
 
Index: firmware/App/Modes/TreatmentStop.c
===================================================================
diff -u -rc65ad0538ff99c3e13d7d7866ac15e38a1ef6002 -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Modes/TreatmentStop.c	(.../TreatmentStop.c)	(revision c65ad0538ff99c3e13d7d7866ac15e38a1ef6002)
+++ firmware/App/Modes/TreatmentStop.c	(.../TreatmentStop.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -53,7 +53,6 @@
 static TREATMENT_STOP_STATE_T handleTreatmentStopNoRecircState( void );
 
 static void publishTreatmentStopData( void );
-static U32 getPublishTreatmentStopInterval( void );
 
 /*********************************************************************//**
  * @brief
@@ -226,7 +225,7 @@
  *************************************************************************/
 static void publishTreatmentStopData( void )
 {
-    if ( ++stopPublishTimerCtr >= getPublishTreatmentStopInterval() )
+    if ( ++stopPublishTimerCtr >= getU32OverrideValue( &treatmentStopPublishInterval ) )
     {
         U32 timeout = MAX_TIME_BLOOD_SITTING  / ( MS_PER_SECOND / TASK_GENERAL_INTERVAL );
         U32 countdown = ( bloodSittingTimerCtr >= MAX_TIME_BLOOD_SITTING ? 0 : ( MAX_TIME_BLOOD_SITTING - bloodSittingTimerCtr ) / ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) );
@@ -236,27 +235,7 @@
     }
 }
 
-/*********************************************************************//**
- * @brief
- * The getPublishTreatmentStopInterval function gets the treatment stop sub-mode data
- * publication interval.
- * @details Inputs: treatmentStopPublishInterval
- * @details Outputs: none
- * @return the current treatment stop sub-mode publication interval (in task intervals).
- *************************************************************************/
-static U32 getPublishTreatmentStopInterval( void )
-{
-    U32 result = treatmentStopPublishInterval.data;
 
-    if ( OVERRIDE_KEY == treatmentStopPublishInterval.override )
-    {
-        result = treatmentStopPublishInterval.ovData;
-    }
-
-    return result;
-}
-
-
 /*************************************************************************
  *                       TEST SUPPORT FUNCTIONS
  *************************************************************************/
Index: firmware/App/Services/AlarmMgmt.c
===================================================================
diff -u -rc65ad0538ff99c3e13d7d7866ac15e38a1ef6002 -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Services/AlarmMgmt.c	(.../AlarmMgmt.c)	(revision c65ad0538ff99c3e13d7d7866ac15e38a1ef6002)
+++ firmware/App/Services/AlarmMgmt.c	(.../AlarmMgmt.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -157,8 +157,6 @@
 static U32  getAlarmStartTime( ALARM_ID_T alarmID );
 
 static void publishAlarmInfo( void );
-static U32 getPublishAlarmStatusInterval( void );
-static U32 getPublishAlarmInfoInterval( void );
 
 /*********************************************************************//**
  * @brief
@@ -232,7 +230,7 @@
     updateAlarmsFlags();
     updateAlarmsSilenceStatus();
     // Publish alarm status at interval
-    if ( ++alarmStatusPublicationTimerCounter >= getPublishAlarmStatusInterval() )
+    if ( ++alarmStatusPublicationTimerCounter >= getU32OverrideValue( &alarmStatusPublishInterval ) )
     {
         // Lamp and audio timing sync'd with broadcast so UI can stay in sync with lamp rhythm
         setAlarmLamp();
@@ -1124,7 +1122,7 @@
 static void publishAlarmInfo( void )
 {
     // Publish voltages monitor data on interval
-    if ( ++alarmInfoPublicationTimerCounter >= getPublishAlarmInfoInterval() )
+    if ( ++alarmInfoPublicationTimerCounter >= getU32OverrideValue( &alarmInfoPublishInterval ) )
     {
         ALARM_INFO_PAYLOAD_T data;
 
@@ -1141,46 +1139,6 @@
 
 /*********************************************************************//**
  * @brief
- * The getPublishAlarmStatusInterval function gets the alarm status data
- * publication interval.
- * @details Inputs: alarmStatusPublishInterval
- * @details Outputs: none
- * @return the current alarm status publication interval (in task intervals).
- *************************************************************************/
-static U32 getPublishAlarmStatusInterval( void )
-{
-    U32 result = alarmStatusPublishInterval.data;
-
-    if ( OVERRIDE_KEY == alarmStatusPublishInterval.override )
-    {
-        result = alarmStatusPublishInterval.ovData;
-    }
-
-    return result;
-}
-
-/*********************************************************************//**
- * @brief
- * The getPublishAlarmInfoInterval function gets the alarm information
- * publication interval.
- * @details Inputs: alarmInfoPublishInterval
- * @details Outputs: none
- * @return the current alarm information publication interval (in task intervals).
- *************************************************************************/
-static U32 getPublishAlarmInfoInterval( void )
-{
-    U32 result = alarmInfoPublishInterval.data;
-
-    if ( OVERRIDE_KEY == alarmInfoPublishInterval.override )
-    {
-        result = alarmInfoPublishInterval.ovData;
-    }
-
-    return result;
-}
-
-/*********************************************************************//**
- * @brief
  * The getAlarmAudioVolume function gets the current alarm audio volume level.
  * @details Inputs: alarmAudioVolumeLevel
  * @details Outputs: none
Index: firmware/App/Services/SystemCommMessages.c
===================================================================
diff -u -rc65ad0538ff99c3e13d7d7866ac15e38a1ef6002 -r7a7bf19d0cf16745566956f45cef57f8eb5df445
--- firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision c65ad0538ff99c3e13d7d7866ac15e38a1ef6002)
+++ firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision 7a7bf19d0cf16745566956f45cef57f8eb5df445)
@@ -6555,11 +6555,11 @@
         memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
         if ( FALSE == payload.reset )
         {
-            result = testSetAlarmInfoPublishIntervalOverride( payload.state.u32 );
+            result = testSetStandbyModePublishIntervalOverride( payload.state.u32 );
         }
         else
         {
-            result = testResetAlarmInfoPublishIntervalOverride();
+            result = testResetStandbyModePublishIntervalOverride();
         }
     }
 
@@ -6587,11 +6587,11 @@
         memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
         if ( FALSE == payload.reset )
         {
-            result = testSetAlarmInfoPublishIntervalOverride( payload.state.u32 );
+            result = testSetOpModePublishIntervalOverride( payload.state.u32 );
         }
         else
         {
-            result = testResetAlarmInfoPublishIntervalOverride();
+            result = testResetOpModePublishIntervalOverride();
         }
     }
 
@@ -6619,11 +6619,11 @@
         memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
         if ( FALSE == payload.reset )
         {
-            result = testSetAlarmInfoPublishIntervalOverride( payload.state.u32 );
+            result = testSetPreTreatmentModePublishIntervalOverride( payload.state.u32 );
         }
         else
         {
-            result = testResetAlarmInfoPublishIntervalOverride();
+            result = testResetPreTreatmentModePublishIntervalOverride();
         }
     }
 
@@ -6683,11 +6683,11 @@
         memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
         if ( FALSE == payload.reset )
         {
-            result = testSetAlarmInfoPublishIntervalOverride( payload.state.u32 );
+            result = testSetPostTreatmentModePublishIntervalOverride( payload.state.u32 );
         }
         else
         {
-            result = testResetAlarmInfoPublishIntervalOverride();
+            result = testResetPostTreatmentModePublishIntervalOverride();
         }
     }