Index: firmware/App/Controllers/ROPump.c =================================================================== diff -u -r6d85a90d2325163e936055a620a8b6aa1a6db65a -r98b3a57e9c46778d2b61877e7c350a7eadceb706 --- firmware/App/Controllers/ROPump.c (.../ROPump.c) (revision 6d85a90d2325163e936055a620a8b6aa1a6db65a) +++ firmware/App/Controllers/ROPump.c (.../ROPump.c) (revision 98b3a57e9c46778d2b61877e7c350a7eadceb706) @@ -56,7 +56,6 @@ // ********** private data ********** static RO_PUMP_STATE_T roPumpState; ///< Current state of pump controller state machine. -static PUMP_CONTROL_MODE_T roPumpControlMode; ///< Requested pump control mode. static BOOL isROPumpOn; ///< Flag indicating whether pump is currently running. static BOOL stopPumpRequest; ///< Flag indicating pump stop is requested. static U32 roPumpDataPublicationTimerCounter; ///< Used to schedule RO pump data publication to CAN bus. @@ -101,7 +100,6 @@ MIN_FLUID_PUMP_DUTY_CYCLE_PCT, MAX_FLUID_PUMP_DUTY_CYCLE_PCT, FALSE, 0 ); roPumpState = RO_PUMP_OFF_STATE; - roPumpControlMode = NUM_OF_PUMP_CONTROL_MODES; isROPumpOn = FALSE; stopPumpRequest = FALSE; roControlTimerCounter = 0; @@ -182,33 +180,32 @@ RO_PUMP_STATE_T state = RO_PUMP_OFF_STATE; isROPumpOn = FALSE; - // If there is a target pressure set, transition to the PI controller and control to pressure. - if ( ( getTargetROPumpPressure() > 0.0F ) && ( PUMP_CONTROL_MODE_CLOSED_LOOP == roPumpControlMode ) ) + // If there is a target flow set, transition to the PI controller and control to flow + if ( getTargetROPumpFlowRateMLPM() > 0 ) { // Set pump to on isROPumpOn = TRUE; - roPumpDutyCyclePctSet = roPumpPresToPWM( getTargetROPumpPressure() ); - resetPIController( PI_CONTROLLER_ID_RO_PUMP_PRES, roPumpDutyCyclePctSet, 0.0F ); + roPumpDutyCyclePctSet = roPumpFlowToPWM( getTargetROPumpFlowRateMLPM() ); + resetPIController( PI_CONTROLLER_ID_RO_PUMP_FLOW, roPumpDutyCyclePctSet, 0.0F ); setFluidPumpPctToPWMDutyCycle( P12_PUMP, roPumpDutyCyclePctSet ); - state = RO_PUMP_CONTROL_TO_TARGET_PRESSURE_STATE; + state = RO_PUMP_CONTROL_TO_TARGET_FLOW_STATE; } - - // If there is a target flow set, transition to the PI controller and control to flow - else if ( ( getTargetROPumpFlowRateMLPM() > 0 ) && ( PUMP_CONTROL_MODE_CLOSED_LOOP == roPumpControlMode ) ) + // If there is a target pressure set, transition to the PI controller and control to pressure. + else if ( getTargetROPumpPressure() > 0.0F ) { // Set pump to on isROPumpOn = TRUE; - roPumpDutyCyclePctSet = roPumpFlowToPWM( getTargetROPumpFlowRateMLPM() ); - resetPIController( PI_CONTROLLER_ID_RO_PUMP_FLOW, roPumpDutyCyclePctSet, 0.0F ); + roPumpDutyCyclePctSet = roPumpPresToPWM( getTargetROPumpPressure() ); + resetPIController( PI_CONTROLLER_ID_RO_PUMP_PRES, roPumpDutyCyclePctSet, 0.0F ); setFluidPumpPctToPWMDutyCycle( P12_PUMP, roPumpDutyCyclePctSet ); - state = RO_PUMP_CONTROL_TO_TARGET_FLOW_STATE; + state = RO_PUMP_CONTROL_TO_TARGET_PRESSURE_STATE; } // If the target duty cycle is greater than zero (minimum is 10%) and the mode has been set to open // loop, set the duty cycle - else if ( ( getTargetROPumpDutyCyclePCT() > 0.0F ) && ( PUMP_CONTROL_MODE_OPEN_LOOP == roPumpControlMode ) ) + else if ( getTargetROPumpDutyCyclePCT() > 0.0F ) { - setFluidPumpPctToPWMDutyCycle( P12_PUMP, getTargetROPumpDutyCyclePCT() ); roPumpDutyCyclePctSet = getTargetROPumpDutyCyclePCT(); + setFluidPumpPctToPWMDutyCycle( P12_PUMP, roPumpDutyCyclePctSet ); isROPumpOn = TRUE; state = RO_PUMP_OPEN_LOOP_STATE; } @@ -232,22 +229,25 @@ if ( TRUE == stopPumpRequest ) { stopPumpRequest = FALSE; - state = RO_PUMP_OFF_STATE; + signalROPumpHardStop(); } + // If there is a target flow set, transition to the PI controller and control to flow + if ( getTargetROPumpFlowRateMLPM() > 0 ) + { + ///transition to closed loop + resetPIController( PI_CONTROLLER_ID_RO_PUMP_FLOW, getTargetROPumpDutyCyclePCT(), 0 ); + state = RO_PUMP_CONTROL_TO_TARGET_FLOW_STATE; + } // If there is a target pressure set, transition to the PI controller and control to pressure. - if ( ( getTargetROPumpPressure() > 0.0F ) && ( PUMP_CONTROL_MODE_CLOSED_LOOP == roPumpControlMode ) ) + else if ( getTargetROPumpPressure() > 0.0F ) { //transition to closed loop resetPIController( PI_CONTROLLER_ID_RO_PUMP_PRES, getTargetROPumpDutyCyclePCT(), 0 ); state = RO_PUMP_CONTROL_TO_TARGET_PRESSURE_STATE; } - - // If there is a target flow set, transition to the PI controller and control to flow - else if ( ( getTargetROPumpFlowRateMLPM() > 0 ) && ( PUMP_CONTROL_MODE_CLOSED_LOOP == roPumpControlMode ) ) + else if ( (F32)getTargetROPumpDutyCyclePCT() == 0.0F ) { - ///transition to closed loop - resetPIController( PI_CONTROLLER_ID_RO_PUMP_FLOW, getTargetROPumpDutyCyclePCT(), 0 ); - state = RO_PUMP_CONTROL_TO_TARGET_FLOW_STATE; + signalROPumpHardStop(); } return state; @@ -266,25 +266,24 @@ RO_PUMP_STATE_T state = RO_PUMP_CONTROL_TO_TARGET_FLOW_STATE; // Check if need to switch control modes - if ( ( getTargetROPumpPressure() > 0.0F ) && ( PUMP_CONTROL_MODE_CLOSED_LOOP == roPumpControlMode ) ) + if ( getTargetROPumpPressure() > 0.0F ) { // Transition to target pressure resetPIController( PI_CONTROLLER_ID_RO_PUMP_PRES, roPumpDutyCyclePctSet, 0 ); state = RO_PUMP_CONTROL_TO_TARGET_PRESSURE_STATE; } - else if ( ( getTargetROPumpDutyCyclePCT() > 0.0F ) && ( PUMP_CONTROL_MODE_OPEN_LOOP == roPumpControlMode ) ) + else if ( getTargetROPumpDutyCyclePCT() > 0.0F ) { - setFluidPumpPctToPWMDutyCycle( P12_PUMP, getTargetROPumpDutyCyclePCT() ); roPumpDutyCyclePctSet = getTargetROPumpDutyCyclePCT(); + setFluidPumpPctToPWMDutyCycle( P12_PUMP, roPumpDutyCyclePctSet ); state = RO_PUMP_OPEN_LOOP_STATE; } - // Control at set interval or shut off - if ( ( (F32)getTargetROPumpFlowRateMLPM() == 0.0F ) && ( PUMP_CONTROL_MODE_CLOSED_LOOP == roPumpControlMode ) ) + else if ( (F32)getTargetROPumpFlowRateMLPM() == 0.0F ) { signalROPumpHardStop(); } - else if ( ( ++roControlTimerCounter >= ROP_CONTROL_INTERVAL ) && ( PUMP_CONTROL_MODE_CLOSED_LOOP == roPumpControlMode ) ) + else if ( ++roControlTimerCounter >= ROP_CONTROL_INTERVAL ) { roPumpDutyCyclePctSet = runPIController( PI_CONTROLLER_ID_RO_PUMP_FLOW, (F32)getTargetROPumpFlowRateMLPM(), getFilteredFlow( P16_FLOW ) ); setFluidPumpPctToPWMDutyCycle( P12_PUMP, roPumpDutyCyclePctSet ); @@ -307,24 +306,23 @@ RO_PUMP_STATE_T state = RO_PUMP_CONTROL_TO_TARGET_PRESSURE_STATE; // Check if we are changing control - if ( ( getTargetROPumpFlowRateMLPM() > 0 ) && ( PUMP_CONTROL_MODE_CLOSED_LOOP == roPumpControlMode ) ) + if ( getTargetROPumpFlowRateMLPM() > 0 ) { resetPIController( PI_CONTROLLER_ID_RO_PUMP_FLOW, roPumpDutyCyclePctSet, 0 ); state = RO_PUMP_CONTROL_TO_TARGET_FLOW_STATE; } - else if ( ( getTargetROPumpDutyCyclePCT() > 0.0F ) && ( PUMP_CONTROL_MODE_OPEN_LOOP == roPumpControlMode ) ) + else if ( getTargetROPumpDutyCyclePCT() > 0.0F ) { setFluidPumpPctToPWMDutyCycle( P12_PUMP, getTargetROPumpDutyCyclePCT() ); roPumpDutyCyclePctSet = getTargetROPumpDutyCyclePCT(); state = RO_PUMP_OPEN_LOOP_STATE; } - // Control at set interval or shut off - if ( ( getTargetROPumpPressure() == 0.0F ) && ( PUMP_CONTROL_MODE_CLOSED_LOOP == roPumpControlMode ) ) + else if ( getTargetROPumpPressure() == 0.0F ) { signalROPumpHardStop(); } - else if ( ( ++roControlTimerCounter >= ROP_CONTROL_INTERVAL ) && ( PUMP_CONTROL_MODE_CLOSED_LOOP == roPumpControlMode ) ) + else if ( ++roControlTimerCounter >= ROP_CONTROL_INTERVAL ) { roPumpDutyCyclePctSet = runPIController( PI_CONTROLLER_ID_RO_PUMP_PRES, getTargetROPumpPressure(), getFilteredPressure( P17_PRES ) ); setFluidPumpPctToPWMDutyCycle( P12_PUMP, roPumpDutyCyclePctSet ); @@ -342,32 +340,42 @@ * @details \b Outputs: targetROPumpFlowRate, roPumpControlMode, roPumpDutyCyclePctSet, * roControlTimerCounter, isROPumpOn * @param roFlowRate which is target RO flow rate in mL/min + * @param firmwareCall indicates whether the call initiated by firmware + * internally or by dialin * @return TRUE if new target flow rate is set successfully, FALSE if not *************************************************************************/ -BOOL setROPumpTargetFlowRateMLPM( U32 roFlowRate ) +BOOL setROPumpTargetFlowRateMLPM( U32 roFlowRate, BOOL firmwareCall ) { BOOL result = FALSE; + BOOL skipSet = FALSE; // First of all, the flow rate must be in range if ( ( roFlowRate <= MAX_RO_FLOWRATE_MLPM ) && ( roFlowRate >= MIN_RO_FLOWRATE_MLPM ) ) { - targetROPumpFlowRate.data = roFlowRate; - roPumpControlMode = PUMP_CONTROL_MODE_CLOSED_LOOP; - // Get the initial guess of the duty cycle - roPumpDutyCyclePctSet = roPumpFlowToPWM( getTargetROPumpFlowRateMLPM() ); - roControlTimerCounter = 0; - isROPumpOn = TRUE; - - // Clear previous target data - if ( getTargetROPumpPressure() > 0.0F ) + if ( firmwareCall == TRUE ) // firmware call { - targetROPumpPressure.data = 0.0F; + // set the target flow and pressure to zero if there are no active override + if ( ( targetROPumpFlowRate.override == OVERRIDE_RESET ) && ( targetROPumpPressure.override == OVERRIDE_RESET ) && ( roPumpOpenLoopTargetDutyCycle.override == OVERRIDE_RESET ) ) + { + targetROPumpPressure.data = 0; + roPumpOpenLoopTargetDutyCycle.data = 0.0F; + } + // skip the firmware set call if any override is active + else + { + result = TRUE; + skipSet = TRUE; + } } - if ( getTargetROPumpDutyCyclePCT() > 0.0F ) + if ( skipSet != TRUE ) { - roPumpOpenLoopTargetDutyCycle.data = 0.0F; + targetROPumpFlowRate.data = roFlowRate; + // Get the initial guess of the duty cycle + roPumpDutyCyclePctSet = roPumpFlowToPWM( getTargetROPumpFlowRateMLPM() ); + roControlTimerCounter = 0; + isROPumpOn = TRUE; + result = TRUE; } - result = TRUE; } // Requested flow rate is out of range else @@ -386,31 +394,42 @@ * @details \b Outputs: roPumpOpenLoopTargetDutyCycle, targetROPumpFlowRate, isROPumpOn, * roControlTimerCounter, roPumpDutyCyclePctSet, roPumpControlMode, targetROPumpPressure * @param roPressure which is target RO pressure + * @param firmwareCall indicates whether the call initiated by firmware + * internally or by dialin * @return TRUE if new target flow rate is set successfully, FALSE if not *************************************************************************/ -BOOL setROPumpTargetPressure( F32 roPressure ) +BOOL setROPumpTargetPressure( F32 roPressure, BOOL firmwareCall ) { BOOL result = FALSE; + BOOL skipSet = FALSE; // First of all, the pressure must be in range if ( ( roPressure <= MAX_RO_PRESSURE_PSI ) && ( roPressure >= MIN_RO_PRESSURE_PSI ) ) { - targetROPumpPressure.data = roPressure; - roPumpControlMode = PUMP_CONTROL_MODE_CLOSED_LOOP; - // Get the initial guess of the duty cycle - roPumpDutyCyclePctSet = roPumpPresToPWM( getTargetROPumpPressure() ); - roControlTimerCounter = 0; - isROPumpOn = TRUE; - // Clear previous target data - if ( getTargetROPumpFlowRateMLPM() > 0 ) + if ( firmwareCall == TRUE ) // firmware call { - targetROPumpFlowRate.data = 0; + // set the target flow and pressure to zero if there are no active override + if ( ( targetROPumpFlowRate.override == OVERRIDE_RESET ) && ( targetROPumpPressure.override == OVERRIDE_RESET ) && ( roPumpOpenLoopTargetDutyCycle.override == OVERRIDE_RESET ) ) + { + targetROPumpFlowRate.data = 0; + roPumpOpenLoopTargetDutyCycle.data = 0.0F; + } + // skip the firmware set call if any override is active + else + { + result = TRUE; + skipSet = TRUE; + } } - if ( getTargetROPumpDutyCyclePCT() > 0.0F ) + if ( skipSet != TRUE ) { - roPumpOpenLoopTargetDutyCycle.data = 0.0F; + targetROPumpPressure.data = roPressure; + // Get the initial guess of the duty cycle + roPumpDutyCyclePctSet = roPumpPresToPWM( getTargetROPumpPressure() ); + roControlTimerCounter = 0; + isROPumpOn = TRUE; + result = TRUE; } - result = TRUE; } // Requested flow rate is out of range else @@ -430,36 +449,57 @@ * @details \b Outputs: roPumpOpenLoopTargetDutyCycle * roPumpControlMode, targetROPumpFlowRate, targetROPumpPressure * @param duty which is the duty cycle + * @param firmwareCall indicates whether the call initiated by firmware + * internally or by dialin * @return none *************************************************************************/ -BOOL setROPumpTargetDutyCycle( F32 dutyCycle ) +BOOL setROPumpTargetDutyCycle( F32 dutyCycle, BOOL firmwareCall ) { - BOOL status = FALSE; + BOOL result = FALSE; + BOOL skipSet = FALSE; if ( ( dutyCycle >= MIN_FLUID_PUMP_DUTY_CYCLE_PCT ) && ( dutyCycle <= MAX_FLUID_PUMP_DUTY_CYCLE_PCT ) ) { - roPumpOpenLoopTargetDutyCycle.data = dutyCycle; - roPumpControlMode = PUMP_CONTROL_MODE_OPEN_LOOP; - status = TRUE; - - // Set the new duty cycle of the pump - setFluidPumpPctToPWMDutyCycle( P12_PUMP, getTargetROPumpDutyCyclePCT() ); - // Clear previous target data - if ( getTargetROPumpFlowRateMLPM() > 0 ) + if ( firmwareCall == TRUE ) // firmware call { - targetROPumpFlowRate.data = 0; + // set the target flow and pressure to zero if there are no active override + if ( ( targetROPumpFlowRate.override == OVERRIDE_RESET ) && ( targetROPumpPressure.override == OVERRIDE_RESET ) && ( roPumpOpenLoopTargetDutyCycle.override == OVERRIDE_RESET ) ) + { + targetROPumpFlowRate.data = 0; + targetROPumpPressure.data = 0.0F; + } + // skip the firmware set call if any override is active + else + { + result = TRUE; + skipSet = TRUE; + } } - if ( getTargetROPumpPressure() > 0.0F ) + if ( skipSet != TRUE ) { - targetROPumpPressure.data = 0.0F; + // Set the new duty cycle of the pump + roPumpOpenLoopTargetDutyCycle.data = dutyCycle; + result = TRUE; + // stop RO Pump if duty cycle is set to zero + if ( dutyCycle == 0.0F ) + { + if ( ( targetROPumpFlowRate.data == 0 ) && ( targetROPumpPressure.data == 0.0F ) ) + { + signalROPumpHardStop(); + } + } + else + { + setFluidPumpPctToPWMDutyCycle( P12_PUMP, getTargetROPumpDutyCyclePCT() ); + } } } else { SET_ALARM_WITH_2_F32_DATA( ALARM_ID_FP_SOFTWARE_FAULT, SW_FAULT_ID_FP_INVALID_PUMP_DUTY_CYCLE_SELECTED, dutyCycle ) } - return status; + return result; } /*********************************************************************//** @@ -580,7 +620,7 @@ roPumpDutyCyclePctSet = 0.0F; roControlTimerCounter = 0; roPumpOpenLoopTargetDutyCycle.data = 0.0F; - stopPumpRequest = TRUE; + stopROPump(); } @@ -676,10 +716,40 @@ *************************************************************************/ BOOL testROPumpTargetPressureOverride( MESSAGE_T *message ) { - BOOL result = f32Override( message, &targetROPumpPressure ); + TEST_OVERRIDE_PAYLOAD_T payload; + OVERRIDE_TYPE_T ovType = getOverridePayloadFromMessage( message, &payload ); + BOOL result = FALSE; + // reset target pressure override + if ( ( ovType == OVERRIDE_RESET_OVERRIDE ) && ( targetROPumpPressure.override != OVERRIDE_RESET ) ) + { + // Restore previous flow, duty cycle and pressure values + targetROPumpPressure.data = targetROPumpPressure.ovInitData; + targetROPumpPressure.ovInitData = 0.0F; + targetROPumpPressure.ovData = targetROPumpPressure.ovInitData; + targetROPumpPressure.override = OVERRIDE_RESET; + if ( targetROPumpFlowRate.override == OVERRIDE_RESET && targetROPumpFlowRate.ovInitData != 0 ) + { + targetROPumpFlowRate.data = targetROPumpFlowRate.ovInitData; + } + if ( roPumpOpenLoopTargetDutyCycle.override == OVERRIDE_RESET && roPumpOpenLoopTargetDutyCycle.ovInitData != 0.0F ) + { + roPumpOpenLoopTargetDutyCycle.data = roPumpOpenLoopTargetDutyCycle.ovInitData; + } + } + // set target pressure override + else if ( ovType == OVERRIDE_OVERRIDE ) + { + targetROPumpPressure.ovData = payload.state.f32; + targetROPumpPressure.override = OVERRIDE_KEY; + if ( targetROPumpPressure.ovInitData == 0.0F ) + { + targetROPumpPressure.ovInitData = targetROPumpPressure.data; + } + handleFluidPumpF32Data( &roPumpOpenLoopTargetDutyCycle ); + handleFluidPumpU32Data( &targetROPumpFlowRate ); + } + result = setROPumpTargetPressure(getTargetROPumpPressure(), FALSE); - setROPumpTargetPressure(getTargetROPumpPressure()); - return result; } @@ -695,10 +765,40 @@ *************************************************************************/ BOOL testROPumpTargetFlowOverride( MESSAGE_T *message ) { - BOOL result = u32Override( message, &targetROPumpFlowRate, MIN_RO_FLOWRATE_MLPM, MAX_RO_FLOWRATE_MLPM ); + TEST_OVERRIDE_PAYLOAD_T payload; + OVERRIDE_TYPE_T ovType = getOverridePayloadFromMessage( message, &payload ); + BOOL result = FALSE; + // reset target flow rate override + if ( ( ovType == OVERRIDE_RESET_OVERRIDE ) && ( targetROPumpFlowRate.override != OVERRIDE_RESET ) ) + { + // Restore previous flow, duty cycle and pressure values + targetROPumpFlowRate.data = targetROPumpFlowRate.ovInitData; + targetROPumpFlowRate.ovInitData = 0; + targetROPumpFlowRate.ovData = targetROPumpFlowRate.ovInitData; + targetROPumpFlowRate.override = OVERRIDE_RESET; + if ( roPumpOpenLoopTargetDutyCycle.override == OVERRIDE_RESET && roPumpOpenLoopTargetDutyCycle.ovInitData != 0.0F ) + { + roPumpOpenLoopTargetDutyCycle.data = roPumpOpenLoopTargetDutyCycle.ovInitData; + } + if ( targetROPumpPressure.override == OVERRIDE_RESET && targetROPumpPressure.ovInitData != 0.0F ) + { + targetROPumpPressure.data = targetROPumpPressure.ovInitData; + } + } + // set target flow rate override + else if ( ovType == OVERRIDE_OVERRIDE ) + { + targetROPumpFlowRate.ovData = payload.state.u32; + targetROPumpFlowRate.override = OVERRIDE_KEY; + if ( targetROPumpFlowRate.ovInitData == 0 ) + { + targetROPumpFlowRate.ovInitData = targetROPumpFlowRate.data; + } + handleFluidPumpF32Data( &roPumpOpenLoopTargetDutyCycle ); + handleFluidPumpF32Data( &targetROPumpPressure ); + } + result = setROPumpTargetFlowRateMLPM(getTargetROPumpFlowRateMLPM(), FALSE); - setROPumpTargetFlowRateMLPM(getTargetROPumpFlowRateMLPM()); - return result; } @@ -714,10 +814,40 @@ *************************************************************************/ BOOL testROPumpTargetDutyCycleOverride( MESSAGE_T *message ) { - BOOL result = f32Override( message, &roPumpOpenLoopTargetDutyCycle ); + TEST_OVERRIDE_PAYLOAD_T payload; + OVERRIDE_TYPE_T ovType = getOverridePayloadFromMessage( message, &payload ); + BOOL result = FALSE; + // reset target duty cycle override + if ( ( ovType == OVERRIDE_RESET_OVERRIDE ) && ( roPumpOpenLoopTargetDutyCycle.override != OVERRIDE_RESET ) ) + { + // Restore previous flow, duty cycle and pressure values + roPumpOpenLoopTargetDutyCycle.data = roPumpOpenLoopTargetDutyCycle.ovInitData; + roPumpOpenLoopTargetDutyCycle.ovInitData = 0.0F; + roPumpOpenLoopTargetDutyCycle.ovData = roPumpOpenLoopTargetDutyCycle.ovInitData; + roPumpOpenLoopTargetDutyCycle.override = OVERRIDE_RESET; + if ( targetROPumpFlowRate.override == OVERRIDE_RESET && targetROPumpFlowRate.ovInitData != 0 ) + { + targetROPumpFlowRate.data = targetROPumpFlowRate.ovInitData; + } + if ( targetROPumpPressure.override == OVERRIDE_RESET && targetROPumpPressure.ovInitData != 0 ) + { + targetROPumpPressure.data = targetROPumpPressure.ovInitData; + } + } + // set target duty cycle override + else if ( ovType == OVERRIDE_OVERRIDE ) + { + roPumpOpenLoopTargetDutyCycle.ovData = payload.state.f32; + roPumpOpenLoopTargetDutyCycle.override = OVERRIDE_KEY; + if ( roPumpOpenLoopTargetDutyCycle.ovInitData == 0.0F ) + { + roPumpOpenLoopTargetDutyCycle.ovInitData = roPumpOpenLoopTargetDutyCycle.data; + } + handleFluidPumpU32Data( &targetROPumpFlowRate ); + handleFluidPumpF32Data( &targetROPumpPressure ); + } + result = setROPumpTargetDutyCycle(getTargetROPumpDutyCyclePCT(), FALSE); - setROPumpTargetDutyCycle(getTargetROPumpDutyCyclePCT()); - return result; }