Index: firmware/App/Controllers/BloodLeak.c
===================================================================
diff -u -r9690fa47c23a2d76f62f385b553db7e565e18a1e -rb8d4f0f17b9069862ef77f0a967b0fe6a7ac7d52
--- firmware/App/Controllers/BloodLeak.c	(.../BloodLeak.c)	(revision 9690fa47c23a2d76f62f385b553db7e565e18a1e)
+++ firmware/App/Controllers/BloodLeak.c	(.../BloodLeak.c)	(revision b8d4f0f17b9069862ef77f0a967b0fe6a7ac7d52)
@@ -32,31 +32,26 @@
 
 #define BLOOD_LEAK_PUB_INTERVAL          ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL )         ///< Interval (ms/task time) at which the blood leak data is published on the CAN bus.
 
-/// Defined states for the blood leak detector state machine.
-typedef enum BloodLeak_States
-{
-    BLOOD_LEAK_INIT_STATE = 0,              ///< Initial state
-    BLOOD_LEAK_ZERO_STATE,                  ///< Zero state
-    BLOOD_LEAK_SELF_TEST_STATE,             ///< Self-test state
-    BLOOD_LEAK_NORMAL_STATE,                ///< Normal state
-    NUM_OF_BLOOD_LEAK_DETECTOR_STATES       ///< Number of blood leak detector states
-} BLOOD_LEAK_STATE_T;
-
 // ********** private data **********
 
 static OVERRIDE_U32_T bloodLeakState;                                                       ///< Current state of blood leak state machine.
-static U32 bloodLeakStatusPublicationTimerCounter = 0;                                      ///< Timer counter used to schedule blood leak status publication to CAN bus.
+static OVERRIDE_U32_T bloodLeakStatus;                                                      ///< Detected blood leak status for blood leak detector.
 
+static U32 bloodLeakZeroTimerCount = 0;                                                     ///< Timer counter for blood leak zeroing.
 static U32 bloodLeakSelfTestTimerCount = 0;                                                 ///< Timer counter for blood leak self-test.
 
 /// Interval (in ms) at which to publish blood leak data to CAN bus.
 static OVERRIDE_U32_T bloodLeakStatusPublishInterval = { BLOOD_LEAK_PUB_INTERVAL, BLOOD_LEAK_PUB_INTERVAL, 0, 0 };
-static OVERRIDE_U32_T bloodLeakStatus;                                                      ///< Detected blood leak status for blood leak detector.
+static OVERRIDE_U32_T bloodLeakStatePublishInterval = { BLOOD_LEAK_PUB_INTERVAL, BLOOD_LEAK_PUB_INTERVAL, 0, 0 };
+static U32 bloodLeakStatusPublicationTimerCounter = 0;                                      ///< Timer counter used to schedule blood leak status publication to CAN bus.
+static U32 bloodLeakStatePublicationTimerCounter = 0;                                       ///< Timer counter used to schedule blood leak state publication to CAN bus.
 
 // ********** private function prototypes **********
 
 static void publishBloodLeakStatus( void );
+static void publishBloodLeakState( void );
 static U32  getPublishBloodLeakStatusInterval( void );
+static U32  getPublishBloodLeakStateInterval( void );
 
 /*********************************************************************//**
  * @brief
@@ -81,14 +76,29 @@
 void zeroBloodLeak( void )
 {
     bloodLeakState.data = BLOOD_LEAK_ZERO_STATE;
-    //setBloodLeakZero();
+    //setBloodLeakZero(); TODO
 }
 
 /*********************************************************************//**
  * @brief
+ * The selfTestBloodLeak function puts the Blood Leak module into self-test state.
+ * @details Inputs: none
+ * @details Outputs: Blood Leak module self test.
+ * @return none
+ *************************************************************************/
+BOOL selfTestBloodLeak( void )
+{
+    bloodLeakState.data = BLOOD_LEAK_SELF_TEST_STATE;
+    //setBloodLeakSelfTest(); TODO
+
+    return TRUE;
+}
+
+/*********************************************************************//**
+ * @brief
  * The execBloodLeak function executes the blood leak monitor.
- * @details Inputs: FPGA blood leak state GPIO pin state
- * @details Outputs: bloodLeakState
+ * @details Inputs: FPGA blood leak status GPIO pin state
+ * @details Outputs: bloodLeakStatus
  * @return none
  *************************************************************************/
 void execBloodLeak( void )
@@ -97,29 +107,49 @@
 
     if ( getCurrentOperationMode() != MODE_INIT )
     {
-        // Get latest state reading
+        // Get latest status reading
         if ( TRUE == noBloodLeakDetected )
         {
-            bloodLeakState.data = BLOOD_LEAK_NOT_DETECTED;
+            bloodLeakStatus.data = BLOOD_LEAK_NOT_DETECTED;
         }
         else
         {
-            bloodLeakState.data = BLOOD_LEAK_DETECTED;
+            bloodLeakStatus.data = BLOOD_LEAK_DETECTED;
         }
 
-        // Check state reading and act upon
-        if ( BLOOD_LEAK_DETECTED == getBloodLeakStatus() )
+        if ( bloodLeakState.data == BLOOD_LEAK_SELF_TEST_STATE )
         {
-            activateAlarmNoData( ALARM_ID_HD_BLOOD_LEAK_DETECTED );
+            if ( FALSE == selfTestBloodLeak() )
+            {
+                activateAlarmNoData( ALARM_ID_HD_BLOOD_LEAK_DETECTOR_FAULT );
+            }
         }
-        else // BLOOD_LEAK_NOT_DETECTED == getBloodLeakStatus()
+        else // Blood Leak Detector is not in self-test state (normal state)
         {
-            clearAlarmCondition( ALARM_ID_HD_BLOOD_LEAK_DETECTED );
+            // Check status reading and act upon
+            if ( BLOOD_LEAK_DETECTED == getBloodLeakStatus() )
+            {
+                if ( getCurrentOperationMode() == HD_PRE_TREATMENT_PATIENT_CONNECTION_STATE ) // TODO: Any other mode/sub-mode to be added here?
+                {
+                    activateAlarmNoData( ALARM_ID_HD_BLOOD_LEAK_DETECTED );
+                }
+                else
+                {
+                    activateAlarmNoData( ALARM_ID_HD_BLOOD_LEAK_DETECTOR_FAULT );
+                }
+            }
+            else // BLOOD_LEAK_NOT_DETECTED == getBloodLeakStatus()
+            {
+                clearAlarmCondition( ALARM_ID_HD_BLOOD_LEAK_DETECTED );
+            }
         }
     }
 
     // Publish blood leak status if due
     publishBloodLeakStatus();
+
+    // Publish blood leak state if due
+    publishBloodLeakState();
 }
 
 /*********************************************************************//**
@@ -130,25 +160,25 @@
  * @details Outputs: none
  * @return the current blood leak status.
  *************************************************************************/
-BLOOD_LEAK_STATES_T getBloodLeakStatus( void )
+BLOOD_LEAK_STATUS_T getBloodLeakStatus( void )
 {
-    BLOOD_LEAK_STATES_T result = (BLOOD_LEAK_STATES_T)bloodLeakStatus.data;
+    BLOOD_LEAK_STATUS_T result = (BLOOD_LEAK_STATUS_T)bloodLeakStatus.data;
 
     if ( OVERRIDE_KEY == bloodLeakStatus.override )
     {
-        result = (BLOOD_LEAK_STATES_T)bloodLeakStatus.ovData;
+        result = (BLOOD_LEAK_STATUS_T)bloodLeakStatus.ovData;
     }
 
     return result;
 }
 
 /*********************************************************************//**
  * @brief
- * The getPublishBloodLeakStatusInterval function gets the blood leak state
+ * The getPublishBloodLeakStatusInterval function gets the blood leak status
  * publication interval.
  * @details Inputs: bloodLeakStatusPublishInterval
  * @details Outputs: none
- * @return the current blood leak state publication interval (in task intervals).
+ * @return the current blood leak status publication interval (in task intervals).
  *************************************************************************/
 static U32  getPublishBloodLeakStatusInterval( void )
 {
@@ -164,24 +194,63 @@
 
 /*********************************************************************//**
  * @brief
- * The publishBloodLeakStatus function publishes blood leak state at the set interval.
- * @details Inputs: bloodLeakState
- * @details Outputs: if broadcast is due, send blood leak state
+ * The publishBloodLeakStatus function publishes blood leak status at the set interval.
+ * @details Inputs: bloodLeakStatus
+ * @details Outputs: if broadcast is due, send blood leak status
  * @return none
  *************************************************************************/
 static void publishBloodLeakStatus( void )
 {
     // Publish blood leak status on interval
     if ( ++bloodLeakStatusPublicationTimerCounter >= getPublishBloodLeakStatusInterval() )
     {
-        BLOOD_LEAK_STATES_T status = getBloodLeakStatus();
+        BLOOD_LEAK_STATUS_T status = getBloodLeakStatus();
 
         broadcastBloodLeakStatus( status );
         bloodLeakStatusPublicationTimerCounter = 0;
     }
 }
 
+/*********************************************************************//**
+ * @brief
+ * The getPublishBloodLeakStateInterval function gets the blood leak state
+ * publication interval.
+ * @details Inputs: bloodLeakStatePublishInterval
+ * @details Outputs: none
+ * @return the current blood leak state publication interval (in task intervals).
+ *************************************************************************/
+static U32  getPublishBloodLeakStateInterval( void )
+{
+    U32 result = bloodLeakStatePublishInterval.data;
 
+    if ( OVERRIDE_KEY == bloodLeakStatePublishInterval.override )
+    {
+        result = bloodLeakStatePublishInterval.ovData;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The publishBloodLeakState function publishes blood leak state at the set interval.
+ * @details Inputs: bloodLeakState
+ * @details Outputs: if broadcast is due, send blood leak state
+ * @return none
+ *************************************************************************/
+static void publishBloodLeakState( void )
+{
+    // Publish blood leak state on interval
+    if ( ++bloodLeakStatePublicationTimerCounter >= getPublishBloodLeakStateInterval() )
+    {
+        BLOOD_LEAK_STATE_T state = getBloodLeakState();
+
+        broadcastBloodLeakState( state );
+        bloodLeakStatePublicationTimerCounter = 0;
+    }
+}
+
+
 /*************************************************************************
  *                       TEST SUPPORT FUNCTIONS
  *************************************************************************/
@@ -190,10 +259,10 @@
 /*********************************************************************//**
  * @brief
  * The testSetBloodLeakStatusPublishIntervalOverride function overrides the
- * blood leak state publish interval.
+ * blood leak status publish interval.
  * @details Inputs: none
  * @details Outputs: bloodLeakStatusPublishInterval
- * @param value override blood leak state publish interval with (in ms)
+ * @param value override blood leak status publish interval with (in ms)
  * @return TRUE if override successful, FALSE if not
  *************************************************************************/
 BOOL testSetBloodLeakStatusPublishIntervalOverride( U32 value )
@@ -215,7 +284,7 @@
 /*********************************************************************//**
  * @brief
  * The testResetBloodLeakStatusPublishIntervalOverride function resets the override
- * of the blood leak state publish interval.
+ * of the blood leak status publish interval.
  * @details Inputs: none
  * @details Outputs: bloodLeakStatusPublishInterval
  * @return TRUE if override reset successful, FALSE if not
@@ -244,16 +313,16 @@
  * @param status override blood leak detector with this
  * @return TRUE if override successful, FALSE if not
  *************************************************************************/
-BOOL testSetBloodLeakStatusOverride( BLOOD_LEAK_STATES_T state )
+BOOL testSetBloodLeakStatusOverride( BLOOD_LEAK_STATUS_T status )
 {
     BOOL result = FALSE;
 
-    if ( ( state < NUM_OF_BLOOD_LEAK_STATES ) )
+    if ( ( status < NUM_OF_BLOOD_LEAK_STATUS ) )
     {
         if ( TRUE == isTestingActivated() )
         {
             result = TRUE;
-            bloodLeakStatus.ovData = (U32)state;
+            bloodLeakStatus.ovData = (U32)status;
             bloodLeakStatus.override = OVERRIDE_KEY;
         }
     }
@@ -285,3 +354,102 @@
 }
 
 /**@}*/
+
+/*********************************************************************//**
+ * @brief
+ * The testSetBloodLeakStatePublishIntervalOverride function overrides the
+ * blood leak state publish interval.
+ * @details Inputs: none
+ * @details Outputs: bloodLeakStatePublishInterval
+ * @param value override blood leak state publish interval with (in ms)
+ * @return TRUE if override successful, FALSE if not
+ *************************************************************************/
+BOOL testSetBloodLeakStatePublishIntervalOverride( U32 value )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        U32 intvl = value / TASK_PRIORITY_INTERVAL;
+
+        result = TRUE;
+        bloodLeakStatePublishInterval.ovData = intvl;
+        bloodLeakStatePublishInterval.override = OVERRIDE_KEY;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testResetBloodLeakStatePublishIntervalOverride function resets the override
+ * of the blood leak state publish interval.
+ * @details Inputs: none
+ * @details Outputs: bloodLeakStatePublishInterval
+ * @return TRUE if override reset successful, FALSE if not
+ *************************************************************************/
+BOOL testResetBloodLeakStatePublishIntervalOverride( void )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        result = TRUE;
+        bloodLeakStatePublishInterval.override = OVERRIDE_RESET;
+        bloodLeakStatePublishInterval.ovData = bloodLeakStatePublishInterval.ovInitData;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testSetBloodLeakStateOverride function overrides the state
+ * of the blood leak detector state machine.
+ * @details Inputs: none
+ * @details Outputs: bloodLeakState
+ * @param none
+ * @param state override blood leak detector with this
+ * @return TRUE if override successful, FALSE if not
+ *************************************************************************/
+BOOL testSetBloodLeakStateOverride( BLOOD_LEAK_STATE_T state )
+{
+    BOOL result = FALSE;
+
+    if ( ( state < NUM_OF_BLOOD_LEAK_STATES ) )
+    {
+        if ( TRUE == isTestingActivated() )
+        {
+            result = TRUE;
+            bloodLeakState.ovData = (U32)state;
+            bloodLeakState.override = OVERRIDE_KEY;
+        }
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testResetBloodLeakStateOverride function resets the override of the
+ * blood leak detector state machine.
+ * @details Inputs: none
+ * @details Outputs: bloodLeakState
+ * @param none
+ * @return TRUE if reset successful, FALSE if not
+ *************************************************************************/
+BOOL testResetBloodLeakStateOverride( void )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        result = TRUE;
+        bloodLeakState.override = OVERRIDE_RESET;
+        bloodLeakState.ovData = bloodLeakState.ovInitData;
+    }
+
+    return result;
+}
+
+/**@}*/