Index: firmware/App/Controllers/ROPump.c =================================================================== diff -u -rc1ef106ed0f97dc998230c6e154aa2362aa476d8 -rab304e2ca6e3e40ed8cb12650e9855ae0b9649d8 --- firmware/App/Controllers/ROPump.c (.../ROPump.c) (revision c1ef106ed0f97dc998230c6e154aa2362aa476d8) +++ firmware/App/Controllers/ROPump.c (.../ROPump.c) (revision ab304e2ca6e3e40ed8cb12650e9855ae0b9649d8) @@ -45,6 +45,29 @@ #define RO_PUMP_DATA_PUB_INTERVAL ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) ///< Interval (ms/task time) at which the RO Pump data is published on the CAN bus. +#define MAX_RO_PUMP_PWM_STEP_CHANGE 0.01 ///< max duty cycle change for controller +#define MAX_RO_PUMP_PWM_DUTY_CYCLE 0.99 ///< max duty cycle +#define MIN_RO_PUMP_PWM_DUTY_CYCLE 0.00 ///< min duty cycle + +#define ROP_CONTROL_INTERVAL ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) ///< interval (ms/task time) at which the RO pump is controlled +#define ROP_P_COEFFICIENT 0.0020 ///< P term for RO pump pressure control +#define ROP_I_COEFFICIENT 0.0015 ///< I term for RO pump pressure control + +#define ROP_RAMP_UP_P_COEFFICIENT 0.0 ///< P term for RO pump flow control +#define ROP_RAMP_UP_I_COEFFICIENT 0.01 ///< I term for RO pump flow control +#define ROP_FLOW_TARGET_TOLERANCE 0.05 ///< Tolerance in between the target flow rate and the actual flow rate in liter + +#define FLOW_SENSOR_ZERO_READING 0xFFFF ///< Flow sensor reading indicates zero flow (or flow lower than can be detected by sensor) + +#define FLOW_SAMPLES_TO_AVERAGE (250 / TASK_PRIORITY_INTERVAL) ///< Averaging flow data over 250 ms intervals. +#define FLOW_AVERAGE_MULTIPLIER (1.0 / (F32)FLOW_SAMPLES_TO_AVERAGE) ///< Optimization - multiplying is faster than dividing +#define FLOW_VERIFICATION_COUNTER_TARGET 40U ///< The time in counts to check the flow and make sure it is in range + +#define RO_FLOW_ADC_TO_LPM_FACTOR 10909.0909 ///< conversion factor from ADC counts to LPM (liters/min) for RO flow rate (multiply this by inverse of FPGA reading). + +// Initial PWM for the requested flow rate. It is assumed that 100% duty cycle will provide 1.2 LPM +#define ROP_FLOW_TO_PWM_DC(flow) ((F32)(flow / 1.2)) ///< Initial conversion factor from target flow rate to PWM duty cycle estimate + #define MAX_RO_PUMP_PWM_STEP_CHANGE 0.01 ///< Max duty cycle change for controller. #define MAX_RO_PUMP_PWM_DUTY_CYCLE 0.99 ///< Max duty cycle. #define MIN_RO_PUMP_PWM_DUTY_CYCLE 0.00 ///< Min duty cycle. @@ -66,7 +89,10 @@ typedef enum ROPump_States { RO_PUMP_OFF_STATE = 0, ///< RO pump off state - RO_PUMP_CONTROL_TO_TARGET_STATE, ///< RO pump control to target pressure state + RO_PUMP_RAMP_UP_STATE, ///< RO pump ramp up to target flow rate state + RO_PUMP_VERIFY_FLOW_STATE, ///< RO pump maintain the flow rate for a set period of time + RO_PUMP_CONTROL_TO_TARGET_STATE, ///< RO pump control to target pressure state + RO_PUMP_OPEN_LOOP_STATE, ///< RO pump open loop state NUM_OF_RO_PUMP_STATES ///< Number of RO pump states } RO_PUMP_STATE_T; @@ -83,36 +109,55 @@ // pin assignments for pump test DIP switch 0 #define RO_PUMP_TEST_SPI5_PORT_MASK 0x00000100 // (ENA - re-purposed as input GPIO) // dialIn pump stop and direction macros -#define GET_DIP_SW0_TEST() ( ( mibspiREG5->PC2 & RO_PUMP_TEST_SPI5_PORT_MASK ) != 0 ) +#define GET_DIP_SW0_TEST() ( ( mibspiREG5->PC2 & RO_PUMP_TEST_SPI5_PORT_MASK ) != 0 ) // ********** private data ********** -static RO_PUMP_STATE_T roPumpState = RO_PUMP_OFF_STATE; ///< Current state of RO pump controller state machine. -static U32 roPumpDataPublicationTimerCounter = 0; ///< RO pump data publication timer counter. -static BOOL isROPumpOn = FALSE; ///< RO pump is currently running. -static F32 roPumpPWMDutyCyclePct = 0.0; ///< Initial RO pump PWM duty cycle. -static F32 roPumpPWMDutyCyclePctSet = 0.0; ///< Currently set RO pump PWM duty cycle. -static PUMP_CONTROL_MODE_T roPumpControlMode = PUMP_CONTROL_MODE_CLOSED_LOOP; ///< Requested RO pump control mode. -static PUMP_CONTROL_MODE_T roPumpControlModeSet = PUMP_CONTROL_MODE_CLOSED_LOOP; ///< Currently set RO pump control mode. +static RO_PUMP_STATE_T roPumpState = RO_PUMP_OFF_STATE; ///< current state of RO pump controller state machine +static U32 roPumpDataPublicationTimerCounter = 0; ///< used to schedule RO pump data publication to CAN bus +static BOOL isROPumpOn = FALSE; ///< RO pump is currently running +static F32 roPumpPWMDutyCyclePct = 0.0; ///< initial RO pump PWM duty cycle +static F32 roPumpPWMDutyCyclePctSet = 0.0; ///< currently set RO pump PWM duty cycle +static PUMP_CONTROL_MODE_T roPumpControlMode = PUMP_CONTROL_MODE_CLOSED_LOOP; ///< requested RO pump control mode //TODO remove +static PUMP_CONTROL_MODE_T roPumpControlModeSet = PUMP_CONTROL_MODE_CLOSED_LOOP; ///< currently set RO pump control mode +static OVERRIDE_F32_T targetROPumpFlowRate = { 0, 0, 0, 0 }; ///< Target RO flow rate (in LPM) static OVERRIDE_U32_T roPumpDataPublishInterval = { RO_PUMP_DATA_PUB_INTERVAL, - RO_PUMP_DATA_PUB_INTERVAL, 0, 0 }; ///< Interval (in ms) at which to publish RO flow data to CAN bus. + RO_PUMP_DATA_PUB_INTERVAL, + 0, 0 }; ///< Interval (in ms) at which to publish RO flow data to CAN bus +static OVERRIDE_F32_T measuredROFlowRateLPM = { 0.0, 0.0, 0.0, 0 }; ///< measured RO flow rate (in LPM) +static F32 measuredROPumpPressure = 0.0; ///< measured RO pressure (in PSI) // TODO remove +static F32 tgtROPumpPressure = 0.0; ///< Target RO control pressure (in PSI) + +static U32 flowVerificationCounter = 0; ///< Counter to verify the flow is in range + +static U32 roControlTimerCounter = 0; ///< determines when to perform control on ro pump + +static U32 roPumpOpenLoopTargetPWM = 0; ///< Target RO pump open loop PWM +static F32 roPumpFlowRateRunningSum = 0; +static F32 roPumpPressureRunningSum = 0; + +/* The variables used for POST. They are not in use yet, so they are commented out +static RO_PUMP_SELF_TEST_STATE_T roPumpSelfTestState = RO_PUMP_SELF_TEST_STATE_START; ///< current ro pump self test state +static U32 roPumpSelfTestTimerCount = 0; ///< timer counter for ro pump self test +*/ + static OVERRIDE_U32_T targetROPumpPressure = { 0, 0, 0, 0 }; ///< Target RO pressure (in PSI). -static OVERRIDE_F32_T measuredROFlowRateLPM = { 0.0, 0.0, 0.0, 0 }; ///< Measured RO flow rate (in LPM). -static F32 measuredROPumpPressure = 0.0; ///< Measured RO pressure (in PSI). static S32 measuredFlowReadingsSum = 0; ///< Raw flow reading sums for averaging. static U32 flowFilterCounter = 0; ///< Flow filtering counter. -static U32 roControlTimerCounter = 0; ///< Timer counter for perform control on RO pump. static RO_PUMP_SELF_TEST_STATE_T roPumpSelfTestState = RO_PUMP_SELF_TEST_STATE_START; ///< Current RO pump self-test state. static U32 roPumpSelfTestTimerCount = 0; ///< Timer counter for RO pump self-test. // ********** private function prototypes ********** static RO_PUMP_STATE_T handleROPumpOffState( void ); -static RO_PUMP_STATE_T handleROPumpControlToTargetState( void ); +static RO_PUMP_STATE_T handleROPumpRampUpState( void ); +static RO_PUMP_STATE_T handleROPumpVerifyFlowState( void ); +static RO_PUMP_STATE_T handleROPumpControlToTargetState( void ); +static RO_PUMP_STATE_T handleROPumpOpenLoopState( void ); static void setROPumpControlSignalPWM( F32 newPWM ); static void stopROPump( void ); static void publishROPumpData( void ); @@ -122,50 +167,114 @@ * @brief * The initROPump function initializes the ROPump module. * @details - * Inputs : none - * Outputs : ROPump module initialized. + * Inputs: none + * Outputs: ROPump module initialized. * @return none *************************************************************************/ void initROPump( void ) { stopROPump(); - // initialize RO pump PI controller - initializePIController( PI_CONTROLLER_ID_RO_PUMP, MIN_RO_PUMP_PWM_DUTY_CYCLE, ROP_P_COEFFICIENT, - ROP_I_COEFFICIENT, MIN_RO_PUMP_PWM_DUTY_CYCLE, MAX_RO_PUMP_PWM_DUTY_CYCLE ); + // Initialize RO pump PI controller + initializePIController( PI_CONTROLLER_ID_RO_PUMP, MIN_RO_PUMP_PWM_DUTY_CYCLE, + ROP_P_COEFFICIENT, ROP_I_COEFFICIENT, + MIN_RO_PUMP_PWM_DUTY_CYCLE, MAX_RO_PUMP_PWM_DUTY_CYCLE ); + + // Initialize the P controller during ramp up + initializePIController( I_CONTROLLER_ID_RO_PUMP_RAMP_UP, MIN_RO_PUMP_PWM_DUTY_CYCLE, + ROP_RAMP_UP_P_COEFFICIENT, ROP_RAMP_UP_I_COEFFICIENT, + MIN_RO_PUMP_PWM_DUTY_CYCLE, MAX_RO_PUMP_PWM_DUTY_CYCLE ); +} + +//TODO TEST AND REMOVE +/*********************************************************************//** + * @brief + * The setROPumpTargetPressure function sets a new target pressure for the RO pump. + * @details + * Inputs : none + * Outputs : targetROPumpPressure, roPumpPWMDutyCyclePct + * @param roPressure new target RO pressure + * @param mode new control mode + * @return TRUE if new target pressure is set, FALSE if not + *************************************************************************/ +BOOL setROPumpTargetPressure( U32 roPressure, PUMP_CONTROL_MODE_T mode ) +{ + BOOL result = FALSE; + + // verify pressure + if ( roPressure >= 10 && roPressure <= 50 ) + { + targetROPumpPressure.data = roPressure; + roPumpControlMode = mode; + // set PWM duty cycle target to an estimated initial target based on target pressure - then we'll control to pressure going forward +#ifdef EMC_TEST_BUILD + roPumpPWMDutyCyclePct = 1.0; +#else + roPumpPWMDutyCyclePct = ROP_PSI_TO_PWM_DC( roPressure ); +#endif + + result = TRUE; + } + else // requested pressure out of range + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, 0, roPressure ) // TODO - replace 1st param with s/w fault enum + } + + return result; +} +//TODO TEST AND REMOVE + +/*********************************************************************//** + * @brief + * The setROPumpTargetPWM function sets the PWM that the pump should run + * @details + * Inputs: roPumpOpenLooptargetPWM, roPumpControlMode + * Outputs: roPumpOpenLooptargetPWM, roPumpControlMode + * @param: pwm + * @return whether the value was set (TRUE) or not (FALSE) + *************************************************************************/ +BOOL setROPumpTargetPWM( U32 pwm ) +{ + BOOL result = FALSE; + + if ( pwm > 0 ) + { + roPumpOpenLoopTargetPWM = pwm; + roPumpPWMDutyCyclePct = ROP_FLOW_TO_PWM_DC( getTargetROPumpFlowRate() ); + roPumpControlMode = PUMP_CONTROL_MODE_OPEN_LOOP; + result = TRUE; + } + return result; } /*********************************************************************//** * @brief - * The setROPumpTargetPressure function sets a new target pressure for the RO pump. + * The setROPumpTargetFlowRate function sets a new target flow rate for the \n + * RO pump. * @details - * Inputs : none - * Outputs : targetROPumpPressure, roPumpPWMDutyCyclePct - * @param roPressure new target RO pressure - * @param mode new control mode - * @return TRUE if new target pressure is set, FALSE if not + * Inputs: none + * Outputs: targetROPumpFlowRate, roPumpPWMDutyCyclePct + * @param: roFlowRate : new target RO flow rate + * @return TRUE if new target flow rate is set, FALSE if not *************************************************************************/ -BOOL setROPumpTargetPressure( U32 roPressure, PUMP_CONTROL_MODE_T mode ) +BOOL setROPumpTargetFlowRate( F32 roFlowRate ) { BOOL result = FALSE; - // verify pressure - if ( roPressure >= MIN_RO_PRESSURE && roPressure <= MAX_RO_PRESSURE ) + if ( roFlowRate < MAX_RO_FLOWRATE_LPM && roFlowRate >= MIN_RO_FLOWRATE_LPM ) { - targetROPumpPressure.data = roPressure; - roPumpControlMode = mode; - // set PWM duty cycle target to an estimated initial target based on target pressure - then we'll control to pressure going forward -#ifdef EMC_TEST_BUILD - roPumpPWMDutyCyclePct = 1.0; -#else - roPumpPWMDutyCyclePct = ROP_PSI_TO_PWM_DC( roPressure ); + targetROPumpFlowRate.data = roFlowRate; + roPumpControlMode = PUMP_CONTROL_MODE_CLOSED_LOOP; + roPumpPWMDutyCyclePct = ROP_FLOW_TO_PWM_DC( roFlowRate ); +#ifdef EMC_TEST_BUILD + roPumpPWMDutyCyclePct = 1.0; +#else + roPumpPWMDutyCyclePct = ROP_FLOW_TO_PWM_DC( roFlowRate ); #endif - - result = TRUE; } else // requested pressure out of range { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, 0, roPressure ) // TODO - replace 1st param with s/w fault enum + //SET_ALARM_WITH_2_U32_DATA( ALARM_ID_SOFTWARE_FAULT, 0, roFlowRate ) // TODO - replace 1st param with s/w fault enum } return result; @@ -175,26 +284,28 @@ * @brief * The signalROPumpHardStop function stops the RO pump immediately. * @details - * Inputs : none - * Outputs : RO pump stopped, set point reset, state changed to off + * Inputs: none + * Outputs: RO pump stopped, set point reset, state changed to off * @return none *************************************************************************/ void signalROPumpHardStop( void ) { - targetROPumpPressure.data = 0; + targetROPumpFlowRate.data = 0; stopROPump(); roPumpState = RO_PUMP_OFF_STATE; roPumpPWMDutyCyclePct = 0.0; - roControlTimerCounter = 0; + roControlTimerCounter = 0; + flowVerificationCounter = 0; + isROPumpOn = FALSE; resetPIController( PI_CONTROLLER_ID_RO_PUMP, MIN_RO_PUMP_PWM_DUTY_CYCLE ); } /*********************************************************************//** * @brief * The execROPumpMonitor function executes the RO Pump monitor. * @details - * Inputs : flowFilterCounter - * Outputs : measuredROPumpPressure, measuredROFlowRateLPM + * Inputs: none + * Outputs: measuredROPumpPressure, measuredROFlowRateLPM * @return none *************************************************************************/ void execROPumpMonitor( void ) @@ -235,8 +346,8 @@ * @brief * The execROPumpController function executes the RO Pump controller. * @details - * Inputs : roPumpState - * Outputs : roPumpState + * Inputs: roPumpState + * Outputs: roPumpState * @return none *************************************************************************/ void execROPumpController( void ) @@ -247,23 +358,36 @@ roPumpState = handleROPumpOffState(); break; + case RO_PUMP_RAMP_UP_STATE: + roPumpState = handleROPumpRampUpState(); + break; + + case RO_PUMP_VERIFY_FLOW_STATE: + roPumpState = handleROPumpVerifyFlowState(); + break; + case RO_PUMP_CONTROL_TO_TARGET_STATE: roPumpState = handleROPumpControlToTargetState(); + break; + + case RO_PUMP_OPEN_LOOP_STATE: + roPumpState = handleROPumpOpenLoopState(); break; default: SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, 0, roPumpState ) // TODO - replace 1st param with s/w fault enum roPumpState = RO_PUMP_OFF_STATE; break; - } + } } /*********************************************************************//** * @brief * The isROPumpOn function returns the status of RO pump. * @details - * Inputs : none - * Outputs : none + * Inputs: none + * Outputs: none + * @param: none * @return isROPumpOn *************************************************************************/ BOOL isReverseOsmosisPumpOn( void ) @@ -273,11 +397,11 @@ /*********************************************************************//** * @brief - * The handleROPumpOffState function handles the RO pump off state of the - * RO pump controller state machine. - * @details - * Inputs : targetROPumpPressure - * Outputs : roPumpPWMDutyCyclePctSet, isROPumpOn + * The handleROPumpOffState function handles the ro pump off state \n + * of the ro pump controller state machine. + * @details + * Inputs: roPumpPWMDutyCyclePctSet, isROPumpOn + * Outputs: roPumpPWMDutyCyclePctSet, isROPumpOn * @return next state *************************************************************************/ static RO_PUMP_STATE_T handleROPumpOffState( void ) @@ -306,32 +430,129 @@ #endif } #endif -#endif +#endif - // if we've been given a pressure, transition to control to target state - if ( getTargetROPumpPressure() > 0 ) + // If there is a flow, transition to P controller to get + // the corresponding pressure of that flow + if ( getTargetROPumpFlowRate() > 0 && roPumpControlMode == PUMP_CONTROL_MODE_CLOSED_LOOP ) { - roPumpControlModeSet = roPumpControlMode; - // set initial PWM duty cycle + roPumpControlModeSet = roPumpControlMode; + // set initial PWM duty cycle roPumpPWMDutyCyclePctSet = roPumpPWMDutyCyclePct; - setROPumpControlSignalPWM( roPumpPWMDutyCyclePctSet ); + setROPumpControlSignalPWM ( roPumpPWMDutyCyclePctSet ); // reset controller - resetPIController( PI_CONTROLLER_ID_RO_PUMP, roPumpPWMDutyCyclePctSet ); + resetPIController ( I_CONTROLLER_ID_RO_PUMP_RAMP_UP, roPumpPWMDutyCyclePctSet ); // set pump to on isROPumpOn = TRUE; - result = RO_PUMP_CONTROL_TO_TARGET_STATE; + result = RO_PUMP_RAMP_UP_STATE; + } + + if ( roPumpOpenLoopTargetPWM > 0 && roPumpControlMode == PUMP_CONTROL_MODE_OPEN_LOOP ) + { + setROPumpControlSignalPWM ( roPumpOpenLoopTargetPWM ); + isROPumpOn = TRUE; + result = RO_PUMP_OPEN_LOOP_STATE; } return result; } + +/*********************************************************************//** + * @brief + * The handleROPumpRampUpState function handles the ro pump ramp up state \n + * of the ro pump controller state machine. + * @details + * Inputs: roControlTimerCounter, roPumpPWMDutyCyclePctSet + * Outputs: roControlTimerCounter, roPumpPWMDutyCyclePctSet + * @return next state + *************************************************************************/ +static RO_PUMP_STATE_T handleROPumpRampUpState( void ) +{ + RO_PUMP_STATE_T result = RO_PUMP_RAMP_UP_STATE; + // control at set interval + if ( ++roControlTimerCounter >= ROP_CONTROL_INTERVAL ) + { + F32 targetFlowRate = getTargetROPumpFlowRate(); + + F32 actualFlowRate = (F32)getMeasuredROFlowRate(); + + if ( fabs( actualFlowRate - targetFlowRate ) > ROP_FLOW_TARGET_TOLERANCE ) + { + F32 newPWM = runPIController( I_CONTROLLER_ID_RO_PUMP_RAMP_UP, targetFlowRate, actualFlowRate ); + roPumpPWMDutyCyclePctSet = newPWM; + setROPumpControlSignalPWM( newPWM ); + } + else + { + result = RO_PUMP_VERIFY_FLOW_STATE; + } + + roControlTimerCounter = 0; + } + + return result; +} + +/*********************************************************************//** + * @brief + * The handleROPumpVerifyFlowState function handles the RO pump verify \n + * flow state of the RO pump controller state machine. + * @details + * Inputs: flowVerificationCounter, roPumpPWMDutyCyclePctSet, \n + * tgtROPumpPressure, roPumpFlowRateRunningSum, roPumpPressureRunningSum + * Outputs: flowVerificationCounter, roPumpPWMDutyCyclePctSet, \n + * tgtROPumpPressure, roPumpFlowRateRunningSum, roPumpPressureRunningSum + * @return next state + *************************************************************************/ +static RO_PUMP_STATE_T handleROPumpVerifyFlowState( void ) +{ + RO_PUMP_STATE_T result = RO_PUMP_VERIFY_FLOW_STATE; + + // Calculate the running sum of the flow rate and RO pump outlet pressure + roPumpFlowRateRunningSum = roPumpFlowRateRunningSum + (F32)getMeasuredROFlowRate(); + roPumpPressureRunningSum = roPumpPressureRunningSum + getMeasuredDGPressure( PRESSURE_SENSOR_RO_PUMP_OUTLET ); + + // Check if the time for flow verification has elapsed + if ( ++flowVerificationCounter >= FLOW_VERIFICATION_COUNTER_TARGET ) + { + // Calculate the average pressure and flow rate + F32 avgPressure = roPumpPressureRunningSum / flowVerificationCounter; + F32 avgFlowRate = roPumpFlowRateRunningSum / flowVerificationCounter; + + F32 targetFlowRate = getTargetROPumpFlowRate(); + + // Calculate the flow rate deviation from the target flow rate + F32 flowRateDeviation = ( targetFlowRate - avgFlowRate ) / targetFlowRate; + // Use the flow rate deviation to adjust the average calculated pressure. This + // pressure is used as the target pressure + avgPressure = avgPressure + ( avgPressure * flowRateDeviation ); + + // Reset the P controller for the flow rate + resetPIController( I_CONTROLLER_ID_RO_PUMP_RAMP_UP, MIN_RO_PUMP_PWM_DUTY_CYCLE ); + tgtROPumpPressure = avgPressure; + + // set initial PWM duty cycle + roPumpPWMDutyCyclePctSet = roPumpPWMDutyCyclePct; + setROPumpControlSignalPWM( roPumpPWMDutyCyclePctSet ); + // reset controller + resetPIController( PI_CONTROLLER_ID_RO_PUMP, roPumpPWMDutyCyclePctSet ); + flowVerificationCounter = 0; + roPumpFlowRateRunningSum = 0; + roPumpPressureRunningSum = 0; + result = RO_PUMP_CONTROL_TO_TARGET_STATE; + } + + return result; +} + /*********************************************************************//** * @brief * The handleROPumpControlToTargetState function handles the "control to * target" state of the RO pump controller state machine. * @details - * Inputs : none - * Outputs : roPumpState + * Inputs: roPumpPWMDutyCyclePctSet, roControlTimerCounter + * Outputs: roPumpPWMDutyCyclePctSet, roControlTimerCounter * @return next state *************************************************************************/ static RO_PUMP_STATE_T handleROPumpControlToTargetState( void ) @@ -341,18 +562,18 @@ // control at set interval if ( ++roControlTimerCounter >= ROP_CONTROL_INTERVAL ) { - if ( roPumpControlModeSet == PUMP_CONTROL_MODE_CLOSED_LOOP ) - { - F32 tgtPres = (F32)getTargetROPumpPressure(); - F32 actPres = measuredROPumpPressure; - F32 newPWM; + F32 actualPressure = getMeasuredDGPressure( PRESSURE_SENSOR_RO_PUMP_OUTLET ); -#ifndef EMC_TEST_BUILD + F32 newPWM = runPIController( PI_CONTROLLER_ID_RO_PUMP, tgtROPumpPressure, actualPressure ); + roPumpPWMDutyCyclePctSet = newPWM; + setROPumpControlSignalPWM( newPWM ); + +/*#ifndef EMC_TEST_BUILD newPWM = runPIController( PI_CONTROLLER_ID_RO_PUMP, tgtPres, actPres ); roPumpPWMDutyCyclePctSet = newPWM; setROPumpControlSignalPWM( newPWM ); -#endif - } +#endif*/ + roControlTimerCounter = 0; } @@ -373,16 +594,30 @@ #endif return result; +} + +/*********************************************************************//** + * @brief + * The handleROPumpOpenLoopState function handles the open loop state \n + * of the RO pump controller + * @details + * Inputs: roPumpPWMDutyCyclePctSet, roControlTimerCounter + * Outputs: roPumpPWMDutyCyclePctSet, roControlTimerCounter + * @return next state + *************************************************************************/ +static RO_PUMP_STATE_T handleROPumpOpenLoopState( void ) +{ + return RO_PUMP_OPEN_LOOP_STATE; } /*********************************************************************//** * @brief * The setROPumpControlSignalPWM function sets the PWM duty cycle for the * RO pump to a given %. * @details - * Inputs : none - * Outputs : PWM duty cycle zeroed - * @param newPWM new duty cycle % to apply to PWM + * Inputs: none + * Outputs: PWM duty cycle zeroed + * @param: newPWM : new duty cycle % to apply to PWM * @return none *************************************************************************/ static void setROPumpControlSignalPWM( F32 newPWM ) @@ -394,8 +629,8 @@ * @brief * The stopROPump function sets the RO pump PWM to zero. * @details - * Inputs : none - * Outputs : PWM duty cycle zeroed + * Inputs: none + * Outputs: PWM duty cycle zeroed * @return none *************************************************************************/ static void stopROPump( void ) @@ -409,8 +644,8 @@ * @brief * The getPublishROPumpDataInterval function gets the RO pump data publish interval. * @details - * Inputs : roPumpDataPublishInterval - * Outputs : none + * Inputs: roPumpDataPublishInterval + * Outputs: none * @return the current RO pump data publication interval (in ms). *************************************************************************/ static U32 getPublishROPumpDataInterval( void ) @@ -427,19 +662,20 @@ /*********************************************************************//** * @brief - * The getTargetROPumpPressure function gets the current target RO pump pressure. + * The getTargetROPumpFlowRate function gets the current target RO pump \n + * flow rate * @details - * Inputs : targetROPumpPressure - * Outputs : none - * @return the current target RO pressure (in PSI). + * Inputs: targetROPumpFlowRate + * Outputs: targetROPumpFlowRate + * @return the current target RO flow rate (in LPM). *************************************************************************/ -U32 getTargetROPumpPressure( void ) +F32 getTargetROPumpFlowRate( void ) { - U32 result = targetROPumpPressure.data; + F32 result = targetROPumpFlowRate.data; - if ( OVERRIDE_KEY == targetROPumpPressure.override ) + if ( OVERRIDE_KEY == targetROPumpFlowRate.override ) { - result = targetROPumpPressure.ovData; + result = targetROPumpFlowRate.ovData; } return result; @@ -449,8 +685,8 @@ * @brief * The getMeasuredROFlowRate function gets the measured RO pump flow rate. * @details - * Inputs : measuredROFlowRateLPM - * Outputs : none + * Inputs: measuredROFlowRateLPM + * Outputs: none * @return the current RO pump flow rate (in LPM). *************************************************************************/ F32 getMeasuredROFlowRate( void ) @@ -469,19 +705,18 @@ * @brief * The publishROPumpData function publishes RO pump data at the set interval. * @details - * Inputs : target pressure, measured pressure, measured RO pump speed. - * Outputs : RO pump data is published to CAN bus. + * Inputs: target pressure, measured pressure, measured RO pump speed. + * Outputs: RO pump data is published to CAN bus. * @return none *************************************************************************/ static void publishROPumpData( void ) { // publish RO pump data on interval if ( ++roPumpDataPublicationTimerCounter >= getPublishROPumpDataInterval() ) { - U32 presStPt = getTargetROPumpPressure(); F32 measFlow = getMeasuredROFlowRate(); F32 pumpPWMPctDutyCycle = roPumpPWMDutyCyclePctSet * FRACTION_TO_PERCENT_FACTOR; - broadcastROPumpData( presStPt, measFlow, pumpPWMPctDutyCycle ); + broadcastROPumpData( tgtROPumpPressure, measFlow, pumpPWMPctDutyCycle, (U32)roPumpState ); roPumpDataPublicationTimerCounter = 0; } } @@ -490,9 +725,9 @@ * @brief * The execROPumpTest function executes the state machine for the ROPump self-test. * @details - * Inputs : none - * Outputs : none - * @return the current state of the ROPump self-test. + * Inputs: none + * Outputs: none + * @return the current state of the ROPump self test. *************************************************************************/ SELF_TEST_STATUS_T execROPumpTest( void ) { @@ -514,9 +749,9 @@ * The testSetROPumpDataPublishIntervalOverride function overrides the * RO pump data publish interval. * @details - * Inputs : none - * Outputs : roPumpDataPublishInterval - * @param value override RO pump data publish interval with (in ms) + * Inputs: none + * Outputs: roPumpDataPublishInterval + * @param: value : override RO pump data publish interval with (in ms) * @return TRUE if override successful, FALSE if not *************************************************************************/ BOOL testSetROPumpDataPublishIntervalOverride( U32 value ) @@ -540,8 +775,8 @@ * The testResetROPumpDataPublishIntervalOverride function resets the override * of the RO pump data publish interval. * @details - * Inputs : none - * Outputs : roPumpDataPublishInterval + * Inputs: none + * Outputs: roPumpDataPublishInterval * @return TRUE if override reset successful, FALSE if not *************************************************************************/ BOOL testResetROPumpDataPublishIntervalOverride( void ) @@ -560,29 +795,29 @@ /*********************************************************************//** * @brief - * The testSetTargetROPumpPressureOverride function overrides the target - * RO pressure. + * The testSetTargetROPumpFlowRateOverride function overrides the target \n + * RO flow rate. \n * @details - * Inputs : none - * Outputs : targetROPumpPressure - * @param value override target RO pressure (in PSI) + * Inputs: targetROPumpFlowRate + * Outputs: targetROPumpPressure + * @param: value : override target RO flow rate (in LPM) * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testSetTargetROPumpPressureOverride( U32 value ) +BOOL testSetTargetROPumpFlowRateOverride( F32 value ) { BOOL result = FALSE; if ( TRUE == isTestingActivated() ) { - targetROPumpPressure.ovInitData = targetROPumpPressure.data; // backup current target pressure - targetROPumpPressure.ovData = value; - targetROPumpPressure.override = OVERRIDE_KEY; - result = setROPumpTargetPressure( value, roPumpControlMode ); + targetROPumpFlowRate.ovInitData = targetROPumpFlowRate.data; // backup current target pressure + targetROPumpFlowRate.ovData = value; + targetROPumpFlowRate.override = OVERRIDE_KEY; + result = setROPumpTargetFlowRate( value ); } return result; } - + /*********************************************************************//** * @brief * The testResetTargetROPumpPressureOverride function resets the override of the @@ -592,30 +827,80 @@ * Outputs : targetROPumpPressure * @return TRUE if override reset successful, FALSE if not *************************************************************************/ -BOOL testResetTargetROPumpPressureOverride( void ) +BOOL testResetTargetROPumpFlowRateOverride( void ) { BOOL result = FALSE; if ( TRUE == isTestingActivated() ) { - targetROPumpPressure.data = targetROPumpPressure.ovInitData; // restore pre-override target pressure - targetROPumpPressure.override = OVERRIDE_RESET; - targetROPumpPressure.ovInitData = 0; - targetROPumpPressure.ovData = 0; - result = setROPumpTargetPressure( targetROPumpPressure.data, roPumpControlMode ); + targetROPumpFlowRate.data = targetROPumpFlowRate.ovInitData; // restore pre-override target pressure + targetROPumpFlowRate.override = OVERRIDE_RESET; + targetROPumpFlowRate.ovInitData = 0; + targetROPumpFlowRate.ovData = 0; + result = setROPumpTargetFlowRate( targetROPumpFlowRate.data ); } return result; -} +} + +/*********************************************************************//** + * @brief + * The testSetTargetROPumpPressureOverride function overrides the target + * RO pressure. + * @details + * Inputs : none + * Outputs : targetROPumpPressure + * @param value override target RO pressure (in PSI) + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testSetTargetROPumpPressureOverride( U32 value ) +{ + BOOL result = FALSE; + + if ( TRUE == isTestingActivated() ) + { + targetROPumpPressure.ovInitData = targetROPumpPressure.data; // backup current target pressure + targetROPumpPressure.ovData = value; + targetROPumpPressure.override = OVERRIDE_KEY; + result = setROPumpTargetPressure( value, roPumpControlMode ); + } + + return result; +} + +/*********************************************************************//** + * @brief + * The testResetTargetROPumpPressureOverride function resets the override of the + * target RO pressure. + * @details + * Inputs : none + * Outputs : targetROPumpPressure + * @return TRUE if override reset successful, FALSE if not + *************************************************************************/ +BOOL testResetTargetROPumpPressureOverride( void ) +{ + BOOL result = FALSE; + + if ( TRUE == isTestingActivated() ) + { + targetROPumpPressure.data = targetROPumpPressure.ovInitData; // restore pre-override target pressure + targetROPumpPressure.override = OVERRIDE_RESET; + targetROPumpPressure.ovInitData = 0; + targetROPumpPressure.ovData = 0; + result = setROPumpTargetPressure( targetROPumpPressure.data, roPumpControlMode ); + } + + return result; +} /*********************************************************************//** * @brief * The testSetMeasuredROFlowRateOverride function overrides the measured * RO flow rate. * @details - * Inputs : none - * Outputs : measuredROFlowRateLPM - * @param value override measured RO pump motor speed (in LPM) + * Inputs: none + * Outputs: measuredROFlowRateLPM + * @param: value : override measured RO pump motor speed (in LPM) * @return TRUE if override successful, FALSE if not *************************************************************************/ BOOL testSetMeasuredROFlowRateOverride( F32 value ) @@ -637,8 +922,10 @@ * The testResetMeasuredROFlowRateOverride function resets the override of the * measured RO flow rate. * @details - * Inputs : none - * Outputs : measuredROFlowRateLPM + * Inputs: none + * Outputs: measuredROFlowRateLPM + * @param: none + * @return TRUE if override successful, FALSE if not *************************************************************************/ BOOL testResetMeasuredROFlowRateOverride( void )