Index: firmware/App/Services/AlarmMgmt.c
===================================================================
diff -u -r9feea867113c62088f0ce91750127972dbd9bf53 -rf0c52f6adff7b61132953890a74f1c462b31eedf
--- firmware/App/Services/AlarmMgmt.c	(.../AlarmMgmt.c)	(revision 9feea867113c62088f0ce91750127972dbd9bf53)
+++ firmware/App/Services/AlarmMgmt.c	(.../AlarmMgmt.c)	(revision f0c52f6adff7b61132953890a74f1c462b31eedf)
@@ -20,8 +20,10 @@
 #define __ALARM_MGMT_C__
 
 #include "AlarmLamp.h"
-#include "FPGA.h"
+#include "FPGA.h"
+#include "InternalADC.h"
 #include "OperationModes.h"
+#include "SafetyShutdown.h"
 #include "SystemCommMessages.h"
 #include "TaskGeneral.h"
 #include "Timers.h"
@@ -35,6 +37,8 @@
 
 /// Interval to control lamp and audio and to publish alarm status data.
 static const U32 ALARM_STATUS_PUBLISH_INTERVAL = ( ALARM_LAMP_AND_AUDIO_CONTROL_INTERVAL_MS / TASK_GENERAL_INTERVAL );
+/// Interval (ms/task time) at which the alarm information is published on the CAN bus.
+#define ALARM_INFO_PUB_INTERVAL                 ( MS_PER_SECOND / TASK_GENERAL_INTERVAL )
 
 #define ALARM_SILENCE_EXPIRES_IN_SECS           (60)                                ///< Alarm silence expiration time in seconds.
 
@@ -64,14 +68,29 @@
 
 // ********** private data **********
 
-static U32 alarmStatusPublicationTimerCounter = 0;                  ///< Used to schedule alarm status publication to CAN bus.
+static U32 alarmStatusPublicationTimerCounter = 0;                  ///< Used to schedule alarm status publication to CAN bus.
+static U32 alarmInfoPublicationTimerCounter = 0;                    ///< Used to schedule alarm information publication to CAN bus.
 
 /// Table - current state of each alarm
 static BOOL alarmIsActive[ NUM_OF_ALARM_IDS ];
 /// Table - current state of each alarm condition (detected or cleared)
 static BOOL alarmIsDetected[ NUM_OF_ALARM_IDS ];
 /// Table - when alarm became active for each alarm (if active) or zero (if inactive)
 static OVERRIDE_U32_T alarmStartedAt[ NUM_OF_ALARM_IDS ];
+/// Interval (in task intervals) at which to publish alarm information to CAN bus.
+static OVERRIDE_U32_T alarmInfoPublishInterval = { ALARM_INFO_PUB_INTERVAL, ALARM_INFO_PUB_INTERVAL, ALARM_INFO_PUB_INTERVAL, 0 };
+#ifndef ALARM_VOLUME_DEFAULT_LOW
+/// Set alarm audio volume attenuation level (0..4 - lower level = higher gain).
+static OVERRIDE_U32_T alarmAudioVolumeLevel = { MIN_ALARM_VOLUME_ATTENUATION, MIN_ALARM_VOLUME_ATTENUATION, MIN_ALARM_VOLUME_ATTENUATION, 0 };
+#else
+static OVERRIDE_U32_T alarmAudioVolumeLevel = { MAX_ALARM_VOLUME_ATTENUATION, MAX_ALARM_VOLUME_ATTENUATION, MAX_ALARM_VOLUME_ATTENUATION, 0 };
+#endif
+/// Alarm audio current (high gain) measured at ADC.
+static OVERRIDE_F32_T alarmPrimaryAudioCurrentHG = { 0.0, 0.0, 0.0, 0 };
+/// Alarm audio current (low gain) measured at ADC.
+static OVERRIDE_F32_T alarmPrimaryAudioCurrentLG = { 0.0, 0.0, 0.0, 0 };
+/// Alarm backup audio current measured at ADC.
+static OVERRIDE_F32_T alarmBackupAudioCurrent = { 0.0, 0.0, 0.0, 0 };
 
 /// Record for the current composite alarm status.
 static COMP_ALARM_STATUS_T alarmStatus;
@@ -82,12 +101,11 @@
 /// Alarm user recovery actions enabled flags.
 static BOOL alarmUserRecoveryActionEnabled[ NUMBER_OF_ALARM_USER_ACTIONS ];
 
-static U32 alarmAudioVolumeLevel = 3; //MIN_ALARM_VOLUME_ATTENUATION;          ///< Set alarm audio volume attenuation level (0..4 - lower level = higher gain).
-
 // ********** private function prototypes **********
 
 static void activateAlarm( ALARM_ID_T alarm );
-
+
+static void monitorAlarms( void );
 static void updateAlarmsState( void );
 static void setAlarmLamp( void );
 static void setAlarmAudio( void );
@@ -99,6 +117,9 @@
 static void resetAlarmPriorityFIFO( ALARM_PRIORITY_T priority );
 
 static U32  getAlarmStartTime( ALARM_ID_T alarmID );
+
+static void publishAlarmInfo( void );
+static U32 getPublishAlarmInfoInterval( void );
 
 /*********************************************************************//**
  * @brief
@@ -139,7 +160,7 @@
     alarmStatus.alarmsSilenceExpiresIn = 0;
     alarmStatus.alarmsEscalatesIn = 0;
     alarmStatus.alarmTop = ALARM_ID_NO_ALARM;
-    alarmStatus.topAlarmConditionnDetected = FALSE;
+    alarmStatus.topAlarmConditionDetected = FALSE;
     alarmStatus.systemFault = FALSE;
     alarmStatus.stop = FALSE;
     alarmStatus.lampOn = FALSE;
@@ -163,6 +184,7 @@
  *************************************************************************/
 void execAlarmMgmt( void )
 {
+    monitorAlarms();
     handleAlarmEscalations();
     updateAlarmsState();
     updateAlarmsFlags();
@@ -564,10 +586,21 @@
 *************************************************************************/
 void setAlarmAudioVolume( U32 volumeLevel )
 {
+    BOOL accepted = FALSE;
+    U32  rejReason = REQUEST_REJECT_REASON_NONE;
+
     if ( ( volumeLevel > 0 ) && ( volumeLevel <= MAX_ALARM_VOLUME_LEVEL ) )
     {   // Convert volume level to attenuation level
-        alarmAudioVolumeLevel = MAX_ALARM_VOLUME_LEVEL - volumeLevel;
+        alarmAudioVolumeLevel.data = MAX_ALARM_VOLUME_LEVEL - volumeLevel;
+        accepted = TRUE;
     }
+    else
+    {
+        rejReason = REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE;
+    }
+
+    // Send response to UI
+    sendAlarmAudioVolumeSetResponse( accepted, rejReason );
 }
 
 /*********************************************************************//**
@@ -600,6 +633,27 @@
 
     return result;
 }
+
+/*********************************************************************//**
+ * @brief
+ * The monitorAlarms function monitors alarm audio current.
+ * @details Inputs: alarmStatusTable[]
+ * @details Outputs: alarmPriorityFIFO[], alarmStatus
+ * @return none
+ *************************************************************************/
+static void monitorAlarms( void )
+{
+    U32 volume = getAlarmAudioVolume();
+
+    alarmPrimaryAudioCurrentHG.data = getIntADCVoltageConverted( INT_ADC_PRIMARY_ALARM_CURRENT_HG );
+    alarmPrimaryAudioCurrentLG.data = getIntADCVoltageConverted( INT_ADC_PRIMARY_ALARM_CURRENT_LG );
+    alarmBackupAudioCurrent.data = getIntADCVoltageConverted( INT_ADC_BACKUP_ALARM_CURRENT );
+
+    // TODO - Check current vs. expected audio output
+
+    // Publish alarm information at interval
+    publishAlarmInfo();
+}
 
 /*********************************************************************//**
  * @brief
@@ -663,7 +717,8 @@
 
     // Update alarm to display per highest priority FIFO
     alarmStatus.alarmsState = highestPriority;
-    alarmStatus.alarmTop = alarmPriorityFIFO[ highestPriority ].alarmID;
+    alarmStatus.alarmTop = alarmPriorityFIFO[ highestPriority ].alarmID;
+    alarmStatus.topAlarmConditionDetected = alarmIsDetected[ alarmStatus.alarmTop ];
     alarmStatus.systemFault = faultsActive;
     alarmStatus.noDialRecirc = dialysateRecircBlocked;
 }
@@ -737,22 +792,24 @@
  *************************************************************************/
 static void setAlarmAudio( void )
 {
+    U32 volume = getAlarmAudioVolume();
+
     if ( TRUE == alarmStatus.alarmsSilenced )
     {
-        setAlarmAudioState( ALARM_PRIORITY_NONE, alarmAudioVolumeLevel );
+        setAlarmAudioState( ALARM_PRIORITY_NONE, volume );
     }
     else // Alarms not silenced
     {
         if ( alarmStatus.alarmsState < NUM_OF_ALARM_PRIORITIES )
         {
 #ifndef DISABLE_ALARM_AUDIO
-            setAlarmAudioState( alarmStatus.alarmsState, alarmAudioVolumeLevel );
+            setAlarmAudioState( alarmStatus.alarmsState, volume );
 #endif
         }
         else
         {
             SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_ALARM_MGMT_AUDIO_INVALID_ALARM_STATE, alarmStatus.alarmsState )
-            setAlarmAudioState( ALARM_PRIORITY_HIGH, alarmAudioVolumeLevel );
+            setAlarmAudioState( ALARM_PRIORITY_HIGH, volume );
         }
     }
 }
@@ -871,6 +928,7 @@
     BOOL noEndTreatment = FALSE;
     BOOL noNewTreatment = FALSE;
     BOOL usrAckReq = FALSE;
+    BOOL noMinimize = TRUE;
     ALARM_ID_T   a;
 
     // Determine alarm flags
@@ -911,7 +969,7 @@
     } // Alarm table loop
 
     // If top alarm condition not cleared, block resume and rinseback flags
-    if ( TRUE == alarmStatus.topAlarmConditionnDetected )
+    if ( TRUE == alarmStatus.topAlarmConditionDetected )
     {
         noResume = TRUE;
         noRinseback = TRUE;
@@ -920,14 +978,20 @@
     // If top alarm requires user ack or no other user options enabled for recoverable alarm and condition cleared, set user ack flag and block other flags
     if ( ( TRUE == ALARM_TABLE[ alarmStatus.alarmTop ].alarmUserAckRequired ) ||
          ( ( FALSE == alarmStatus.noClear ) && ( noResume ) && ( noRinseback ) && ( noEndTreatment ) &&
-           ( FALSE == alarmStatus.topAlarmConditionnDetected ) ) )
+           ( FALSE == alarmStatus.topAlarmConditionDetected ) ) )
     {
         usrAckReq = TRUE;
         noResume = TRUE;
         noRinseback = TRUE;
         noEndTreatment = TRUE;
     }
 
+    // If in Treatment-Stop state, allow user to minimize the alarm window
+    if ( ( MODE_TREA == getCurrentOperationMode() ) && ( TREATMENT_STOP_STATE == getTreatmentState() ) )
+    {
+        noMinimize = FALSE;
+    }
+
     // Set updated alarm flags
     alarmStatus.systemFault = systemFault;
     alarmStatus.stop = stop;
@@ -936,7 +1000,8 @@
     alarmStatus.noRinseback = noRinseback;
     alarmStatus.noEndTreatment = noEndTreatment;
     alarmStatus.noNewTreatment = noNewTreatment;
-    alarmStatus.usrACKRequired = usrAckReq;
+    alarmStatus.usrACKRequired = usrAckReq;
+    alarmStatus.noMinimize = noMinimize;
 }
 
 /*********************************************************************//**
@@ -984,6 +1049,131 @@
         SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_ALARM_MGMT_INVALID_FIFO_TO_RESET, priority )
     }
 }
+
+/*********************************************************************//**
+ * @brief
+ * The publishAlarmInfo function publishes alarm information at the set
+ * interval.
+ * @details Inputs:
+ * @details Outputs: alarm information are published to CAN bus.
+ * @return none
+ *************************************************************************/
+static void publishAlarmInfo( void )
+{
+    // Publish voltages monitor data on interval
+    if ( ++alarmInfoPublicationTimerCounter >= getPublishAlarmInfoInterval() )
+    {
+        ALARM_INFO_PAYLOAD_T data;
+
+        data.audioVolume = MAX_ALARM_VOLUME_LEVEL - getAlarmAudioVolume();  // convert back to 1..5 volume level for publication
+        data.audioCurrHG = getAlarmAudioPrimaryHighGainCurrent();
+        data.audioCurrLG = getAlarmAudioPrimaryLowGainCurrent();
+        data.backupAudioCurr = getAlarmAudioBackupCurrent();
+        data.safetyShutdown = isSafetyShutdownActivated();
+
+        broadcastAlarmInfo( data );
+        alarmInfoPublicationTimerCounter = 0;
+    }
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getPublishAlarmInfoInterval function gets the blood flow data
+ * 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
+ * @return the current alarm audio volume level.
+ *************************************************************************/
+U32 getAlarmAudioVolume( void )
+{
+    U32 result = alarmAudioVolumeLevel.data;
+
+    if ( OVERRIDE_KEY == alarmAudioVolumeLevel.override )
+    {
+        result = alarmAudioVolumeLevel.ovData;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getAlarmAudioPrimaryHighGainCurrent function gets the current alarm
+ * audio high gain current.
+ * @details Inputs: alarmPrimaryAudioCurrentHG
+ * @details Outputs: none
+ * @return the current alarm audio high gain current (in mA).
+ *************************************************************************/
+F32 getAlarmAudioPrimaryHighGainCurrent( void )
+{
+    F32 result = alarmPrimaryAudioCurrentHG.data;
+
+    if ( OVERRIDE_KEY == alarmPrimaryAudioCurrentHG.override )
+    {
+        result = alarmPrimaryAudioCurrentHG.ovData;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getAlarmAudioPrimaryLowGainCurrent function gets the current alarm
+ * audio low gain current.
+ * @details Inputs: alarmPrimaryAudioCurrentLG
+ * @details Outputs: none
+ * @return the current alarm audio low gain current (in mA).
+ *************************************************************************/
+F32 getAlarmAudioPrimaryLowGainCurrent( void )
+{
+    F32 result = alarmPrimaryAudioCurrentLG.data;
+
+    if ( OVERRIDE_KEY == alarmPrimaryAudioCurrentLG.override )
+    {
+        result = alarmPrimaryAudioCurrentLG.ovData;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The getAlarmAudioBackupCurrent function gets the current backup alarm
+ * audio current.
+ * @details Inputs: alarmBackupAudioCurrent
+ * @details Outputs: none
+ * @return the current backup alarm audio current (in mA).
+ *************************************************************************/
+F32 getAlarmAudioBackupCurrent( void )
+{
+    F32 result = alarmBackupAudioCurrent.data;
+
+    if ( OVERRIDE_KEY == alarmBackupAudioCurrent.override )
+    {
+        result = alarmBackupAudioCurrent.ovData;
+    }
+
+    return result;
+}
 
 
 /*************************************************************************
@@ -1154,6 +1344,233 @@
     }
 
     return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testSetAlarmInfoPublishIntervalOverride function sets the override of the
+ * alarm information publication interval.
+ * @details Inputs: none
+ * @details Outputs: alarmInfoPublishInterval
+ * @param ms milliseconds between alarm info broadcasts
+ * @return TRUE if override set successful, FALSE if not
+ *************************************************************************/
+BOOL testSetAlarmInfoPublishIntervalOverride( U32 ms )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        U32 intvl = ms / TASK_GENERAL_INTERVAL;
+
+        result = TRUE;
+        alarmInfoPublishInterval.ovData = intvl;
+        alarmInfoPublishInterval.override = OVERRIDE_KEY;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testResetAlarmInfoPublishIntervalOverride function resets the override of the
+ * alarm information publication interval.
+ * @details Inputs: none
+ * @details Outputs: alarmInfoPublishInterval
+ * @return TRUE if override reset successful, FALSE if not
+ *************************************************************************/
+BOOL testResetAlarmInfoPublishIntervalOverride( void )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        result = TRUE;
+        alarmInfoPublishInterval.override = OVERRIDE_RESET;
+        alarmInfoPublishInterval.ovData = alarmInfoPublishInterval.ovInitData;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testSetAlarmAudioVolumeLevelOverride function sets the override of the
+ * alarm audio volume.
+ * @details Inputs: none
+ * @details Outputs: alarmAudioVolumeLevel
+ * @param volume volume level (1..5) of alarm audio
+ * @return TRUE if override set successful, FALSE if not
+ *************************************************************************/
+BOOL testSetAlarmAudioVolumeLevelOverride( U32 volume )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        result = TRUE;
+        alarmAudioVolumeLevel.ovData = MAX_ALARM_VOLUME_LEVEL - volume;
+        alarmAudioVolumeLevel.override = OVERRIDE_KEY;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testResetAlarmAudioVolumeLevelOverride function resets the override of the
+ * alarm audio volume.
+ * @details Inputs: none
+ * @details Outputs: alarmAudioVolumeLevel
+ * @return TRUE if override reset successful, FALSE if not
+ *************************************************************************/
+BOOL testResetAlarmAudioVolumeLevelOverride( void )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        result = TRUE;
+        alarmAudioVolumeLevel.override = OVERRIDE_RESET;
+        alarmAudioVolumeLevel.ovData = alarmAudioVolumeLevel.ovInitData;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testSetPrimaryAlarmAudioCurrentHGOverride function sets the override of the
+ * alarm audio current (high gain) in mA.
+ * @details Inputs: none
+ * @details Outputs: alarmPrimaryAudioCurrentHG
+ * @param mA milliamps measured from high gain channel of primary alarm audio
+ * @return TRUE if override set successful, FALSE if not
+ *************************************************************************/
+BOOL testSetPrimaryAlarmAudioCurrentHGOverride( F32 mA )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        result = TRUE;
+        alarmPrimaryAudioCurrentHG.ovData = mA;
+        alarmPrimaryAudioCurrentHG.override = OVERRIDE_KEY;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testResetPrimaryAlarmAudioCurrentHGOverride function resets the override of the
+ * alarm audio current (high gain).
+ * @details Inputs: none
+ * @details Outputs: alarmPrimaryAudioCurrentHG
+ * @return TRUE if override reset successful, FALSE if not
+ *************************************************************************/
+BOOL testResetPrimaryAlarmAudioCurrentHGOverride( void )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        result = TRUE;
+        alarmPrimaryAudioCurrentHG.override = OVERRIDE_RESET;
+        alarmPrimaryAudioCurrentHG.ovData = alarmPrimaryAudioCurrentHG.ovInitData;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testSetPrimaryAlarmAudioCurrentLGOverride function sets the override of the
+ * alarm audio current (low gain) in mA.
+ * @details Inputs: none
+ * @details Outputs: alarmPrimaryAudioCurrentLG
+ * @param mA milliamps measured from low gain channel of primary alarm audio
+ * @return TRUE if override set successful, FALSE if not
+ *************************************************************************/
+BOOL testSetPrimaryAlarmAudioCurrentLGOverride( F32 mA )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        result = TRUE;
+        alarmPrimaryAudioCurrentLG.ovData = mA;
+        alarmPrimaryAudioCurrentLG.override = OVERRIDE_KEY;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testResetPrimaryAlarmAudioCurrentLGOverride function resets the override of the
+ * alarm audio current (low gain).
+ * @details Inputs: none
+ * @details Outputs: alarmPrimaryAudioCurrentLG
+ * @return TRUE if override reset successful, FALSE if not
+ *************************************************************************/
+BOOL testResetPrimaryAlarmAudioCurrentLGOverride( void )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        result = TRUE;
+        alarmPrimaryAudioCurrentLG.override = OVERRIDE_RESET;
+        alarmPrimaryAudioCurrentLG.ovData = alarmPrimaryAudioCurrentLG.ovInitData;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testSetBackupAlarmAudioCurrentOverride function sets the override of the
+ * alarm audio current (backup) in mA.
+ * @details Inputs: none
+ * @details Outputs: alarmBackupAudioCurrent
+ * @param mA milliamps measured from backup channel of primary alarm audio
+ * @return TRUE if override set successful, FALSE if not
+ *************************************************************************/
+BOOL testSetBackupAlarmAudioCurrentOverride( F32 mA )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        result = TRUE;
+        alarmBackupAudioCurrent.ovData = mA;
+        alarmBackupAudioCurrent.override = OVERRIDE_KEY;
+    }
+
+    return result;
+}
+
+/*********************************************************************//**
+ * @brief
+ * The testResetBackupAlarmAudioCurrentOverride function resets the override of the
+ * alarm audio current (backup).
+ * @details Inputs: none
+ * @details Outputs: alarmBackupAudioCurrent
+ * @return TRUE if override reset successful, FALSE if not
+ *************************************************************************/
+BOOL testResetBackupAlarmAudioCurrentOverride( void )
+{
+    BOOL result = FALSE;
+
+    if ( TRUE == isTestingActivated() )
+    {
+        result = TRUE;
+        alarmBackupAudioCurrent.override = OVERRIDE_RESET;
+        alarmBackupAudioCurrent.ovData = alarmBackupAudioCurrent.ovInitData;
+    }
+
+    return result;
 }
 
 /**@}*/