Index: firmware/App/Controllers/ConcentratePumps.c =================================================================== diff -u -r88fdd83b43ef9c2d2f06a51e555db1439b668921 -r62ee40b55ed96eb0de1c0f05455eb986f76c1842 --- firmware/App/Controllers/ConcentratePumps.c (.../ConcentratePumps.c) (revision 88fdd83b43ef9c2d2f06a51e555db1439b668921) +++ firmware/App/Controllers/ConcentratePumps.c (.../ConcentratePumps.c) (revision 62ee40b55ed96eb0de1c0f05455eb986f76c1842) @@ -31,17 +31,17 @@ #define CONCENTRATE_PUMP_ON_CONTROL 0x1A ///< Configuration to turn on concentrate pump with 8 microsteps. #define CONCENTRATE_PUMP_OFF_CONTROL 0x3A ///< Configuration to turn off concentrate pump. -#define CONCENTRATE_PUMP_SPEED_INCREAMENT 8.0 ///< Speed increase (mL/min) when controlling concentrate pump to target step speed. +#define CONCENTRATE_PUMP_SPEED_INCREMENT 8.0 ///< Speed increase (mL/min) when controlling concentrate pump to target step speed. #define CONCENTRATE_PUMP_MIN_SPEED 3.0 ///< Minimum speed for concentrate pump in mL per min. #define CONCENTRATE_PUMP_MAX_SPEED 49.0 ///< Maximum speed for concentrate pump in mL per min. #define CONCENTRATE_PUMP_VOLUME_PER_REV 0.15 ///< Volume output every revolution (mL). -#define CONCENTRATE_PUMP_PULSE_PER_REV 4 ///< Number of pulses generate for every revolution. -#define CONCENTRATE_PUMP_STEP_PER_REV 200 ///< Number of steps for every revolution. -#define CONCENTRATE_PUMP_HALL_SENSE_PERIOD_RESOLUTION 100 ///< Hall sense period resolution in microseconds. +#define CONCENTRATE_PUMP_PULSE_PER_REV 4.0 ///< Number of pulses generate for every revolution. +#define CONCENTRATE_PUMP_STEP_PER_REV 200.0 ///< Number of steps for every revolution. +#define CONCENTRATE_PUMP_HALL_SENSE_PERIOD_RESOLUTION 100.0 ///< Hall sense period resolution in microseconds. -#define CONCENTRATE_PUMP_MICRO_STEPS 8 ///< Number of micro-steps. -#define CONCENTRATE_PUMP_STEP_PERIOD_RESOLUTION ( 2 * 0.25 / ( US_PER_SECOND * SEC_PER_MIN ) ) ///< Step period resolution in minute. +#define CONCENTRATE_PUMP_MICRO_STEPS_PER_STEP 8.0 ///< Number of micro-steps ( fractions of step) per step. +#define CONCENTRATE_PUMP_STEP_PERIOD_RESOLUTION ( 0.5 / ( US_PER_SECOND * SEC_PER_MIN ) ) ///< Convert one step period (0.5 us) to minute. /// Volume output per pulse. #define CONCENTRATE_PUMP_VOLUME_PER_PULSE ( CONCENTRATE_PUMP_VOLUME_PER_REV / CONCENTRATE_PUMP_PULSE_PER_REV ) @@ -68,9 +68,9 @@ /// Concentrate pump data publish interval. static OVERRIDE_U32_T concentratePumpDataPublishInterval = { CONCENTRATE_PUMP_DATA_PUBLISH_INTERVAL, CONCENTRATE_PUMP_DATA_PUBLISH_INTERVAL, 0, 0 }; -static OVERRIDE_F32_T pumpTargetSpeed[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Target concentrate pumps' speed (mL/min). +static F32 pumpTargetSpeed[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Target concentrate pumps' speed (mL/min). static F32 currentPumpSpeed[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Current controlled concentrate pumps' speed (mL/min). -static U16 convertedStepSpeed[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Converted pump speed (mL/min) to step speed. +static U16 convertedStepSpeedPeriod[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Converted pump speed (mL/min) to step speed period. // ********** private function prototypes ********** @@ -79,7 +79,6 @@ static void stepConcentratePumpToTargetSpeed( CONCENTRATE_PUMPS_T pumpId ); static CONCENTRATE_PUMP_STATE_T handleConcentratePumpOnState( void ); -static F32 getConcentratePumpTargetSpeed( CONCENTRATE_PUMPS_T pumpId ); static U32 getPublishConcentratePumpDataInterval( void ); /*********************************************************************//** @@ -120,9 +119,9 @@ F32 const cp1SpeedMlPerMin = ( 1 / cp1PulseWidthInSecond ) * CONCENTRATE_PUMP_VOLUME_PER_PULSE * SEC_PER_MIN; F32 const cp2SpeedMlPerMin = ( 1 / cp2PulseWidthInSecond ) * CONCENTRATE_PUMP_VOLUME_PER_PULSE * SEC_PER_MIN; - data.cp1TargetSpeed = getConcentratePumpTargetSpeed( CONCENTRATEPUMPS_CP1 ); + data.cp1TargetSpeed = pumpTargetSpeed[ CONCENTRATEPUMPS_CP1 ]; data.cp1MeasuredSpeed = cp1SpeedMlPerMin; - data.cp2TargetSpeed = getConcentratePumpTargetSpeed( CONCENTRATEPUMPS_CP2 ); + data.cp2TargetSpeed = pumpTargetSpeed[ CONCENTRATEPUMPS_CP2 ]; data.cp2MeasuredSpeed = cp2SpeedMlPerMin; broadcastConcentratePumpData( &data ); @@ -157,30 +156,30 @@ /*********************************************************************//** * @brief - * The requestConcentratePumpOn function requests the module to turn on + * The requestConcentratePumpsOn function requests the module to turn on * the concentrate pumps. * @details Inputs: none * @details Outputs: set flag isPumpOnRequested to TRUE * @return none *************************************************************************/ -void requestConcentratePumpOn( void ) +void requestConcentratePumpsOn( void ) { isPumpOnRequested = TRUE; } /*********************************************************************//** * @brief - * The requestConcentratePumpOff function requests the module to turn off + * The requestConcentratePumpsOff function requests the module to turn off * the concentrate pumps. * @details Inputs: none * @details Outputs: set flag isPumpOffRequested to TRUE * @return none *************************************************************************/ -void requestConcentratePumpOff( void ) +void requestConcentratePumpsOff( void ) { isPumpOffRequested = TRUE; - pumpTargetSpeed[ CONCENTRATEPUMPS_CP1 ].data = 0.0; - pumpTargetSpeed[ CONCENTRATEPUMPS_CP2 ].data = 0.0; + pumpTargetSpeed[ CONCENTRATEPUMPS_CP1 ] = 0.0; + pumpTargetSpeed[ CONCENTRATEPUMPS_CP2 ] = 0.0; } /*********************************************************************//** @@ -195,22 +194,21 @@ *************************************************************************/ void setConcentratePumpTargetSpeed( CONCENTRATE_PUMPS_T pumpId, F32 targetSpeed_ml_min ) { - if ( ( CONCENTRATE_PUMP_MIN_SPEED <= targetSpeed_ml_min ) && ( targetSpeed_ml_min <= CONCENTRATE_PUMP_MAX_SPEED ) && - ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) ) + if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) { - pumpTargetSpeed[ pumpId ].data = targetSpeed_ml_min; - } - else - { - if ( pumpId >= NUM_OF_CONCENTRATE_PUMPS ) + if ( ( CONCENTRATE_PUMP_MIN_SPEED <= targetSpeed_ml_min ) && ( targetSpeed_ml_min <= CONCENTRATE_PUMP_MAX_SPEED ) ) { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_CONCENTRATE_PUMP_INVALID_PUMP_ID, pumpId ) + pumpTargetSpeed[ pumpId ] = targetSpeed_ml_min; } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_CONCENTRATE_PUMP_SPEED_OUT_OF_RANGE, targetSpeed_ml_min ) } } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_CONCENTRATE_PUMP_INVALID_PUMP_ID, pumpId ); + } } /*********************************************************************//** @@ -227,11 +225,7 @@ for ( ii = 0; ii < NUM_OF_CONCENTRATE_PUMPS; ii++ ) { - pumpTargetSpeed[ ii ].data = 0.0; - pumpTargetSpeed[ ii ].ovData = 0.0; - pumpTargetSpeed[ ii ].ovInitData = 0.0; - pumpTargetSpeed[ ii ].override = OVERRIDE_RESET; - + pumpTargetSpeed[ ii ] = 0.0; currentPumpSpeed[ ii ] = 0.0; } @@ -276,32 +270,32 @@ *************************************************************************/ static void stepConcentratePumpToTargetSpeed( CONCENTRATE_PUMPS_T pumpId ) { - F32 const currentToTargetDiff = fabs( getConcentratePumpTargetSpeed( pumpId ) - currentPumpSpeed[ pumpId ] ); + F32 const currentToTargetDiff = fabs( pumpTargetSpeed[ pumpId ] - currentPumpSpeed[ pumpId ] ); F32 speedIncrease; if ( currentToTargetDiff > NEARLY_ZERO ) { - if ( currentToTargetDiff > CONCENTRATE_PUMP_SPEED_INCREAMENT ) + if ( currentToTargetDiff > CONCENTRATE_PUMP_SPEED_INCREMENT ) { - speedIncrease = CONCENTRATE_PUMP_SPEED_INCREAMENT; + speedIncrease = CONCENTRATE_PUMP_SPEED_INCREMENT; } else { speedIncrease = currentToTargetDiff; } // Subtract current speed when target speed is smaller - if ( getConcentratePumpTargetSpeed( pumpId ) < currentPumpSpeed[ pumpId ] ) + if ( pumpTargetSpeed[ pumpId ] < currentPumpSpeed[ pumpId ] ) { - speedIncrease *= -1; + speedIncrease *= -1.0; } currentPumpSpeed[ pumpId ] += speedIncrease; } F32 const timePerStep = CONCENTRATE_PUMP_VOLUME_PER_REV / ( currentPumpSpeed[ pumpId ] * CONCENTRATE_PUMP_STEP_PER_REV ) ; - F32 const stepPeriod = timePerStep / ( CONCENTRATE_PUMP_STEP_PERIOD_RESOLUTION * CONCENTRATE_PUMP_MICRO_STEPS ); - convertedStepSpeed[ pumpId ] = (U16)( stepPeriod ); + F32 const stepPeriod = timePerStep / ( CONCENTRATE_PUMP_STEP_PERIOD_RESOLUTION * CONCENTRATE_PUMP_MICRO_STEPS_PER_STEP ); + convertedStepSpeedPeriod[ pumpId ] = (U16)( stepPeriod + 0.5 ); } /*********************************************************************//** @@ -324,8 +318,8 @@ stepConcentratePumpToTargetSpeed( CONCENTRATEPUMPS_CP1 ); stepConcentratePumpToTargetSpeed( CONCENTRATEPUMPS_CP2 ); - setFPGACP1SetStepSpeed( convertedStepSpeed[ CONCENTRATEPUMPS_CP1 ] ); - setFPGACP2SetStepSpeed( convertedStepSpeed[ CONCENTRATEPUMPS_CP2 ] ); + setFPGACP1SetStepSpeed( convertedStepSpeedPeriod[ CONCENTRATEPUMPS_CP1 ] ); + setFPGACP2SetStepSpeed( convertedStepSpeedPeriod[ CONCENTRATEPUMPS_CP2 ] ); } if ( isPumpOffRequested ) @@ -345,31 +339,32 @@ * target speed for a given pump id. * @details Inputs: pumpTargetSpeed * @details Outputs: none + * @param pumpId concentrate pump id to increase current step speed * @return the current concentrate pump target speed. *************************************************************************/ -static F32 getConcentratePumpTargetSpeed( CONCENTRATE_PUMPS_T pumpId ) -{ - F32 result = 0.0; +//static F32 getConcentratePumpTargetSpeed( CONCENTRATE_PUMPS_T pumpId ) +//{ +// F32 result = 0.0; +// +// if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) +// { +// if ( OVERRIDE_KEY == pumpTargetSpeed[ pumpId ].override ) +// { +// result = pumpTargetSpeed[ pumpId ].ovData; +// } +// else +// { +// result = pumpTargetSpeed[ pumpId ].data; +// } +// } +// else +// { +// activateAlarmNoData( ALARM_ID_DG_SOFTWARE_FAULT ); +// } +// +// return result; +//} - if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) - { - if ( OVERRIDE_KEY == pumpTargetSpeed[ pumpId ].override ) - { - result = pumpTargetSpeed[ pumpId ].ovData; - } - else - { - result = pumpTargetSpeed[ pumpId ].data; - } - } - else - { - activateAlarmNoData( ALARM_ID_DG_SOFTWARE_FAULT ); - } - - return result; -} - /*********************************************************************//** * @brief * The getPublishConcentratePumpDataInterval function gets the concentrate pump @@ -462,35 +457,11 @@ if ( ( CONCENTRATE_PUMP_MIN_SPEED <= value ) && ( value <= CONCENTRATE_PUMP_MAX_SPEED ) ) { result = TRUE; - pumpTargetSpeed[ pumpId ].ovData = value; - pumpTargetSpeed[ pumpId ].override = OVERRIDE_KEY; + setConcentratePumpTargetSpeed( (CONCENTRATE_PUMPS_T)pumpId, value ); } } return result; } -/*********************************************************************//** - * @brief - * The testResetConcentratePumpTargetSpeedOverride function resets the override of the - * speed value of given concentrate pump id. - * @details Inputs: none - * @details Outputs: targetPumpSpeed[] - * @param pumpId concentrate pump id - * @return TRUE if override successful, FALSE if not - *************************************************************************/ -BOOL testResetConcentratePumpTargetSpeedOverride( U32 pumpId ) -{ - BOOL result = FALSE; - - if ( pumpId < NUM_OF_CONCENTRATE_PUMPS && isTestingActivated() ) - { - result = TRUE; - pumpTargetSpeed[ pumpId ].ovData = pumpTargetSpeed[ pumpId ].ovInitData; - pumpTargetSpeed[ pumpId ].override = OVERRIDE_RESET; - } - - return result; -} - /**@}*/ Index: firmware/App/Controllers/ConcentratePumps.h =================================================================== diff -u -r7336ffd91e991f7156b01a7f15ed2afd85b62f80 -r62ee40b55ed96eb0de1c0f05455eb986f76c1842 --- firmware/App/Controllers/ConcentratePumps.h (.../ConcentratePumps.h) (revision 7336ffd91e991f7156b01a7f15ed2afd85b62f80) +++ firmware/App/Controllers/ConcentratePumps.h (.../ConcentratePumps.h) (revision 62ee40b55ed96eb0de1c0f05455eb986f76c1842) @@ -53,15 +53,14 @@ void execConcentratePumpMonitor( void ); void execConcentratePumpController( void ); -void requestConcentratePumpOn( void ); -void requestConcentratePumpOff( void ); +void requestConcentratePumpsOn( void ); +void requestConcentratePumpsOff( void ); void setConcentratePumpTargetSpeed( CONCENTRATE_PUMPS_T pumpId, F32 targetSpeed_ml_min ); BOOL testSetConcentratePumpDataPublishIntervalOverride( U32 value ); BOOL testResetConcentratePumpDataPublishIntervalOverride( void ); BOOL testSetConcentratePumpTargetSpeedOverride( U32 pumpId, F32 value ); -BOOL testResetConcentratePumpTargetSpeedOverride( U32 pumpId ); /**@}*/ Index: firmware/App/Controllers/ConductivitySensors.c =================================================================== diff -u -r7e2931d9a468ca3b6e1f2bb88ef0910960dfdb29 -r62ee40b55ed96eb0de1c0f05455eb986f76c1842 --- firmware/App/Controllers/ConductivitySensors.c (.../ConductivitySensors.c) (revision 7e2931d9a468ca3b6e1f2bb88ef0910960dfdb29) +++ firmware/App/Controllers/ConductivitySensors.c (.../ConductivitySensors.c) (revision 62ee40b55ed96eb0de1c0f05455eb986f76c1842) @@ -66,10 +66,6 @@ #define EMSTAT_PICO_GOOD_STATUS 0x10 ///< Measurement good status. #define EMSTAT_PICO_FIFO_EMPTY_MASK 0x8000 ///< Emstat Pico buffer empty indication bit. -#define ASCII_CODE_LETTER_A 0x41 ///< ASCII code in hex for letter A. -#define ASCII_CODE_NUMBER_ZERO 0x30 ///< ASCII code in hex for number zero. -#define ASCII_CODE_NUMBER_SEVEN 0x37 ///< ASCII code in hex for number seven. - #pragma pack(push,1) /// Emstat pico measurement data package structure typedef struct @@ -113,7 +109,6 @@ static void calcRORejectionRatio( void ); static void processCPiCPoSensorRead( U32 sensorId, U32 fgpaRead, U08 fpgaReadCount, U08 fpgaErrorCount, U08 fpgaSensorFault ); -static U32 hexStrToDec( U08 const * const valuePtr, U08 size ); static U32 prefixStrToSIFactor( U08 prefix ); static void processMeasurementDataPackage( U32 sensorId ); static void processCD1CD2SensorRead( U16 fpgaReadCount, U08 fpgaErrorCount ); @@ -222,6 +217,7 @@ #ifndef DISABLE_DIALYSATE_CHECK F32 const cpo = getConductivityValue( CONDUCTIVITYSENSORS_CPO_SENSOR ); BOOL const isRORejectionRatioOutOfRange = ( roRejectionRatio > MAX_RO_REJECTION_RATIO_ALLOW ) || ( cpo >= MAX_CPO_CONDUCTIVITY_ALLOW ); + checkPersistentAlarm( PERSISTENT_ALARM_RO_REJECTION_RATIO_OUT_OF_RANGE, isRORejectionRatioOutOfRange, roRejectionRatio ); #endif } @@ -246,7 +242,6 @@ checkPersistentAlarm( PERSISTENT_ALARM_POST_BICARB_CONDUCTIVITY_OUT_OF_RANGE, isPostBicarbConductivityOutOfRange, postBicarbonateConductivity ); } - /*********************************************************************//** * @brief * The getConductivityValue function gets the compensated conductivity @@ -290,10 +285,10 @@ * @param temperature temperature to compensate conductivity with * @return compensated conductivity based on temperature *************************************************************************/ -static F32 calcCompensatedConductivity( F32 conductivity, F32 temperature) +static F32 calcCompensatedConductivity( F32 conductivity, F32 temperature ) { // EC = EC_25 * (1 + temp_coef * (temperature - 25)) - F32 const compensatedCoef = ( 1.0 + ( COND_SENSOR_TEMPERATURE_COEF * (temperature - COND_SENSOR_REFERENCE_TEMPERATURE) ) ); + F32 const compensatedCoef = ( 1.0 + ( COND_SENSOR_TEMPERATURE_COEF * ( temperature - COND_SENSOR_REFERENCE_TEMPERATURE ) ) ); return conductivity * compensatedCoef; } @@ -310,6 +305,7 @@ { F32 const cpi = getConductivityValue( CONDUCTIVITYSENSORS_CPI_SENSOR ); F32 const cpo = getConductivityValue( CONDUCTIVITYSENSORS_CPO_SENSOR ); + roRejectionRatio = RO_REJECTION_RATIO_OUT_OF_RANGE_VALUE; if ( fabs(cpi) >= NEARLY_ZERO ) @@ -364,38 +360,6 @@ /*********************************************************************//** * @brief - * The hexStrToDec function convert hex string to decimal value. - * @details Inputs: none - * @details Outputs: none - * @param valuePtr pointer to hex string to convert - * @param size size of the hex string to convert - * @return converted value of hex string - *************************************************************************/ -static U32 hexStrToDec( U08 const * const valuePtr, U08 size ) -{ - U08 ii; - U08 value; - U32 result = 0; - - for ( ii = 0; ii < size; ++ii ) - { - if ( valuePtr[ii] < ASCII_CODE_LETTER_A ) - { - value = ( valuePtr[ii] - ASCII_CODE_NUMBER_ZERO ); - result = ( result << 4 ) | value; - } - else - { - value = ( valuePtr[ii] - ASCII_CODE_NUMBER_SEVEN ); - result = ( result << 4 ) | value; - } - } - - return result; -} - -/*********************************************************************//** - * @brief * The prefixStrToSIFactor function returns SI factor based on a given ascii prefix. * @details Inputs: none * @details Outputs: none @@ -405,6 +369,7 @@ static U32 prefixStrToSIFactor( U08 prefix ) { U32 result; + switch ( prefix ) { case 'm': @@ -439,12 +404,12 @@ if ( EMSTAT_PICO_GOOD_STATUS == hexStrToDec( (U08 *)&measurementPtr->status, sizeof( measurementPtr->status ) ) ) { - internalErrorCount[ sensorId ] = 0; U32 const prefix = prefixStrToSIFactor( measurementPtr->prefix ); F32 const resistance = ( ( F32 )( hexStrToDec( measurementPtr->value, sizeof( measurementPtr->value ) ) - EMSTAT_PICO_MEASUREMENT_OFFSET ) / prefix ); - F32 const temperature = getTemperatureValue( associateTempSensor[ sensorId ] ); F32 const conductivity = ( 1 / resistance * SIEMENS_TO_MICROSIEMENS_CONVERSION ); + + internalErrorCount[ sensorId ] = 0; compensatedConductivityValues[ sensorId ].data = calcCompensatedConductivity( conductivity, temperature ); } else @@ -464,7 +429,8 @@ * it raises an alarm. If the read count has changed, the new reading will be processed. * @details Inputs: none * @details Outputs: none - * @param sensorId Conductivity sensor id to process + * @param fpgaReadCount FPGA read count for rx fifo + * @param fpgaErrorCount FPGA error count * @return none *************************************************************************/ static void processCD1CD2SensorRead( U16 fpgaReadCount, U08 fpgaErrorCount ) Index: firmware/App/Controllers/ConductivitySensors.h =================================================================== diff -u -r16cd633e1d18224face6f977120ccab3846e7671 -r62ee40b55ed96eb0de1c0f05455eb986f76c1842 --- firmware/App/Controllers/ConductivitySensors.h (.../ConductivitySensors.h) (revision 16cd633e1d18224face6f977120ccab3846e7671) +++ firmware/App/Controllers/ConductivitySensors.h (.../ConductivitySensors.h) (revision 62ee40b55ed96eb0de1c0f05455eb986f76c1842) @@ -23,6 +23,8 @@ /** * @defgroup ConductivitySensors ConductivitySensors * @brief Conductivity Sensors monitor module. Monitors and filters conductivity sensor readings. + * The module uses Atlas Scientific EC OEM for conductivity sensors CPi and CPo with probe type K 1.0 and 0.1 respectively. + * The module uses Emstat Pico from PalmSens to measure electrical resistance and convert to conductivity. * * @addtogroup ConductivitySensors * @{ Index: firmware/App/Modes/ModeDrain.c =================================================================== diff -u -r2059f906368ba0bf0ac280b80fecee61aba1846b -r62ee40b55ed96eb0de1c0f05455eb986f76c1842 --- firmware/App/Modes/ModeDrain.c (.../ModeDrain.c) (revision 2059f906368ba0bf0ac280b80fecee61aba1846b) +++ firmware/App/Modes/ModeDrain.c (.../ModeDrain.c) (revision 62ee40b55ed96eb0de1c0f05455eb986f76c1842) @@ -120,7 +120,7 @@ RESERVOIR_ID_T inactiveReservoir = getInactiveReservoir(); // if we have reached our target drain to volume (by weight) or cannot drain anymore, we are done draining - go back to re-circ mode - if ( hasTargetDrainVolumeReached( inactiveReservoir, DRAIN_WEIGH_UNCHANGE_TIMEOUT ) ) + if ( hasTargetDrainVolumeBeenReached( inactiveReservoir, DRAIN_WEIGH_UNCHANGE_TIMEOUT ) ) { setDrainPumpTargetSpeed( 0 ); requestNewOperationMode( DG_MODE_CIRC ); Index: firmware/App/Modes/ModeFill.c =================================================================== diff -u -r41c7186ac17200977b632102c9c6e3a07b3eb211 -r62ee40b55ed96eb0de1c0f05455eb986f76c1842 --- firmware/App/Modes/ModeFill.c (.../ModeFill.c) (revision 41c7186ac17200977b632102c9c6e3a07b3eb211) +++ firmware/App/Modes/ModeFill.c (.../ModeFill.c) (revision 62ee40b55ed96eb0de1c0f05455eb986f76c1842) @@ -156,7 +156,7 @@ if ( isInletWaterReady ) { // Concentrate pumps on request and set RO pump to flow rate 800 mL/min - requestConcentratePumpOn(); + requestConcentratePumpsOn(); // TODO: Change to set flow rate once RO pump driver is updated // setROPumpFlowRate( FILL_TARGET_RO_FLOW_RATE ); setROPumpTargetPressure( FILL_TARGET_RO_PRESSURE_PSI, PUMP_CONTROL_MODE_CLOSED_LOOP ); @@ -228,9 +228,9 @@ } // if we've reached our target fill to volume (by weight), we're done filling - go back to re-circ mode - if ( hasTargetFillVolumeReached( inactiveReservoir ) ) + if ( hasTargetFillVolumeBeenReached( inactiveReservoir ) ) { - requestConcentratePumpOff(); + requestConcentratePumpsOff(); requestNewOperationMode( DG_MODE_CIRC ); } Index: firmware/App/Services/Reservoirs.c =================================================================== diff -u -r945dcc1391faefe5f4ddb4f505361501d008e293 -r62ee40b55ed96eb0de1c0f05455eb986f76c1842 --- firmware/App/Services/Reservoirs.c (.../Reservoirs.c) (revision 945dcc1391faefe5f4ddb4f505361501d008e293) +++ firmware/App/Services/Reservoirs.c (.../Reservoirs.c) (revision 62ee40b55ed96eb0de1c0f05455eb986f76c1842) @@ -41,7 +41,9 @@ #define MAX_FILL_VOLUME_ML MAX_RESERVOIR_VOLUME_ML ///> Maximum fill volume in mL. #define DEFAULT_DRAIN_VOLUME_ML 100 ///> Default drain volume in mL. #define MAX_DRAIN_VOLUME_ML MAX_RESERVOIR_VOLUME_ML ///> Maximum drain volume in mL. -#define MIN_DRAIN_VOLUME_ML 100 ///> Minimum drain volume in mL. +#define MIN_DRAIN_VOLUME_ML 100 ///> Minimum drain volume in mL. + +#define MAX_RESERVOIR_WEIGHT 10000 ///> Maximum reservoir weight in grams. #define RESERVOIR_DATA_PUB_INTERVAL ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) ///< interval (ms/task time) at which the reservoir data is published on the CAN bus. @@ -53,13 +55,13 @@ static OVERRIDE_U32_T fillVolumeTargetMl = { 0, 0, 0, 0 }; ///< The target reservoir fill volume (in mL). static OVERRIDE_U32_T drainVolumeTargetMl = { 0, 0, 0, 0 }; ///< The target reservoir drain volume (in mL). -static LOAD_CELL_ID_T associateLoadCell[ NUM_OF_RESERVOIRS ] = { LOAD_CELL_A1, - LOAD_CELL_B1 }; ///< The reservoirs' associate load cell. +static LOAD_CELL_ID_T associatedLoadCell[ NUM_OF_RESERVOIRS ] = { LOAD_CELL_A1, + LOAD_CELL_B1 }; ///< The reservoirs' associate load cell. static LOAD_CELL_ID_T redundantLoadCell[ NUM_OF_RESERVOIRS ] = { LOAD_CELL_A2, LOAD_CELL_B2 }; ///< The reservoirs' associate redundant load cell. -static F32 reservoirLowestWeight[ NUM_OF_RESERVOIRS ] = { MAX_RESERVOIR_VOLUME_ML, - MAX_RESERVOIR_VOLUME_ML }; ///< The reservoirs' lowest weight during draining. +static F32 reservoirLowestWeight[ NUM_OF_RESERVOIRS ] = { MAX_RESERVOIR_WEIGHT, + MAX_RESERVOIR_WEIGHT }; ///< The reservoirs' lowest weight during draining. static U32 reservoirWeightUnchangeStartTime[ NUM_OF_RESERVOIRS ] = { 0, 0 }; ///< The reservoirs' weight start time when weight stop decreasing. static BOOL tareLoadCellRequest; ///< Flag indicates if load cell tare has been requested by HD. @@ -314,12 +316,11 @@ * @param reservoirId reservoir id * @return TRUE if target fill volume has been reached, FALSE if not. *************************************************************************/ -BOOL hasTargetFillVolumeReached( RESERVOIR_ID_T reservoirId ) +BOOL hasTargetFillVolumeBeenReached( RESERVOIR_ID_T reservoirId ) { - F32 const loadcellWeight = getLoadCellFilteredWeight( associateLoadCell[ reservoirId ] ); - F32 const redundantLoadcellWeight = getLoadCellFilteredWeight( redundantLoadCell[ reservoirId ] ); + F32 const loadcellWeight = getLoadCellFilteredWeight( associatedLoadCell[ reservoirId ] ); U32 const targetFillVolume = getReservoirFillVolumeTargetMl(); - BOOL const hasTargetReached = ( loadcellWeight >= targetFillVolume ) || ( redundantLoadcellWeight >= targetFillVolume ); + BOOL const hasTargetReached = ( loadcellWeight >= targetFillVolume ); return hasTargetReached; } @@ -334,31 +335,30 @@ * @param timeout timeout period when weight remains the same * @return TRUE if target drain volume has been reached or exceeds time limit, FALSE if not. *************************************************************************/ -BOOL hasTargetDrainVolumeReached( RESERVOIR_ID_T reservoirId, U32 timeout ) +BOOL hasTargetDrainVolumeBeenReached( RESERVOIR_ID_T reservoirId, U32 timeout ) { BOOL result = FALSE; - F32 const loadcellWeight = getLoadCellFilteredWeight( associateLoadCell[ reservoirId ] ); - F32 const redundantLoadcellWeight = getLoadCellFilteredWeight( redundantLoadCell[ reservoirId ] ); + F32 const loadcellWeight = getLoadCellFilteredWeight( associatedLoadCell[ reservoirId ] ); U32 const targetDrainVolume = getReservoirDrainVolumeTargetMl(); - if ( ( loadcellWeight < reservoirLowestWeight[ reservoirId ] ) || ( redundantLoadcellWeight < reservoirLowestWeight[ reservoirId ] ) ) + if ( loadcellWeight < reservoirLowestWeight[ reservoirId ] ) { - reservoirLowestWeight[ reservoirId ] = loadcellWeight < redundantLoadcellWeight ? loadcellWeight : redundantLoadcellWeight; + reservoirLowestWeight[ reservoirId ] = loadcellWeight; reservoirWeightUnchangeStartTime[ reservoirId ] = getMSTimerCount(); } BOOL const hasTimeOut = didTimeout( reservoirWeightUnchangeStartTime[ reservoirId ], timeout ); - BOOL const hasTargetReached = ( targetDrainVolume >= loadcellWeight ) || ( targetDrainVolume >= redundantLoadcellWeight ); + BOOL const hasTargetReached = ( targetDrainVolume >= loadcellWeight ); if ( hasTimeOut || hasTargetReached ) { result = TRUE; - reservoirLowestWeight[ reservoirId ] = MAX_RESERVOIR_VOLUME_ML; + reservoirLowestWeight[ reservoirId ] = MAX_RESERVOIR_WEIGHT; if ( tareLoadCellRequest ) { tareLoadCellRequest = FALSE; - tareLoadCell( associateLoadCell[ reservoirId ] ); + tareLoadCell( associatedLoadCell[ reservoirId ] ); tareLoadCell( redundantLoadCell[ reservoirId ] ); } } @@ -377,7 +377,7 @@ *************************************************************************/ void resetReservoirLoadCellsOffset( RESERVOIR_ID_T reservoirId ) { - resetLoadCellOffset( associateLoadCell[ reservoirId ] ); + resetLoadCellOffset( associatedLoadCell[ reservoirId ] ); resetLoadCellOffset( redundantLoadCell[ reservoirId ] ); } Index: firmware/App/Services/Reservoirs.h =================================================================== diff -u -r945dcc1391faefe5f4ddb4f505361501d008e293 -r62ee40b55ed96eb0de1c0f05455eb986f76c1842 --- firmware/App/Services/Reservoirs.h (.../Reservoirs.h) (revision 945dcc1391faefe5f4ddb4f505361501d008e293) +++ firmware/App/Services/Reservoirs.h (.../Reservoirs.h) (revision 62ee40b55ed96eb0de1c0f05455eb986f76c1842) @@ -61,8 +61,8 @@ BOOL stopTrimmerHeaterCmd( void ); // handle stop trimmer heater control command from HD RESERVOIR_ID_T getInactiveReservoir( void ); -BOOL hasTargetFillVolumeReached( RESERVOIR_ID_T reservoirId ); -BOOL hasTargetDrainVolumeReached( RESERVOIR_ID_T reservoirId , U32 timeout ); +BOOL hasTargetFillVolumeBeenReached( RESERVOIR_ID_T reservoirId ); +BOOL hasTargetDrainVolumeBeenReached( RESERVOIR_ID_T reservoirId , U32 timeout ); void resetReservoirLoadCellsOffset( RESERVOIR_ID_T reservoirId ); Index: firmware/App/Services/SystemCommMessages.c =================================================================== diff -u -r7e2931d9a468ca3b6e1f2bb88ef0910960dfdb29 -r62ee40b55ed96eb0de1c0f05455eb986f76c1842 --- firmware/App/Services/SystemCommMessages.c (.../SystemCommMessages.c) (revision 7e2931d9a468ca3b6e1f2bb88ef0910960dfdb29) +++ firmware/App/Services/SystemCommMessages.c (.../SystemCommMessages.c) (revision 62ee40b55ed96eb0de1c0f05455eb986f76c1842) @@ -1902,14 +1902,7 @@ if ( sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) == message->hdr.payloadLen ) { memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) ); - if ( FALSE == payload.reset ) - { - result = testSetConcentratePumpTargetSpeedOverride( payload.index, payload.state.f32 ); - } - else - { - result = testResetConcentratePumpTargetSpeedOverride( payload.index ); - } + result = testSetConcentratePumpTargetSpeedOverride( payload.index, payload.state.f32 ); } // respond to request @@ -1938,11 +1931,11 @@ memcpy( &payload, message->payload, sizeof( BOOL ) ); if ( TRUE == payload ) { - requestConcentratePumpOn(); + requestConcentratePumpsOn(); } else { - requestConcentratePumpOff(); + requestConcentratePumpsOff(); } }