Index: firmware/App/Controllers/BoostPump.c =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Controllers/BoostPump.c (.../BoostPump.c) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Controllers/BoostPump.c (.../BoostPump.c) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -19,6 +19,7 @@ #include "BoostPump.h" #include "Flow.h" +#include "FluidPump.h" //#include "NVDataMgmt.h" #include "Messaging.h" #include "MessageSupport.h" @@ -55,9 +56,6 @@ #define DATA_PUBLISH_COUNTER_START_COUNT 10 ///< Data publish counter start count. -#define BOOST_FLOW_TO_PWM(flow) ( BOOST_FLOW_TO_PWM_SLOPE * flow + BOOST_FLOW_TO_PWM_INTERCEPT ) ///< PWM line equation for flow. -#define BOOST_PRESSURE_TO_PWM(pres) ( BOOST_PRESSURE_TO_PWM_SLOPE * pres + BOOST_PRESSURE_TO_PWM_INTERCEPT ) ///< PWM line equation for pressure. - /// Enumeration of Boost pump states. typedef enum BoostPump_States { @@ -194,7 +192,7 @@ isBoostPumpOn = FALSE; // Do not control unless boost is installed - if ( TRUE == isBoostPumpInstalled ) + if ( TRUE == isBoostPumpInstalled() ) { // If there is a target pressure set, transition to the PI controller and control to pressure. if ( ( getTargetBoostPumpPressure() > 0.0F ) && ( PUMP_CONTROL_MODE_CLOSED_LOOP == boostPumpControlMode ) ) @@ -464,8 +462,37 @@ return status; } + /*********************************************************************//** * @brief + * The getTargetBoostPumpDutyCyclePCT function gets the current target Boost pump + * pwm. + * @details \b Inputs: boostPumpOpenLoopTargetDutyCycle + * @details \b Outputs: none + * @return the current target Boost pwm between 0 and 0.99 + *************************************************************************/ +F32 getTargetBoostPumpDutyCyclePCT( void ) +{ + return boostPumpOpenLoopTargetDutyCycle; +} + +/*********************************************************************//** + * @brief + * The getCurrentBoostPumpDutyCyclePCT function gets the current Boost pump + * pwm. + * @details \b Inputs: none + * @details \b Outputs: none + * @return the current feedback Boost pwm between 0 and 0.99 + *************************************************************************/ +F32 getCurrentBoostPumpDutyCyclePCT( void ) +{ + U16 dutyCyclePct = convertDutyCycleCntToPct( getFluidPumpReadPWMDutyCycle( P40_PUMP ) ); + + return dutyCyclePct; +} + +/*********************************************************************//** + * @brief * The getTargetBoostPumpPressure function gets the current target Boost pump * pressure. * @details \b Inputs: targetBoostPumpPressure Index: firmware/App/Controllers/BoostPump.h =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Controllers/BoostPump.h (.../BoostPump.h) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Controllers/BoostPump.h (.../BoostPump.h) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -37,6 +37,9 @@ #define MAX_BOOST_PRESSURE_PSI 40.0F ///< Maximum allowed pressure that the Boost pump can go to. #define MIN_BOOST_PRESSURE_PSI 10.0F ///< Minimum allowed pressure that the Boost pump can go to. +#define BOOST_FLOW_TO_PWM(flow) ( BOOST_FLOW_TO_PWM_SLOPE * flow + BOOST_FLOW_TO_PWM_INTERCEPT ) ///< PWM line equation for flow. +#define BOOST_PRESSURE_TO_PWM(pres) ( BOOST_PRESSURE_TO_PWM_SLOPE * pres + BOOST_PRESSURE_TO_PWM_INTERCEPT ) ///< PWM line equation for pressure. + /// Boost pump data record. typedef struct { @@ -62,7 +65,8 @@ BOOL setBoostPumpTargetPressure( F32 roPressure ); BOOL setBoostPumpTargetDutyCycle( F32 duty ); -F32 getBoostFeedbackDutyCycle( void ); +F32 getCurrentBoostPumpDutyCyclePCT( void ); +F32 getTargetBoostPumpDutyCyclePCT( void ); U32 getTargetBoostPumpFlowRateMLPM( void ); F32 getTargetBoostPumpPressure( void ); Index: firmware/App/Controllers/ROPump.c =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Controllers/ROPump.c (.../ROPump.c) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Controllers/ROPump.c (.../ROPump.c) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -55,8 +55,6 @@ #define DATA_PUBLISH_COUNTER_START_COUNT 10 ///< Data publish counter start count. -#define ROP_FLOW_TO_PWM(flow) ( ROP_FLOW_TO_PWM_SLOPE * flow + ROP_FLOW_TO_PWM_INTERCEPT ) ///< PWM line equation for flow. -#define ROP_PRESSURE_TO_PWM(pres) ( ROP_PRESSURE_TO_PWM_SLOPE * pres + ROP_PRESSURE_TO_PWM_INTERCEPT ) ///< PWM line equation for pressure. /// Enumeration of RO pump states. typedef enum ROPump_States @@ -463,6 +461,34 @@ /*********************************************************************//** * @brief + * The getTargetRODutyCyclePCT function gets the current target RO pump + * pwm. + * @details \b Inputs: roPumpOpenLoopTargetDutyCycle + * @details \b Outputs: none + * @return the current target RO pwm between 0 and 0.99 + *************************************************************************/ +F32 getTargetROPumpDutyCyclePCT( void ) +{ + return roPumpOpenLoopTargetDutyCycle; +} + +/*********************************************************************//** + * @brief + * The getCurrentRODutyCyclePCT function gets the current RO pump + * pwm. + * @details \b Inputs: none + * @details \b Outputs: none + * @return the current feedback RO pwm between 0 and 0.99 + *************************************************************************/ +F32 getCurrentROPumpDutyCyclePCT( void ) +{ + U16 dutyCyclePct = convertDutyCycleCntToPct( getFluidPumpReadPWMDutyCycle( P12_PUMP ) ); + + return dutyCyclePct; +} + +/*********************************************************************//** + * @brief * The getTargetROPumpPressure function gets the current target RO pump * pressure. * @details \b Inputs: targetROPumpPressure Index: firmware/App/Controllers/ROPump.h =================================================================== diff -u -r863f8f88c73ee5dd285242f6e131a14862b4f5c4 -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Controllers/ROPump.h (.../ROPump.h) (revision 863f8f88c73ee5dd285242f6e131a14862b4f5c4) +++ firmware/App/Controllers/ROPump.h (.../ROPump.h) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -37,6 +37,9 @@ #define MAX_RO_PRESSURE_PSI 120.0F ///< Maximum allowed pressure that the RO pump can go to. #define MIN_RO_PRESSURE_PSI 10.0F ///< Minimum allowed pressure that the RO pump can go to. +#define ROP_FLOW_TO_PWM(flow) ( ROP_FLOW_TO_PWM_SLOPE * flow + ROP_FLOW_TO_PWM_INTERCEPT ) ///< PWM line equation for flow. +#define ROP_PRESSURE_TO_PWM(pres) ( ROP_PRESSURE_TO_PWM_SLOPE * pres + ROP_PRESSURE_TO_PWM_INTERCEPT ) ///< PWM line equation for pressure. + /// RO pump data record. typedef struct { @@ -62,7 +65,8 @@ BOOL setROPumpTargetPressure( F32 roPressure ); BOOL setROPumpTargetDutyCycle( F32 duty ); -F32 getROFeedbackDutyCycle( void ); +F32 getCurrentROPumpDutyCyclePCT( void ); +F32 getTargetROPumpDutyCyclePCT( void ); U32 getTargetROPumpFlowRateMLPM( void ); F32 getTargetROPumpPressure( void ); Index: firmware/App/Drivers/FluidPump.c =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Drivers/FluidPump.c (.../FluidPump.c) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Drivers/FluidPump.c (.../FluidPump.c) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -136,7 +136,7 @@ if ( pumpID < NUM_OF_PUMPS ) { pwmCnt = convertDutyCyclePctToCnt( dutyCyclePct ); - result = setFluidPumpPWMDutyCycle (pumpID, pwmCnt); + result = setFluidPumpPWMDutyCycle(pumpID, pwmCnt); } else { @@ -302,7 +302,21 @@ return pwmCnt; } +/*********************************************************************//** + * @brief + * The convertDutyCycleCntToPct function converts a duty cycle counts + * into percentage to read the PWM magnitude. + * @details Inputs: none + * @details Outputs: none + * @param dutyCyclePct duty cycle count to be converted. + * @return Value (0..0.99) indicating magnitude of PWM duty cycle as a percentage. + *************************************************************************/ +F32 convertDutyCycleCntToPct( F32 dutyCycleCnt ) +{ + F32 pwmCnt = (F32)MAX( ( dutyCycleCnt / MAX_FLUID_PUMP_PWM_DUTY_CYCLE ) , MIN_FLUID_PUMP_PWM_DUTY_CYCLE ); + return pwmCnt; +} /************************************************************************* * TEST SUPPORT FUNCTIONS Index: firmware/App/Drivers/FluidPump.h =================================================================== diff -u -rd5574e12aa9638c933d11b9bee8d5cf024864440 -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Drivers/FluidPump.h (.../FluidPump.h) (revision d5574e12aa9638c933d11b9bee8d5cf024864440) +++ firmware/App/Drivers/FluidPump.h (.../FluidPump.h) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -57,6 +57,7 @@ U16 getFluidPumpReadPWMDutyCycle( FP_FLUID_PUMP_T pumpID ); F32 getFluidPumpRPM( FP_FLUID_PUMP_T pumpID ); +F32 convertDutyCycleCntToPct( F32 dutyCycleCnt ); U16 convertDutyCyclePctToCnt( F32 dutyCyclePct ); BOOL setFluidPumpPctToPWMDutyCycle( FP_FLUID_PUMP_T pumpID, F32 dutyCyclePct); Index: firmware/App/Drivers/TemperatureSensor.c =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Drivers/TemperatureSensor.c (.../TemperatureSensor.c) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Drivers/TemperatureSensor.c (.../TemperatureSensor.c) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -350,45 +350,6 @@ /*********************************************************************//** * @brief - * The monitorTemperatureSensors function monitors the temperature sensors' - * temperature value and raises an alarm if any of them are out of range - * for more than the specified time. - * @details \b Inputs: tempSensors - * @details \b Outputs: tempSensors - * @details \b Alarms: ALARM_ID_DD_TEMPERATURE_SENSOR_OUT_OF_RANGE when the - * measured temperature exceeds the maximum limit temperature. - * @return none - *************************************************************************/ -void monitorTemperatureSenors( void ) -{ -// TEMPERATURE_SENSOR_T sensorId; -// TEMPERATURE_SENSOR_T sensorInAlarm = TEMPSENSORS_FIRST; -// F32 temperature = 0.0F; -// BOOL isTemperatureOutOfRange = FALSE; -// F32 alarmTemperature = 0.0F; -// -// for ( sensorId = TEMPSENSORS_FIRST; sensorId < NUM_OF_TEMPERATURE_SENSORS; sensorId++ ) -// { -// // Get temperature value. -// temperature = getTemperatureValue( sensorId ); -// // Check both temperature and to be in range -// if ( ( ( temperature < TEMP_SENSORS_MIN_ALLOWED_DEGREE_C ) || ( temperature > tempSensors[ sensorId ].maxAllowedTemp ) ) && -// ( getCurrentOperationMode() != DD_MODE_INIT ) ) -// { -// isTemperatureOutOfRange |= TRUE; -// sensorInAlarm = sensorId; -// alarmTemperature = temperature; -// } -// } -// -// checkPersistentAlarm( ALARM_ID_DD_TEMPERATURE_SENSOR_OUT_OF_RANGE, isTemperatureOutOfRange, sensorInAlarm, alarmTemperature ); -// -// //check freshness of temperature read -// checkTemperatureSensors(); -} - -/*********************************************************************//** - * @brief * The getCalibrationAppliedTemperatureValue function applies the calibration * values to the provided temperature value * @details \b Inputs: tempSensorCalRecord Index: firmware/App/Drivers/TemperatureSensor.h =================================================================== diff -u -r051cd0430ef8342bd606115c98871e26dc24acf1 -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Drivers/TemperatureSensor.h (.../TemperatureSensor.h) (revision 051cd0430ef8342bd606115c98871e26dc24acf1) +++ firmware/App/Drivers/TemperatureSensor.h (.../TemperatureSensor.h) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -40,6 +40,7 @@ P22_TEMP, ///< Pre-tank temperature sensor at coldest point. P10_TEMP, ///< Inlet conductivity sensor temperature. P19_TEMP, ///< Outlet conductivity sensor temperature. + M4_TEMP, NUM_OF_TEMPERATURE_SENSORS ///< Number of temperature sensors } TEMPERATURE_SENSOR_T; @@ -48,7 +49,6 @@ void initTemperatureSensors( void ); void readTemperatureSensors( void ); -void monitorTemperatureSenors( void ); F32 getTemperatureValue( TEMPERATURE_SENSOR_T sensorIndex ); //U32 getTemperatureSensorsReadCount( void ); Index: firmware/App/Modes/FlushConcentrate.c =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Modes/FlushConcentrate.c (.../FlushConcentrate.c) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Modes/FlushConcentrate.c (.../FlushConcentrate.c) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -1 +1,395 @@ +/************************************************************************** +* +* Copyright (c) 2024-2024 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 FlushConcentrate.c +* +* @author (last) Michael Garthwaite +* @date (last) 28-Feb-2025 +* +* @author (original) Michael Garthwaite +* @date (original) 28-Feb-2025 +* +***************************************************************************/ + +#include + +#include "Conductivity.h" +#include "BoostPump.h" +#include "FlowSensor.h" +#include "FlushConcentrate.h" +#include "MessageSupport.h" +#include "Messaging.h" +#include "OperationModes.h" +#include "Pressure.h" +#include "ROPump.h" +#include "TaskGeneral.h" +#include "Timers.h" +#include "Valves.h" + +/** + * @addtogroup FPConcentrateFlush + * @{ + */ + +// ********** private definitions ********** + +#define CONCENTRATE_FLUSH_MAX_TIMEOUT ( 600 * MS_PER_SECOND ) ///< Max override timeout for 10 minutes +#define CONCENTRATE_FLUSH_DATA_PUBLISH_INTERVAL ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) ///< Interval (ms/task time) at which the gen water mode data published. +#define CONCENTRATE_FLUSH_TIMEOUT ( 30 * MS_PER_SECOND ) ///< Concentrate flush timer (in ms) +#define CONCENTRATE_FLUSH_RO_PUMP_TGT_PWM 0.8F ///< target in PWM % for the RO pump during concentrate flush. +#define CONCENTRATE_FLUSH_BOOST_PUMP_TGT_PSI 25 ///< Pressure target in PSI for the boost pump during concentrate flush. +#define CONCENTRATE_FLUSH_VOLUME_THRESHOLD_ML 1000.0F ///< Integrated volume threshold in ml +#define CONCENTRATE_FLUSH_VOLUME_THRESHOLD_PCT 0.9F ///< Integrated volume threshold percentage +#define CONCENTRATE_FLUSH_VOLUME_THRESHOLD CONCENTRATE_FLUSH_VOLUME_THRESHOLD_ML * CONCENTRATE_FLUSH_VOLUME_THRESHOLD_PCT ///< alarm threshold for integrated volume + +// ********** private data ********** +/// Multiplier to convert flow (mL/min) into volume (mL) for period of general task interval. +static const F32 CONCENTRATE_FLOW_INTEGRATOR = 1.0F / (F32)( SEC_PER_MIN * ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) ); +static FP_CONC_FLUSH_STATE_T concentrateFlushState; ///< Currently active Concentrate flush state. +static U32 concentrateFlushDataPublicationTimerCounter; ///< Used to schedule Concentrate flush data publication to CAN bus. +static OVERRIDE_U32_T concentrateFlushDataPublishInterval; ///< Concentrate Flush mode data publish interval. +static OVERRIDE_U32_T concentrateFlushTimeout; ///< Concentrate Flush timeout value +static U32 concentrateFlushTimer; ///< Concentrate Flush timeout timer +static BOOL pendingStartConcentrateFlushRequest; ///< signal to start flushing. +static BOOL isFlushComplete; ///< Concentrate Flush complete BOOL +static F32 cumulativeConcentrateVolume_mL; + +// ********** private function prototypes ********** + +static void publishConcentrateFlushData( void ); +static FP_CONC_FLUSH_STATE_T handleConcentrateFlushProgressState( void ); +static FP_CONC_FLUSH_STATE_T handleConcentrateFlushPausedState( void ); +static void setConcentrateFlushTransition( FP_CONC_FLUSH_STATE_T state ); +static U32 getConcentrateFlushTimeout( void ); +static U32 getConcentrateFlushPublishInterval( void ); + +/*********************************************************************//** + * @brief + * The initConcentrateFlush function initializes the Concentrate flush unit. + * @details \b Inputs: none + * @details \b Outputs: Concentrate flush unit initialized + * @return none + *************************************************************************/ +void initConcentrateFlush( void ) +{ + concentrateFlushState = CONC_FLUSH_PAUSED; + concentrateFlushDataPublishInterval.data = CONCENTRATE_FLUSH_DATA_PUBLISH_INTERVAL; + concentrateFlushDataPublishInterval.ovData = CONCENTRATE_FLUSH_DATA_PUBLISH_INTERVAL; + concentrateFlushDataPublishInterval.ovInitData = 0; + concentrateFlushDataPublishInterval.override = OVERRIDE_RESET; + concentrateFlushTimeout.data = CONCENTRATE_FLUSH_TIMEOUT; + concentrateFlushTimeout.ovData = CONCENTRATE_FLUSH_TIMEOUT; + concentrateFlushTimeout.ovInitData = 0; + concentrateFlushTimeout.override = OVERRIDE_RESET; + concentrateFlushDataPublicationTimerCounter = 0; + concentrateFlushTimer = 0; + isFlushComplete = FALSE; + pendingStartConcentrateFlushRequest = FALSE; + cumulativeConcentrateVolume_mL = 0.0F; +} + +/*********************************************************************//** + * @brief + * The execConcentrateFlush function executes the Concentrate flush state machine + * and publishes Concentrate flush data. + * @details \b Inputs: concentrateFlushState + * @details \b Outputs: concentrateFlushState + * @details \b Alarm: ALARM_ID_FP_SOFTWARE_FAULT if in invalid flush state + * @return none + *************************************************************************/ +void execConcentrateFlush( void ) +{ + switch ( concentrateFlushState ) + { + case CONC_FLUSH_IN_PROGRESS: + concentrateFlushState = handleConcentrateFlushProgressState(); + break; + + case CONC_FLUSH_PAUSED: + concentrateFlushState = handleConcentrateFlushPausedState(); + break; + + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_SOFTWARE_FAULT, SW_FAULT_ID_FP_INVALID_CONCENTRATE_FLUSH_STATE, (U32)concentrateFlushState ) + concentrateFlushState = CONC_FLUSH_PAUSED; + break; + } + + // publish Concentrate flush data on interval + publishConcentrateFlushData(); +} + +/*********************************************************************//** + * @brief + * The handleConcentrateFlushProgressState handles the in progress state of Concentrate flush + * @details \b Inputs: none + * @details \b Outputs: none + * @return the next state of Concentrate flush state + *************************************************************************/ +static FP_CONC_FLUSH_STATE_T handleConcentrateFlushProgressState( void ) +{ + FP_CONC_FLUSH_STATE_T state = CONC_FLUSH_IN_PROGRESS; + BOOL isVolumeOutOfRange = FALSE; + + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + setConcentrateFlushTransition( CONC_FLUSH_PAUSED ); + state = CONC_FLUSH_PAUSED; + } + + cumulativeConcentrateVolume_mL = getFlowRate(P7_FLOW) * CONCENTRATE_FLOW_INTEGRATOR; + + if( TRUE == didTimeout( concentrateFlushTimer, getConcentrateFlushTimeout() ) ) + { + + isVolumeOutOfRange = ( cumulativeConcentrateVolume_mL >= CONCENTRATE_FLUSH_VOLUME_THRESHOLD ? TRUE : FALSE ); + + if( FALSE == isVolumeOutOfRange ) + { + isFlushComplete = TRUE; + setConcentrateFlushTransition( CONC_FLUSH_PAUSED ); + state = CONC_FLUSH_PAUSED; + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_CONCENTRATE_FLUSH_VOLUME_OUT_OF_RANGE, CONCENTRATE_FLUSH_VOLUME_THRESHOLD, cumulativeConcentrateVolume_mL) + setConcentrateFlushTransition( CONC_FLUSH_PAUSED ); + state = CONC_FLUSH_PAUSED; + } + } + + return state; +} + +/*********************************************************************//** + * @brief + * The handleConcentrateFlushProgressState handles the in progress state of Concentrate flush + * @details \b Inputs: none + * @details \b Outputs: none + * @return the next state of Concentrate flush state + *************************************************************************/ +static FP_CONC_FLUSH_STATE_T handleConcentrateFlushPausedState( void ) +{ + FP_CONC_FLUSH_STATE_T state = CONC_FLUSH_PAUSED; + + if ( TRUE == pendingStartConcentrateFlushRequest ) + { + isFlushComplete = FALSE; + pendingStartConcentrateFlushRequest = FALSE; + setConcentrateFlushTransition( CONC_FLUSH_IN_PROGRESS ); + state = CONC_FLUSH_IN_PROGRESS; + } + return state; +} + +/*********************************************************************//** + * @brief + * The setConcentrateFlushTransition function sets the actuators and variables + * for the state transition in Concentrate flush mode. + * @details Inputs: Valve states, Pump speed + * @details Outputs: Actuate valves, pumps as desired. + * @param state Concentrate flush state enum + * @return none + *************************************************************************/ +static void setConcentrateFlushTransition( FP_CONC_FLUSH_STATE_T state ) +{ + // Execute on running state + switch( state ) + { + case CONC_FLUSH_IN_PROGRESS: + setValveState( M4_VALV, VALVE_STATE_OPEN ); + setValveState( P6_VALV, VALVE_STATE_CLOSED ); + setValveState( P11_VALV, VALVE_STATE_OPEN ); + setValveState( P33_VALV, VALVE_STATE_CLOSED ); + setValveState( P34_VALV, VALVE_STATE_CLOSED ); + setValveState( P37_VALV, VALVE_STATE_OPEN ); + setValveState( P39_VALV, VALVE_STATE_OPEN ); + + if ( TRUE == isBoostPumpInstalled() ) + { + setBoostPumpTargetPressure( CONCENTRATE_FLUSH_BOOST_PUMP_TGT_PSI ); + } + setROPumpTargetDutyCycle( CONCENTRATE_FLUSH_RO_PUMP_TGT_PWM ); + concentrateFlushTimer = getMSTimerCount(); + cumulativeConcentrateVolume_mL = 0; + break; + + case CONC_FLUSH_PAUSED: + + // Stop pumps and close only if we alarm ( pause ) during flush. + if ( FALSE == isConcentrateFlushComplete() ) + { + setValveState( M4_VALV, VALVE_STATE_CLOSED ); + setValveState( P6_VALV, VALVE_STATE_CLOSED ); + setValveState( P11_VALV, VALVE_STATE_CLOSED ); + setValveState( P33_VALV, VALVE_STATE_CLOSED ); + setValveState( P34_VALV, VALVE_STATE_CLOSED ); + setValveState( P37_VALV, VALVE_STATE_CLOSED ); + setValveState( P39_VALV, VALVE_STATE_CLOSED ); + + if ( TRUE == isBoostPumpInstalled() ) + { + signalBoostPumpHardStop(); + } + signalROPumpHardStop(); + } + break; + + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_SOFTWARE_FAULT, SW_FAULT_ID_FP_INVALID_CONCENTRATE_FLUSH_STATE, state ) + break; + } +} + +/*********************************************************************//** + * @brief + * The signalStartConcentrateFlush function signals the FP to start Concentrate flush. + * @details \b Inputs: none + * @details \b Outputs: pendingStartConcentrateFlushRequest + * @return the current state of Concentrate flush + *************************************************************************/ +void signalStartConcentrateFlush( void ) +{ + if ( CONC_FLUSH_PAUSED == getCurrentConcentrateFlushState() ) + { + pendingStartConcentrateFlushRequest = TRUE; + } +} + +/*********************************************************************//** + * @brief + * The resetFilterFlushSignals function resets the signal values for + * FP filter flush. + * @details \b Inputs: none + * @details \b Outputs: pendingStartFilterFlushRequest, isFlushComplete + * @return none + *************************************************************************/ +void resetConcentrateFlushSignals( void ) +{ + pendingStartConcentrateFlushRequest = FALSE; + isFlushComplete = FALSE; +} + +/*********************************************************************//** + * @brief + * The getCurrentConcentrateFlushState function returns the current state of + * Concentrate flush. + * @details \b Inputs: concentrateFlushState + * @details \b Outputs: concentrateFlushState + * @return the current state of Concentrate flush + *************************************************************************/ +FP_CONC_FLUSH_STATE_T getCurrentConcentrateFlushState( void ) +{ + return concentrateFlushState; +} + +/*********************************************************************//** + * @brief + * The isConcentrateFlushComplete function returns isConcentrateFlushComplete. + * @details \b Inputs: none + * @details \b Outputs: none + * @return the complete boolean for Concentrate flush. + *************************************************************************/ +BOOL isConcentrateFlushComplete( void ) +{ + return isFlushComplete; +} + +/*********************************************************************//** + * @brief + * The getConcentrateFlushTimeout function gets the generate water + * mode data publish interval. + * @details \b Inputs: ConcentrateFlushTimeOut + * @details \b Outputs: none + * @return the timeout timer for Concentrate flush. + *************************************************************************/ +static U32 getConcentrateFlushTimeout( void ) +{ + U32 result = getU32OverrideValue( &concentrateFlushTimeout ); + + return result; +} + +/*********************************************************************//** + * @brief + * The getConcentrateFlushPublishInterval function gets the Concentrate flush + * mode data publish interval. + * @details \b Inputs: concentrateFlushDataPublishInterval + * @details \b Outputs: none + * @return the interval at Concentrate flush mode data being published. + *************************************************************************/ +static U32 getConcentrateFlushPublishInterval( void ) +{ + U32 result = getU32OverrideValue( &concentrateFlushDataPublishInterval ); + + return result; +} + +/*********************************************************************//** + * @brief + * The publishConcentrateFlushData function broadcasts the Concentrate flush + * mode data at defined interval. + * @details \b Inputs: concentrateFlushDataPublicationTimerCounter + * @details \b Outputs: fp Concentrate flush data broadcast message sent + * @details \b Message \Sent: MSG_ID_FP_CONCENTRATE_FLUSH_DATA to publish the + * Concentrate flush mode data. + * @return none + *************************************************************************/ +static void publishConcentrateFlushData( void ) +{ + if ( ++concentrateFlushDataPublicationTimerCounter >= getConcentrateFlushPublishInterval() ) + { + CONC_FLUSH_DATA_T data; + + data.concentrateFlushExecState = (U32)getCurrentConcentrateFlushState(); + broadcastData( MSG_ID_FP_CONCENTRATE_FLUSH_DATA, COMM_BUFFER_OUT_CAN_FP_BROADCAST, (U08*)&data, sizeof( CONC_FLUSH_DATA_T ) ); + + concentrateFlushDataPublicationTimerCounter = 0; + } +} + + +/************************************************************************* + * TEST SUPPORT FUNCTIONS + *************************************************************************/ + + +/*********************************************************************//** + * @brief + * The testConcentrateFlushDataPublishIntervalOverride function overrides the + * FP Concentrate flush mode data publish interval. + * @details \b Inputs: concentrateFlushDataPublishInterval + * @details \b Outputs: concentrateFlushDataPublishInterval + * @param Override message from Dialin which includes the interval + * (in ms) to override the FP Concentrate flush data publish interval to. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testConcentrateFlushDataPublishIntervalOverride( MESSAGE_T *message ) +{ + BOOL result = u32BroadcastIntervalOverride( message, &concentrateFlushDataPublishInterval, TASK_GENERAL_INTERVAL ); + + return result; +} + +/*********************************************************************//** + * @brief + * The testConcentrateFlushTimerOverride function overrides the + * FP Concentrate flush timeout value. + * @details \b Inputs: concentrateFlushTimeout + * @details \b Outputs: concentrateFlushTimeout + * @param Override message from Dialin which includes the interval + * (in ms) to override the FP Concentrate flush timeout to. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testConcentrateFlushTimerOverride( MESSAGE_T *message ) +{ + BOOL result = u32Override( message, &concentrateFlushTimeout, 0, CONCENTRATE_FLUSH_MAX_TIMEOUT ); + + return result; +} + +/**@}*/ Index: firmware/App/Modes/FlushConcentrate.h =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Modes/FlushConcentrate.h (.../FlushConcentrate.h) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Modes/FlushConcentrate.h (.../FlushConcentrate.h) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -1,15 +1,56 @@ -/* - * FlushConcentrate.h +/************************************************************************** +* +* Copyright (c) 2024-2025 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 FlushConcentrate.h +* +* @author (last) Michael Garthwaite +* @date (last) 03-Mar-2025 +* +* @author (original) Michael Garthwaite +* @date (original) 03-Mar-2025 +* +***************************************************************************/ + +#ifndef __FLUSH_CONCENTRATE_H__ +#define __FLUSH_CONCENTRATE_H_ + +#include "FPCommon.h" +#include "FPDefs.h" + +/** + * @defgroup FPConcentrateFlush FPConcentrateFlush + * @brief Concentrate Flush unit. Manages Concentrate flush functions via a state machine. * - * Created on: Jul 2, 2025 - * Author: fw + * @addtogroup FPConcentrateFlush + * @{ */ -#ifndef APP_MODES_FLUSHCONCENTRATE_H_ -#define APP_MODES_FLUSHCONCENTRATE_H_ +// ********** public definitions ********** +/// Concentrate Flush data structure +typedef struct +{ + U32 concentrateFlushExecState; ///< Concentrate Flush execution state +} CONC_FLUSH_DATA_T; +// ********** public function prototypes ********** +void initConcentrateFlush( void ); // Initialize this Concentrate Flush unit +U32 transitionToConcentrateFlush( void ); // Transition to Concentrate Flush +void execConcentrateFlush( void ); // Execute the Concentrate Flush state machine +BOOL isConcentrateFlushComplete( void ); // returns if flush is complete +void signalStartConcentrateFlush( void ); // signal to start flush +void resetConcentrateFlushSignals( void ); // reset signals for flush +FP_CONC_FLUSH_STATE_T getCurrentConcentrateFlushState( void ); // Get the current state of the Concentrate Flush -#endif /* APP_MODES_FLUSHCONCENTRATE_H_ */ +BOOL testConcentrateFlushDataPublishIntervalOverride( MESSAGE_T *message ); +BOOL testConcentrateFlushTimerOverride( MESSAGE_T *message ); +/**@}*/ + + +#endif Index: firmware/App/Modes/FlushFilter.c =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Modes/FlushFilter.c (.../FlushFilter.c) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Modes/FlushFilter.c (.../FlushFilter.c) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -125,6 +125,12 @@ BOOL isPressureOutOfRange = FALSE; F32 pressureDif = 0.0; + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + setFilterFlushTransition( FILTER_FLUSH_PAUSED ); + state = FILTER_FLUSH_PAUSED; + } + if( TRUE == didTimeout( filterFlushTimer, getFilterFlushTimeout() ) ) { pressureDif = fabs( getFilteredPressure(M3_PRES) - getFilteredPressure(P8_PRES) ); Index: firmware/App/Modes/FlushPermeate.c =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Modes/FlushPermeate.c (.../FlushPermeate.c) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Modes/FlushPermeate.c (.../FlushPermeate.c) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -137,6 +137,12 @@ { FP_PERM_FLUSH_STATE_T state = PERM_FLUSH_IN_PROGRESS; + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + setPermeateFlushTransition( PERM_FLUSH_PAUSED ); + state = PERM_FLUSH_PAUSED; + } + if( TRUE == didTimeout( permeateFlushTimer, getPermeateFlushTimeout() ) ) { F32 p18conductivity = getFilteredConductivity( P18_COND ); @@ -176,9 +182,6 @@ if ( TRUE == pendingStartPermeateFlushRequest ) { isFlushComplete = FALSE; - pendingStartPermeateFlushRequest = FALSE; - permeateFlushTimer = getMSTimerCount(); - permeateFlushAlarmTimer = getMSTimerCount(); setPermeateFlushTransition( PERM_FLUSH_IN_PROGRESS ); state = PERM_FLUSH_IN_PROGRESS; } @@ -207,10 +210,15 @@ setValveState( P34_VALV, VALVE_STATE_CLOSED ); setValveState( P37_VALV, VALVE_STATE_CLOSED ); setValveState( P39_VALV, VALVE_STATE_OPEN ); + + if ( TRUE == isBoostPumpInstalled() ) + { + setBoostPumpTargetPressure( PERMEATE_FLUSH_BOOST_PUMP_TGT_PSI ); + } setROPumpTargetPressure( PERMEATE_FLUSH_RO_PUMP_TGT_PSI ); - setBoostPumpTargetPressure( PERMEATE_FLUSH_BOOST_PUMP_TGT_PSI ); permeateFlushTimer = getMSTimerCount(); permeateFlushAlarmTimer = getMSTimerCount(); + pendingStartPermeateFlushRequest = FALSE; break; case PERM_FLUSH_PAUSED: @@ -225,7 +233,11 @@ setValveState( P34_VALV, VALVE_STATE_CLOSED ); setValveState( P37_VALV, VALVE_STATE_CLOSED ); setValveState( P39_VALV, VALVE_STATE_CLOSED ); - signalBoostPumpHardStop(); + + if ( TRUE == isBoostPumpInstalled() ) + { + signalBoostPumpHardStop(); + } signalROPumpHardStop(); } break; Index: firmware/App/Modes/ModeGenPermeate.c =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Modes/ModeGenPermeate.c (.../ModeGenPermeate.c) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Modes/ModeGenPermeate.c (.../ModeGenPermeate.c) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -15,14 +15,16 @@ * ***************************************************************************/ -#include +#include "BoostPump.h" #include "DDInterface.h" #include "Level.h" #include "MessageSupport.h" #include "Messaging.h" #include "ModeGenPermeate.h" +#include "ModePreGenPermeate.h" #include "ModeStandby.h" #include "OperationModes.h" +#include "ROPump.h" #include "TaskGeneral.h" #include "Timers.h" #include "Valves.h" @@ -34,16 +36,21 @@ // ********** private definitions ********** -#define GEN_PERMEATE_DATA_PUBLISH_INTERVAL ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) ///< Interval (ms/task time) at which the gen permeate mode data published. -#define GEN_PERMEATE_TIMEOUT_MS ( 6 * MS_PER_SECOND ) ///< state switch timeout (in ms) +#define PRE_GEN_PERMEATE_DATA_PUBLISH_INTERVAL ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) ///< Interval (ms/task time) at which the gen permeate mode data published. +#define GEN_PERMEATE_TANK_FULL_SWITCH_MS ( 6 * MS_PER_SECOND ) ///< state switch timeout (in ms) +#define GEN_PERMEATE_TANK_FULL_TIMEOUT_MS ( 60 * MS_PER_SECOND ) +#define GEN_PERMEATE_BOOST_PUMP_TGT_PSI 25 // ********** private data ********** static FP_GENP_MODE_STATE_T genPermeateState; ///< Currently active generate Permeate state. static U32 genPermeateDataPublicationTimerCounter; ///< Used to schedule generate Permeate data publication to CAN bus. static OVERRIDE_U32_T genPermeateDataPublishInterval; ///< Generate permeate mode data publish interval. -static U32 stateDelayTime; ///< Time stamp to track delay before valve switch. -static U32 pendingStartGenRequest; ///< Flag indicating DD has requested FP start the generate permeate. +static U32 tankFullDelayTime; ///< Time stamp to track delay before valve switch. +static BOOL pendingStartGenRequest; ///< Flag indicating DD has requested FP start the generate permeate. +static F32 genPermeateRODutyCycle; +static F32 genPermeateBoostDutyCycle; +static U32 tankFullAlarmTimeout; // ********** private function prototypes ********** @@ -63,13 +70,16 @@ void initGenPermeateMode( void ) { genPermeateState = FP_GENP_TANK_FILL_STATE; - genPermeateDataPublishInterval.data = GEN_PERMEATE_DATA_PUBLISH_INTERVAL; - genPermeateDataPublishInterval.ovData = GEN_PERMEATE_DATA_PUBLISH_INTERVAL; + genPermeateDataPublishInterval.data = PRE_GEN_PERMEATE_DATA_PUBLISH_INTERVAL; + genPermeateDataPublishInterval.ovData = PRE_GEN_PERMEATE_DATA_PUBLISH_INTERVAL; genPermeateDataPublishInterval.ovInitData = 0; genPermeateDataPublishInterval.override = OVERRIDE_RESET; genPermeateDataPublicationTimerCounter = 0; - stateDelayTime = 0; + tankFullDelayTime = 0; + tankFullAlarmTimeout = 0; pendingStartGenRequest = 0; + genPermeateRODutyCycle = 0.0F; + genPermeateBoostDutyCycle = 0.0F; } /*********************************************************************//** @@ -84,7 +94,6 @@ { initGenPermeateMode(); setCurrentSubState( genPermeateState ); - return genPermeateState; } @@ -98,13 +107,8 @@ *************************************************************************/ U32 execGenPermeateMode( void ) { - LEVEL_STATE_T level = getLevelStatus(); + FP_GENP_MODE_STATE_T prevState = genPermeateState; - if ( LEVEL_STATE_ILLEGAL == level ) - { - // TODO: Raise illegal level alarm - } - // execute current gen Permeate state switch ( genPermeateState ) { @@ -121,6 +125,12 @@ break; } + + if ( prevState != genPermeateState ) + { + setModeGenPTransition( genPermeateState ); + SEND_EVENT_WITH_2_U32_DATA( FP_EVENT_GENP_CHANGE, genPermeateState, prevState ) + } //Publish Gen Permeate mode data publishGenPModeData(); @@ -147,6 +157,12 @@ setValveState( P6_VALV,VALVE_STATE_CLOSED ); setValveState( P39_VALV,VALVE_STATE_OPEN ); setValveState( P11_VALV, VALVE_STATE_OPEN ); + + if ( TRUE == isBoostPumpInstalled() ) + { + setBoostPumpTargetPressure( GEN_PERMEATE_BOOST_PUMP_TGT_PSI ); + } + setROPumpTargetDutyCycle( getGenPermeateRODutyCycle() ); break; case FP_GENP_TANK_FULL_STATE: @@ -155,7 +171,14 @@ setValveState( P6_VALV,VALVE_STATE_CLOSED ); setValveState( P39_VALV,VALVE_STATE_OPEN ); setValveState( P11_VALV, VALVE_STATE_CLOSED ); - stateDelayTime = getMSTimerCount(); + + if ( TRUE == isBoostPumpInstalled() ) + { + signalBoostPumpHardStop(); + } + tankFullDelayTime = getMSTimerCount(); + tankFullAlarmTimeout = getMSTimerCount(); + setROPumpTargetDutyCycle( getGenPermeateRODutyCycle() ); break; default: @@ -178,8 +201,13 @@ if ( LEVEL_STATE_HIGH == level ) { - setModeGenPTransition( FP_GENP_TANK_FULL_STATE ); state = FP_GENP_TANK_FULL_STATE; + // save boost pump + if ( TRUE == isBoostPumpInstalled() ) + { + setGenPermeateBoostDutyCycle( getCurrentBoostPumpDutyCyclePCT() ); + SEND_EVENT_WITH_2_U32_DATA( FP_EVENT_GENP_BOOST_SET_PWM, getCurrentBoostPumpDutyCyclePCT(), getFluidPumpReadPWMDutyCycle( P40_PUMP ) ) + } } else if ( level <= LEVEL_STATE_MEDIUM ) @@ -203,14 +231,14 @@ FP_GENP_MODE_STATE_T state = FP_GENP_TANK_FULL_STATE; LEVEL_STATE_T level = getLevelStatus(); - if ( LEVEL_STATE_LOW == level ) + if ( TRUE == didTimeout( tankFullAlarmTimeout, GEN_PERMEATE_TANK_FULL_TIMEOUT_MS ) ) { - // TODO: Turn off heater. + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_FP_GEN_PERMEATE_TANK_FULL_TIMEOUT, level ) } - else if ( ( level >= LEVEL_STATE_MEDIUM ) && ( TRUE == didTimeout( stateDelayTime, GEN_PERMEATE_TIMEOUT_MS ) ) ) + if ( ( ( level == LEVEL_STATE_MEDIUM ) && ( TRUE == didTimeout( tankFullDelayTime, GEN_PERMEATE_TANK_FULL_SWITCH_MS ) ) ) || + ( level == LEVEL_STATE_LOW ) ) { - setModeGenPTransition( FP_GENP_TANK_FILL_STATE ); state = FP_GENP_TANK_FILL_STATE; } @@ -219,6 +247,58 @@ /*********************************************************************//** * @brief + * The getGenPermeateBoostDutyCycle function returns the current Boost pump pwm setting + * in gen permeate mode. + * @details \b Inputs: genPermeateBoostDutyCycle + * @details \b Outputs: genPermeateBoostDutyCycle + * @return the current pwm setting for the RO Pump + *************************************************************************/ +F32 getGenPermeateBoostDutyCycle( void ) +{ + return genPermeateBoostDutyCycle; +} + +/*********************************************************************//** + * @brief + * The setGenPermeateBoostDutyCycle function sets the Boost pump pwm in gen permeate + * mode + * @details \b Inputs: none + * @details \b Outputs: genPermeateBoostDutyCycle + * @return none + *************************************************************************/ +void setGenPermeateBoostDutyCycle( F32 duty) +{ + genPermeateBoostDutyCycle = duty; +} + +/*********************************************************************//** + * @brief + * The getGenPermeateRODutyCycle function returns the current pwm setting + * for the RO pump in gen permeate mode. + * @details \b Inputs: genPermeateRODutyCycle + * @details \b Outputs: genPermeateRODutyCycle + * @return the current pwm setting for the RO Pump + *************************************************************************/ +F32 getGenPermeateRODutyCycle( void ) +{ + return genPermeateRODutyCycle; +} + +/*********************************************************************//** + * @brief + * The setGenPermeateRODutyCycle function sets the RO PWM pump in gen permeate + * mode + * @details \b Inputs: none + * @details \b Outputs: genPermeateRODutyCycle + * @return none + *************************************************************************/ +void setGenPermeateRODutyCycle( F32 duty) +{ + genPermeateRODutyCycle = duty; +} + +/*********************************************************************//** + * @brief * The getCurrentGenPermeateState function returns the current state of the * gen permeate mode. * @details \b Inputs: genPermeateState @@ -232,6 +312,19 @@ /*********************************************************************//** * @brief + * The getGenPermeateRequest function returns the current state of the + * gen permeate mode. + * @details \b Inputs: pendingStartGenRequest + * @details \b Outputs: none + * @return the current state of gen permeate request + *************************************************************************/ +BOOL getGenPermeateRequest( void ) +{ + return pendingStartGenRequest; +} + +/*********************************************************************//** + * @brief * The getGenPermeateDataPublishInterval function gets the generate water * mode data publish interval. * @details \b Inputs: genPermeateDataPublishInterval @@ -285,6 +378,7 @@ { result = TRUE; pendingStartGenRequest = TRUE; + requestNewOperationMode( FP_MODE_GENP ); } return result; @@ -301,6 +395,12 @@ { BOOL result = TRUE; pendingStartGenRequest = FALSE; + signalROPumpHardStop(); + + if ( TRUE == isBoostPumpInstalled() ) + { + signalBoostPumpHardStop(); + } requestNewOperationMode( FP_MODE_STAN ); return result; Index: firmware/App/Modes/ModeGenPermeate.h =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Modes/ModeGenPermeate.h (.../ModeGenPermeate.h) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Modes/ModeGenPermeate.h (.../ModeGenPermeate.h) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -45,6 +45,10 @@ U32 execGenPermeateMode( void ); // Execute the gen permeate mode state machine (call from OperationModes) BOOL requestGenWaterStart( void ); BOOL requestGenWaterStop( void ); +F32 getGenPermeateRODutyCycle( void ); +void setGenPermeateRODutyCycle( F32 duty); +F32 getGenPermeateBoostDutyCycle( void ); +void setGenPermeateBoostDutyCycle( F32 duty); FP_GENP_MODE_STATE_T getCurrentGenPermeateState( void ); // Get the current state of the gen water mode Index: firmware/App/Modes/ModeGenPermeateDefeatured.c =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Modes/ModeGenPermeateDefeatured.c (.../ModeGenPermeateDefeatured.c) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Modes/ModeGenPermeateDefeatured.c (.../ModeGenPermeateDefeatured.c) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -1,28 +1,322 @@ +/************************************************************************** +* +* Copyright (c) 2024-2024 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 ModeGenPermeateDefeatured.c +* +* @author (last) Michael Garthwaite +* @date (last) 28-Feb-2025 +* +* @author (original) Michael Garthwaite +* @date (original) 28-Feb-2025 +* +***************************************************************************/ +#include "Messaging.h" +#include "MessageSupport.h" #include "ModeGenPermeateDefeatured.h" +#include "ModePreGenPermeateDefeatured.h" +#include "ModeStandby.h" +#include "OperationModes.h" +#include "TaskGeneral.h" +#include "Timers.h" +#include "Valves.h" /** - * @addtogroup FPGenPermeateDefeatured + * @addtogroup FPGenPermeateDefeaturedMode * @{ */ +// ********** private definitions ********** + +#define PRE_GEN_DEF_PERMEATE_DATA_PUBLISH_INTERVAL ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) ///< Interval (ms/task time) at which the gen permeate mode data published. + // ********** private data ********** +static FP_GENP_DEF_MODE_STATE_T genPermeateDefState; ///< Currently active generate Permeate Defeatured state. +static U32 genPermeateDefDataPublicationTimerCounter; ///< Used to schedule generate Permeate data publication to CAN bus. +static OVERRIDE_U32_T genPermeateDefDataPublishInterval; ///< Generate permeate mode data publish interval. +static BOOL pendingStartGenDefRequest; ///< Flag indicating DD has requested FP start the generate permeate. +// ********** private function prototypes ********** + +static FP_GENP_DEF_MODE_STATE_T handleGenPDefSupplyWaterState( void ); +static FP_GENP_DEF_MODE_STATE_T handleGenPDefPausedState( void ); +static void setModeGenPDefTransition( FP_GENP_DEF_MODE_STATE_T state ); +static U32 getGenPermeateDefDataPublishInterval( void ); +static void publishGenPDefModeData( void ); + +/*********************************************************************//** + * @brief + * The initGenPermeateDefeaturedMode function initializes the + * defeatured permeate generation mode. + * @details \b Inputs: none + * @details \b Outputs: defeatured permeate mode unit initialized + * @return none + *************************************************************************/ void initGenPermeateDefeaturedMode( void ) { - + genPermeateDefState = FP_GENP_DEF_PAUSED; + genPermeateDefDataPublishInterval.data = PRE_GEN_DEF_PERMEATE_DATA_PUBLISH_INTERVAL; + genPermeateDefDataPublishInterval.ovData = PRE_GEN_DEF_PERMEATE_DATA_PUBLISH_INTERVAL; + genPermeateDefDataPublishInterval.ovInitData = 0; + genPermeateDefDataPublishInterval.override = OVERRIDE_RESET; + genPermeateDefDataPublicationTimerCounter = 0; + pendingStartGenDefRequest = FALSE; } +/*********************************************************************//** + * @brief + * The transitionToGenPermeateDefeaturedMode function prepares for transition + * to defeatured gen permeate mode. + * @details \b Inputs: none + * @details \b Outputs: none + * @return initial state + *************************************************************************/ U32 transitionToGenPermeateDefeaturedMode( void ) { - return 0; + initGenPermeateDefeaturedMode(); + setCurrentSubState( genPermeateDefState ); + return genPermeateDefState; } +/*********************************************************************//** + * @brief + * The execGenPermeateDefeaturedMode function executes the Gen + * Permeate defeatured mode state machine. + * @details \b Inputs: none + * @details \b Outputs: Gen Permeate defeatured mode state machine executed + * @details \b Alarm: ALARM_ID_FP_SOFTWARE_FAULT when wrong state invoked. + * @return current state. + *************************************************************************/ U32 execGenPermeateDefeaturedMode( void ) { - return 0; + FP_GENP_DEF_MODE_STATE_T prevState = genPermeateDefState; + + // execute current gen Permeate defeatured state + switch ( genPermeateDefState ) + { + case FP_GENP_DEF_SUPPLY_WATER: + genPermeateDefState = handleGenPDefSupplyWaterState(); + break; + + case FP_GENP_DEF_PAUSED: + genPermeateDefState = handleGenPDefPausedState(); + break; + + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_SOFTWARE_FAULT, SW_FAULT_ID_FP_INVALD_GENP_DEF_STATE, genPermeateDefState ) + break; + } + + if ( prevState != genPermeateDefState ) + { + setModeGenPDefTransition( genPermeateDefState ); + SEND_EVENT_WITH_2_U32_DATA( FP_EVENT_GENP_DEF_CHANGE, genPermeateDefState, prevState ) + } + //Publish Gen Permeate mode data + publishGenPDefModeData(); + + return genPermeateDefState; } -/**@}*/ +/*********************************************************************//** + * @brief + * The setModeGenPDefTransition function sets the actuators and variables + * for the state transition in generate permeate mode. + * @details Inputs: Valve states, Pump speed + * @details Outputs: Actuate valves, pumps as desired. + * @param state gen permeate state enum + * @return none + *************************************************************************/ +static void setModeGenPDefTransition( FP_GENP_DEF_MODE_STATE_T state ) +{ + // Execute on running state + switch( state ) + { + case FP_GENP_DEF_SUPPLY_WATER: + setValveState( M4_VALV, VALVE_STATE_OPEN ); + setValveState( P6_VALV, VALVE_STATE_CLOSED ); + setValveState( P11_VALV, VALVE_STATE_CLOSED ); + setValveState( P33_VALV, VALVE_STATE_CLOSED ); + setValveState( P34_VALV, VALVE_STATE_CLOSED ); + setValveState( P37_VALV, VALVE_STATE_CLOSED ); + setValveState( P39_VALV, VALVE_STATE_CLOSED ); + break; + case FP_GENP_DEF_PAUSED: + setValveState( M4_VALV, VALVE_STATE_CLOSED ); + setValveState( P6_VALV, VALVE_STATE_CLOSED ); + setValveState( P11_VALV, VALVE_STATE_CLOSED ); + setValveState( P33_VALV, VALVE_STATE_CLOSED ); + setValveState( P34_VALV, VALVE_STATE_CLOSED ); + setValveState( P37_VALV, VALVE_STATE_CLOSED ); + setValveState( P39_VALV, VALVE_STATE_CLOSED ); + break; + + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_SOFTWARE_FAULT, SW_FAULT_ID_FP_INVALID_GENP_STATE, state ) + break; + } +} + +/*********************************************************************//** + * @brief + * The handleGenPDefSupplyWaterState handles the supply water of gen permeate + * defeatured mode. + * @details \b Inputs: none + * @details \b Outputs: nones + * @return the next state of gen water defeatured mode + *************************************************************************/ +static FP_GENP_DEF_MODE_STATE_T handleGenPDefSupplyWaterState( void ) +{ + FP_GENP_DEF_MODE_STATE_T state = FP_GENP_DEF_SUPPLY_WATER; + + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + state = FP_GENP_DEF_PAUSED; + } + return state; +} + +/*********************************************************************//** + * @brief + * The handleGenPDefPausedState handles the pause state of gen permeate + * defeatured mode. + * @details \b Inputs: none + * @details \b Outputs: none + * @return the next state of gen water defeatured mode + *************************************************************************/ +static FP_GENP_DEF_MODE_STATE_T handleGenPDefPausedState( void ) +{ + FP_GENP_DEF_MODE_STATE_T state = FP_GENP_DEF_PAUSED; + + return state; +} + +/*********************************************************************//** + * @brief + * The getCurrentGenPermeateDefState function returns the current state of the + * gen permeate defeatured mode. + * @details \b Inputs: genPermeateDefState + * @details \b Outputs: genPermeateDefState + * @return the current state of gen permeate defeatured mode + *************************************************************************/ +FP_GENP_DEF_MODE_STATE_T getCurrentGenPermeateDefState( void ) +{ + return genPermeateDefState; +} + +/*********************************************************************//** + * @brief + * The requestGenWaterDefStart function handles an DD request to start (go to gen permeate mode). + * @details \b Inputs: none + * @details \b Outputs: pendingStartGenDefRequest + * @return TRUE if request accepted, FALSE if not. + *************************************************************************/ +BOOL requestGenWaterDefStart( void ) +{ + BOOL result = FALSE; + + result = TRUE; + pendingStartGenDefRequest = TRUE; + requestNewOperationMode( FP_MODE_DEGW ); + + return result; +} + +/*********************************************************************//** + * @brief + * The getGenPermeateDefRequest function returns the current state of the + * gen permeate defeatured mode. + * @details \b Inputs: pendingStartGenDefRequest + * @details \b Outputs: none + * @return the current state of gen permeate defeatured request + *************************************************************************/ +BOOL getGenPermeateDefRequest( void ) +{ + return pendingStartGenDefRequest; +} + +/*********************************************************************//** + * @brief + * The requestGenWaterDefStop function handles an DD request to stop (go to standby mode). + * @details \b Inputs: none + * @details \b Outputs: pendingStartGenDefRequest + * @return TRUE if request accepted, FALSE if not. + *************************************************************************/ +BOOL requestGenWaterDefStop( void ) +{ + BOOL result = TRUE; + pendingStartGenDefRequest = FALSE; + requestNewOperationMode( FP_MODE_STAN ); + + return result; +} + +/*********************************************************************//** + * @brief + * The getGenPermeateDataPublishInterval function gets the generate permeate + * defeatured mode data publish interval. + * @details \b Inputs: genPermeateDefDataPublishInterval + * @details \b Outputs: none + * @return the interval at generate permeate defeatured mode data being published. + *************************************************************************/ +static U32 getGenPermeateDefDataPublishInterval( void ) +{ + U32 result = getU32OverrideValue( &genPermeateDefDataPublishInterval ); + + return result; +} + +/*********************************************************************//** + * @brief + * The publishGenPModeData function broadcasts the generate water + * mode data at defined interval. + * @details \b Inputs: genPermeateDataPublicationTimerCounter + * @details \b Outputs: FP generate permeate data broadcast message sent + * @details \b Message \Sent: MSG_ID_FP_GENP_DEF_DATA to publish the + * generate water mode data. + * @return none + *************************************************************************/ +static void publishGenPDefModeData( void ) +{ + if ( ++genPermeateDefDataPublicationTimerCounter >= getGenPermeateDefDataPublishInterval() ) + { + GEN_PERMEATE_DEF_MODE_DATA_T data; + + data.genPermeateDefExecState = (U32)getCurrentGenPermeateDefState(); + + broadcastData( MSG_ID_FP_GENP_DEF_DATA, COMM_BUFFER_OUT_CAN_FP_BROADCAST, (U08*)&data, sizeof( GEN_PERMEATE_DEF_MODE_DATA_T ) ); + + genPermeateDefDataPublicationTimerCounter = 0; + } +} + + +/************************************************************************* + * TEST SUPPORT FUNCTIONS + *************************************************************************/ + + +/*********************************************************************//** + * @brief + * The testGenPermeateDefDataPublishIntervalOverride function overrides the + * DD generate water mode data publish interval. + * @details \b Inputs: genPermeateDefDataPublishInterval + * @details \b Outputs: genPermeateDefDataPublishInterval + * @param Override message from Dialin which includes the interval + * (in ms) to override the FP generate permeate data publish interval to. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testGenPermeateDefDataPublishIntervalOverride( MESSAGE_T *message ) +{ + BOOL result = u32BroadcastIntervalOverride( message, &genPermeateDefDataPublishInterval, TASK_GENERAL_INTERVAL ); + + return result; +} + +/**@}*/ Index: firmware/App/Modes/ModeGenPermeateDefeatured.h =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Modes/ModeGenPermeateDefeatured.h (.../ModeGenPermeateDefeatured.h) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Modes/ModeGenPermeateDefeatured.h (.../ModeGenPermeateDefeatured.h) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -1,11 +1,56 @@ +/************************************************************************** +* +* Copyright (c) 2024-2025 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 ModeGenPermeateDefeatured.h +* +* @author (last) Michael Garthwaite +* @date (last) 03-Mar-2025 +* +* @author (original) Michael Garthwaite +* @date (original) 03-Mar-2025 +* +***************************************************************************/ - #ifndef __MODE_GENP_DEF_H__ #define __MODE_GENP_DEF_H__ #include "FPCommon.h" #include "FPDefs.h" +/** + * @defgroup FPGenPermeateDefeaturedMode FPGenPermeateDefeaturedMode + * @brief Generate Permeate Defeatured unit. Manages water generation functions via a state machine. + * + * @addtogroup FPGenPermeateDefeaturedMode + * @{ + */ +// ********** public definitions ********** +/// Generate Permeate mode data structure +typedef struct +{ + U32 genPermeateDefExecState; ///< Generate Permeate Defeatured execution state +} GEN_PERMEATE_DEF_MODE_DATA_T; + +// ********** public function prototypes ********** + +void initGenPermeateDefeaturedMode( void ); // Initialize this gen permeate mode unit +U32 transitionToGenPermeateDefeaturedMode( void ); // Transition to gen permeate mode +U32 execGenPermeateDefeaturedMode( void ); // Execute the gen permeate mode state machine (call from OperationModes) +BOOL requestGenWaterDefStart( void ); +BOOL requestGenWaterDefStop( void ); +BOOL getGenPermeateRequest( void ); + +FP_GENP_DEF_MODE_STATE_T getCurrentGenPermeateDefState( void ); // Get the current state of the gen water mode + +BOOL testGenPermeateDefDataPublishIntervalOverride( MESSAGE_T *message ); // override broadcast interval for gen permeate + +/**@}*/ + + #endif Index: firmware/App/Modes/ModePreGenPermeate.c =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Modes/ModePreGenPermeate.c (.../ModePreGenPermeate.c) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Modes/ModePreGenPermeate.c (.../ModePreGenPermeate.c) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -15,17 +15,21 @@ * ***************************************************************************/ +#include "BoostPump.h" #include "DDInterface.h" #include "FlushFilter.h" #include "FlushPermeate.h" +#include "FlushConcentrate.h" #include "MessageSupport.h" #include "Messaging.h" #include "ModeGenPermeate.h" #include "ModePreGenPermeate.h" #include "ModeStandby.h" #include "OperationModes.h" +#include "ROPump.h" #include "TaskGeneral.h" #include "Timers.h" +#include "Valves.h" /** * @addtogroup FPPreGenPermeateMode @@ -35,13 +39,18 @@ // ********** private definitions ********** #define PRE_GENP_DATA_PUBLISH_INTERVAL ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) ///< Interval (ms/task time) at which the pre gen Permeate mode data published. +#define VERIFY_WATER_RO_PUMP_TGT_PSI 15 +#define VERIFY_WATER_BOOST_PUMP_TGT_PSI 25 +#define VERIFY_WATER_TIMEOUT_MS ( 5 * MS_PER_SECOND ) // ********** private data ********** static FP_PRE_GENP_MODE_STATE_T preGenPState; ///< Currently active pre generate Permeate state. static U32 preGenPDataPublicationTimerCounter; ///< Used to schedule pre generate Permeate data publication to CAN bus. static OVERRIDE_U32_T preGenPDataPublishInterval; ///< Pre Generate Permeate mode data publish interval. +static BOOL isPreGenComplete; ///< Flag indicating if Pre generation has completed. static U32 pendingStartPreGenRequest; ///< Flag indicating DD has requested FP start the generate permeate. +static U32 verifyWaterTimer; // ********** private function prototypes ********** @@ -70,6 +79,8 @@ preGenPDataPublishInterval.override = OVERRIDE_RESET; preGenPDataPublicationTimerCounter = 0; pendingStartPreGenRequest = FALSE; + isPreGenComplete = FALSE; + verifyWaterTimer = 0; } /*********************************************************************//** @@ -84,7 +95,6 @@ { initPreGenPMode(); setCurrentSubState( preGenPState ); - return preGenPState; } @@ -98,6 +108,7 @@ *************************************************************************/ U32 execPreGenPMode( void ) { + FP_PRE_GENP_MODE_STATE_T previouspreGenPState = preGenPState; // execute current pre gen Permeate state switch ( preGenPState ) { @@ -110,11 +121,11 @@ break; case FP_PRE_GENP_PERMEATE_FLUSH: - preGenPState = handlePreGenPConcentrateFlushState(); + preGenPState = handlePreGenPPermeateFlushState(); break; case FP_PRE_GENP_CONCENTRATE_FLUSH: - preGenPState = handlePreGenPPermeateFlushState(); + preGenPState = handlePreGenPConcentrateFlushState(); break; case FP_PRE_GENP_VERIFY_WATER: @@ -129,6 +140,12 @@ SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_SOFTWARE_FAULT, SW_FAULT_ID_FP_INVALID_PGEN_STATE, preGenPState ) break; } + + if( previouspreGenPState != preGenPState ) + { + setModePreGenPTransition( preGenPState ); + SEND_EVENT_WITH_2_U32_DATA( FP_EVENT_PRE_GEN_CHANGE, preGenPState, previouspreGenPState ) + } //Publish pre Gen Permeate mode data publishPreGenPModeData(); @@ -165,7 +182,20 @@ break; case FP_PRE_GENP_VERIFY_WATER: - // Actuator transitions happen within Verify Water exec + setValveState( M4_VALV, VALVE_STATE_OPEN ); + setValveState( P6_VALV, VALVE_STATE_CLOSED ); + setValveState( P11_VALV, VALVE_STATE_OPEN ); + setValveState( P33_VALV, VALVE_STATE_CLOSED ); // TODO - Change valves to handle RO rejection config + setValveState( P34_VALV, VALVE_STATE_CLOSED ); + setValveState( P37_VALV, VALVE_STATE_CLOSED ); + setValveState( P39_VALV, VALVE_STATE_OPEN ); + + if ( TRUE == isBoostPumpInstalled() ) + { + setBoostPumpTargetPressure( VERIFY_WATER_BOOST_PUMP_TGT_PSI ); + } + setROPumpTargetPressure( VERIFY_WATER_RO_PUMP_TGT_PSI ); + verifyWaterTimer = getMSTimerCount(); break; case FP_PRE_GENP_PAUSED: @@ -188,9 +218,15 @@ { FP_PRE_GENP_MODE_STATE_T state = FP_PRE_GENP_INLET_PRESSURE_CHECK; + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + state = FP_PRE_GENP_PAUSED; + } + if ( FALSE == isBoostPumpInstalled() ) { signalStartFilterFlush(); + state = FP_PRE_GENP_FILTER_FLUSH; } else { @@ -210,10 +246,16 @@ { FP_PRE_GENP_MODE_STATE_T state = FP_PRE_GENP_FILTER_FLUSH; + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + state = FP_PRE_GENP_PAUSED; + } + execFilterFlush(); if( TRUE == isFilterFlushComplete() ) { + signalStartPermeateFlush(); state = FP_PRE_GENP_PERMEATE_FLUSH; } @@ -232,10 +274,16 @@ { FP_PRE_GENP_MODE_STATE_T state = FP_PRE_GENP_PERMEATE_FLUSH; + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + state = FP_PRE_GENP_PAUSED; + } + execPermeateFlush(); if( TRUE == isPermeateFlushComplete() ) { + signalStartConcentrateFlush(); state = FP_PRE_GENP_CONCENTRATE_FLUSH; } @@ -254,9 +302,14 @@ { FP_PRE_GENP_MODE_STATE_T state = FP_PRE_GENP_CONCENTRATE_FLUSH; - execFilterFlush(); + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + state = FP_PRE_GENP_PAUSED; + } - if( TRUE == isFilterFlushComplete() ) + execConcentrateFlush(); + + if( TRUE == isConcentrateFlushComplete() ) { state = FP_PRE_GENP_VERIFY_WATER; } @@ -269,13 +322,28 @@ * The handlePreGenPVerifyWaterState handles the verify water state of * pre gen water. * @details \b Inputs: none - * @details \b Outputs: none + * @details \b Outputs: isPreGenComplete * @return the next state of pre gen water mode *************************************************************************/ static FP_PRE_GENP_MODE_STATE_T handlePreGenPVerifyWaterState( void ) { FP_PRE_GENP_MODE_STATE_T state = FP_PRE_GENP_VERIFY_WATER; + F32 roCurrentDutyCycle = getCurrentROPumpDutyCyclePCT(); + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + state = FP_PRE_GENP_PAUSED; + } + + if( TRUE == didTimeout( verifyWaterTimer, VERIFY_WATER_TIMEOUT_MS ) ) + { + setGenPermeateRODutyCycle( roCurrentDutyCycle ); + transitionToGenPermeateMode(); + requestGenWaterStart(); // transition function will clear start flag + isPreGenComplete = TRUE; + SEND_EVENT_WITH_2_U32_DATA( FP_EVENT_PRE_GEN_RO_SET_PWM, roCurrentDutyCycle, getFluidPumpReadPWMDutyCycle( P12_PUMP ) ) + } + return state; } @@ -310,6 +378,18 @@ /*********************************************************************//** * @brief + * The isPreGenPComplete function returns isPreGenComplete. + * @details \b Inputs: none + * @details \b Outputs: none + * @return the complete boolean for Pre-Gen Mode. + *************************************************************************/ +BOOL isPreGenPComplete( void ) +{ + return isPreGenComplete; +} + +/*********************************************************************//** + * @brief * The getPreGenRequest function returns the current state of the * pre gen water mode. * @details \b Inputs: pendingStartPreGenRequest @@ -375,6 +455,7 @@ { result = TRUE; pendingStartPreGenRequest = TRUE; + requestNewOperationMode( FP_MODE_PGEN ); } return result; @@ -391,6 +472,12 @@ { BOOL result = TRUE; pendingStartPreGenRequest = FALSE; + signalROPumpHardStop(); + + if ( TRUE == isBoostPumpInstalled() ) + { + signalBoostPumpHardStop(); + } requestNewOperationMode( FP_MODE_STAN ); return result; Index: firmware/App/Modes/ModePreGenPermeateDefeatured.c =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Modes/ModePreGenPermeateDefeatured.c (.../ModePreGenPermeateDefeatured.c) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Modes/ModePreGenPermeateDefeatured.c (.../ModePreGenPermeateDefeatured.c) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -1,28 +1,380 @@ +/************************************************************************** +* +* Copyright (c) 2024-2024 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 ModePreGenPermeateDefeatured.c +* +* @author (last) Michael Garthwaite +* @date (last) 28-Feb-2025 +* +* @author (original) Michael Garthwaite +* @date (original) 28-Feb-2025 +* +***************************************************************************/ +#include "Messaging.h" +#include "MessageSupport.h" +#include "ModeGenPermeateDefeatured.h" #include "ModePreGenPermeateDefeatured.h" +#include "ModeStandby.h" +#include "OperationModes.h" +#include "TaskGeneral.h" +#include "Timers.h" +#include "Valves.h" /** - * @addtogroup FPreGenPermeateDefeatured + * @addtogroup FPGenPermeateDefeaturedMode * @{ */ +// ********** private definitions ********** + +#define PRE_GEN_DEF_PERMEATE_DATA_PUBLISH_INTERVAL ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) ///< Interval (ms/task time) at which the gen permeate mode data published. +#define PRE_GEN_DEF_FLUSH_TIMEOUT_MS ( 30 * MS_PER_SECOND ) +#define PRE_GEN_DEF_WATER_CHECK_TIMEOUT_MS ( 10 * MS_PER_SECOND ) + // ********** private data ********** +static FP_PRE_GENP_DEF_MODE_STATE_T preGenPermeateDefState; ///< Currently active generate Permeate Defeatured state. +static U32 preGenPermeateDefDataPublicationTimerCounter; ///< Used to schedule generate Permeate data publication to CAN bus. +static OVERRIDE_U32_T preGenPermeateDefDataPublishInterval; ///< Generate permeate mode data publish interval. +static BOOL pendingStartPreGenDefRequest; ///< Flag indicating DD has requested FP start the generate permeate. +static U32 preGenPermeateDefFlushTimer; +static U32 preGenPermeateDefWaterCheckTimer; -void initPreGenPDefMode( void ) +// ********** private function prototypes ********** + +static FP_PRE_GENP_DEF_MODE_STATE_T handlePreGenPDefFlushState( void ); +static FP_PRE_GENP_DEF_MODE_STATE_T handlePreGenPDefInletWaterState( void ); +static FP_PRE_GENP_DEF_MODE_STATE_T handlePreGenPDefPausedState( void ); +static void setModePreGenPDefTransition( FP_GENP_DEF_MODE_STATE_T state ); +static U32 getPreGenPermeateDefDataPublishInterval( void ); +static void publishPreGenPDefModeData( void ); + +/*********************************************************************//** + * @brief + * The initPreGenPermeateDefeaturedMode function initializes the + * defeatured permeate generation mode. + * @details \b Inputs: none + * @details \b Outputs: defeatured permeate mode unit initialized + * @return none + *************************************************************************/ +void initPreGenPermeateDefeaturedMode( void ) { + preGenPermeateDefState = FP_PRE_GENP_DEF_FLUSH; + preGenPermeateDefDataPublishInterval.data = PRE_GEN_DEF_PERMEATE_DATA_PUBLISH_INTERVAL; + preGenPermeateDefDataPublishInterval.ovData = PRE_GEN_DEF_PERMEATE_DATA_PUBLISH_INTERVAL; + preGenPermeateDefDataPublishInterval.ovInitData = 0; + preGenPermeateDefDataPublishInterval.override = OVERRIDE_RESET; + preGenPermeateDefDataPublicationTimerCounter = 0; + pendingStartPreGenDefRequest = FALSE; + preGenPermeateDefFlushTimer = 0; + preGenPermeateDefWaterCheckTimer = 0; +} +/*********************************************************************//** + * @brief + * The transitionToPreGenPermeateDefeaturedMode function prepares for transition + * to defeatured gen permeate mode. + * @details \b Inputs: none + * @details \b Outputs: none + * @return initial state + *************************************************************************/ +U32 transitionToPreGenPermeateDefeaturedMode( void ) +{ + initGenPermeateDefeaturedMode(); + setCurrentSubState( preGenPermeateDefState ); + return preGenPermeateDefState; } -U32 transitionToPreGenPDefMode( void ) +/*********************************************************************//** + * @brief + * The execPreGenPermeateDefeaturedMode function executes the Gen + * Permeate defeatured mode state machine. + * @details \b Inputs: none + * @details \b Outputs: Gen Permeate defeatured mode state machine executed + * @details \b Alarm: ALARM_ID_FP_SOFTWARE_FAULT when wrong state invoked. + * @return current state. + *************************************************************************/ +U32 execPreGenPermeateDefeaturedMode( void ) { - return 0; + FP_PRE_GENP_DEF_MODE_STATE_T prevState = preGenPermeateDefState; + + // execute current gen Permeate defeatured state + switch ( preGenPermeateDefState ) + { + case FP_PRE_GENP_DEF_FLUSH: + preGenPermeateDefState = handlePreGenPDefFlushState(); + break; + + case FP_PRE_GENP_DEF_INLET_WATER_CHECK: + preGenPermeateDefState = handlePreGenPDefInletWaterState(); + break; + + case FP_PRE_GENP_DEF_PAUSED: + preGenPermeateDefState = handlePreGenPDefPausedState(); + break; + + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_SOFTWARE_FAULT, SW_FAULT_ID_FP_INVALD_GENP_DEF_STATE, preGenPermeateDefState ) + break; + } + + if ( prevState != preGenPermeateDefState ) + { + setModePreGenPDefTransition( preGenPermeateDefState ); + SEND_EVENT_WITH_2_U32_DATA( FP_EVENT_GENP_DEF_CHANGE, preGenPermeateDefState, prevState ) + } + //Publish Gen Permeate mode data + publishPreGenPDefModeData(); + + return preGenPermeateDefState; } -U32 execPreGenPDefMode( void ) +/*********************************************************************//** + * @brief + * The setModePreGenPDefTransition function sets the actuators and variables + * for the state transition in generate permeate mode. + * @details Inputs: Valve states, Pump speed + * @details Outputs: Actuate valves, pumps as desired. + * @param state gen permeate state enum + * @return none + *************************************************************************/ +static void setModePreGenPDefTransition( FP_GENP_DEF_MODE_STATE_T state ) { - return 0; + // Execute on running state + switch( state ) + { + case FP_PRE_GENP_DEF_FLUSH: + setValveState( M4_VALV, VALVE_STATE_OPEN ); + setValveState( P6_VALV, VALVE_STATE_CLOSED ); + setValveState( P11_VALV, VALVE_STATE_CLOSED ); + setValveState( P33_VALV, VALVE_STATE_CLOSED ); + setValveState( P34_VALV, VALVE_STATE_CLOSED ); + setValveState( P37_VALV, VALVE_STATE_CLOSED ); + setValveState( P39_VALV, VALVE_STATE_CLOSED ); + preGenPermeateDefFlushTimer = getMSTimerCount(); + break; + + case FP_PRE_GENP_DEF_INLET_WATER_CHECK: + setValveState( M4_VALV, VALVE_STATE_OPEN ); + setValveState( P6_VALV, VALVE_STATE_CLOSED ); + setValveState( P11_VALV, VALVE_STATE_CLOSED ); + setValveState( P33_VALV, VALVE_STATE_CLOSED ); + setValveState( P34_VALV, VALVE_STATE_CLOSED ); + setValveState( P37_VALV, VALVE_STATE_CLOSED ); + setValveState( P39_VALV, VALVE_STATE_CLOSED ); + preGenPermeateDefWaterCheckTimer = getMSTimerCount(); + break; + + case FP_PRE_GENP_DEF_PAUSED: + setValveState( M4_VALV, VALVE_STATE_CLOSED ); + setValveState( P6_VALV, VALVE_STATE_CLOSED ); + setValveState( P11_VALV, VALVE_STATE_CLOSED ); + setValveState( P33_VALV, VALVE_STATE_CLOSED ); + setValveState( P34_VALV, VALVE_STATE_CLOSED ); + setValveState( P37_VALV, VALVE_STATE_CLOSED ); + setValveState( P39_VALV, VALVE_STATE_CLOSED ); + break; + + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_SOFTWARE_FAULT, SW_FAULT_ID_FP_INVALID_GENP_STATE, state ) + break; + } } -/**@}*/ +/*********************************************************************//** + * @brief + * The handlePreGenPDefFlushState handles the supply water of gen permeate + * defeatured mode. + * @details \b Inputs: none + * @details \b Outputs: nones + * @return the next state of gen water defeatured mode + *************************************************************************/ +static FP_PRE_GENP_DEF_MODE_STATE_T handlePreGenPDefFlushState( void ) +{ + FP_PRE_GENP_DEF_MODE_STATE_T state = FP_PRE_GENP_DEF_FLUSH; + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + state = FP_PRE_GENP_DEF_PAUSED; + } + + if( TRUE == didTimeout( preGenPermeateDefFlushTimer, PRE_GEN_DEF_FLUSH_TIMEOUT_MS ) ) + { + state = FP_PRE_GENP_DEF_INLET_WATER_CHECK; + } + return state; +} + +/*********************************************************************//** + * @brief + * The handlePreGenPDefInletWaterState handles the pause state of gen permeate + * defeatured mode. + * @details \b Inputs: none + * @details \b Outputs: none + * @return the next state of gen water defeatured mode + *************************************************************************/ +static FP_PRE_GENP_DEF_MODE_STATE_T handlePreGenPDefInletWaterState( void ) +{ + FP_PRE_GENP_DEF_MODE_STATE_T state = FP_PRE_GENP_DEF_INLET_WATER_CHECK; + + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + state = FP_PRE_GENP_DEF_PAUSED; + } + + if( TRUE == didTimeout( preGenPermeateDefWaterCheckTimer, PRE_GEN_DEF_WATER_CHECK_TIMEOUT_MS ) ) + { + transitionToGenPermeateDefeaturedMode(); + requestGenWaterDefStart(); + } + return state; +} + +/*********************************************************************//** + * @brief + * The handlePreGenPDefPausedState handles the pause state of gen permeate + * defeatured mode. + * @details \b Inputs: none + * @details \b Outputs: none + * @return the next state of gen water defeatured mode + *************************************************************************/ +static FP_PRE_GENP_DEF_MODE_STATE_T handlePreGenPDefPausedState( void ) +{ + FP_PRE_GENP_DEF_MODE_STATE_T state = FP_PRE_GENP_DEF_PAUSED; + + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + state = FP_PRE_GENP_DEF_PAUSED; + } + + return state; +} + +/*********************************************************************//** + * @brief + * The getCurrentPreGenPermeateDefState function returns the current state of the + * gen permeate defeatured mode. + * @details \b Inputs: preGenPermeateDefState + * @details \b Outputs: preGenPermeateDefState + * @return the current state of gen permeate defeatured mode + *************************************************************************/ +FP_PRE_GENP_DEF_MODE_STATE_T getCurrentPreGenPermeateDefState( void ) +{ + return preGenPermeateDefState; +} + +/*********************************************************************//** + * @brief + * The requestPreGenDefStart function handles an DD request to start (go to gen permeate mode). + * @details \b Inputs: none + * @details \b Outputs: pendingStartPreGenDefRequest + * @return TRUE if request accepted, FALSE if not. + *************************************************************************/ +BOOL requestPreGenDefStart( void ) +{ + BOOL result = FALSE; + + result = TRUE; + pendingStartPreGenDefRequest = TRUE; + requestNewOperationMode( FP_MODE_DPGW ); + + return result; +} + +/*********************************************************************//** + * @brief + * The getPreGenPermeateRequest function returns the current state of the + * gen permeate defeatured mode. + * @details \b Inputs: pendingStartPreGenDefRequest + * @details \b Outputs: none + * @return the current state of gen permeate defeatured request + *************************************************************************/ +BOOL getPreGenPermeateRequest( void ) +{ + return pendingStartPreGenDefRequest; +} + +/*********************************************************************//** + * @brief + * The requestPreGenDefStop function handles an DD request to stop (go to standby mode). + * @details \b Inputs: none + * @details \b Outputs: pendingStartPreGenDefRequest + * @return TRUE if request accepted, FALSE if not. + *************************************************************************/ +BOOL requestPreGenDefStop( void ) +{ + BOOL result = TRUE; + pendingStartPreGenDefRequest = FALSE; + requestNewOperationMode( FP_MODE_STAN ); + + return result; +} + +/*********************************************************************//** + * @brief + * The getGenPermeateDataPublishInterval function gets the generate permeate + * defeatured mode data publish interval. + * @details \b Inputs: preGenPermeateDefDataPublishInterval + * @details \b Outputs: none + * @return the interval at generate permeate defeatured mode data being published. + *************************************************************************/ +static U32 getPreGenPermeateDefDataPublishInterval( void ) +{ + U32 result = getU32OverrideValue( &preGenPermeateDefDataPublishInterval ); + + return result; +} + +/*********************************************************************//** + * @brief + * The publishGenPModeData function broadcasts the generate water + * mode data at defined interval. + * @details \b Inputs: preGenPermeateDefDataPublicationTimerCounter + * @details \b Outputs: FP generate permeate data broadcast message sent + * @details \b Message \Sent: MSG_ID_FP_GENP_DEF_DATA to publish the + * generate water mode data. + * @return none + *************************************************************************/ +static void publishPreGenPDefModeData( void ) +{ + if ( ++preGenPermeateDefDataPublicationTimerCounter >= getPreGenPermeateDefDataPublishInterval() ) + { + PRE_GEN_PERMEATE_DEF_MODE_DATA_T data; + + data.preGenPermeateDefExecState = (U32)getCurrentGenPermeateDefState(); + + broadcastData( MSG_ID_FP_GENP_DEF_DATA, COMM_BUFFER_OUT_CAN_FP_BROADCAST, (U08*)&data, sizeof( PRE_GEN_PERMEATE_DEF_MODE_DATA_T ) ); + + preGenPermeateDefDataPublicationTimerCounter = 0; + } +} + + +/************************************************************************* + * TEST SUPPORT FUNCTIONS + *************************************************************************/ + + +/*********************************************************************//** + * @brief + * The testGenPermeateDefDataPublishIntervalOverride function overrides the + * DD generate water mode data publish interval. + * @details \b Inputs: preGenPermeateDefDataPublishInterval + * @details \b Outputs: preGenPermeateDefDataPublishInterval + * @param Override message from Dialin which includes the interval + * (in ms) to override the FP generate permeate data publish interval to. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testPreGenPermeateDefDataPublishIntervalOverride( MESSAGE_T *message ) +{ + BOOL result = u32BroadcastIntervalOverride( message, &preGenPermeateDefDataPublishInterval, TASK_GENERAL_INTERVAL ); + + return result; +} + +/**@}*/ Index: firmware/App/Modes/ModePreGenPermeateDefeatured.h =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Modes/ModePreGenPermeateDefeatured.h (.../ModePreGenPermeateDefeatured.h) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Modes/ModePreGenPermeateDefeatured.h (.../ModePreGenPermeateDefeatured.h) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -1,11 +1,56 @@ +/************************************************************************** +* +* Copyright (c) 2024-2025 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 ModePreGenPermeateDefeatured.h +* +* @author (last) Michael Garthwaite +* @date (last) 03-Mar-2025 +* +* @author (original) Michael Garthwaite +* @date (original) 03-Mar-2025 +* +***************************************************************************/ - #ifndef __MODE_PRE_GENP_DEF_H__ #define __MODE_PRE_GENP_DEF_H__ #include "FPCommon.h" #include "FPDefs.h" +/** + * @defgroup FPPreGenPermeateDefeaturedMode FPPreGenPermeateDefeaturedMode + * @brief Pre-Generate Permeate Defeatured unit. Manages water generation functions via a state machine. + * + * @addtogroup FPPreGenPermeateDefeaturedMode + * @{ + */ +// ********** public definitions ********** +/// Pre-Generate Permeate defeatured mode data structure +typedef struct +{ + U32 preGenPermeateDefExecState; ///< Pre-Generate Permeate Defeatured execution state +} PRE_GEN_PERMEATE_DEF_MODE_DATA_T; + +// ********** public function prototypes ********** + +void initPreGenPermeateDefeaturedMode( void ); // Initialize this Pre gen permeate mode unit +U32 transitionToPreGenPermeateDefeaturedMode( void ); // Transition to Pre gen permeate mode +U32 execPreGenPermeateDefeaturedMode( void ); // Execute the Pre gen permeate mode state machine (call from OperationModes) +BOOL requestPreGenDefStart( void ); +BOOL requestPreGenDefStop( void ); +BOOL getPreGenPermeateRequest( void ); + +FP_PRE_GENP_DEF_MODE_STATE_T getCurrentPreGenPermeateDefState( void ); // Get the current state of the Pre gen water mode + +BOOL testPreGenPermeateDefDataPublishIntervalOverride( MESSAGE_T *message ); // override broadcast interval for Pre gen permeate + +/**@}*/ + + #endif Index: firmware/App/Modes/ModeStandby.c =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Modes/ModeStandby.c (.../ModeStandby.c) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Modes/ModeStandby.c (.../ModeStandby.c) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -105,19 +105,6 @@ { FP_STANDBY_MODE_STATE_T state = FP_STANDBY_MODE_STATE_IDLE; - if ( TRUE == getPreGenRequest() ) - { - if ( FALSE == isDefeatured() ) - { - requestNewOperationMode( FP_MODE_PGEN ); - } - else - { - requestNewOperationMode( FP_MODE_DPGW ); - } - - } - return state; } Fisheye: Tag 8d272582cbd2cb5fc0c6af0fead2867ce02658b0 refers to a dead (removed) revision in file `firmware/App/Modes/VerifyWater.c'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag 8d272582cbd2cb5fc0c6af0fead2867ce02658b0 refers to a dead (removed) revision in file `firmware/App/Modes/VerifyWater.h'. Fisheye: No comparison available. Pass `N' to diff? Index: firmware/App/Monitors/Conductivity.c =================================================================== diff -u -r98a9ee30d7c8b568f3ccc52c4c48bdbc36a419e9 -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Monitors/Conductivity.c (.../Conductivity.c) (revision 98a9ee30d7c8b568f3ccc52c4c48bdbc36a419e9) +++ firmware/App/Monitors/Conductivity.c (.../Conductivity.c) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -22,6 +22,10 @@ #include "ConductivitySensor.h" #include "MessageSupport.h" #include "Messaging.h" +#include "ModeGenPermeate.h" +#include "ModeGenPermeateDefeatured.h" +#include "ModePreGenPermeate.h" +#include "ModePreGenPermeateDefeatured.h" #include "OperationModes.h" #include "TaskPriority.h" #include "Utilities.h" @@ -71,7 +75,7 @@ *************************************************************************/ void initConductivity( void ) { - CONDUCTIVITY_SENSORS_T sensor + CONDUCTIVITY_SENSORS_T sensor; // initialize conductivity sensors driver initConductivitySensors(); @@ -88,7 +92,7 @@ filteredConductivityReadings[ sensor ].conductivityReadingsIdx = 0; filteredConductivityReadings[ sensor ].conductivityReadingsTotal = 0.0F; - filteredConductivityReadings[ sensor ].conductivityReadingsCount = 0F; + filteredConductivityReadings[ sensor ].conductivityReadingsCount = 0; } conductivityDataPublishInterval.data = COND_SENSOR_REPORT_PERIOD; Index: firmware/App/Monitors/Flow.c =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Monitors/Flow.c (.../Flow.c) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Monitors/Flow.c (.../Flow.c) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -18,6 +18,11 @@ #include "AlarmMgmtFP.h" #include "Flow.h" #include "Messaging.h" +#include "ModeGenPermeate.h" +#include "ModeGenPermeateDefeatured.h" +#include "ModePreGenPermeate.h" +#include "ModePreGenPermeateDefeatured.h" +#include "OperationModes.h" #include "PersistentAlarm.h" #include "TaskPriority.h" Index: firmware/App/Monitors/Pressure.c =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Monitors/Pressure.c (.../Pressure.c) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Monitors/Pressure.c (.../Pressure.c) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -17,10 +17,14 @@ #include "AlarmMgmtFP.h" #include "Messaging.h" +#include "ModeGenPermeate.h" +#include "ModeGenPermeateDefeatured.h" +#include "ModePreGenPermeate.h" +#include "ModePreGenPermeateDefeatured.h" +#include "OperationModes.h" #include "Pressure.h" #include "PersistentAlarm.h" #include "TaskPriority.h" -#include "Valves.h" /** * @addtogroup Pressure @@ -36,17 +40,18 @@ #define SIZE_OF_PRESSURE_ROLLING_AVG ( PRESSURE_SAMPLE_FILTER_MS / TASK_PRIORITY_INTERVAL ) ///< Filtered pressure moving average. #define SIZE_OF_PRESSURETEMP_ROLLING_AVG ( PRESSURE_TEMP_SAMPLE_FILTER_MS / TASK_PRIORITY_INTERVAL ) ///< Filtered pressure temprature w/ 1 second moving average. -#define MIN_INLET_WATER_PRESSURE_WARNING_LOW_PSIG 20.0F ///< Minimum allowed Input low pressure value in psig. -#define MAX_INLET_WATER_PRESSURE_WARNING_HIGH_PSIG 80.0F ///< Maximum allowed Input high pressure value in psig. -#define MIN_INLET_PRESSURE_TO_CLEAR_WARINING_PSIG 24.0F ///< Minimum allowed Input low pressure value in psig ( to clear alarm) -#define MIN_INLET_WATER_PRESSURE_WARNING_HIGH_PSIG 78.0F ///< Minimum allowed Input high pressure value in psig. -#define INLET_WATER_PRES_OUT_OF_RANGE_TIMEOUT_MS ( 20 * MS_PER_SECOND ) ///< Persistence period for pressure out of range error in milliseconds. -#define INLET_WATER_PRES_OUT_OF_RANGE_CLEAR_MS ( 10 * MS_PER_SECOND ) ///< Persistence period for pressure out of range clear in milliseconds. +#define MAX_INLET_RO_PUMP_PRESSURE_WARNING 120.0F +#define MIN_INLET_WATER_PRESSURE_WARNING_LOW_PSIG 30.0F ///< Minimum allowed Input low pressure value in psig without boost pump. +#define MAX_INLET_WATER_PRESSURE_WARNING_HIGH_PSIG 80.0F ///< Maximum allowed Input high pressure value in psig without boost pump. +#define MIN_INLET_WATER_PRESSURE_WARNING_BOOST_LOW_PSIG 10.0F ///< Minimum allowed Input low pressure value in psig with boost pump. +#define MAX_INLET_WATER_PRESSURE_WARNING_BOOST_HIGH_PSIG 80.0F ///< Maximum allowed Input high pressure value in psig with boost pump. +#define MIN_PRESSURE_RELIEF_WARNING_LOW_PSI 13.0F +#define MAX_PRESSURE_RELIEF_WARNING_HIGH_PSIG 17.0F +#define INLET_WATER_PRES_OUT_OF_RANGE_TIMEOUT_MS ( 5 * MS_PER_SECOND ) ///< Persistence period for pressure out of range error in milliseconds. +#define INLET_WATER_PRES_OUT_OF_RANGE_CLEAR_MS ( 5 * MS_PER_SECOND ) ///< Persistence period for pressure out of range clear in milliseconds. +#define INLET_WATER_PRES_RELIEF_OUT_OF_RANGE_TIMEOUT_MS ( 5 * MS_PER_SECOND ) ///< Persistence period for pressure out of range error in milliseconds. +#define INLET_WATER_PRES_RELIEF_OUT_OF_RANGE_CLEAR_MS ( 5 * MS_PER_SECOND ) ///< Persistence period for pressure out of range clear in milliseconds. -#define MIN_INLET_WATER_PRES_OUT_WARNING_LOW_PSIG 10.0F ///< Minimum allowed output low pressure value in psig. -#define MAX_INLET_WATER_PRES_OUT_WARNING_HIGH_PSIG 20.0F ///< Maximum allowed output high pressure value in psig. -#define MIN_INLET_PRES_OUT_TO_CLEAR_WARINING_PSIG 11.0F ///< Minimum allowed output low pressure value in psig ( to clear alarm) -#define MIN_INLET_WATER_PRES_OUT_WARNING_HIGH_PSIG 18.0F ///< Minimum allowed output high pressure value in psig. /// Defined states for the pressures monitor state machine. typedef enum PresMonitor_States @@ -96,6 +101,10 @@ static PRESSURE_STATE_T handlePressuresInitState( void ); static PRESSURE_STATE_T handlePressuresContReadState( void ); static void publishPressuresData( void ); +static void monitorPressureSenors( void ); +static void monitorOperationModeAlarms( FP_OP_MODE_T opMode ); +static void monitorPreGenAlarms( void ); +static void monitorGenPAlarms( void ); /*********************************************************************//** * @brief @@ -141,10 +150,11 @@ pressuresDataPublishInterval.ovInitData = 0; pressuresDataPublishInterval.override = OVERRIDE_RESET; -// initPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_IN_LOW_RANGE, INLET_WATER_PRES_OUT_OF_RANGE_CLEAR_MS, INLET_WATER_PRES_OUT_OF_RANGE_TIMEOUT_MS ); -// initPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_IN_HIGH_RANGE, INLET_WATER_PRES_OUT_OF_RANGE_CLEAR_MS, INLET_WATER_PRES_OUT_OF_RANGE_TIMEOUT_MS ); -// initPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_OUT_LOW_RANGE, INLET_WATER_PRES_OUT_OF_RANGE_CLEAR_MS, INLET_WATER_PRES_OUT_OF_RANGE_TIMEOUT_MS ); -// initPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_OUT_HIGH_RANGE, INLET_WATER_PRES_OUT_OF_RANGE_CLEAR_MS, INLET_WATER_PRES_OUT_OF_RANGE_TIMEOUT_MS ); + initPersistentAlarm( ALARM_ID_FP_INLET_PRESSURE_OUT_LOW_RANGE, INLET_WATER_PRES_OUT_OF_RANGE_CLEAR_MS, INLET_WATER_PRES_OUT_OF_RANGE_TIMEOUT_MS ); + initPersistentAlarm( ALARM_ID_FP_INLET_PRESSURE_OUT_HIGH_RANGE, INLET_WATER_PRES_OUT_OF_RANGE_CLEAR_MS, INLET_WATER_PRES_OUT_OF_RANGE_TIMEOUT_MS ); + initPersistentAlarm( ALARM_ID_FP_PRESSURE_RELIEF_OUT_LOW_RANGE, INLET_WATER_PRES_RELIEF_OUT_OF_RANGE_CLEAR_MS, INLET_WATER_PRES_RELIEF_OUT_OF_RANGE_TIMEOUT_MS ); + initPersistentAlarm( ALARM_ID_FP_PRESSURE_RELIEF_OUT_HIGH_RANGE, INLET_WATER_PRES_RELIEF_OUT_OF_RANGE_CLEAR_MS, INLET_WATER_PRES_RELIEF_OUT_OF_RANGE_TIMEOUT_MS ); + initPersistentAlarm( ALARM_ID_FP_INLET_PRESSURE_REGULATOR_OUT_OF_RANGE, INLET_WATER_PRES_OUT_OF_RANGE_CLEAR_MS, INLET_WATER_PRES_OUT_OF_RANGE_TIMEOUT_MS ); } /*********************************************************************//** @@ -332,12 +342,152 @@ break; } + monitorPressureSenors(); // publish pressure/occlusion data on interval publishPressuresData(); } /*********************************************************************//** * @brief + * The monitorPressureSenors function monitors the temperature sensors' + * temperature value and raises an alarm if any of them are out of range + * for more than the specified time. + * @details \b Inputs: tempSensors + * @details \b Outputs: tempSensors + * @details \b Alarms: ALARM_ID_DD_TEMPERATURE_SENSOR_OUT_OF_RANGE when the + * measured temperature exceeds the maximum limit temperature. + * @return none + *************************************************************************/ +static void monitorPressureSenors( void ) +{ + monitorOperationModeAlarms( getCurrentOperationMode() ); + +} + +static void monitorOperationModeAlarms( FP_OP_MODE_T opMode ) +{ + switch ( opMode ) + { + case FP_MODE_FAUL: + break; + + case FP_MODE_SERV: + break; + + case FP_MODE_INIT: + break; + + case FP_MODE_STAN: + break; + + case FP_MODE_PGEN: + monitorPreGenAlarms(); + break; + + case FP_MODE_GENP: + monitorGenPAlarms(); + break; + + case FP_MODE_DPGW: + break; + + case FP_MODE_DEGW: + break; + default: + // SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_TEMPERATURE_SENSORS_EXEC_INVALID_STATE, tempSensorsExecState ); + // tempSensorsExecState = TEMPSENSORS_EXEC_STATE_GET_ADC_VALUES; + break; + } +} + +/*********************************************************************//** + * @brief + * The monitorPreGenAlarms function checks pressure alarm conditions for alarms that are + * monitored in Pre-Generate Permeate mode. + * @details \b Inputs: none + * @details \b Outputs: none + * @return none + *************************************************************************/ +static void monitorPreGenAlarms( void ) +{ + FP_PRE_GENP_MODE_STATE_T preGenState = getCurrentPreGenPState(); + F32 pressureM1 = getFilteredPressure( M1_PRES ); + F32 pressureP17 = getFilteredPressure( P17_PRES ); + F32 pressureP13 = getFilteredPressure( P13_PRES ); + BOOL isPresOutOfLowRange = FALSE; + BOOL isPresOutOfHighRange = FALSE; + BOOL isPresReliefOutOfLowRange = FALSE; + BOOL isPresReliefOutOfHighRange = FALSE; + + if ( pressureP13 > MAX_INLET_RO_PUMP_PRESSURE_WARNING ) + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_RO_INLET_PRESSURE_OUT_HIGH_RANGE, pressureP13, MAX_INLET_RO_PUMP_PRESSURE_WARNING ) + } + + if (TRUE == isBoostPumpInstalled() ) + { + isPresOutOfLowRange = ( ( pressureM1 < MIN_INLET_WATER_PRESSURE_WARNING_BOOST_LOW_PSIG ) ? TRUE : FALSE); + isPresOutOfHighRange = ( ( pressureM1 > MAX_INLET_WATER_PRESSURE_WARNING_BOOST_HIGH_PSIG ) ? TRUE : FALSE); + checkPersistentAlarm( ALARM_ID_FP_INLET_PRESSURE_OUT_LOW_RANGE, isPresOutOfLowRange, pressureM1, MIN_INLET_WATER_PRESSURE_WARNING_BOOST_LOW_PSIG ); + checkPersistentAlarm( ALARM_ID_FP_INLET_PRESSURE_OUT_HIGH_RANGE, isPresOutOfHighRange, pressureM1, MAX_INLET_WATER_PRESSURE_WARNING_BOOST_HIGH_PSIG ); + } + else + { + isPresOutOfLowRange = ( ( pressureM1 < MIN_INLET_WATER_PRESSURE_WARNING_LOW_PSIG ) ? TRUE : FALSE); + isPresOutOfHighRange = ( ( pressureM1 > MAX_INLET_WATER_PRESSURE_WARNING_HIGH_PSIG ) ? TRUE : FALSE); + checkPersistentAlarm( ALARM_ID_FP_INLET_PRESSURE_OUT_LOW_RANGE, isPresOutOfLowRange, pressureM1, MIN_INLET_WATER_PRESSURE_WARNING_LOW_PSIG ); + checkPersistentAlarm( ALARM_ID_FP_INLET_PRESSURE_OUT_HIGH_RANGE, isPresOutOfHighRange, pressureM1, MAX_INLET_WATER_PRESSURE_WARNING_HIGH_PSIG ); + } + + if ( preGenState == FP_PRE_GENP_VERIFY_WATER ) + { + isPresReliefOutOfLowRange = ( ( pressureP17 < MIN_PRESSURE_RELIEF_WARNING_LOW_PSI ) ? TRUE : FALSE); + isPresReliefOutOfHighRange = ( ( pressureP17 > MAX_PRESSURE_RELIEF_WARNING_HIGH_PSIG ) ? TRUE : FALSE); + checkPersistentAlarm( ALARM_ID_FP_PRESSURE_RELIEF_OUT_LOW_RANGE, isPresReliefOutOfLowRange, pressureP17, MIN_PRESSURE_RELIEF_WARNING_LOW_PSI ); + checkPersistentAlarm( ALARM_ID_FP_PRESSURE_RELIEF_OUT_HIGH_RANGE, isPresReliefOutOfHighRange, pressureP17, MAX_PRESSURE_RELIEF_WARNING_HIGH_PSIG ); + } + +} + +/*********************************************************************//** + * @brief + * The monitorGenPAlarms function checks pressure alarm conditions for alarms that are + * monitored in Generate Permeate mode + * @details \b Inputs: none + * @details \b Outputs: none + * @return none + *************************************************************************/ +static void monitorGenPAlarms( void ) +{ + F32 pressureM1 = getFilteredPressure( M1_PRES ); + F32 pressureP13 = getFilteredPressure( P13_PRES ); + BOOL isPresOutOfLowRange = FALSE; + BOOL isPresOutOfHighRange = FALSE; + + if ( pressureP13 > MAX_INLET_RO_PUMP_PRESSURE_WARNING ) + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_RO_INLET_PRESSURE_OUT_HIGH_RANGE, pressureP13, MAX_INLET_RO_PUMP_PRESSURE_WARNING ) + } + + if (TRUE == isBoostPumpInstalled() ) + { + isPresOutOfLowRange = ( ( pressureM1 < MIN_INLET_WATER_PRESSURE_WARNING_BOOST_LOW_PSIG ) ? TRUE : FALSE); + isPresOutOfHighRange = ( ( pressureM1 > MAX_INLET_WATER_PRESSURE_WARNING_BOOST_HIGH_PSIG ) ? TRUE : FALSE); + checkPersistentAlarm( ALARM_ID_FP_INLET_PRESSURE_OUT_LOW_RANGE, isPresOutOfLowRange, pressureM1, MIN_INLET_WATER_PRESSURE_WARNING_BOOST_LOW_PSIG ); + checkPersistentAlarm( ALARM_ID_FP_INLET_PRESSURE_OUT_HIGH_RANGE, isPresOutOfHighRange, pressureM1, MAX_INLET_WATER_PRESSURE_WARNING_BOOST_HIGH_PSIG ); + } + else + { + isPresOutOfLowRange = ( ( pressureM1 < MIN_INLET_WATER_PRESSURE_WARNING_LOW_PSIG ) ? TRUE : FALSE); + isPresOutOfHighRange = ( ( pressureM1 > MAX_INLET_WATER_PRESSURE_WARNING_HIGH_PSIG ) ? TRUE : FALSE); + checkPersistentAlarm( ALARM_ID_FP_INLET_PRESSURE_OUT_LOW_RANGE, isPresOutOfLowRange, pressureM1, MIN_INLET_WATER_PRESSURE_WARNING_LOW_PSIG ); + checkPersistentAlarm( ALARM_ID_FP_INLET_PRESSURE_OUT_HIGH_RANGE, isPresOutOfHighRange, pressureM1, MAX_INLET_WATER_PRESSURE_WARNING_HIGH_PSIG ); + } + +} + +/*********************************************************************//** + * @brief * The filterPressureSensorReadings function filters the pressures for * defined interval to get average pressure reading. * @details \b Inputs: filteredPressureReadings,currentPressureReadings Index: firmware/App/Monitors/Temperature.c =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Monitors/Temperature.c (.../Temperature.c) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Monitors/Temperature.c (.../Temperature.c) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -15,9 +15,15 @@ * ***************************************************************************/ +#include "AlarmMgmtFP.h" #include "Messaging.h" #include "MessageSupport.h" +#include "ModeGenPermeate.h" +#include "ModeGenPermeateDefeatured.h" +#include "ModePreGenPermeate.h" +#include "ModePreGenPermeateDefeatured.h" #include "OperationModes.h" +#include "PersistentAlarm.h" #include "Temperature.h" #include "Timers.h" #include "TaskPriority.h" @@ -36,6 +42,11 @@ #define DATA_PUBLISH_COUNTER_START_COUNT 30 ///< Data publish counter start count. +#define TEMPERATURE_INLET_LOW_THRESHOLD 5.0F +#define TEMPERATURE_INLET_HIGH_THRESHOLD 30.0F +#define TEMPERATURE_INLET_PERSISTENCE_TIMER ( 5 * MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) +#define TEMPERATURE_INLET_PERSISTENCE_CLEAR ( 5 * MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) + /// Temperature sensor exec states. typedef enum tempSensors_Exec_States { @@ -56,6 +67,11 @@ static TEMPSENSORS_EXEC_STATES_T handleExecStart( void ); static TEMPSENSORS_EXEC_STATES_T handleExecGetADCValues( void ); static void publishTemperatureSensorsData( void ); +static void monitorTemperatureSenors( void ); +static void monitorOperationModeAlarms( FP_OP_MODE_T opMode ); +static void monitorPreGenAlarms( void ); +static void monitorPreGenDefAlarms( void ); +static void monitorGenPAlarms( void ); /*********************************************************************//** * @brief @@ -77,6 +93,9 @@ // Initialize the temperature sensors initTemperatureSensors(); + + initPersistentAlarm( ALARM_ID_FP_INLET_TEMPERATURE_OUT_LOW_RANGE, TEMPERATURE_INLET_PERSISTENCE_CLEAR, TEMPERATURE_INLET_PERSISTENCE_TIMER ); + initPersistentAlarm( ALARM_ID_FP_INLET_TEMPERATURE_OUT_HIGH_RANGE, TEMPERATURE_INLET_PERSISTENCE_CLEAR, TEMPERATURE_INLET_PERSISTENCE_TIMER ); } /*********************************************************************//** @@ -195,6 +214,133 @@ /*********************************************************************//** * @brief + * The monitorTemperatureSensors function monitors the temperature sensors' + * temperature value and raises an alarm if any of them are out of range + * for more than the specified time. + * @details \b Inputs: tempSensors + * @details \b Outputs: tempSensors + * @details \b Alarms: ALARM_ID_DD_TEMPERATURE_SENSOR_OUT_OF_RANGE when the + * measured temperature exceeds the maximum limit temperature. + * @return none + *************************************************************************/ +static void monitorTemperatureSenors( void ) +{ + monitorOperationModeAlarms( getCurrentOperationMode() ); +} + +static void monitorOperationModeAlarms( FP_OP_MODE_T opMode ) +{ + switch ( opMode ) + { + case FP_MODE_FAUL: + break; + + case FP_MODE_SERV: + break; + + case FP_MODE_INIT: + break; + + case FP_MODE_STAN: + break; + + case FP_MODE_PGEN: + monitorPreGenAlarms(); + break; + + case FP_MODE_GENP: + monitorGenPAlarms(); + break; + + case FP_MODE_DPGW: + monitorPreGenDefAlarms(); + break; + + case FP_MODE_DEGW: + break; + default: + // SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_TEMPERATURE_SENSORS_EXEC_INVALID_STATE, tempSensorsExecState ); + // tempSensorsExecState = TEMPSENSORS_EXEC_STATE_GET_ADC_VALUES; + break; + } +} + +/*********************************************************************//** + * @brief + * The monitorPreGenAlarms function checks temperature alarm conditions for alarms that are + * monitored in Pre-Generate Permeate mode + * @details \b Inputs: none + * @details \b Outputs: none + * @return none + *************************************************************************/ +static void monitorPreGenAlarms( void ) +{ + FP_PRE_GENP_MODE_STATE_T preGenState = getCurrentPreGenPState(); + F32 temperatureP10 = getTemperatureValue( P10_TEMP ); + BOOL isTempOutOfLowRange = FALSE; + BOOL isTempOutOfHighRange = FALSE; + + if ( ( preGenState > FP_PRE_GENP_FILTER_FLUSH ) && ( preGenState != FP_PRE_GENP_PAUSED ) ) + { + isTempOutOfLowRange = ( ( temperatureP10 < TEMPERATURE_INLET_LOW_THRESHOLD ) ? TRUE : FALSE); + isTempOutOfHighRange = ( ( temperatureP10 > TEMPERATURE_INLET_HIGH_THRESHOLD ) ? TRUE : FALSE); + checkPersistentAlarm( ALARM_ID_FP_INLET_TEMPERATURE_OUT_LOW_RANGE, isTempOutOfLowRange, temperatureP10, TEMPERATURE_INLET_LOW_THRESHOLD ); + checkPersistentAlarm( ALARM_ID_FP_INLET_TEMPERATURE_OUT_HIGH_RANGE, isTempOutOfHighRange, temperatureP10, TEMPERATURE_INLET_HIGH_THRESHOLD ); + // TODO - Check M1 temp + } +} + + +/*********************************************************************//** + * @brief + * The monitorGenPAlarms function checks temperature alarm conditions for alarms that are + * monitored in Generate Permeate mode + * @details \b Inputs: none + * @details \b Outputs: none + * @return none + *************************************************************************/ +static void monitorGenPAlarms( void ) +{ + FP_GENP_MODE_STATE_T genState = getCurrentGenPermeateState(); + F32 temperatureP10 = getTemperatureValue( P10_TEMP ); + BOOL isTempOutOfLowRange = FALSE; + BOOL isTempOutOfHighRange = FALSE; + + isTempOutOfLowRange = ( ( temperatureP10 < TEMPERATURE_INLET_LOW_THRESHOLD ) ? TRUE : FALSE); + isTempOutOfHighRange = ( ( temperatureP10 > TEMPERATURE_INLET_HIGH_THRESHOLD ) ? TRUE : FALSE); + checkPersistentAlarm( ALARM_ID_FP_INLET_TEMPERATURE_OUT_LOW_RANGE, isTempOutOfLowRange, temperatureP10, TEMPERATURE_INLET_LOW_THRESHOLD ); + checkPersistentAlarm( ALARM_ID_FP_INLET_TEMPERATURE_OUT_HIGH_RANGE, isTempOutOfHighRange, temperatureP10, TEMPERATURE_INLET_HIGH_THRESHOLD ); + // TODO - Check M1 temp + +} + +/*********************************************************************//** + * @brief + * The monitorPreGenDefAlarms function checks temperature alarm conditions for alarms that are + * monitored in Pre-Generate Permeate, Defeatured mode + * @details \b Inputs: none + * @details \b Outputs: none + * @return none + *************************************************************************/ +static void monitorPreGenDefAlarms( void ) +{ + //FP_PRE_GENP_DEF_MODE_STATE_T preGenDefState; + F32 temperatureM4 = getTemperatureValue( M4_TEMP ); + BOOL isTempOutOfLowRange = FALSE; + BOOL isTempOutOfHighRange = FALSE; + + //if ( preGenDefState == FP_PRE_GENP_DEF_INLET_WATER_CHECK ) + + isTempOutOfLowRange = ( ( temperatureM4 < TEMPERATURE_INLET_LOW_THRESHOLD ) ? TRUE : FALSE); + isTempOutOfHighRange = ( ( temperatureM4 > TEMPERATURE_INLET_HIGH_THRESHOLD ) ? TRUE : FALSE); + checkPersistentAlarm( ALARM_ID_FP_INLET_TEMPERATURE_OUT_LOW_RANGE, isTempOutOfLowRange, temperatureM4, TEMPERATURE_INLET_LOW_THRESHOLD ); + checkPersistentAlarm( ALARM_ID_FP_INLET_TEMPERATURE_OUT_HIGH_RANGE, isTempOutOfHighRange, temperatureM4, TEMPERATURE_INLET_HIGH_THRESHOLD ); + + +} + +/*********************************************************************//** + * @brief * The publishTemperatureSensorsData function broadcasts the temperature * sensors data at the publication interval. * @details \b Inputs: dataPublicationTimerCounter and publish interval time. Index: firmware/App/Services/AlarmMgmtFP.c =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Services/AlarmMgmtFP.c (.../AlarmMgmtFP.c) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Services/AlarmMgmtFP.c (.../AlarmMgmtFP.c) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -271,13 +271,13 @@ /*********************************************************************//** * @brief - * The isDDFaultAlarmActive function determines whether a fault alarm is currently + * The isFPFaultAlarmActive function determines whether a fault alarm is currently * active. * @details \b Inputs: alarmStatus * @details \b Outputs: none * @return TRUE if any alarm is active, FALSE if not *************************************************************************/ -BOOL isDDFaultAlarmActive( void ) +BOOL isFPFaultAlarmActive( void ) { return isAFaultAlarmActive; } Index: firmware/App/Services/AlarmMgmtSWFaults.h =================================================================== diff -u -r98a9ee30d7c8b568f3ccc52c4c48bdbc36a419e9 -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Services/AlarmMgmtSWFaults.h (.../AlarmMgmtSWFaults.h) (revision 98a9ee30d7c8b568f3ccc52c4c48bdbc36a419e9) +++ firmware/App/Services/AlarmMgmtSWFaults.h (.../AlarmMgmtSWFaults.h) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -135,6 +135,8 @@ SW_FAULT_ID_FP_INVALID_FILTER_FLUSH_STATE = 118, SW_FAULT_ID_FP_INVALID_PERMEATE_FLUSH_STATE = 119, SW_FAULT_ID_INVALID_FILTERED_CONDUCTIVITY_SENSOR_ID = 120, + SW_FAULT_ID_FP_INVALID_CONCENTRATE_FLUSH_STATE = 121, + SW_FAULT_ID_FP_INVALD_GENP_DEF_STATE = 122, NUM_OF_SW_FAULT_IDS } SW_FAULT_ID_T; Index: firmware/App/Services/DDInterface.c =================================================================== diff -u -r410afd26b3ae5e372310c696c82f58c59235e10d -r8d272582cbd2cb5fc0c6af0fead2867ce02658b0 --- firmware/App/Services/DDInterface.c (.../DDInterface.c) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) +++ firmware/App/Services/DDInterface.c (.../DDInterface.c) (revision 8d272582cbd2cb5fc0c6af0fead2867ce02658b0) @@ -15,16 +15,20 @@ * ***************************************************************************/ -#include -#include + +#include "BoostPump.h" #include "DDInterface.h" #include "Messaging.h" #include "MessagePayloads.h" #include "ModeGenPermeate.h" +#include "ModeGenPermeateDefeatured.h" +#include "ModePreGenPermeate.h" +#include "ModePreGenPermeateDefeatured.h" #include "ModeStandby.h" #include "OperationModes.h" #include "PersistentAlarm.h" #include "ROPump.h" +#include "SystemCommFP.h" #include "TaskGeneral.h" #include "Timers.h" @@ -180,16 +184,25 @@ if ( ( FP_MODE_STAN == roMode ) && ( TRUE == start ) ) { setDDPermeateFlowRate( roRate ); - setFluidPumpPWMDutyCycle( P12_PUMP, roRate ); - result = requestPreGenStart(); + if ( TRUE == isDefeatured() ) + { + result = requestPreGenDefStart(); + } + + else + { + result = requestPreGenStart(); + } + } + else if ( FP_MODE_PGEN == roMode ) { if ( FALSE == start ) { - signalROPumpHardStop(); result = requestPreGenStop(); } + else { // Set flow rate and delivery. @@ -198,6 +211,11 @@ } } + else if ( FP_MODE_DPGW == roMode ) + { + result = requestPreGenDefStop(); + } + return result; } @@ -219,16 +237,24 @@ if ( ( FP_MODE_PGEN == roMode ) && ( TRUE == start ) ) { setDDPermeateFlowRate( roRate ); - setFluidPumpPWMDutyCycle( P12_PUMP,roRate ); - result = requestGenWaterStart(); + if ( TRUE == isDefeatured() ) + { + result = requestGenWaterDefStart(); + } + + else + { + result = requestGenWaterStart(); + } } + else if ( FP_MODE_GENP == roMode ) { if ( FALSE == start ) { - signalROPumpHardStop(); result = requestGenWaterStop(); } + else { // Set flow rate and delivery. @@ -237,6 +263,11 @@ } } + else if ( FP_MODE_DEGW == roMode ) + { + result = requestGenWaterDefStop(); + } + return result; }