Index: firmware/App/Modes/SelfTests.c =================================================================== diff -u -r6742b3e355d70e0bdf036ed93cc2268bdd36cb99 -r12708a04ae3365e11180182fc52d005c229a7bc6 --- firmware/App/Modes/SelfTests.c (.../SelfTests.c) (revision 6742b3e355d70e0bdf036ed93cc2268bdd36cb99) +++ firmware/App/Modes/SelfTests.c (.../SelfTests.c) (revision 12708a04ae3365e11180182fc52d005c229a7bc6) @@ -7,8 +7,8 @@ * * @file SelfTests.c * -* @author (last) Dara Navaei -* @date (last) 11-Jan-2023 +* @author (last) Sean Nash +* @date (last) 04-May-2023 * * @author (original) Quang Nguyen * @date (original) 28-Jan-2021 @@ -27,6 +27,7 @@ #include "ModeTreatmentParams.h" #include "PresOccl.h" #include "SelfTests.h" +#include "Switches.h" #include "SyringePump.h" #include "SystemCommMessages.h" #include "TaskGeneral.h" @@ -46,12 +47,14 @@ #define DIAL_IN_PUMP_PRESSURE_SELF_TEST_FLOW 400 #define SYRINGE_PUMP_OCCLUSION_CHECK_DELAY ( 1 * MS_PER_SECOND ) ///< Delay 1 second then check for syringe pump prime occlusion. +#define PRE_NORMAL_PRESSURE_SELF_TEST_DELAY_MS ( 1 * MS_PER_SECOND ) ///< Delay 1 second prior to getting initial normal baseline pressures. #define BLOOD_PUMP_RUN_TIME_PRESSURE_SELF_TEST ( 30 * MS_PER_SECOND ) ///< Pressure self-test time to run blood pump in ms. -#define VENOUS_PRESSURE_SELF_TEST_MAX_TEST_TIME ( 30 * MS_PER_SECOND ) ///< Pressure self-test time to run venous self test in ms. +#define VENOUS_PRESSURE_SELF_TEST_MAX_TEST_TIME ( 60 * MS_PER_SECOND ) ///< Pressure self-test time to run venous self test in ms. #define DECAY_PRESSURE_SELF_TEST_TIME ( 4 * MS_PER_SECOND ) ///< time to wait for pressure to decay in ms. #define STABILTY_PRESSURE_SELF_TEST_TIME ( 5 * MS_PER_SECOND ) ///< Time to wait for pressure to stabilize in ms. #define NORMALIZED_PRESSURE_SELF_TEST_TIME ( 20 * MS_PER_SECOND ) ///< Time to wait for pressure to normalize in ms. -#define NORMALIZED_PRESSURE_SELF_TEST_VBT_TIMER ( 7 * MS_PER_SECOND ) ///< Time to wait until we open VBT during normal pressure tests. +#define NORMALIZED_PRESSURE_SELF_TEST_VBT_TIMER ( 1 * MS_PER_SECOND ) ///< Time to wait until we open VBT during normal pressure tests. +#define NORMALIZED_PRESSURE_SELF_TEST_VBT_TIMERX ( 7 * MS_PER_SECOND ) ///< Time to wait until we open VBT during normal pressure tests (for old builds that don't support air pump). #define NORMALIZED_PRESSURE_SELF_TEST_VDI_TIMER ( 5 * MS_PER_SECOND ) ///< Time to wait until we open VDI during normal pressure tests. #define ARTERIAL_DECAY_PRESSURE_DIFF_TOLERANCE_MMHG 5.0F ///< Difference in arterial pressure readings after the pump stops (in mmHg). @@ -71,8 +74,9 @@ #define WET_SELF_TEST_FIRST_DISPLACEMENT_TARGET_VOLUME_ML 100.0F ///< Target of first displacement volume in ml. #define WET_SELF_TEST_SECOND_DISPLACEMENT_TARGET_VOLUME_ML 600.0F ///< Target of second displacement volume in ml. -#define WET_SELF_TEST_INTEGRATED_VOLUME_PCT_TOLERANCE 0.05F ///< Tolerance on integrated volume as a percentage (5%). +#define WET_SELF_TEST_INTEGRATED_VOLUME_PCT_TOLERANCE 0.10F ///< Tolerance on integrated volume as a percentage (10%). #define WET_SELF_TEST_INTEGRATED_VOLUME_TOLERANCE 20.0F ///< Tolerance on integrated volume in grams. +#define WET_SELF_TEST_INTEGRATED_VOLUME_WIDER_TOLERANCE 100.0F ///< Wider tolerance on integrated volume in grams, during debug. #define WET_SELF_TEST_DISPLACEMENT_TOLERANCE_G 20.0F ///< Tolerance in the load cell readings of the displacement in grams. #define WET_SELF_TEST_FIRST_DISPLACEMENT_TIME_MS ( SEC_PER_MIN * MS_PER_SECOND ) ///< Time to displace dialysate in wet self-test in ms (first). #define WET_SELF_TEST_SECOND_DISPLACEMENT_TIME_MS ( 30 * MS_PER_SECOND ) ///< Time to displace dialysate in wet self-test in ms (second). @@ -95,6 +99,7 @@ static BOOL pumpHomingRequestedForNCST; ///< Flag indicates pumps should be homed after running no cartridge pumps self-test. static DRY_SELF_TESTS_STATE_T currentDrySelfTestsState; ///< Current state of the dry self-tests state machine. +static U32 pressureSelfTestPreNormalStartTime; ///< Pressure dry self-test pre-normal start time. static U32 pressureSelfTestBloodPumpRunStartTime; ///< Pressure dry self-test blood pump runs start time. static U32 pressureSelfTestVenousTestStartTime; ///< Pressure dry self-test dip runs start time. static U32 pressureSelfTestNormalizedStartTime; ///< Normalized pressure dry self-test start time. @@ -106,15 +111,17 @@ static F32 peakVenousPressure; ///< Holds the peak normal venous pressure reading. static F32 decayedArterialPressure; ///< Holds the decayed arterial pressure reading after blood pump is stopped. static F32 decayedVenousPressure; ///< Holds the decayed venous pressure reading after blood pump is stopped. +static BOOL dryPressureTestsCompleted; ///< Flag indicates dry cartridge pressure leak testing has been completed. static BOOL wetSelfTestsResult; ///< Result of wet self-tests. static WET_SELF_TESTS_STATE_T currentWetSelfTestsState; ///< Current state of the wet self-tests state machine. static U32 settleStartTime; ///< Wait for reservoir to settle start time. static U32 displacementStartTime; ///< Dialysate displacement starting time. static F32 fmdIntegratedVolume; ///< FMD integrated volume over displacement time. static F32 reservoirVolume[ NUM_OF_DG_RESERVOIRS ]; ///< Hold the current volume of all reservoirs. -static BOOL isValvesSettingSent; ///< Flag indicates valve setting change has been send to DG. +static BOOL isValvesSettingSent; ///< Flag indicates valve setting change has been sent to DG. +static U32 selfTestCartridgeSettleTime; ///< Cartridge settle start time. static U32 selfTestStartTime; ///< Starting time of self-test (in ms). static U32 selfTestPreviousPublishDataTime; ///< Last time self-test time data is being published (in ms). static U32 syringeOcclusionDelayStartTime; ///< Used to calculate the 1 second delay time before check for prime occlusion. @@ -127,6 +134,7 @@ static void resetSelfTestsFlags( void ); static void setupForSelfTestsStop( void ); +static void setAlarmResumePerDoorAndLatch( void ); static NO_CART_SELF_TESTS_STATE_T handleNoCartSelfTestsWaitForClosedDoor( void ); static NO_CART_SELF_TESTS_STATE_T handleNoCartSelfTestHomeValvesState( void ); @@ -135,8 +143,10 @@ static NO_CART_SELF_TESTS_STATE_T handleNoCartSelfTestHomeIdleState( void ); static NO_CART_SELF_TESTS_STATE_T handleNoCartSelfTestStoppedState( void ); +static DRY_SELF_TESTS_STATE_T handleDrySelfTestStartState( void ); static DRY_SELF_TESTS_STATE_T handleDrySelfTestWaitForDoorCloseState( void ); static DRY_SELF_TESTS_STATE_T handleDrySelfTestUsedCartridgeCheckState( void ); +static DRY_SELF_TESTS_STATE_T handleDrySelfTestCartridgeLoadedCheckState( void ); static DRY_SELF_TESTS_STATE_T handleDrySelfTestPressureSensorsNormalSetupState( void ); static DRY_SELF_TESTS_STATE_T handleDrySelfTestPressureSensorsVenousSetupState( void ); static DRY_SELF_TESTS_STATE_T handleDrySelfTestPressureSensorsVenousState( void ); @@ -214,6 +224,7 @@ signalBloodPumpHardStop(); signalDialInPumpHardStop(); signalDialOutPumpHardStop(); + cmdStopDGTrimmerHeater(); if ( TRUE == isAlarmActive( ALARM_ID_HD_SYRINGE_PUMP_NOT_ENOUGH_HEPARIN_ALARM ) ) { @@ -232,6 +243,30 @@ /*********************************************************************//** * @brief + * The setAlarmResumePerDoorAndLatch function sets alarm resume enable for + * stop states based on whether door and pump track are closed. + * @details Inputs: state of front door and pump track + * @details Outputs: resume alarm enabled/disabled + * @return none + *************************************************************************/ +static void setAlarmResumePerDoorAndLatch( void ) +{ + BOOL doorClosed = ( STATE_CLOSED == getSwitchStatus( FRONT_DOOR ) ? TRUE : FALSE ); + BOOL latchClosed = ( STATE_CLOSED == getSwitchStatus( PUMP_TRACK_SWITCH ) ? TRUE : FALSE ); + + // require front door and pump track to be closed before allowing resume + if ( ( TRUE == doorClosed ) && ( TRUE == latchClosed ) ) + { + setAlarmUserActionEnabled( ALARM_USER_ACTION_RESUME, TRUE ); + } + else + { + setAlarmUserActionEnabled( ALARM_USER_ACTION_RESUME, FALSE ); + } +} + +/*********************************************************************//** + * @brief * The transitionToNoCartSelfTests function resets anything required before * the start of no cartridge self-tests. * @details Inputs: none @@ -254,7 +289,7 @@ useHeparin = ( ( bolusVol > 0.0 ) || ( hepRate > 0.0 ) ? TRUE : FALSE ); } - currentNoCartSelfTestsState = NO_CART_SELF_TESTS_START_STATE; + currentNoCartSelfTestsState = NO_CART_SELF_TESTS_WAIT_FOR_DOOR_CLOSE_STATE; runPumpStartTime = 0; havePumpsStartedForNCST = FALSE; pumpHomingRequestedForNCST = FALSE; @@ -289,13 +324,11 @@ *************************************************************************/ void execNoCartSelfTests( void ) { + NO_CART_SELF_TESTS_STATE_T priorSubState = currentNoCartSelfTestsState; + // execute no cartridge self-tests state machine switch ( currentNoCartSelfTestsState ) { - case NO_CART_SELF_TESTS_START_STATE: - currentNoCartSelfTestsState = NO_CART_SELF_TESTS_WAIT_FOR_DOOR_CLOSE_STATE; - break; - case NO_CART_SELF_TESTS_WAIT_FOR_DOOR_CLOSE_STATE: currentNoCartSelfTestsState = handleNoCartSelfTestsWaitForClosedDoor(); break; @@ -336,6 +369,10 @@ // Self-tests flags should be handled by now, reset if flags not handled with current state resetSelfTestsFlags(); + if ( priorSubState != currentNoCartSelfTestsState ) + { + SEND_EVENT_WITH_2_U32_DATA( HD_EVENT_SUB_STATE_CHANGE, priorSubState, currentNoCartSelfTestsState ); + } // Publish current self-test time data if ( calcTimeSince( selfTestPreviousPublishDataTime ) >= SELF_TEST_TIME_DATA_PUB_INTERVAL ) { @@ -349,7 +386,7 @@ data.timeout = MAX_NO_CARTRIDGE_SELF_TEST_TIME; data.countdown = ( MAX_NO_CARTRIDGE_SELF_TEST_TIME - elapsedSelfTestTimeInSecs ); - broadcastData( MSG_ID_HD_NO_CART_SELF_TEST_PROGRESS, COMM_BUFFER_OUT_CAN_HD_BROADCAST, (U08*)&data, sizeof( SELF_TEST_NO_CARTRIDGE_PAYLOAD_T ) ); + broadcastData( MSG_ID_HD_NO_CART_SELF_TEST_PROGRESS_DATA, COMM_BUFFER_OUT_CAN_HD_BROADCAST, (U08*)&data, sizeof( SELF_TEST_NO_CARTRIDGE_PAYLOAD_T ) ); } else { @@ -386,11 +423,12 @@ pressureSelfTestNormalizedStartTime = 0; previousNormalArterialPressure = 0.0; previousNormalVenousPressure = 0.0; + dryPressureTestsCompleted = FALSE; selfTestStartTime = getMSTimerCount(); selfTestPreviousPublishDataTime = getMSTimerCount(); + selfTestCartridgeSettleTime = getMSTimerCount(); + doorClosedRequired( FALSE, TRUE ); - doorClosedRequired( TRUE, TRUE ); - // Pumps should be off signalBloodPumpHardStop(); signalDialInPumpHardStop(); @@ -411,30 +449,18 @@ * @brief * The execDrySelfTests function executes the dry self-tests state machine. * @details Inputs: currentDrySelfTestsState - * @details Outputs: currentDrySelfTestsState + * @details Outputs: currentDrySelfTestsState, pressureSelfTestPreNormalStartTime * @return none *************************************************************************/ void execDrySelfTests( void ) { + DRY_SELF_TESTS_STATE_T priorSubState = currentDrySelfTestsState; + // execute dry self-tests state machine switch ( currentDrySelfTestsState ) { case DRY_SELF_TESTS_START_STATE: - // Ensure occlusion sensor has time to settle after cartridge insertion before starting dry self-tests - if ( TRUE == didTimeout( selfTestStartTime, CARTRIDGE_INSERT_PRESSURE_SETTLE_TIME_MS ) ) - { - setOcclusionInstallLevel(); // Record occlusion pressure level after a new cartridge is installed -#ifndef _RELEASE_ - if ( SW_CONFIG_ENABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_DISABLE_DRY_SELF_TESTS ) ) - { - currentDrySelfTestsState = DRY_SELF_TESTS_SYRINGE_PUMP_PRIME_STATE; - } - else -#endif - { - currentDrySelfTestsState = DRY_SELF_TESTS_WAIT_FOR_DOOR_CLOSE_STATE; - } - } + currentDrySelfTestsState = handleDrySelfTestStartState(); break; case DRY_SELF_TESTS_WAIT_FOR_DOOR_CLOSE_STATE: @@ -445,16 +471,8 @@ currentDrySelfTestsState = handleDrySelfTestUsedCartridgeCheckState(); break; - case DRY_SELF_TESTS_OCCLUSION_SENSORS_STATE: - if ( SELF_TEST_STATUS_PASSED == execPresOcclDryTest() ) - { - setValvePosition( VDI, VALVE_POSITION_C_CLOSE ); - setValvePosition( VDO, VALVE_POSITION_C_CLOSE ); - setValvePosition( VBA, VALVE_POSITION_C_CLOSE ); - setValvePosition( VBV, VALVE_POSITION_C_CLOSE ); - setValveAirTrap( STATE_OPEN ); - currentDrySelfTestsState = DRY_SELF_TESTS_PRESSURE_SENSORS_NORMAL_SETUP_STATE; - } + case DRY_SELF_TESTS_CARTRIDGE_LOADED_CHECK_STATE: + currentDrySelfTestsState = handleDrySelfTestCartridgeLoadedCheckState(); break; case DRY_SELF_TESTS_PRESSURE_SENSORS_NORMAL_SETUP_STATE: @@ -512,25 +530,21 @@ // Self-tests flags should be handled by now, reset if flags not handled with current state resetSelfTestsFlags(); + if ( priorSubState != currentDrySelfTestsState ) + { + SEND_EVENT_WITH_2_U32_DATA( HD_EVENT_SUB_STATE_CHANGE, priorSubState, currentDrySelfTestsState ); + } // Publish current self-test time data if ( calcTimeSince( selfTestPreviousPublishDataTime ) >= SELF_TEST_TIME_DATA_PUB_INTERVAL ) { U32 const elapsedSelfTestTimeInSecs = calcTimeSince( selfTestStartTime ) / MS_PER_SECOND; + SELF_TEST_DRY_PAYLOAD_T data; selfTestPreviousPublishDataTime = getMSTimerCount(); - if ( elapsedSelfTestTimeInSecs <= MAX_DRY_SELF_TEST_TIME ) - { - SELF_TEST_DRY_PAYLOAD_T data; - - data.timeout = MAX_DRY_SELF_TEST_TIME; - data.countdown = ( MAX_DRY_SELF_TEST_TIME - elapsedSelfTestTimeInSecs ); - broadcastData( MSG_ID_HD_DRY_SELF_TEST_PROGRESS, COMM_BUFFER_OUT_CAN_HD_BROADCAST, (U08*)&data, sizeof( SELF_TEST_DRY_PAYLOAD_T ) ); - } - else - { - SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_DRY_SELF_TEST_TIMEOUT, currentDrySelfTestsState ); - } + data.timeout = MAX_DRY_SELF_TEST_TIME; + data.countdown = ( elapsedSelfTestTimeInSecs <= MAX_DRY_SELF_TEST_TIME ? ( MAX_DRY_SELF_TEST_TIME - elapsedSelfTestTimeInSecs ) : 0 ); + broadcastData( MSG_ID_HD_DRY_SELF_TEST_PROGRESS_DATA, COMM_BUFFER_OUT_CAN_HD_BROADCAST, (U08*)&data, sizeof( SELF_TEST_DRY_PAYLOAD_T ) ); } } @@ -590,6 +604,8 @@ *************************************************************************/ void execWetSelfTests( void ) { + WET_SELF_TESTS_STATE_T priorSubState = currentWetSelfTestsState; + #ifndef _RELEASE_ if ( ( SW_CONFIG_ENABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_DISABLE_PRIMING ) ) || ( SW_CONFIG_ENABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_DISABLE_WET_SELF_TEST ) ) ) @@ -605,11 +621,11 @@ currentWetSelfTestsState = handleWetSelfTestStartState(); break; - case WET_SELF_TESTS_SETUP_STATE: + case WET_SELF_TESTS_BUBBLE_CHECK_SETUP_STATE: currentWetSelfTestsState = handleWetSelfTestSetupState(); break; - case WET_SELF_TESTS_BUBBLES_STATE: + case WET_SELF_TESTS_BUBBLE_CHECK_STATE: currentWetSelfTestsState = handleWetSelfTestBubblesState(); break; @@ -660,6 +676,11 @@ // Self-tests flags should be handled by now, reset if flags not handled with current state resetSelfTestsFlags(); + + if ( priorSubState != currentWetSelfTestsState ) + { + SEND_EVENT_WITH_2_U32_DATA( HD_EVENT_SUB_STATE_CHANGE, priorSubState, currentWetSelfTestsState ); + } } /*********************************************************************//** @@ -733,7 +754,7 @@ for ( valve = VDI; valve < NUM_OF_VALVES; ++valve ) { - homeValve( valve ); + homeValve( valve, VALVE_FORCE_HOME, VALVE_NO_CARTRIDGE_PRESENT ); } if ( TRUE == doesAlarmStatusIndicateStop() ) @@ -757,19 +778,27 @@ NO_CART_SELF_TESTS_STATE_T state = NO_CART_SELF_TESTS_HOME_SYRINGE_PUMP_STATE; BOOL syringeHome = isSyringePumpHome(); BOOL syringeStopped = isSyringePumpStopped(); - BOOL syringePreload = isSyringePumpPreLoaded(); + BOOL syringePreloaded = isSyringePumpPreLoaded(); if ( TRUE == useHeparin ) { - if ( ( TRUE != syringeHome ) && ( TRUE == syringeStopped ) && ( FALSE == syringePreload ) ) + if ( ( TRUE != syringeHome ) && ( TRUE == syringeStopped ) && ( FALSE == syringePreloaded ) ) { retractSyringePump(); } - else if ( ( TRUE == syringeHome ) && ( TRUE == syringeStopped ) && ( FALSE == syringePreload ) ) + else if ( ( TRUE == syringeHome ) && ( TRUE == syringeStopped ) && ( FALSE == syringePreloaded ) ) { - preloadSyringePlunger(); + // Is syringe loaded? + if ( TRUE == isSyringeDetected() ) + { + activateAlarmNoData( ALARM_ID_HD_SYRINGE_DETECTED ); + } + else + { + preloadSyringePlunger(); + } } - else if ( TRUE == syringePreload ) + else if ( TRUE == syringePreloaded ) { state = NO_CART_SELF_TESTS_PUMPS_STATE; } @@ -874,6 +903,7 @@ { NO_CART_SELF_TESTS_STATE_T state = NO_CART_SELF_TESTS_STOPPED_STATE; + setAlarmResumePerDoorAndLatch(); doorClosedRequired( FALSE, FALSE ); // Restart self-test start time @@ -893,6 +923,62 @@ /*********************************************************************//** * @brief + * The handleDrySelfTestStartState function makes sure door is + * closed before starting self-tests. + * @details Inputs: none + * @details Outputs: none + * @return the next state of dry self-tests state machine + *************************************************************************/ +static DRY_SELF_TESTS_STATE_T handleDrySelfTestStartState( void ) +{ + DRY_SELF_TESTS_STATE_T state = DRY_SELF_TESTS_START_STATE; + OPN_CLS_STATE_T pumpTrack = getSwitchStatus( PUMP_TRACK_SWITCH ); + + if ( STATE_CLOSED == pumpTrack ) + { + // Ensure occlusion sensor has time to settle after cartridge insertion before starting dry self-tests + if ( TRUE == didTimeout( selfTestCartridgeSettleTime, CARTRIDGE_INSERT_PRESSURE_SETTLE_TIME_MS ) ) + { + setOcclusionInstallLevel(); // Record occlusion pressure level after a new cartridge is installed + doorClosedRequired( TRUE, TRUE ); +#ifndef _RELEASE_ + if ( SW_CONFIG_ENABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_DISABLE_DRY_SELF_TESTS ) ) + { + signalAllowDGFlushFills(); + signalAllowDGFillRes1(); + signalAllowDGFillRes2(); + state = DRY_SELF_TESTS_SYRINGE_PUMP_PRIME_STATE; + } + else +#endif + { +#ifndef _RELEASE_ + if ( SW_CONFIG_DISABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_DISABLE_AIR_PUMP ) ) // Allow res 1&2 fills now if air pump not disabled +#endif + { + signalAllowDGFillRes1(); + signalAllowDGFillRes2(); + } + state = DRY_SELF_TESTS_WAIT_FOR_DOOR_CLOSE_STATE; + } + } + } + + else + { + // doorClosedRequired() will trigger alarms if pumpTrack is open + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + state = DRY_SELF_TESTS_STOPPED_STATE; + setupForSelfTestsStop(); + } + } + + return state; +} + +/*********************************************************************//** + * @brief * The handleDrySelfTestWaitForDoorCloseState function makes sure door is * closed before starting self-tests. * @details Inputs: none @@ -908,8 +994,7 @@ // Restart self-test start time selfTestStartTime = getMSTimerCount(); - // TODO: Use appropriate sensor driver - if (( STATE_CLOSED == frontDoor ) && (STATE_CLOSED == pumpTrack ) ) + if ( ( STATE_CLOSED == frontDoor ) && ( STATE_CLOSED == pumpTrack ) ) { state = DRY_SELF_TESTS_USED_CARTRIDGE_CHECK_STATE; setValvePosition( VDI, VALVE_POSITION_C_CLOSE ); @@ -946,20 +1031,20 @@ ( AIR_TRAP_LEVEL_AIR == getAirTrapLevel( AIR_TRAP_LEVEL_SENSOR_LOWER ) ) && ( AIR_TRAP_LEVEL_AIR == getAirTrapLevel( AIR_TRAP_LEVEL_SENSOR_UPPER ) ) ) { - state = DRY_SELF_TESTS_OCCLUSION_SENSORS_STATE; + state = DRY_SELF_TESTS_CARTRIDGE_LOADED_CHECK_STATE; } else { #ifndef _RELEASE_ if ( getSoftwareConfigStatus( SW_CONFIG_ENABLE_WORN_OUT_CARTRIDGE ) != SW_CONFIG_ENABLE_VALUE ) #endif { - activateAlarmNoData( ALARM_ID_INSTALL_NEW_CARTRIDGE ); + activateAlarmNoData( ALARM_ID_HD_INSTALL_NEW_CARTRIDGE ); } #ifndef _RELEASE_ else { - state = DRY_SELF_TESTS_OCCLUSION_SENSORS_STATE; + state = DRY_SELF_TESTS_CARTRIDGE_LOADED_CHECK_STATE; } #endif } @@ -975,9 +1060,41 @@ /*********************************************************************//** * @brief + * The handleDrySelfTestCartridgeLoadedCheckState function verifies a cartridge + * is installed by checking sufficient pressure at OB sensor. + * @details Inputs: none + * @details Outputs: none + * @return the next state of dry self-tests state machine + *************************************************************************/ +static DRY_SELF_TESTS_STATE_T handleDrySelfTestCartridgeLoadedCheckState( void ) +{ + DRY_SELF_TESTS_STATE_T state = DRY_SELF_TESTS_USED_CARTRIDGE_CHECK_STATE; + + if ( SELF_TEST_STATUS_PASSED == execPresOcclDryTest() ) + { + setValvePosition( VDI, VALVE_POSITION_C_CLOSE ); + setValvePosition( VDO, VALVE_POSITION_C_CLOSE ); + setValvePosition( VBA, VALVE_POSITION_C_CLOSE ); + setValvePosition( VBV, VALVE_POSITION_C_CLOSE ); + setValveAirTrap( STATE_OPEN ); + pressureSelfTestPreNormalStartTime = getMSTimerCount(); + state = DRY_SELF_TESTS_PRESSURE_SENSORS_NORMAL_SETUP_STATE; + } + + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + state = DRY_SELF_TESTS_STOPPED_STATE; + setupForSelfTestsStop(); + } + + return state; +} + +/*********************************************************************//** + * @brief * The handleDrySelfTestPressureSensorsSetupState function handles the setup * for pressure sensors dry self-test. - * @details Inputs: none + * @details Inputs: pressureSelfTestPreNormalStartTime * @details Outputs: none * @return the next state of dry self-tests state machine *************************************************************************/ @@ -999,30 +1116,37 @@ // Wait for reservoirs to drain before starting this test if ( ( getLoadCellWeight( LOAD_CELL_RESERVOIR_1_PRIMARY ) < MAX_EMPTY_RESERVOIR_WEIGHT_G ) && ( getLoadCellWeight( LOAD_CELL_RESERVOIR_2_PRIMARY ) < MAX_EMPTY_RESERVOIR_WEIGHT_G ) ) { - // TODO - wait 1 sec before taking pressure readings and beginning pressure check - previousNormalArterialPressure = getFilteredArterialPressure(); - previousNormalVenousPressure = getFilteredVenousPressure(); - state = DRY_SELF_TESTS_PRESSURE_SENSORS_VENOUS_SETUP_STATE; - - // Check to see if sensor is within normal ranges before we execute pressure sensor tests - if ( ( fabs( previousNormalArterialPressure ) > PRESSURE_CHECK_START_PRESSURE_TOLERANCE_MMHG ) || ( fabs( previousNormalVenousPressure ) > PRESSURE_CHECK_START_PRESSURE_TOLERANCE_MMHG ) ) + if ( TRUE == didTimeout( pressureSelfTestPreNormalStartTime, PRE_NORMAL_PRESSURE_SELF_TEST_DELAY_MS ) ) { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_PRE_TREATMENT_DRY_PRESSURE_TEST_FAILURE, previousNormalArterialPressure, previousNormalVenousPressure ); + previousNormalArterialPressure = getFilteredArterialPressure(); + previousNormalVenousPressure = getFilteredVenousPressure(); + state = DRY_SELF_TESTS_PRESSURE_SENSORS_VENOUS_SETUP_STATE; + + // Check to see if sensor is within normal ranges before we execute pressure sensor tests + if ( ( fabs( previousNormalArterialPressure ) > PRESSURE_CHECK_START_PRESSURE_TOLERANCE_MMHG ) || ( fabs( previousNormalVenousPressure ) > PRESSURE_CHECK_START_PRESSURE_TOLERANCE_MMHG ) ) + { + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_PRE_TREATMENT_DRY_PRESSURE_TEST_FAILURE, previousNormalArterialPressure, previousNormalVenousPressure ); + } } } } else #endif { - // TODO - wait 1 sec before taking pressure readings and beginning pressure check - previousNormalArterialPressure = getFilteredArterialPressure(); - previousNormalVenousPressure = getFilteredVenousPressure(); - state = DRY_SELF_TESTS_PRESSURE_SENSORS_VENOUS_SETUP_STATE; + if ( TRUE == didTimeout( pressureSelfTestPreNormalStartTime, PRE_NORMAL_PRESSURE_SELF_TEST_DELAY_MS ) ) + { // Record baseline pressures before pressurizing blood side circuit side of cartridge + previousNormalArterialPressure = getFilteredArterialPressure(); + previousNormalVenousPressure = getFilteredVenousPressure(); - // Check to see if sensor is within normal ranges before we execute pressure sensor tests - if ( ( fabs( previousNormalArterialPressure ) > PRESSURE_CHECK_START_PRESSURE_TOLERANCE_MMHG ) || ( fabs( previousNormalVenousPressure ) > PRESSURE_CHECK_START_PRESSURE_TOLERANCE_MMHG ) ) - { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_PRE_TREATMENT_DRY_PRESSURE_TEST_FAILURE, previousNormalArterialPressure, previousNormalVenousPressure ); + // Check to see if sensor is within normal ranges before we execute pressure sensor tests + if ( ( fabs( previousNormalArterialPressure ) > PRESSURE_CHECK_START_PRESSURE_TOLERANCE_MMHG ) || ( fabs( previousNormalVenousPressure ) > PRESSURE_CHECK_START_PRESSURE_TOLERANCE_MMHG ) ) + { + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_PRE_TREATMENT_DRY_PRESSURE_TEST_FAILURE, previousNormalArterialPressure, previousNormalVenousPressure ); + } + else + { + state = DRY_SELF_TESTS_PRESSURE_SENSORS_VENOUS_SETUP_STATE; + } } } @@ -1117,11 +1241,13 @@ if ( TRUE == didTimeout( pressureSelfTestVenousTestStartTime, VENOUS_PRESSURE_SELF_TEST_MAX_TEST_TIME ) ) { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_PRE_TREATMENT_DRY_PRESSURE_TEST_FAILURE, venousPressure, VENOUS_PRESSURE_SELF_TEST_HIGH_LIMIT_MMHG ); + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_PRE_TREATMENT_DRY_PRESSURE_TEST_FAILURE, venousPressure, VENOUS_PRESSURE_SELF_TEST_FIRST_PASS_LIMIT_MMHG ); + setAirPumpState( AIR_PUMP_STATE_OFF ); } if ( TRUE == doesAlarmStatusIndicateStop() ) { + setAirPumpState( AIR_PUMP_STATE_OFF ); state = DRY_SELF_TESTS_STOPPED_STATE; setupForSelfTestsStop(); } @@ -1189,7 +1315,7 @@ if ( TRUE == didTimeout( pressureSelfTestBloodPumpRunStartTime, BLOOD_PUMP_RUN_TIME_PRESSURE_SELF_TEST ) ) { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_PRE_TREATMENT_DRY_PRESSURE_TEST_FAILURE, venousPressure, arterialPressure ); + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_PRE_TREATMENT_DRY_PRESSURE_TEST_FAILURE, venousPressure, arterialPressure ); } if ( TRUE == doesAlarmStatusIndicateStop() ) @@ -1224,11 +1350,10 @@ // update peak pressure value from pressurized state // if pressure continues to increase due to filter lag. // Arterial goes negative while Venous goes positive. - if (arterialPressure < peakArterialPressure ) + if ( arterialPressure < peakArterialPressure ) { peakArterialPressure = arterialPressure; } - if ( venousPressure > peakVenousPressure ) { peakVenousPressure = venousPressure; @@ -1249,7 +1374,7 @@ } else { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_PRE_TREATMENT_DRY_PRESSURE_TEST_FAILURE, arterialDecayDiff, venousDecayDiff ); + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_PRE_TREATMENT_DRY_PRESSURE_TEST_FAILURE, arterialDecayDiff, venousDecayDiff ); } } @@ -1292,7 +1417,7 @@ } else { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_PRE_TREATMENT_DRY_PRESSURE_TEST_FAILURE, arterialStabilityDiff, venousStabilityDiff ); + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_PRE_TREATMENT_DRY_PRESSURE_TEST_FAILURE, arterialStabilityDiff, venousStabilityDiff ); } } @@ -1309,7 +1434,7 @@ * @brief * The handleDrySelfTestPressureSensorsNormalState function verify the readings of * pressure sensors after returning to normal state. - * @details Inputs: none + * @details Inputs: pressureSelfTestNormalizedStartTime * @details Outputs: none * @return the next state of dry self-tests state machine *************************************************************************/ @@ -1320,26 +1445,42 @@ F32 const arterialPressureDiff = fabs( getFilteredArterialPressure() - previousNormalArterialPressure ); F32 const venousPressureDiff = fabs( getFilteredVenousPressure() - previousNormalVenousPressure ); - // open VDI to Pos A after timer threshold - if ( TRUE == didTimeout( pressureSelfTestNormalizedStartTime, NORMALIZED_PRESSURE_SELF_TEST_VDI_TIMER ) ) +#ifndef _RELEASE_ + if ( SW_CONFIG_ENABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_DISABLE_AIR_PUMP ) ) { - setValvePosition( VDI, VALVE_POSITION_A_INSERT_EJECT ); + // open VDI to Pos A after timer threshold + if ( TRUE == didTimeout( pressureSelfTestNormalizedStartTime, NORMALIZED_PRESSURE_SELF_TEST_VDI_TIMER ) ) + { + setValvePosition( VDI, VALVE_POSITION_A_INSERT_EJECT ); + } + // open air trap after time threshold. + if ( TRUE == didTimeout( pressureSelfTestNormalizedStartTime, NORMALIZED_PRESSURE_SELF_TEST_VBT_TIMERX ) ) + { + setValveAirTrap( STATE_OPEN ); + } } - - // open air trap after time threshold. - if ( TRUE == didTimeout( pressureSelfTestNormalizedStartTime, NORMALIZED_PRESSURE_SELF_TEST_VBT_TIMER ) ) + else +#endif { - setValveAirTrap( STATE_OPEN ); + // open air trap after time threshold. + if ( TRUE == didTimeout( pressureSelfTestNormalizedStartTime, NORMALIZED_PRESSURE_SELF_TEST_VBT_TIMER ) ) + { + setValveAirTrap( STATE_OPEN ); + } } - if ( ( arterialPressureDiff <= NORMAL_PRESSURE_DIFF_TOLERANCE_MMHG ) && ( venousPressureDiff <= NORMAL_PRESSURE_DIFF_TOLERANCE_MMHG ) ) + // After VBT opened, start looking to see if pressures normalize + if ( ( STATE_OPEN == getValveAirTrapStatus() ) && + ( arterialPressureDiff <= NORMAL_PRESSURE_DIFF_TOLERANCE_MMHG ) && ( venousPressureDiff <= NORMAL_PRESSURE_DIFF_TOLERANCE_MMHG ) ) { + dryPressureTestsCompleted = TRUE; state = DRY_SELF_TESTS_SYRINGE_PUMP_PRIME_STATE; } + // If pressures do not normalize within max t/o, alarm if ( TRUE == didTimeout( pressureSelfTestNormalizedStartTime, NORMALIZED_PRESSURE_SELF_TEST_TIME ) ) { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_PRE_TREATMENT_DRY_PRESSURE_NORMAL_TEST_FAILURE, arterialPressureDiff, venousPressureDiff ); + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_PRE_TREATMENT_DRY_PRESSURE_NORMAL_TEST_FAILURE, arterialPressureDiff, venousPressureDiff ); } if ( TRUE == doesAlarmStatusIndicateStop() ) @@ -1373,7 +1514,6 @@ { state = DRY_SELF_TESTS_SYRINGE_PUMP_OCCLUSION_DETECTION_STATE; syringeOcclusionDelayStartTime = getMSTimerCount(); // Get the current time to check for occlusion after 3 seconds has elapsed - signalActionToResumeFill(); } else { @@ -1388,14 +1528,13 @@ } else { - SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, (U32)SW_FAULT_ID_HD_SYRINGE_NOT_PRELOADED ) + preloadSyringePlunger(); } } } } else { - signalActionToResumeFill(); state = DRY_SELF_TESTS_COMPLETE_STATE; } @@ -1405,6 +1544,19 @@ setupForSelfTestsStop(); } +#ifndef _RELEASE_ + if ( ( SW_CONFIG_ENABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_DISABLE_AIR_PUMP ) ) || // Allow res 1&2 fills now if air pump not disabled + ( SW_CONFIG_ENABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_DISABLE_DRY_SELF_TESTS ) ) ) + { + if ( state != DRY_SELF_TESTS_SYRINGE_PUMP_PRIME_STATE ) + { + signalAllowDGFlushFills(); + signalAllowDGFillRes1(); + signalAllowDGFillRes2(); + } + } +#endif + return state; } @@ -1422,10 +1574,8 @@ if ( TRUE == didTimeout( syringeOcclusionDelayStartTime, SYRINGE_PUMP_OCCLUSION_CHECK_DELAY ) ) { - if ( FALSE == checkForPrimeOcclusion() ) // transition to complete state only when occlusion is removed + if ( FALSE == checkForSyringeOcclusion() ) // transition to complete state only when occlusion is removed { - // clear the occlusion alarm condition to allow user to resume - clearAlarmCondition( ALARM_ID_HD_SYRINGE_PUMP_OCCLUSION ); // Resume option will appear state = DRY_SELF_TESTS_COMPLETE_STATE; } } @@ -1451,24 +1601,53 @@ { DRY_SELF_TESTS_STATE_T state = DRY_SELF_TESTS_STOPPED_STATE; + setAlarmResumePerDoorAndLatch(); doorClosedRequired( FALSE, FALSE ); - // Restart self-test start time - selfTestStartTime = getMSTimerCount(); + // if not enough heparin alarm, pre-load pusher after retract completes + if ( TRUE == isAlarmActive( ALARM_ID_HD_SYRINGE_PUMP_NOT_ENOUGH_HEPARIN_ALARM ) ) + { // prevent resume until syringe is retracted and pre-loaded + setAlarmUserActionEnabled( ALARM_USER_ACTION_RESUME, FALSE ); + if ( isSyringePumpRunning() != TRUE ) + { + if ( TRUE == isSyringePumpHome() ) + { + preloadSyringePlunger(); + } + else if ( TRUE == isSyringePumpPreLoaded() ) + { + setAlarmUserActionEnabled( ALARM_USER_ACTION_RESUME, TRUE ); + } + } + } + // if resume request, resume dry self-tests if ( TRUE == selfTestsResumeRequested ) { + // Restart self-test start time + selfTestStartTime = getMSTimerCount(); selfTestsResumeRequested = FALSE; - doorClosedRequired( TRUE, TRUE ); + selfTestCartridgeSettleTime = getMSTimerCount(); + #ifndef _RELEASE_ if ( SW_CONFIG_ENABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_DISABLE_DRY_SELF_TESTS ) ) { + doorClosedRequired( TRUE, TRUE ); state = DRY_SELF_TESTS_SYRINGE_PUMP_PRIME_STATE; } else #endif - { - state = DRY_SELF_TESTS_WAIT_FOR_DOOR_CLOSE_STATE; + { // if we've completed pressure testing, resume to syringe pump prime state, otherwise go back to start of dry self-tests + if ( TRUE == dryPressureTestsCompleted ) + { + doorClosedRequired( TRUE, TRUE ); + state = DRY_SELF_TESTS_SYRINGE_PUMP_PRIME_STATE; + } + else + { + doorClosedRequired( FALSE, TRUE ); + state = DRY_SELF_TESTS_START_STATE; + } } } @@ -1479,21 +1658,19 @@ * @brief * The handleWetSelfTestStartState function handles setup state for wet * self-tests sub-mode. - * @details Inputs: reservoir one weight - * @details Outputs: setup valves and dialysate inlet pump + * @details Inputs: heparin bolus volume setting + * @details Outputs: setup valves * @return the next state of wet self-tests state machine *************************************************************************/ static WET_SELF_TESTS_STATE_T handleWetSelfTestStartState( void ) { - WET_SELF_TESTS_STATE_T state = WET_SELF_TESTS_SETUP_STATE; - F32 resOneWeight = getReservoirWeightLargeFilter( DG_RESERVOIR_1 ); + WET_SELF_TESTS_STATE_T state = WET_SELF_TESTS_BUBBLE_CHECK_SETUP_STATE; F32 bolusVol = getTreatmentParameterF32( TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME ); - isValvesSettingSent = TRUE; setValvePosition( VDI, VALVE_POSITION_C_CLOSE ); setValvePosition( VDO, VALVE_POSITION_C_CLOSE ); - fmdIntegratedVolume = 0.0F; + // if user set a Heparin bolus volume, request bolus to be initiated now if ( ( bolusVol > 0.0F ) && ( getSyringePumpVolumeDelivered() < bolusVol ) ) { startHeparinBolus(); // moved here from startHeparinPump() in Dialysis.c @@ -1510,15 +1687,15 @@ /*********************************************************************//** * @brief - * The handleWetSelfTestSetupState function setup reservoir one before - * the start of wet self-tests. - * @details Inputs: dialysate inlet flow rate - * @details Outputs: stop dialysate inlet pump + * The handleWetSelfTestSetupState function setup for bubble self-test + * check. + * @details Inputs: none + * @details Outputs: bubble detector self-test requested * @return the next state of wet self-tests state machine *************************************************************************/ static WET_SELF_TESTS_STATE_T handleWetSelfTestSetupState( void ) { - WET_SELF_TESTS_STATE_T state = WET_SELF_TESTS_BUBBLES_STATE; + WET_SELF_TESTS_STATE_T state = WET_SELF_TESTS_BUBBLE_CHECK_STATE; selfTestBubble( ADV ); @@ -1541,7 +1718,7 @@ *************************************************************************/ static WET_SELF_TESTS_STATE_T handleWetSelfTestBubblesState( void ) { - WET_SELF_TESTS_STATE_T state = WET_SELF_TESTS_BUBBLES_STATE; + WET_SELF_TESTS_STATE_T state = WET_SELF_TESTS_BUBBLE_CHECK_STATE; if ( SELF_TEST_STATUS_PASSED == getBubbleSelfTestStatus( ADV ) ) { @@ -1579,7 +1756,7 @@ else { #ifndef _RELEASE_ - if ( ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_BLOOD_LEAK_SELF_TEST ) == SW_CONFIG_ENABLE_VALUE ) ) + if ( ( SW_CONFIG_ENABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_DISABLE_BLOOD_LEAK_SELF_TEST ) ) ) { state = WET_SELF_TESTS_FIRST_DISPLACEMENT_SETUP_STATE; } @@ -1592,7 +1769,7 @@ } else { - activateAlarmNoData( ALARM_ID_PRE_TREATMENT_WET_PRIME_TEST_FAILURE ); + activateAlarmNoData( ALARM_ID_HD_PRE_TREATMENT_WET_PRIME_TEST_FAILURE ); } if ( TRUE == doesAlarmStatusIndicateStop() ) @@ -1656,12 +1833,13 @@ if ( ( TRUE == isValvesSettingSent ) && ( TRUE == getDGCommandResponse( DG_CMD_VALVE_SETTING, &cmdResp ) ) ) { - // Re-send command if DG rejects isValvesSettingSent = FALSE; + // Re-send command if DG rejects if ( DG_CMD_REQUEST_REJECT_REASON_NONE == cmdResp.rejectCode ) { setDialInPumpTargetFlowRate( DIP_FLOW_RATE_FIRST_DISPLACEMENT_ML_MIN, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP ); + cmdStartDGTrimmerHeater(); settleStartTime = getMSTimerCount(); state = WET_SELF_TESTS_FIRST_DISPLACEMENT_STATE; } @@ -1688,29 +1866,30 @@ { WET_SELF_TESTS_STATE_T state = WET_SELF_TESTS_FIRST_DISPLACEMENT_STATE; - if ( ( TRUE == didTimeout( settleStartTime, RESERVOIR_SETTLE_TIME_MS ) ) && ( settleStartTime != 0 ) ) - { - reservoirVolume[ DG_RESERVOIR_1 ] = getReservoirWeight( DG_RESERVOIR_1 ); - reservoirVolume[ DG_RESERVOIR_2 ] = getReservoirWeight( DG_RESERVOIR_2 ); - displacementStartTime = getMSTimerCount(); - fmdIntegratedVolume = 0.0F; - settleStartTime = 0; - } - + // Once we've settled (5 sec), integrate flow to volume over duration of fluid transfer if ( 0 == settleStartTime ) { - // This is not a volume for now and it is a flow rate. - fmdIntegratedVolume += getMeasuredDialInFlowRate(); + fmdIntegratedVolume += ( getMeasuredDialInFlowRate() / (F32)( ( SEC_PER_MIN * MS_PER_SECOND ) / TASK_GENERAL_INTERVAL ) ); if ( TRUE == didTimeout( displacementStartTime, WET_SELF_TEST_FIRST_DISPLACEMENT_TIME_MS ) ) { signalDialInPumpHardStop(); - fmdIntegratedVolume = ( ( fmdIntegratedVolume * TASK_GENERAL_INTERVAL ) / ( WET_SELF_TEST_FIRST_DISPLACEMENT_TIME_MS ) ); + cmdStopDGTrimmerHeater(); settleStartTime = getMSTimerCount(); state = WET_SELF_TESTS_FIRST_DISPLACEMENT_VERIFY_STATE; } } + // Wait for settle time, then initiate transfer test + if ( ( TRUE == didTimeout( settleStartTime, RESERVOIR_SETTLE_TIME_MS ) ) && ( settleStartTime != 0 ) ) + { + reservoirVolume[ DG_RESERVOIR_1 ] = getReservoirWeight( DG_RESERVOIR_1 ); + reservoirVolume[ DG_RESERVOIR_2 ] = getReservoirWeight( DG_RESERVOIR_2 ); + displacementStartTime = getMSTimerCount(); + fmdIntegratedVolume = 0.0F; + settleStartTime = 0; + } + if ( TRUE == doesAlarmStatusIndicateStop() ) { state = WET_SELF_TESTS_STOPPED_STATE; @@ -1741,7 +1920,7 @@ #ifndef _RELEASE_ if ( SW_CONFIG_ENABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_ENABLE_WET_SELF_TEST_WIDER_VOLUME_TOL ) ) { - integrateVolumeToleranceG = 50.0F; + integrateVolumeToleranceG = WET_SELF_TEST_INTEGRATED_VOLUME_WIDER_TOLERANCE; } #endif @@ -1758,11 +1937,11 @@ { if ( fabs( resOneDiffAfterDisplacement - resTwoDiffAfterDisplacement) > WET_SELF_TEST_DISPLACEMENT_TOLERANCE_G ) { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_PRE_TREATMENT_WET_LC_TEST_FAILURE, resOneDiffAfterDisplacement, resTwoDiffAfterDisplacement ); + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_PRE_TREATMENT_WET_LC_TEST_FAILURE, resOneDiffAfterDisplacement, resTwoDiffAfterDisplacement ); } else { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_PRE_TREATMENT_WET_FLOW_TEST_FAILURE, averageDisp, fmdIntegratedVolume ); + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_PRE_TREATMENT_WET_FLOW_TEST_FAILURE, averageDisp, fmdIntegratedVolume ); } } @@ -1799,12 +1978,13 @@ if ( ( TRUE == isValvesSettingSent ) && ( TRUE == getDGCommandResponse( DG_CMD_VALVE_SETTING, &cmdResp ) ) ) { - // Re-send command if DG rejects isValvesSettingSent = FALSE; + // Re-send command if DG rejects if ( DG_CMD_REQUEST_REJECT_REASON_NONE == cmdResp.rejectCode ) { setDialInPumpTargetFlowRate( DIP_FLOW_RATE_SECOND_DISPLACEMENT_ML_MIN, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP ); + cmdStartDGTrimmerHeater(); settleStartTime = getMSTimerCount(); state = WET_SELF_TESTS_SECOND_DISPLACEMENT_STATE; } @@ -1842,12 +2022,12 @@ if ( 0 == settleStartTime ) { - fmdIntegratedVolume += getMeasuredDialInFlowRate(); + fmdIntegratedVolume += ( getMeasuredDialInFlowRate() / (F32)( ( SEC_PER_MIN * MS_PER_SECOND ) / TASK_GENERAL_INTERVAL ) ); if ( TRUE == didTimeout( displacementStartTime, WET_SELF_TEST_SECOND_DISPLACEMENT_TIME_MS ) ) { signalDialInPumpHardStop(); - fmdIntegratedVolume = ( ( fmdIntegratedVolume * TASK_GENERAL_INTERVAL ) / ( WET_SELF_TEST_SECOND_DISPLACEMENT_TIME_MS ) ); + cmdStopDGTrimmerHeater(); settleStartTime = getMSTimerCount(); state = WET_SELF_TESTS_SECOND_DISPLACEMENT_VERIFY_STATE; } @@ -1883,7 +2063,7 @@ #ifndef _RELEASE_ if ( SW_CONFIG_ENABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_ENABLE_WET_SELF_TEST_WIDER_VOLUME_TOL ) ) { - integrateVolumeToleranceG = 50.0F; + integrateVolumeToleranceG = WET_SELF_TEST_INTEGRATED_VOLUME_WIDER_TOLERANCE; } #endif @@ -1900,11 +2080,11 @@ { if ( fabs( resOneDiffAfterDisplacement - resTwoDiffAfterDisplacement) > WET_SELF_TEST_DISPLACEMENT_TOLERANCE_G ) { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_PRE_TREATMENT_WET_LC_TEST_FAILURE, resOneDiffAfterDisplacement, resTwoDiffAfterDisplacement ); + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_PRE_TREATMENT_WET_LC_TEST_FAILURE, resOneDiffAfterDisplacement, resTwoDiffAfterDisplacement ); } else { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_PRE_TREATMENT_WET_FLOW_TEST_FAILURE, avgDisp, fmdIntegratedVolume ); + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_PRE_TREATMENT_WET_FLOW_TEST_FAILURE, avgDisp, fmdIntegratedVolume ); } } @@ -1929,13 +2109,14 @@ { WET_SELF_TESTS_STATE_T state = WET_SELF_TESTS_STOPPED_STATE; + setAlarmResumePerDoorAndLatch(); doorClosedRequired( FALSE, FALSE ); if ( TRUE == selfTestsResumeRequested ) { doorClosedRequired( TRUE, TRUE ); selfTestsResumeRequested = FALSE; - state = WET_SELF_TESTS_START_STATE; + state = WET_SELF_TESTS_START_STATE; // TODO - should start state make sure there is sufficient/appropriate res volumes to restart wet self-tests? and if not, should it signal res mgmt to drain and fill R1 and R2 before resuming wet self-tests? } return state;