Index: firmware/App/Services/AlarmMgmt.c =================================================================== diff -u -rd3b7ae356aae29c99cb039713a2e120fdbce5a9c -ra7208ef0e06ae2d91b2f144e6e25a6fefde8c022 --- firmware/App/Services/AlarmMgmt.c (.../AlarmMgmt.c) (revision d3b7ae356aae29c99cb039713a2e120fdbce5a9c) +++ firmware/App/Services/AlarmMgmt.c (.../AlarmMgmt.c) (revision a7208ef0e06ae2d91b2f144e6e25a6fefde8c022) @@ -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,25 +37,35 @@ /// 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. #define SUPERVISOR_ALARM_KEY 0xD2C3B4A5 ///< 32-bit key required for clear all alarms request. -#define LOWEST_ALARM_SUB_RANK 999 ///< Lowest alarm sub-rank that can be set. +#define LOWEST_ALARM_SUB_RANK 999 ///< Lowest alarm sub-rank that can be set. +#define MAX_ALARM_LIST_SIZE 10 ///< Maximum number of active alarms inside alarm list. // *** This declaration will cause a compiler error if ALARM_TABLE does not have same # of alarms as the Alarm_List enumeration. U08 alarmTableSizeAssertion[ ( ( sizeof( ALARM_TABLE ) / sizeof( ALARM_T ) ) == NUM_OF_ALARM_IDS ? 1 : -1 ) ]; +// *** This declaration will cause a compiler error if ALARM_RANK_TABLE does not have same # of alarms as the Alarm_List enumeration. +U08 alarmRankTableSizeAssertion[ ( ( sizeof( ALARM_RANK_TABLE ) / sizeof( ALARM_RANK_T ) ) == NUM_OF_ALARM_IDS ? 1 : -1 ) ]; + /// A blank alarm data record for alarms that do not include alarm data when triggered. const ALARM_DATA_T BLANK_ALARM_DATA = { ALARM_DATA_TYPE_NONE, 0 }; -// Pin assignment for backup alarm audio enable -#define BACKUP_AUDIO_ENABLE_SPI3_PORT_MASK 0x00000001 ///< Pin SPI3-CS0 - re-purposed as output GPIO for back audio enable. +/// Pin SPI3-CS0 - re-purposed as output GPIO for backup alarm audio enable. +#define BACKUP_AUDIO_ENABLE_SPI3_PORT_MASK 0x00000001 // Backup alarm audio enable/disable macros #define SET_BACKUP_AUDIO_ENABLE() {mibspiREG3->PC3 |= BACKUP_AUDIO_ENABLE_SPI3_PORT_MASK;} ///< Macro to enable backup alarm audio. #define CLR_BACKUP_AUDIO_ENABLE() {mibspiREG3->PC3 &= ~BACKUP_AUDIO_ENABLE_SPI3_PORT_MASK;} ///< Macro to disable backup alarm audio. +#define ALARM_AUDIO_TEST_TONE 4 ///< Alarm audio state for continuous test tone. +#define ALARM_AUDIO_CURRENT_HG_MIN_MA 10.0 ///< Minimum audio current (high gain) during test tone self-test (in mA). +#define ALARM_AUDIO_CURRENT_LG_MIN_MA 10.0 ///< Minimum audio current (low gain) during test tone self-test (in mA). + /// Alarm priority ranking record. typedef struct { @@ -64,30 +76,40 @@ // ********** private data ********** -static U32 alarmStatusPublicationTimerCounter = 0; ///< Used to schedule alarm status publication to CAN bus. +static BOOL alarmIsActive[ NUM_OF_ALARM_IDS ]; ///< Table - current state of each alarm +static BOOL alarmIsDetected[ NUM_OF_ALARM_IDS ]; ///< Table - current state of each alarm condition (detected or cleared) +static OVERRIDE_U32_T alarmStartedAt[ NUM_OF_ALARM_IDS ]; ///< Table - when alarm became active for each alarm (if active) or zero (if inactive) +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; +static COMP_ALARM_STATUS_T alarmStatus; ///< Record for the current composite alarm status. +static ALARM_PRIORITY_RANKS_T alarmPriorityFIFO[ NUM_OF_ALARM_PRIORITIES ]; ///< FIFO - first activated or highest sub-rank alarm in each alarm priority category. -/// FIFO - first activated or highest sub-rank alarm in each alarm priority category. -static ALARM_PRIORITY_RANKS_T alarmPriorityFIFO[ NUM_OF_ALARM_PRIORITIES ]; +static BOOL alarmUserRecoveryActionEnabled[ NUMBER_OF_ALARM_USER_ACTIONS ]; ///< Alarm user recovery actions enabled flags. -/// Alarm user recovery actions enabled flags. -static BOOL alarmUserRecoveryActionEnabled[ NUMBER_OF_ALARM_USER_ACTIONS ]; +/// Flag indicates whether alarm audio test tone should be output. +static BOOL alarmAudioTestToneRequested; -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 +121,9 @@ static void resetAlarmPriorityFIFO( ALARM_PRIORITY_T priority ); static U32 getAlarmStartTime( ALARM_ID_T alarmID ); + +static void publishAlarmInfo( void ); +static U32 getPublishAlarmInfoInterval( void ); /*********************************************************************//** * @brief @@ -110,7 +135,7 @@ void initAlarmMgmt( void ) { ALARM_PRIORITY_T p; - ALARM_ID_T a; + ALARM_ID_T a; // Disable backup audio CLR_BACKUP_AUDIO_ENABLE(); @@ -139,7 +164,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; @@ -149,7 +174,9 @@ alarmStatus.noEndTreatment = FALSE; alarmStatus.noNewTreatment = FALSE; alarmStatus.noDialRecirc = FALSE; - alarmStatus.usrACKRequired = FALSE; + alarmStatus.usrACKRequired = FALSE; + + alarmAudioTestToneRequested = FALSE; } /*********************************************************************//** @@ -163,6 +190,7 @@ *************************************************************************/ void execAlarmMgmt( void ) { + monitorAlarms(); handleAlarmEscalations(); updateAlarmsState(); updateAlarmsFlags(); @@ -239,13 +267,8 @@ * @return none *************************************************************************/ void activateAlarmNoData( ALARM_ID_T alarm ) -{ - // Broadcast alarm and data if alarm not already active - if ( FALSE == alarmIsActive[ alarm ] ) - { - broadcastAlarmTriggered( (U16)alarm, BLANK_ALARM_DATA, BLANK_ALARM_DATA ); - } - activateAlarm( alarm ); +{ + activateAlarm2Data( alarm, BLANK_ALARM_DATA, BLANK_ALARM_DATA ); } /*********************************************************************//** @@ -261,12 +284,7 @@ *************************************************************************/ void activateAlarm1Data( ALARM_ID_T alarm, ALARM_DATA_T alarmData ) { - // Broadcast alarm and data if alarm not already active - if ( FALSE == alarmIsActive[ alarm ] ) - { - broadcastAlarmTriggered( (U16)alarm, alarmData, BLANK_ALARM_DATA ); - } - activateAlarm( alarm ); + activateAlarm2Data( alarm, alarmData, BLANK_ALARM_DATA ); } /*********************************************************************//** @@ -286,7 +304,12 @@ // Broadcast alarm and data if alarm not already active if ( FALSE == alarmIsActive[ alarm ] ) { - broadcastAlarmTriggered( (U16)alarm, alarmData1, alarmData2 ); + broadcastAlarmTriggered( alarm, alarmData1, alarmData2 ); + // Send information for UI to log to treatment log + if ( ( TRUE == ALARM_TABLE[ alarm ].alarmTreatmentLog ) && ( MODE_TREA == getCurrentOperationMode() ) ) + { + sendTreatmentLogAlarmEventData( alarm, alarmData1, alarmData2 ); + } } activateAlarm( alarm ); } @@ -463,7 +486,7 @@ break; default: - // TODO - s/w fault? + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_ALARM_USER_ACTION, action ); break; } } @@ -564,11 +587,71 @@ *************************************************************************/ 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 ); } + +/*********************************************************************//** + * @brief +* The getNoNewTreatmentStatus function gets the persistent no new +* treatment alarm status flag. +* @details Inputs: alarmStatus.noNewTreatment +* @details Outputs: none +* @return TRUE if no new treatment allowed, otherwise FALSE +*************************************************************************/ +BOOL getNoNewTreatmentStatus( void ) +{ + return alarmStatus.noNewTreatment; +} + +/*********************************************************************//** + * @brief +* The handleActiveAlarmListRequest function processed the active alarms list +* request from UI. +* @details Inputs: alarmIsActive[] +* @details Outputs: sent active alarms list to UI +* @return none +*************************************************************************/ +void handleActiveAlarmListRequest( void ) +{ + BOOL accepted = TRUE; + REQUEST_REJECT_REASON_CODE_T rejReason = REQUEST_REJECT_REASON_NONE; + U32 activeAlarmList[ MAX_ALARM_LIST_SIZE ]; + U32 index; + U32 activeAlarmListIndex = 0; + + for ( index = 0; index < MAX_ALARM_LIST_SIZE; index++ ) + { + activeAlarmList[ index ] = ALARM_ID_NO_ALARM; + } + + if ( TRUE == isAnyAlarmActive() ) + { + for ( index = 0; index < NUM_OF_ALARM_IDS; index++ ) + { + if ( ( TRUE == isAlarmActive( ALARM_RANK_TABLE[ index ].alarmID ) ) && ( activeAlarmListIndex < MAX_ALARM_LIST_SIZE ) ) + { + activeAlarmList[ activeAlarmListIndex ] = ALARM_RANK_TABLE[ index ].alarmID; + activeAlarmListIndex++; + } + } + } + + sendActiveAlarmsList( accepted, rejReason, activeAlarmList, sizeof( activeAlarmList ) ); +} /*********************************************************************//** * @brief @@ -600,6 +683,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 +767,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 +842,29 @@ *************************************************************************/ static void setAlarmAudio( void ) { - if ( TRUE == alarmStatus.alarmsSilenced ) + U32 volume = getAlarmAudioVolume(); + + if ( TRUE == alarmAudioTestToneRequested ) + { // Play test tone at max volume for next 50 ms + setAlarmAudioState( ALARM_AUDIO_TEST_TONE, 0 ); + alarmAudioTestToneRequested = FALSE; + } + else if ( TRUE == alarmStatus.alarmsSilenced ) { - setAlarmAudioState( ALARM_PRIORITY_NONE, alarmAudioVolumeLevel ); + setAlarmAudioState( ALARM_PRIORITY_NONE, volume ); } - else // Alarms not silenced + else { 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 +983,7 @@ BOOL noEndTreatment = FALSE; BOOL noNewTreatment = FALSE; BOOL usrAckReq = FALSE; + BOOL noMinimize = TRUE; ALARM_ID_T a; // Determine alarm flags @@ -911,7 +1024,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,23 +1033,30 @@ // 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; alarmStatus.noClear = noClear; alarmStatus.noResume = noResume; alarmStatus.noRinseback = noRinseback; alarmStatus.noEndTreatment = noEndTreatment; - alarmStatus.noNewTreatment = noNewTreatment; + alarmStatus.noNewTreatment |= noNewTreatment; alarmStatus.usrACKRequired = usrAckReq; + alarmStatus.noMinimize = noMinimize; } /*********************************************************************//** @@ -984,6 +1104,171 @@ 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; +} + +/*********************************************************************//** + * @brief + * The execAlarmAudioSelfTest function outputs a test audio tone and + * measures the audio current level. The test passes if the audio current + * exceeds TBD mA. + * @details Inputs: alarmBackupAudioCurrent + * @details Outputs: none + * @return the current backup alarm audio current (in mA). + *************************************************************************/ +SELF_TEST_STATUS_T execAlarmAudioSelfTest( void ) +{ + SELF_TEST_STATUS_T result = SELF_TEST_STATUS_IN_PROGRESS; + + if ( alarmAudioTestToneRequested != TRUE ) + { + alarmAudioTestToneRequested = TRUE; + setAlarmAudio(); + } + else + { + F32 almHGCurrent = getIntADCVoltageConverted( INT_ADC_PRIMARY_ALARM_CURRENT_HG ); + F32 almLGCurrent = getIntADCVoltageConverted( INT_ADC_PRIMARY_ALARM_CURRENT_LG ); + + // Check if alarm audio current is sufficiently high indicating alarm tone is being output +// TODO - need tone to be on longer than 50ms. make duration long (1 sec) at first to characterize the audio, then change to exit test when threshold met or t/o +// if ( ( almHGCurrent > ALARM_AUDIO_CURRENT_HG_MIN_MA ) && +// ( almLGCurrent > ALARM_AUDIO_CURRENT_LG_MIN_MA ) ) + { + result = SELF_TEST_STATUS_PASSED; + } +// else +// { +// result = SELF_TEST_STATUS_FAILED; +// SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_ALARM_AUDIO_SELF_TEST_FAILURE, almHGCurrent, almLGCurrent ); +// } + } + + return result; +} /************************************************************************* @@ -1154,6 +1439,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; } /**@}*/