Index: firmware/App/Services/SystemCommMessages.c
===================================================================
diff -u -r8dad6fab1c33602ad94908fd31b8b15153a9eb6e -r637f38d98b89720a903d63b62a73f303b48e15f1
--- firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision 8dad6fab1c33602ad94908fd31b8b15153a9eb6e)
+++ firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision 637f38d98b89720a903d63b62a73f303b48e15f1)
@@ -1950,7 +1950,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_ARRAY_OVERRIDE_HANDLER_FUNC_U32( BOOL, handleTestWatchdogCheckInStateOverrideRequest, testSetWatchdogTaskCheckInOverride, testResetWatchdogTaskCheckInOverride )
+void handleTestWatchdogCheckInStateOverrideRequest( 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 ( 0 == payload.reset )
+        {
+            result = testSetWatchdogTaskCheckInOverride( payload.index, payload.state.u32 );
+        }
+        else
+        {
+            result = testResetWatchdogTaskCheckInOverride( payload.index );
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -1962,7 +1983,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_ARRAY_OVERRIDE_HANDLER_FUNC_U32( BOOL, handleTestAlarmStateOverrideRequest, testSetAlarmStateOverride, testResetAlarmStateOverride )
+void handleTestAlarmStateOverrideRequest( 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 ( 0 == payload.reset )
+        {
+            result = testSetAlarmStateOverride( payload.index, payload.state.u32 );
+        }
+        else
+        {
+            result = testResetAlarmStateOverride( payload.index );
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -1974,7 +2016,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_ARRAY_OVERRIDE_HANDLER_FUNC_U32( U32, handleTestAlarmTimeOverrideRequest, testSetAlarmStartOverride, testResetAlarmStartOverride )
+void handleTestAlarmTimeOverrideRequest( 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 ( 0 == payload.reset )
+        {
+            result = testSetAlarmStartOverride( payload.index, payload.state.u32 );
+        }
+        else
+        {
+            result = testResetAlarmStartOverride( payload.index );
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -1986,7 +2049,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_U32( U32, handleTestAlarmStatusBroadcastIntervalOverrideRequest, testSetAlarmStatusPublishIntervalOverride, testResetAlarmStatusPublishIntervalOverride )
+void handleTestAlarmStatusBroadcastIntervalOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetAlarmStatusPublishIntervalOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetAlarmStatusPublishIntervalOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2001,9 +2085,9 @@
 void handleTestBloodFlowSetPointOverrideRequest( MESSAGE_T *message )
 {
     OVERRIDE_PUMP_SET_PT_PAYLOAD_T payload;
-    BOOL result = 0;
+    BOOL result = FALSE;
 
-    /* verify payload length */
+    // verify payload length
     if ( sizeof(OVERRIDE_PUMP_SET_PT_PAYLOAD_T) == message->hdr.payloadLen )
     {
         memcpy( &payload, message->payload, sizeof(OVERRIDE_PUMP_SET_PT_PAYLOAD_T) );
@@ -2016,7 +2100,8 @@
             result = testResetTargetBloodFlowRateOverride();
         }
     }
-    /* respond to request */
+
+    // respond to request
     sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
 }
 
@@ -2030,7 +2115,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestBloodFlowMeasuredOverrideRequest, testSetMeasuredBloodFlowRateOverride, testResetMeasuredBloodFlowRateOverride )
+void handleTestBloodFlowMeasuredOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetMeasuredBloodFlowRateOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetMeasuredBloodFlowRateOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2042,7 +2148,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestBloodPumpRotorMeasuredSpeedOverrideRequest, testSetMeasuredBloodPumpRotorSpeedOverride, testResetMeasuredBloodPumpRotorSpeedOverride )
+void handleTestBloodPumpRotorMeasuredSpeedOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetMeasuredBloodPumpRotorSpeedOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetMeasuredBloodPumpRotorSpeedOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2054,7 +2181,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestBloodPumpMeasuredSpeedOverrideRequest, testSetMeasuredBloodPumpSpeedOverride, testResetMeasuredBloodPumpSpeedOverride )
+void handleTestBloodPumpMeasuredSpeedOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetMeasuredBloodPumpSpeedOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetMeasuredBloodPumpSpeedOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2066,7 +2214,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestBloodPumpMCMeasuredSpeedOverrideRequest, testSetMeasuredBloodPumpMCSpeedOverride, testResetMeasuredBloodPumpMCSpeedOverride )
+void handleTestBloodPumpMCMeasuredSpeedOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetMeasuredBloodPumpMCSpeedOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetMeasuredBloodPumpMCSpeedOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2078,7 +2247,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestBloodPumpMCMeasuredCurrentOverrideRequest, testSetMeasuredBloodPumpMCCurrentOverride, testResetMeasuredBloodPumpMCCurrentOverride )
+void handleTestBloodPumpMCMeasuredCurrentOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetMeasuredBloodPumpMCCurrentOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetMeasuredBloodPumpMCCurrentOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2090,7 +2280,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_U32( U32, handleTestBloodFlowBroadcastIntervalOverrideRequest, testSetBloodFlowDataPublishIntervalOverride, testResetBloodFlowDataPublishIntervalOverride )
+void handleTestBloodFlowBroadcastIntervalOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetBloodFlowDataPublishIntervalOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetBloodFlowDataPublishIntervalOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2105,9 +2316,9 @@
 void handleTestDialInFlowSetPointOverrideRequest( MESSAGE_T *message )
 {
     OVERRIDE_PUMP_SET_PT_PAYLOAD_T payload;
-    BOOL result = 0;
+    BOOL result = FALSE;
 
-    /* verify payload length */
+    // verify payload length
     if ( sizeof(OVERRIDE_PUMP_SET_PT_PAYLOAD_T) == message->hdr.payloadLen )
     {
         memcpy( &payload, message->payload, sizeof(OVERRIDE_PUMP_SET_PT_PAYLOAD_T) );
@@ -2120,7 +2331,8 @@
             result = testResetTargetDialInFlowRateOverride();
         }
     }
-    /* respond to request */
+
+    // respond to request
     sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
 }
 
@@ -2137,9 +2349,9 @@
 void handleTestDialOutFlowSetPointOverrideRequest( MESSAGE_T *message )
 {
     OVERRIDE_PUMP_SET_PT_PAYLOAD_T payload;
-    BOOL result = 0;
+    BOOL result = FALSE;
 
-    /* verify payload length */
+    // verify payload length
     if ( sizeof(OVERRIDE_PUMP_SET_PT_PAYLOAD_T) == message->hdr.payloadLen )
     {
         memcpy( &payload, message->payload, sizeof(OVERRIDE_PUMP_SET_PT_PAYLOAD_T) );
@@ -2152,7 +2364,8 @@
             result = testResetTargetDialOutFlowRateOverride();
         }
     }
-    /* respond to request */
+
+    // respond to request
     sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
 }
 
@@ -2166,7 +2379,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestDialInFlowMeasuredOverrideRequest, testSetMeasuredDialInFlowRateOverride, testResetMeasuredDialInFlowRateOverride )
+void handleTestDialInFlowMeasuredOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetMeasuredDialInFlowRateOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetMeasuredDialInFlowRateOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2178,7 +2412,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestDialInPumpRotorMeasuredSpeedOverrideRequest, testSetMeasuredDialInPumpRotorSpeedOverride, testResetMeasuredDialInPumpRotorSpeedOverride )
+void handleTestDialInPumpRotorMeasuredSpeedOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetMeasuredDialInPumpRotorSpeedOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetMeasuredDialInPumpRotorSpeedOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2190,7 +2445,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestDialInPumpMeasuredSpeedOverrideRequest, testSetMeasuredDialInPumpSpeedOverride, testResetMeasuredDialInPumpSpeedOverride )
+void handleTestDialInPumpMeasuredSpeedOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetMeasuredDialInPumpSpeedOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetMeasuredDialInPumpSpeedOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2202,7 +2478,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestDialInPumpMCMeasuredSpeedOverrideRequest, testSetMeasuredDialInPumpMCSpeedOverride, testResetMeasuredDialInPumpMCSpeedOverride )
+void handleTestDialInPumpMCMeasuredSpeedOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetMeasuredDialInPumpMCSpeedOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetMeasuredDialInPumpMCSpeedOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2214,7 +2511,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestDialInPumpMCMeasuredCurrentOverrideRequest, testSetMeasuredDialInPumpMCCurrentOverride, testResetMeasuredDialInPumpMCCurrentOverride )
+void handleTestDialInPumpMCMeasuredCurrentOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetMeasuredDialInPumpMCCurrentOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetMeasuredDialInPumpMCCurrentOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2226,7 +2544,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_U32( U32, handleTestDialInFlowBroadcastIntervalOverrideRequest, testSetDialInFlowDataPublishIntervalOverride, testResetDialInFlowDataPublishIntervalOverride )
+void handleTestDialInFlowBroadcastIntervalOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetDialInFlowDataPublishIntervalOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetDialInFlowDataPublishIntervalOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2238,7 +2577,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestArterialPressureOverrideRequest, testSetArterialPressureOverride, testResetArterialPressureOverride )
+void handleTestArterialPressureOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetArterialPressureOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetArterialPressureOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2250,7 +2610,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestVenousPressureOverrideRequest, testSetVenousPressureOverride, testResetVenousPressureOverride )
+void handleTestVenousPressureOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetVenousPressureOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetVenousPressureOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2262,7 +2643,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestBloodPumpOcclusionOverrideRequest, testSetBloodPumpOcclusionOverride, testResetBloodPumpOcclusionOverride )
+void handleTestBloodPumpOcclusionOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetBloodPumpOcclusionOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetBloodPumpOcclusionOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2274,7 +2676,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestDialysateInletPumpOcclusionOverrideRequest, testSetDialInPumpOcclusionOverride, testResetDialInPumpOcclusionOverride )
+void handleTestDialysateInletPumpOcclusionOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetDialInPumpOcclusionOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetDialInPumpOcclusionOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2286,7 +2709,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestDialysateOutletPumpOcclusionOverrideRequest, testSetDialOutPumpOcclusionOverride, testResetDialOutPumpOcclusionOverride )
+void handleTestDialysateOutletPumpOcclusionOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetDialOutPumpOcclusionOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetDialOutPumpOcclusionOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2298,7 +2742,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_U32( U32, handleTestPresOcclBroadcastIntervalOverrideRequest, testSetPresOcclDataPublishIntervalOverride, testResetPresOcclDataPublishIntervalOverride )
+void handleTestPresOcclBroadcastIntervalOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetPresOcclDataPublishIntervalOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetPresOcclDataPublishIntervalOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2341,7 +2806,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_U32( U32, handleTestDialOutFlowBroadcastIntervalOverrideRequest, testSetDialOutPumpAndLoadCellDataPublishIntervalOverride, testResetDialOutPumpAndLoadCellDataPublishIntervalOverride )
+void handleTestDialOutFlowBroadcastIntervalOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetDialOutPumpAndLoadCellDataPublishIntervalOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetDialOutPumpAndLoadCellDataPublishIntervalOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2354,7 +2840,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestDialOutUFReferenceVolumeOverrideRequest, testSetDialOutUFRefVolumeOverride, testResetDialOutUFRefVolumeOverride )
+void handleTestDialOutUFReferenceVolumeOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetDialOutUFRefVolumeOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetDialOutUFRefVolumeOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2367,7 +2874,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestDialOutUFMeasuredVolumeOverrideRequest, testSetDialOutUFTotVolumeOverride, testResetDialOutUFTotVolumeOverride )
+void handleTestDialOutUFMeasuredVolumeOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetDialOutUFTotVolumeOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetDialOutUFTotVolumeOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2380,7 +2908,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestDialOutPumpMCMeasuredSpeedOverrideRequest, testSetMeasuredDialOutPumpMCSpeedOverride, testResetMeasuredDialOutPumpMCSpeedOverride )
+void handleTestDialOutPumpMCMeasuredSpeedOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetMeasuredDialOutPumpMCSpeedOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetMeasuredDialOutPumpMCSpeedOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2393,7 +2942,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestDialOutPumpMCMeasuredCurrentOverrideRequest, testSetMeasuredDialOutPumpMCCurrentOverride, testResetMeasuredDialOutPumpMCCurrentOverride )
+void handleTestDialOutPumpMCMeasuredCurrentOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetMeasuredDialOutPumpMCCurrentOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetMeasuredDialOutPumpMCCurrentOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2405,7 +2975,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestDialOutPumpMeasuredSpeedOverrideRequest, testSetMeasuredDialOutPumpSpeedOverride, testResetMeasuredDialOutPumpSpeedOverride )
+void handleTestDialOutPumpMeasuredSpeedOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetMeasuredDialOutPumpSpeedOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetMeasuredDialOutPumpSpeedOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2417,7 +3008,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestDialOutPumpMeasuredRotorSpeedOverrideRequest, testSetMeasuredDialOutPumpRotorSpeedOverride, testResetMeasuredDialOutPumpRotorSpeedOverride )
+void handleTestDialOutPumpMeasuredRotorSpeedOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
+
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetMeasuredDialOutPumpRotorSpeedOverride( payload.state.f32 );
+        }
+        else
+        {
+            result = testResetMeasuredDialOutPumpRotorSpeedOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2429,7 +3041,28 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_ARRAY_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestDialOutLoadCellWeightOverrideRequest, testSetDialOutLoadCellWeightOverride, testResetDialOutLoadCellWeightOverride )
+void handleTestDialOutLoadCellWeightOverrideRequest( 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 ( 0 == payload.reset )
+        {
+            result = testSetDialOutLoadCellWeightOverride( payload.index, payload.state.f32 );
+        }
+        else
+        {
+            result = testResetDialOutLoadCellWeightOverride( payload.index );
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
 
 /*********************************************************************//**
  * @brief
@@ -2441,8 +3074,29 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_U32( U32, handleTestHDSafetyShutdownOverrideRequest, testSetSafetyShutdownOverride, testResetSafetyShutdownOverride )
+void handleTestHDSafetyShutdownOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
 
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetSafetyShutdownOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetSafetyShutdownOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
 /*********************************************************************//**
  * @brief
  * The handleTestHDAccelOverrideRequest function handles a request to
@@ -2453,8 +3107,29 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_ARRAY_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestHDAccelOverrideRequest, testSetAccelAxisOverride, testResetAccelAxisOverride )
+void handleTestHDAccelOverrideRequest( 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 ( 0 == payload.reset )
+        {
+            result = testSetAccelAxisOverride( payload.index, payload.state.f32 );
+        }
+        else
+        {
+            result = testResetAccelAxisOverride( payload.index );
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
 /*********************************************************************//**
  * @brief
  * The handleTestHDAccelMaxOverrideRequest function handles a request to
@@ -2465,8 +3140,29 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_ARRAY_OVERRIDE_HANDLER_FUNC_F32( F32, handleTestHDAccelMaxOverrideRequest, testSetAccelMaxOverride, testResetAccelMaxOverride )
+void handleTestHDAccelMaxOverrideRequest( 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 ( 0 == payload.reset )
+        {
+            result = testSetAccelMaxOverride( payload.index, payload.state.f32 );
+        }
+        else
+        {
+            result = testResetAccelMaxOverride( payload.index );
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
 /*********************************************************************//**
  * @brief
  * The handleTestHDAccelBroadcastIntervalOverrideRequest function handles a
@@ -2477,8 +3173,29 @@
  * @param message a pointer to the message to handle
  * @return none
  *************************************************************************/
-DATA_OVERRIDE_HANDLER_FUNC_U32( U32, handleTestHDAccelBroadcastIntervalOverrideRequest, testSetAccelDataPublishIntervalOverride, testResetAccelDataPublishIntervalOverride )
+void handleTestHDAccelBroadcastIntervalOverrideRequest( MESSAGE_T *message )
+{
+    TEST_OVERRIDE_PAYLOAD_T payload;
+    BOOL result = FALSE;
 
+    // verify payload length
+    if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen )
+    {
+        memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) );
+        if ( 0 == payload.reset )
+        {
+            result = testSetAccelDataPublishIntervalOverride( payload.state.u32 );
+        }
+        else
+        {
+            result = testResetAccelDataPublishIntervalOverride();
+        }
+    }
+
+    // respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
 /*********************************************************************//**
  * @brief
  * The handleSetAccelCalibration function handles a request to set