Index: firmware/App/Modes/ModePreTreat.c =================================================================== diff -u -rf1d120886e090e82cef5b31d371db9ac294d3479 -rf760ffc4b10556e5186e9ceb90294262063440ca --- firmware/App/Modes/ModePreTreat.c (.../ModePreTreat.c) (revision f1d120886e090e82cef5b31d371db9ac294d3479) +++ firmware/App/Modes/ModePreTreat.c (.../ModePreTreat.c) (revision f760ffc4b10556e5186e9ceb90294262063440ca) @@ -1,14 +1,14 @@ /************************************************************************** * -* Copyright (c) 2019-2022 Diality Inc. - All Rights Reserved. +* Copyright (c) 2019-2023 Diality Inc. - All Rights Reserved. * * THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN * WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. * * @file ModePreTreat.c * -* @author (last) Dara Navaei -* @date (last) 19-Sep-2022 +* @author (last) Sean Nash +* @date (last) 31-Jan-2023 * * @author (original) Dara Navaei * @date (original) 05-Nov-2019 @@ -47,8 +47,8 @@ #define DIP_PATIENT_CONNECTION_FLOW_RATE_ML_MIN 250 ///< Patient connection sub-mode dialysate inlet pump flow rate in mL/min. #define PRE_TREATMENT_FLUSH_RESERVOIR_VOLUME_ML 500 ///< Fill reservoir to this volume (in mL) to flush filter and lines. -#define PRE_TREATMENT_FILL_RESERVOIR_ONE_VOLUME_ML 1300 ///< Fill reservoir one to this volume (in mL) during pre-treatment mode. -#define PRE_TREATMENT_FILL_RESERVOIR_TWO_VOLUME_ML 700 ///< Fill reservoir two to this volume (in mL) during pre-treatment mode. +#define PRE_TREATMENT_FILL_RESERVOIR_ONE_VOLUME_ML 900 ///< Fill reservoir one to this volume (in mL) during pre-treatment mode. +#define PRE_TREATMENT_FILL_RESERVOIR_TWO_VOLUME_ML 1100 ///< Fill reservoir two to this volume (in mL) during pre-treatment mode. /// States of the pre-treatment reservoir management state machine. typedef enum PreTreatmentReservoirMgmt_States @@ -59,7 +59,8 @@ PRE_TREATMENT_RESERVOIR_MGMT_START_FILL_STATE, ///< Command DG to start filling reservoir PRE_TREATMENT_RESERVOIR_MGMT_FILL_CMD_RESP_STATE, ///< After sending fill command, process DG fill command response PRE_TREATMENT_RESERVOIR_MGMT_FILL_COMPLETE_STATE, ///< Reservoir fill has completed - PRE_TREATMENT_RESERVOIR_MGMT_WAIT_FOR_RESERVOIR_SWITCH_STATE, ///< Wait for prime operation to switch reservoir + PRE_TREATMENT_RESERVOIR_MGMT_REQUEST_RESERVOIR_SWITCH_STATE, ///< Command DG to switch (toggle) reservoirs + PRE_TREATMENT_RESERVOIR_MGMT_WAIT_FOR_RESERVOIR_SWITCH_STATE, ///< After sending switch command, process DG fill command response PRE_TREATMENT_RESERVOIR_MGMT_COMPLETE_STATE, ///< Pre-treatment reservoir management complete state NUM_OF_PRE_TREATMENT_RESERVOIR_MGMT_STATES ///< Number of pre-treatments reservoir mgmt. states } PRE_TREATMENT_RESERVOIR_MGMT_STATE_T; @@ -75,15 +76,17 @@ static BOOL alarmActionResumeReceived = FALSE; ///< Flag indicates alarm action resume received. static HD_PRE_TREATMENT_MODE_STATE_T currentPreTreatmentState; ///< Current state of pre-treatment mode state machine. +static BOOL fillReservoirOneStartRequested; ///< Flag indicates fill reservoir one has been requested. static U32 preTreatmentPublishTimerCounter; ///< Pre-treatment data broadcast timer counter used to schedule when to transmit data. /// Interval (in task intervals) at which to publish pre-treatment mode data to CAN bus. static OVERRIDE_U32_T preTreatmentModePublishInterval = { PRE_TREATMENT_DATA_PUB_INTERVAL, PRE_TREATMENT_DATA_PUB_INTERVAL, PRE_TREATMENT_DATA_PUB_INTERVAL, 0 }; static U32 submodeCompleteTransitionTimeCounter; ///< Sub-mode completed transition wait time counter. static PRE_TREATMENT_RESERVOIR_MGMT_STATE_T currentReservoirMgmtState; ///< Current pre-treatment reservoir management state. -static BOOL fillReservoirOneStartRequested; ///< Flag indicates fill reservoir one has been requested. static BOOL reservoirFilledStatus[ NUM_OF_DG_RESERVOIRS ]; ///< Flag indicates a reservoir has been filled. static BOOL reservoirFlushedStatus[ NUM_OF_DG_RESERVOIRS ]; ///< Flag indicates a reservoir has been flushed. +static PRE_TREATMENT_RESERVOIR_FLAGS_T reservoirFlags[ NUM_OF_DG_RESERVOIRS ]; ///< Set of Flags that signal if the DG should wait to fill. +static BOOL initialReservoirDrain[ NUM_OF_DG_RESERVOIRS ]; ///< Flags indicate whether a reservoir has been requested to initially drain. // ********** private function prototypes ********** @@ -108,7 +111,9 @@ static PRE_TREATMENT_RESERVOIR_MGMT_STATE_T handlePreTreatmentReservoirMgmtFillCmdState( void ); static PRE_TREATMENT_RESERVOIR_MGMT_STATE_T handlePreTreatmentReservoirMgmtFillCmdRespState( void ); static PRE_TREATMENT_RESERVOIR_MGMT_STATE_T handlePreTreatmentReservoirMgmtFillCompleteState( void ); +static PRE_TREATMENT_RESERVOIR_MGMT_STATE_T handlePreTreatmentReservoirMgmtRequestReservoirSwitchState( void ); static PRE_TREATMENT_RESERVOIR_MGMT_STATE_T handlePreTreatmentReservoirMgmtWaitReservoirSwitchState( void ); +static U32 getPreTreatmentFillVolume( DG_RESERVOIR_ID_T inactiveRes ); /*********************************************************************//** * @brief @@ -119,7 +124,7 @@ *************************************************************************/ void initPreTreatmentMode( void ) { - currentPreTreatmentState = HD_PRE_TREATMENT_START_STATE; + currentPreTreatmentState = HD_PRE_TREATMENT_WATER_SAMPLE_STATE; currentReservoirMgmtState = PRE_TREATMENT_RESERVOIR_MGMT_START_STATE; setUFVolStatus = FALSE; patientConnectionConfirm = FALSE; @@ -128,7 +133,17 @@ reservoirFilledStatus[ DG_RESERVOIR_1 ] = FALSE; reservoirFilledStatus[ DG_RESERVOIR_2 ] = FALSE; + reservoirFlushedStatus[ DG_RESERVOIR_1 ] = FALSE; + reservoirFlushedStatus[ DG_RESERVOIR_2 ] = FALSE; + reservoirFlags[ DG_RESERVOIR_1 ].startFlushFill = FALSE; + reservoirFlags[ DG_RESERVOIR_1 ].startNormalFill = FALSE; + reservoirFlags[ DG_RESERVOIR_2 ].startFlushFill = FALSE; + reservoirFlags[ DG_RESERVOIR_2 ].startNormalFill = FALSE; + + initialReservoirDrain[ DG_RESERVOIR_1 ] = FALSE; + initialReservoirDrain[ DG_RESERVOIR_2 ] = FALSE; + initSampleWater(); initConsumableSelfTest(); initPrime(); @@ -181,6 +196,9 @@ doorClosedRequired( FALSE, FALSE ); + // Start pre-treatment mode in sample water state + transitionToSampleWater(); + return currentPreTreatmentState; } @@ -203,16 +221,6 @@ // execute mode state machine switch ( currentPreTreatmentState ) { - case HD_PRE_TREATMENT_START_STATE: -#ifndef _RELEASE_ - if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_SAMPLE_WATER ) != SW_CONFIG_ENABLE_VALUE ) -#endif - { - transitionToSampleWater(); - } - currentPreTreatmentState = HD_PRE_TREATMENT_WATER_SAMPLE_STATE; - break; - case HD_PRE_TREATMENT_WATER_SAMPLE_STATE: currentPreTreatmentState = handleWaterSampleState(); break; @@ -474,6 +482,22 @@ /*********************************************************************//** * @brief + * The signalActionToResumeFill function sets the remaining reservior fill + * flags to resume filling while in PreTreatment Mode. + * @details Inputs: none + * @details Outputs: reservoirFlags + * @return none + *************************************************************************/ +void signalActionToResumeFill( void ) +{ + reservoirFlags[ DG_RESERVOIR_1 ].startFlushFill = TRUE; + reservoirFlags[ DG_RESERVOIR_1 ].startNormalFill = TRUE; + reservoirFlags[ DG_RESERVOIR_2 ].startFlushFill = TRUE; + reservoirFlags[ DG_RESERVOIR_2 ].startNormalFill = TRUE; +} + +/*********************************************************************//** + * @brief * The getReservoirFillStatus function returns the fill complete status for * given reservoir. * @details Inputs: reservoirFilledStatus @@ -589,7 +613,7 @@ patientConnectionConfirm = FALSE; treatmentStartRequested = FALSE; - doorClosedRequired( FALSE, FALSE ); + doorClosedRequired( TRUE, TRUE ); for ( valve = VDI; valve < NUM_OF_VALVES; ++valve ) { @@ -621,27 +645,25 @@ if ( SAMPLE_WATER_COMPLETE_STATE == getSampleWaterState() ) { - { - cmdDGSampleWater( SAMPLE_WATER_CMD_END ); + cmdDGSampleWater( SAMPLE_WATER_CMD_END ); - if ( SELF_TEST_STATUS_PASSED == getSampleWaterResult() ) + if ( SELF_TEST_STATUS_PASSED == getSampleWaterResult() ) + { + if ( ( DG_MODE_STAN == dgOpMode ) && ( DG_STANDBY_MODE_STATE_IDLE == dgSubMode ) ) { - if ( ( DG_MODE_STAN == dgOpMode ) && ( DG_STANDBY_MODE_STATE_IDLE == dgSubMode ) ) - { - state = HD_PRE_TREATMENT_SELF_TEST_CONSUMABLE_STATE; - cmdStartDG(); - transitionToConsumableSelfTest(); - } - else - { - cmdStopDG(); - } + state = HD_PRE_TREATMENT_SELF_TEST_CONSUMABLE_STATE; + cmdStartDG(); + transitionToConsumableSelfTest(); } else { - requestNewOperationMode( MODE_STAN ); + cmdStopDG(); } } + else + { + requestNewOperationMode( MODE_STAN ); + } } return state; @@ -651,8 +673,8 @@ * @brief * The handleSelfTestConsumableState function handles consumable self-test state * during pre-treatment mode. - * @details Inputs: none - * @details Outputs: executed consumable self-test state machine + * @details Inputs: submodeCompleteTransitionTimeCounter + * @details Outputs: execute consumable self-test state machine * @return current state (sub-mode) *************************************************************************/ static HD_PRE_TREATMENT_MODE_STATE_T handleSelfTestConsumableState( void ) @@ -670,6 +692,12 @@ fillReservoirOneStartRequested = TRUE; transitionToNoCartSelfTests(); } +#ifndef _RELEASE_ + if ( SW_CONFIG_DISABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_DISABLE_AIR_PUMP ) ) +#endif + { + signalActionToResumeFill(); + } } return state; @@ -843,7 +871,7 @@ * @brief * The handlePatientConnectionState function handles patient connection state * during pre-treatment mode. - * @details Inputs: none + * @details Inputs: alarmActionResumeReceived * @details Outputs: requested mode transition to treatment mode * @return current state (sub-mode) *************************************************************************/ @@ -857,6 +885,19 @@ requestNewOperationMode( MODE_TREA ); } + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + signalDialInPumpHardStop(); + cmdStopDGTrimmerHeater(); + } + else if ( TRUE == alarmActionResumeReceived ) + { + alarmActionResumeReceived = FALSE; + //setDialInPumpTargetFlowRate( DIP_PATIENT_CONNECTION_FLOW_RATE_ML_MIN, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP ); + setDialInPumpTargetFlowRate( 250, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP ); // TODO remove this line once the new flow control is implemented + cmdStartDGTrimmerHeater(); + } + return HD_PRE_TREATMENT_PATIENT_CONNECTION_STATE; } @@ -897,6 +938,10 @@ currentReservoirMgmtState = handlePreTreatmentReservoirMgmtFillCompleteState(); break; + case PRE_TREATMENT_RESERVOIR_MGMT_REQUEST_RESERVOIR_SWITCH_STATE: + currentReservoirMgmtState = handlePreTreatmentReservoirMgmtRequestReservoirSwitchState(); + break; + case PRE_TREATMENT_RESERVOIR_MGMT_WAIT_FOR_RESERVOIR_SWITCH_STATE: currentReservoirMgmtState = handlePreTreatmentReservoirMgmtWaitReservoirSwitchState(); break; @@ -916,7 +961,7 @@ * The handlePreTreatmentReservoirMgmtStartState function handles reservoir * management start state for pre-treatment mode. * @details Inputs: fillReservoirOneStartRequested - * @details Outputs: processed fill reservoir one request + * @details Outputs: fillReservoirOneStartRequested * @return current state of pre-treatment reservoir management *************************************************************************/ static PRE_TREATMENT_RESERVOIR_MGMT_STATE_T handlePreTreatmentReservoirMgmtStartState( void ) @@ -925,9 +970,14 @@ if ( TRUE == fillReservoirOneStartRequested ) { - fillReservoirOneStartRequested = FALSE; - state = PRE_TREATMENT_RESERVOIR_MGMT_DRAIN_CMD_STATE; - cmdSetDGActiveReservoir( DG_RESERVOIR_2 ); + DG_SWITCH_RSRVRS_CMD_T rsrvrCmd; + + rsrvrCmd.reservoirID = (U32)DG_RESERVOIR_2; + rsrvrCmd.useLastTrimmerHeaterDC = FALSE; + fillReservoirOneStartRequested = FALSE; + state = PRE_TREATMENT_RESERVOIR_MGMT_DRAIN_CMD_STATE; + + cmdSetDGActiveReservoir( &rsrvrCmd ); } return state; @@ -937,7 +987,7 @@ * @brief * The handlePreTreatmentReservoirMgmtDrainCmdState function sends drain * command to DG when DG is in re-circulate mode. - * @details Inputs: fillReservoirOneStartRequested + * @details Inputs: none * @details Outputs: processed fill reservoir one request * @return current state of pre-treatment reservoir management *************************************************************************/ @@ -953,6 +1003,7 @@ cmdStartDG(); } + // Ensure any pending reservoir switches are completed before sending drain command if ( TRUE == hasDGCompletedReservoirSwitch() ) { if ( ( DG_MODE_GENE == dgOpMode ) && ( DG_GEN_IDLE_MODE_STATE_FLUSH_WATER == dgSubMode ) ) @@ -979,11 +1030,15 @@ DG_CMD_RESPONSE_T dgCmdResp; DG_OP_MODE_T dgOpMode = getDGOpMode(); + // Check DG response to drain command if ( TRUE == getDGCommandResponse( DG_CMD_START_DRAIN, &dgCmdResp ) ) { if ( DG_CMD_REQUEST_REJECT_REASON_NONE == dgCmdResp.rejectCode ) { - state = PRE_TREATMENT_RESERVOIR_MGMT_START_FILL_STATE; + if ( DG_MODE_DRAI == dgOpMode ) + { + state = PRE_TREATMENT_RESERVOIR_MGMT_START_FILL_STATE; + } } else { @@ -998,7 +1053,8 @@ * @brief * The handlePreTreatmentReservoirMgmtFillCmdState function sends fill * command to DG when DG is in re-circulate mode. - * @details Inputs: DG operation mode and operation sub-mode + * @details Inputs: DG operation mode, DG operation sub-mode, + * reservoirFlushedStatus, reservoirFlags * @details Outputs: sent fill command to DG * @return current state of pre-treatment reservoir management *************************************************************************/ @@ -1007,52 +1063,37 @@ PRE_TREATMENT_RESERVOIR_MGMT_STATE_T state = PRE_TREATMENT_RESERVOIR_MGMT_START_FILL_STATE; DG_OP_MODE_T dgOpMode = getDGOpMode(); U32 dgSubMode = getDGSubMode(); + U32 volume = 0; + DG_RESERVOIR_ID_T inactiveReservoir = getDGInactiveReservoir(); if ( ( DG_MODE_GENE == dgOpMode ) && ( DG_GEN_IDLE_MODE_STATE_FLUSH_WATER == dgSubMode ) ) { - state = PRE_TREATMENT_RESERVOIR_MGMT_FILL_CMD_RESP_STATE; - - if ( ( TRUE == reservoirFlushedStatus[ DG_RESERVOIR_1 ] ) && ( TRUE == reservoirFlushedStatus[ DG_RESERVOIR_2 ] ) ) + // Drain both reservoirs and return to active res 2 before initial fills + if ( initialReservoirDrain[ inactiveReservoir ] != TRUE ) { - if ( DG_RESERVOIR_1 == getDGInactiveReservoir() ) - { - U32 volume = FILL_RESERVOIR_TO_VOLUME_ML; + initialReservoirDrain[ inactiveReservoir ] = TRUE; + state = PRE_TREATMENT_RESERVOIR_MGMT_REQUEST_RESERVOIR_SWITCH_STATE; + } + // Once both reservoirs drained and returned to active res 2, wait for pre-tx workflow to get to point where fills allowed before filling + else if ( TRUE == reservoirFlags[ DG_RESERVOIR_1 ].startFlushFill ) + { + volume = getPreTreatmentFillVolume( inactiveReservoir ); -#ifndef _RELEASE_ - if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_PRIMING ) != SW_CONFIG_ENABLE_VALUE ) - { - volume = PRE_TREATMENT_FILL_RESERVOIR_ONE_VOLUME_ML; - } -#endif - - cmdStartDGFill( volume, DEFAULT_TARGET_FILL_FLOW_RATE_LPM ); - } - else + // not flushed and need to fill + if ( ( TRUE != reservoirFlushedStatus[ inactiveReservoir ] ) && + ( TRUE == reservoirFlags[ inactiveReservoir ].startFlushFill ) ) { - U32 volume = FILL_RESERVOIR_TO_VOLUME_ML; - -#ifndef _RELEASE_ - if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_PRIMING ) != SW_CONFIG_ENABLE_VALUE ) - { - volume = PRE_TREATMENT_FILL_RESERVOIR_TWO_VOLUME_ML; - } -#endif - cmdStartDGFill( volume, DEFAULT_TARGET_FILL_FLOW_RATE_LPM ); + state = PRE_TREATMENT_RESERVOIR_MGMT_FILL_CMD_RESP_STATE; } - } - else - { - U32 volume = PRE_TREATMENT_FLUSH_RESERVOIR_VOLUME_ML; -#ifndef _RELEASE_ - if ( SW_CONFIG_ENABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_DISABLE_PRIMING ) ) + // flushed and need to fill + if ( ( TRUE == reservoirFlushedStatus[ inactiveReservoir ] ) && + ( TRUE == reservoirFlags[ inactiveReservoir ].startNormalFill ) ) { - volume = FILL_RESERVOIR_TO_VOLUME_ML; + cmdStartDGFill( volume, DEFAULT_TARGET_FILL_FLOW_RATE_LPM ); + state = PRE_TREATMENT_RESERVOIR_MGMT_FILL_CMD_RESP_STATE; } -#endif - - cmdStartDGFill( volume, DEFAULT_TARGET_FILL_FLOW_RATE_LPM ); } } @@ -1116,7 +1157,7 @@ { if ( FALSE == reservoirFilledStatus[ DG_RESERVOIR_1 ] ) { - state = PRE_TREATMENT_RESERVOIR_MGMT_WAIT_FOR_RESERVOIR_SWITCH_STATE; + state = PRE_TREATMENT_RESERVOIR_MGMT_REQUEST_RESERVOIR_SWITCH_STATE; reservoirFilledStatus[ DG_RESERVOIR_1 ] = TRUE; } else @@ -1142,14 +1183,22 @@ else #endif { + DG_SWITCH_RSRVRS_CMD_T rsrvrCmd; + + rsrvrCmd.reservoirID = (U32)DG_RESERVOIR_1; + rsrvrCmd.useLastTrimmerHeaterDC = FALSE; reservoirFlushedStatus[ DG_RESERVOIR_1 ] = TRUE; - cmdSetDGActiveReservoir( DG_RESERVOIR_1 ); + cmdSetDGActiveReservoir( &rsrvrCmd ); } } else { + DG_SWITCH_RSRVRS_CMD_T rsrvrCmd; + + rsrvrCmd.reservoirID = (U32)DG_RESERVOIR_2; + rsrvrCmd.useLastTrimmerHeaterDC = FALSE; reservoirFlushedStatus[ DG_RESERVOIR_2 ] = TRUE; - cmdSetDGActiveReservoir( DG_RESERVOIR_2 ); + cmdSetDGActiveReservoir( &rsrvrCmd ); } } } @@ -1159,6 +1208,35 @@ /*********************************************************************//** * @brief + * The handlePreTreatmentReservoirMgmtRequestReservoirSwitchState function waits + * until prime operation switches the active reservoir before filling up next reservoir. + * @details Inputs: DG intactive reservoir + * @details Outputs: start filling next reservoir + * @return current state of pre-treatment reservoir management + *************************************************************************/ +static PRE_TREATMENT_RESERVOIR_MGMT_STATE_T handlePreTreatmentReservoirMgmtRequestReservoirSwitchState( void ) +{ + PRE_TREATMENT_RESERVOIR_MGMT_STATE_T state = PRE_TREATMENT_RESERVOIR_MGMT_REQUEST_RESERVOIR_SWITCH_STATE; + DG_OP_MODE_T dgOpMode = getDGOpMode(); + U32 dgSubMode = getDGSubMode(); + DG_RESERVOIR_ID_T inactiveReservoir = getDGInactiveReservoir(); + + //wait after drain or fill + if ( ( DG_MODE_GENE == dgOpMode ) && ( DG_GEN_IDLE_MODE_STATE_FLUSH_WATER == dgSubMode ) ) + { + DG_SWITCH_RSRVRS_CMD_T rsrvrCmd; + + rsrvrCmd.reservoirID = (U32)inactiveReservoir; + rsrvrCmd.useLastTrimmerHeaterDC = TRUE; + state = PRE_TREATMENT_RESERVOIR_MGMT_WAIT_FOR_RESERVOIR_SWITCH_STATE; + cmdSetDGActiveReservoir( &rsrvrCmd ); + } + + return state; +} + +/*********************************************************************//** + * @brief * The handlePreTreatmentReservoirMgmtWaitReservoirSwitchState function waits * until prime operation switches the active reservoir before filling up next reservoir. * @details Inputs: DG intactive reservoir @@ -1168,23 +1246,79 @@ static PRE_TREATMENT_RESERVOIR_MGMT_STATE_T handlePreTreatmentReservoirMgmtWaitReservoirSwitchState( void ) { PRE_TREATMENT_RESERVOIR_MGMT_STATE_T state = PRE_TREATMENT_RESERVOIR_MGMT_WAIT_FOR_RESERVOIR_SWITCH_STATE; + DG_CMD_RESPONSE_T dgCmdResp; - if ( ( TRUE == reservoirFilledStatus[ DG_RESERVOIR_1 ] ) && ( FALSE == reservoirFilledStatus[ DG_RESERVOIR_2 ] ) ) + // handle fill command response from DG + if ( TRUE == getDGCommandResponse( DG_CMD_SWITCH_RESERVOIR, &dgCmdResp ) ) { - if ( DG_RESERVOIR_2 == getDGInactiveReservoir() ) + if ( DG_CMD_REQUEST_REJECT_REASON_INVALID_MODE == dgCmdResp.rejectCode ) { + state = PRE_TREATMENT_RESERVOIR_MGMT_REQUEST_RESERVOIR_SWITCH_STATE; + } + else if ( dgCmdResp.rejectCode != DG_CMD_REQUEST_REJECT_REASON_NONE ) + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_DG_INVALID_FILL_COMMAND_REJECTED, dgCmdResp.rejectCode ) + } + else + { state = PRE_TREATMENT_RESERVOIR_MGMT_DRAIN_CMD_STATE; } } + + return state; +} + +/*********************************************************************//** + * @brief + * The getPreTreatmentFillVolume function determines which volume to fill + * the inactive reservoir. + * @details Inputs: reservoirFlushedStatus + * @details Outputs: none + * @param DG inactive Reservoir + * @return volume to fill + *************************************************************************/ +static U32 getPreTreatmentFillVolume( DG_RESERVOIR_ID_T inactiveRes ) +{ + U32 volume = 0; + + // Fill volumes after flushing + if ( TRUE == reservoirFlushedStatus[ inactiveRes ] ) + { + if ( DG_RESERVOIR_1 == inactiveRes ) + { + volume = FILL_RESERVOIR_TO_VOLUME_ML; +#ifndef _RELEASE_ + if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_PRIMING ) != SW_CONFIG_ENABLE_VALUE ) + { + volume = PRE_TREATMENT_FILL_RESERVOIR_ONE_VOLUME_ML; + } +#endif + } + // Reservoir 2 + else + { + volume = FILL_RESERVOIR_TO_VOLUME_ML; +#ifndef _RELEASE_ + if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_PRIMING ) != SW_CONFIG_ENABLE_VALUE ) + { + volume = PRE_TREATMENT_FILL_RESERVOIR_TWO_VOLUME_ML; + } +#endif + } + } + // Flush fill volumes else { - if ( TRUE == hasDGCompletedReservoirSwitch() ) + volume = PRE_TREATMENT_FLUSH_RESERVOIR_VOLUME_ML; +#ifndef _RELEASE_ + if ( SW_CONFIG_ENABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_DISABLE_PRIMING ) ) { - state = PRE_TREATMENT_RESERVOIR_MGMT_DRAIN_CMD_STATE; + volume = FILL_RESERVOIR_TO_VOLUME_ML; } +#endif } - return state; + return volume; }