Index: firmware/App/Controllers/LoadCell.c =================================================================== diff -u -r87a22cbaa87daab0d7cedabc67452cead83d8630 -r484b185f0cf4b2ea0ba9de331573952b1b5124b4 --- firmware/App/Controllers/LoadCell.c (.../LoadCell.c) (revision 87a22cbaa87daab0d7cedabc67452cead83d8630) +++ firmware/App/Controllers/LoadCell.c (.../LoadCell.c) (revision 484b185f0cf4b2ea0ba9de331573952b1b5124b4) @@ -34,12 +34,23 @@ #define ADC2GRAM (0.0894 * 1.1338) ///< Conversion factor from ADC counts to grams. #define LOAD_CELL_ZERO_OFFSET -1215.0 ///< Zero offset (in grams). TODO - right now, this is empty reservoir weight. +#define SIZE_OF_SMALL_LOAD_CELL_AVG 10 ///< Small load cell moving average has 10 samples. +#define SIZE_OF_LARGE_LOAD_CELL_AVG 40 ///< Large load cell moving average has 40 samples. + /// Load cell data structure typedef struct { - U32 measuredReadingSum; ///< Raw load cell sums for averaging - OVERRIDE_F32_T filteredWeight; ///< Latest filtered load cell weights - F32 autoCalOffset; ///< Load cell auto-calibration offset + U32 measuredReadingSum; ///< Raw load cell sums for averaging + OVERRIDE_F32_T filteredWeight; ///< Latest filtered load cell weights + F32 autoCalOffset; ///< Load cell auto-calibration offset + + F32 smallFilterReadings[ SIZE_OF_SMALL_LOAD_CELL_AVG ]; ///< Load cell samples for small load cell moving average + F32 smallFilterTotal; ///< Small filter rolling total - used to calc small load cell moving average + F32 smallFilteredWeight; ///< Load cell small filtered (8 sample) weight. + + F32 largeFilterReadings[ SIZE_OF_LARGE_LOAD_CELL_AVG ]; ///< Load cell samples for large load cell moving average + F32 largeFilterTotal; ///< Large filter rolling total - used to calc small load cell moving average + F32 largeFilteredWeight; ///< Load cell large filtered (32 sample) weight. } LOADCELL_T; // ********** private data ********** @@ -50,6 +61,9 @@ static U32 loadCellFilterTimerCount = 0; ///< Load cell filtering timer count. static U32 loadCellDataPublicationTimerCounter = 0; ///< Load cell data publication timer counter to CAN bus. +static U32 smallReadingsIdx; ///< Index for next sample in load cell small rolling average sample array +static U32 largeReadingsIdx; ///< Index for next sample in load cell large rolling average sample array + // ********** private function prototypes ********** static U32 getLoadCellDataPublishInterval( void ); @@ -64,7 +78,11 @@ void initLoadCell( void ) { U32 i; + U32 j; + smallReadingsIdx = 0; + largeReadingsIdx = 0; + for ( i = 0; i < NUM_OF_LOAD_CELLS; i++ ) { loadcells[ i ].filteredWeight.data = 0.0; @@ -74,6 +92,22 @@ loadcells[ i ].measuredReadingSum = 0; loadcells[ i ].autoCalOffset = 0.0; + + loadcells[ i ].largeFilterTotal = 0.0; + loadcells[ i ].largeFilteredWeight = 0.0; + + loadcells[ i ].smallFilterTotal = 0.0; + loadcells[ i ].smallFilteredWeight = 0.0; + + for ( j = 0; j < SIZE_OF_SMALL_LOAD_CELL_AVG; j++ ) + { + loadcells[ i ].smallFilterReadings[ j ] = 0.0; + } + + for ( j = 0; j < SIZE_OF_LARGE_LOAD_CELL_AVG; j++ ) + { + loadcells[ i ].largeFilterReadings[ j ] = 0.0; + } } } @@ -90,10 +124,10 @@ U32 ii; // update sums for load cell average calculations - loadcells[ LOAD_CELL_A1 ].measuredReadingSum += getFPGALoadCellA1(); - loadcells[ LOAD_CELL_A2 ].measuredReadingSum += getFPGALoadCellA2(); - loadcells[ LOAD_CELL_B1 ].measuredReadingSum += getFPGALoadCellB1(); - loadcells[ LOAD_CELL_B2 ].measuredReadingSum += getFPGALoadCellB2(); + loadcells[ LOAD_CELL_RESERVOIR_1_PRIMARY ].measuredReadingSum += getFPGALoadCellA1(); + loadcells[ LOAD_CELL_RESERVOIR_1_BACKUP ].measuredReadingSum += getFPGALoadCellA2(); + loadcells[ LOAD_CELL_RESERVOIR_2_PRIMARY ].measuredReadingSum += getFPGALoadCellB1(); + loadcells[ LOAD_CELL_RESERVOIR_2_BACKUP ].measuredReadingSum += getFPGALoadCellB2(); // filter every 100ms if ( ++loadCellFilterTimerCount >= LOAD_CELL_SAMPLES_TO_AVERAGE ) @@ -106,9 +140,22 @@ // reset sums for next averaging loadcells[ ii ].measuredReadingSum = 0; + + // Update filtered with new filtered weight sample and moving averages + loadcells[ ii ].smallFilterTotal -= loadcells[ ii ].smallFilterReadings[ smallReadingsIdx ]; + loadcells[ ii ].smallFilterReadings[ smallReadingsIdx ] = loadcells[ ii ].filteredWeight.data; + loadcells[ ii ].smallFilterTotal += loadcells[ ii ].filteredWeight.data; + loadcells[ ii ].smallFilteredWeight = loadcells[ ii ].smallFilterTotal / (F32)SIZE_OF_SMALL_LOAD_CELL_AVG; + + loadcells[ ii ].largeFilterTotal -= loadcells[ ii ].largeFilterReadings[ largeReadingsIdx ]; + loadcells[ ii ].largeFilterReadings[ largeReadingsIdx ] = loadcells[ ii ].filteredWeight.data; + loadcells[ ii ].largeFilterTotal += loadcells[ ii ].filteredWeight.data; + loadcells[ ii ].largeFilteredWeight = loadcells[ ii ].largeFilterTotal / (F32)SIZE_OF_LARGE_LOAD_CELL_AVG; } loadCellFilterTimerCount = 0; + smallReadingsIdx = INC_WRAP( smallReadingsIdx, 0, SIZE_OF_SMALL_LOAD_CELL_AVG - 1 ); + largeReadingsIdx = INC_WRAP( largeReadingsIdx, 0, SIZE_OF_LARGE_LOAD_CELL_AVG - 1 ); } // broadcast load cell data if we are at scheduled interval. @@ -117,8 +164,8 @@ loadCellDataPublicationTimerCounter = 0; // broadcast load cell data - broadcastLoadCellData( getLoadCellFilteredWeight( LOAD_CELL_A1 ), getLoadCellFilteredWeight( LOAD_CELL_A2 ), - getLoadCellFilteredWeight( LOAD_CELL_B1 ), getLoadCellFilteredWeight( LOAD_CELL_B2 ) ); + broadcastLoadCellData( getLoadCellFilteredWeight( LOAD_CELL_RESERVOIR_1_PRIMARY ), getLoadCellFilteredWeight( LOAD_CELL_RESERVOIR_1_BACKUP ), + getLoadCellFilteredWeight( LOAD_CELL_RESERVOIR_2_PRIMARY ), getLoadCellFilteredWeight( LOAD_CELL_RESERVOIR_2_BACKUP ) ); } } @@ -182,6 +229,56 @@ /*********************************************************************//** * @brief + * The getLoadCellSmallFilteredWeight function gets the small filtered load cell + * weight for a given load cell ID. + * @details Inputs: load cell filtered weight + * @details Outputs: none + * @param loadCellID ID of load cell to get small filtered weight for + * @return the small filtered load cell weight for the given load cell ID. + *************************************************************************/ +F32 getLoadCellSmallFilteredWeight( LOAD_CELL_ID_T loadCellID ) +{ + F32 result = 0; + + if ( loadCellID < NUM_OF_LOAD_CELLS ) + { + result = loadcells[ loadCellID ].smallFilteredWeight; + } + else + { + activateAlarmNoData( ALARM_ID_DG_SOFTWARE_FAULT ); + } + + return result; +} + +/*********************************************************************//** + * @brief + * The getLoadCellSmallFilteredWeight function gets the large filtered load cell + * weight for a given load cell ID. + * @details Inputs: load cell filtered weight + * @details Outputs: none + * @param loadCellID ID of load cell to get large filtered weight for + * @return the large filtered load cell weight for the given load cell ID. + *************************************************************************/ +F32 getLoadCellLargeFilteredWeight( LOAD_CELL_ID_T loadCellID ) +{ + F32 result = 0; + + if ( loadCellID < NUM_OF_LOAD_CELLS ) + { + result = loadcells[ loadCellID ].largeFilteredWeight; + } + else + { + activateAlarmNoData( ALARM_ID_DG_SOFTWARE_FAULT ); + } + + return result; +} + +/*********************************************************************//** + * @brief * The getLoadCellDataPublishInterval function gets the load cell data publish interval. * @details Inputs: loadCellDataPublishInterval * @details Outputs: none Index: firmware/App/Controllers/LoadCell.h =================================================================== diff -u -r87a22cbaa87daab0d7cedabc67452cead83d8630 -r484b185f0cf4b2ea0ba9de331573952b1b5124b4 --- firmware/App/Controllers/LoadCell.h (.../LoadCell.h) (revision 87a22cbaa87daab0d7cedabc67452cead83d8630) +++ firmware/App/Controllers/LoadCell.h (.../LoadCell.h) (revision 484b185f0cf4b2ea0ba9de331573952b1b5124b4) @@ -19,6 +19,7 @@ #define __LOADCELL_H__ #include "DGCommon.h" +#include "DGDefs.h" /** * @defgroup LoadCells LoadCells @@ -30,16 +31,6 @@ // ********** public definitions ********** -/// Enumeration of load cells. -typedef enum LoadCells -{ - LOAD_CELL_A1 = 0, ///< Load cell A1 - LOAD_CELL_A2, ///< Load cell A2 - LOAD_CELL_B1, ///< Load cell B1 - LOAD_CELL_B2, ///< Load cell B2 - NUM_OF_LOAD_CELLS ///< Number of reservoirs -} LOAD_CELL_ID_T; - // ********** public function prototypes ********** void initLoadCell( void ); // Initialize the LoadCell module. @@ -48,6 +39,8 @@ void tareLoadCell( LOAD_CELL_ID_T loadCellID ); void resetLoadCellOffset( LOAD_CELL_ID_T loadCellID ); F32 getLoadCellFilteredWeight( LOAD_CELL_ID_T loadCellID ); +F32 getLoadCellSmallFilteredWeight( LOAD_CELL_ID_T loadCellID ); +F32 getLoadCellLargeFilteredWeight( LOAD_CELL_ID_T loadCellID ); BOOL testSetLoadCellOverride( U32 loadCellID, F32 value ); BOOL testResetLoadCellOverride( U32 loadCellID ); Index: firmware/App/Controllers/Pressures.c =================================================================== diff -u -r2fea76e972a450a97c74b2a9f627095032a3b586 -r484b185f0cf4b2ea0ba9de331573952b1b5124b4 --- firmware/App/Controllers/Pressures.c (.../Pressures.c) (revision 2fea76e972a450a97c74b2a9f627095032a3b586) +++ firmware/App/Controllers/Pressures.c (.../Pressures.c) (revision 484b185f0cf4b2ea0ba9de331573952b1b5124b4) @@ -318,7 +318,7 @@ #ifdef PRESSURES_DEBUG { // TODO - temporary debug code - remove later - F32 lc1 = getLoadCellFilteredWeight(LOAD_CELL_A1); + F32 lc1 = getLoadCellFilteredWeight(LOAD_CELL_RESERVOIR_1_PRIMARY); F32 lc2 = getLoadCellFilteredWeight(LOAD_CELL_B1); char debugPresStr[ 256 ]; Index: firmware/App/Modes/ModeDrain.c =================================================================== diff -u -r55425a4c5370a6fa1faad61dc24fcd76b854d3ed -r484b185f0cf4b2ea0ba9de331573952b1b5124b4 --- firmware/App/Modes/ModeDrain.c (.../ModeDrain.c) (revision 55425a4c5370a6fa1faad61dc24fcd76b854d3ed) +++ firmware/App/Modes/ModeDrain.c (.../ModeDrain.c) (revision 484b185f0cf4b2ea0ba9de331573952b1b5124b4) @@ -33,15 +33,15 @@ // ********** private definitions ********** -#define TARGET_DRAIN_PUMP_RPM 1800 ///< Target drain pump speed (in RPM). -#define DRAIN_WEIGH_UNCHANGE_TIMEOUT ( 2 * MS_PER_SECOND ) ///< Time period of unchanged weight during draining before timeout. +#define TARGET_DRAIN_PUMP_RPM 1800 ///< Target drain pump speed (in RPM). +#define DRAIN_WEIGH_UNCHANGE_TIMEOUT ( 2 * MS_PER_SECOND ) ///< Time period of unchanged weight during draining before timeout. -#define TARGET_RO_PRESSURE_PSI 130 ///< Target pressure for RO pump. -#define TARGET_RO_FLOW_RATE_L 0.5 ///< Target flow rate for RO pump. +#define TARGET_RO_PRESSURE_PSI 130 ///< Target pressure for RO pump. +#define TARGET_RO_FLOW_RATE_L 0.5 ///< Target flow rate for RO pump. // ********** private data ********** -static DG_DRAIN_STATE_T drainState = DG_DRAIN_STATE_START; ///< Currently active drain state. +static DG_DRAIN_STATE_T drainState = DG_DRAIN_STATE_START; ///< Currently active drain state. // ********** private function prototypes ********** @@ -122,7 +122,7 @@ static DG_DRAIN_STATE_T handleDrainState( void ) { DG_DRAIN_STATE_T result = DG_DRAIN_STATE_DRAIN; - RESERVOIR_ID_T inactiveReservoir = getInactiveReservoir(); + DG_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 ( hasTargetDrainVolumeBeenReached( inactiveReservoir, DRAIN_WEIGH_UNCHANGE_TIMEOUT ) ) Index: firmware/App/Modes/ModeFill.c =================================================================== diff -u -r2fea76e972a450a97c74b2a9f627095032a3b586 -r484b185f0cf4b2ea0ba9de331573952b1b5124b4 --- firmware/App/Modes/ModeFill.c (.../ModeFill.c) (revision 2fea76e972a450a97c74b2a9f627095032a3b586) +++ firmware/App/Modes/ModeFill.c (.../ModeFill.c) (revision 484b185f0cf4b2ea0ba9de331573952b1b5124b4) @@ -25,6 +25,7 @@ #include "Pressures.h" #include "Reservoirs.h" #include "ROPump.h" +#include "TaskGeneral.h" #include "TemperatureSensors.h" #include "Timers.h" #include "Valves.h" @@ -47,10 +48,18 @@ #define DIALYSATE_FILL_TIME_OUT ( 5 * SEC_PER_MIN * MS_PER_SECOND ) ///< Time out period when reservoir is not filled with correct dialysate. +#define ACID_BICARB_CONCENTRATE_ADDITION_MULTIPLER 1.06 ///< Acid and bicarbonate concentrates make up around 6% to total volume. +#define FLOW_INTEGRATED_VOLUME_CHECK_TOLERANCE 0.1 ///< Flow integrated volume has 10% tolerance compare to load cell reading. + +/// Multiplier to conver flow (mL/min) into volume (mL) for period of general task interval. +static const F32 RO_FLOW_INTEGRATOR = ( ( ML_PER_LITER * TASK_GENERAL_INTERVAL ) / ( SEC_PER_MIN * MS_PER_SECOND ) ); + // ********** private data ********** -static DG_FILL_MODE_STATE_T fillState; ///< Currently active fill state. -static U32 dialysateFillStartTime; ///< Current time when starting to fill dialysate. +static DG_FILL_MODE_STATE_T fillState; ///< Currently active fill state. +static U32 dialysateFillStartTime; ///< Current time when starting to fill dialysate. +static F32 reservoirBaseWeight; ///< Fill reservoir base weight. +static F32 totalROFlowRate; ///< Total RO flow rate over period of time. // ********** private function prototypes ********** @@ -83,6 +92,8 @@ { fillState = DG_FILL_MODE_STATE_START; dialysateFillStartTime = getMSTimerCount(); + reservoirBaseWeight = 0.0; + totalROFlowRate = 0.0; // set initial actuator states setValveState( VDR, VALVE_STATE_DRAIN_C_TO_NO ); @@ -149,6 +160,7 @@ static DG_FILL_MODE_STATE_T handleCheckInletWaterState( void ) { DG_FILL_MODE_STATE_T result = DG_FILL_MODE_STATE_CHECK_INLET_WATER; + DG_RESERVOIR_ID_T inactiveReservoir = getInactiveReservoir(); BOOL const isWaterTemperatureGood = !isAlarmActive( ALARM_ID_INLET_WATER_HIGH_TEMPERATURE ) && !isAlarmActive( ALARM_ID_INLET_WATER_LOW_TEMPERATURE ); BOOL const isWaterConductivityGood = !isAlarmActive( ALARM_ID_INLET_WATER_HIGH_CONDUCTIVITY ) && !isAlarmActive( ALARM_ID_INLET_WATER_LOW_CONDUCTIVITY ) && @@ -162,6 +174,8 @@ if ( isInletWaterReady ) { + reservoirBaseWeight = getReservoirWeight( inactiveReservoir ); + // Concentrate pumps on request and set RO pump to flow rate 800 mL/min requestConcentratePumpsOn( CONCENTRATEPUMPS_CP1 ); requestConcentratePumpsOn( CONCENTRATEPUMPS_CP2 ); @@ -216,11 +230,13 @@ static DG_FILL_MODE_STATE_T handleDeliverDialysateState( void ) { DG_FILL_MODE_STATE_T result = DG_FILL_MODE_STATE_DELIVER_DIALYSATE; - RESERVOIR_ID_T inactiveReservoir = getInactiveReservoir(); + DG_RESERVOIR_ID_T inactiveReservoir = getInactiveReservoir(); handleDialysateMixing(); checkConcentrateConductivity(); + totalROFlowRate += getMeasuredROFlowRate(); + BOOL isDialysateConductivityBad = ( isAlarmActive( ALARM_ID_POST_ACID_CONDUCTIVITY_OUT_OF_RANGE ) || isAlarmActive( ALARM_ID_POST_BICARB_CONDUCTIVITY_OUT_OF_RANGE ) ); #ifdef DISABLE_DIALYSATE_CHECK @@ -237,6 +253,15 @@ // if we've reached our target fill to volume (by weight), we're done filling - go back to re-circ mode if ( hasTargetFillVolumeBeenReached( inactiveReservoir ) ) { + F32 const filledWeight = getReservoirWeight( inactiveReservoir ) - reservoirBaseWeight; + F32 const integratedVolume = totalROFlowRate * RO_FLOW_INTEGRATOR * ACID_BICARB_CONCENTRATE_ADDITION_MULTIPLER; + F32 const integratedVolumeToLoadCellReadingPercent = 1 - ( filledWeight / integratedVolume ); + + if ( integratedVolumeToLoadCellReadingPercent > FLOW_INTEGRATED_VOLUME_CHECK_TOLERANCE ) + { + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_DG_FLOW_METER_CHECK_FAILURE, filledWeight, integratedVolume ); + } + requestConcentratePumpsOff( CONCENTRATEPUMPS_CP1 ); requestConcentratePumpsOff( CONCENTRATEPUMPS_CP2 ); requestNewOperationMode( DG_MODE_CIRC ); Index: firmware/App/Modes/ModeStandby.c =================================================================== diff -u -r3461c140ba07e74863dee1d4c51d0119076fecf8 -r484b185f0cf4b2ea0ba9de331573952b1b5124b4 --- firmware/App/Modes/ModeStandby.c (.../ModeStandby.c) (revision 3461c140ba07e74863dee1d4c51d0119076fecf8) +++ firmware/App/Modes/ModeStandby.c (.../ModeStandby.c) (revision 484b185f0cf4b2ea0ba9de331573952b1b5124b4) @@ -89,8 +89,8 @@ requestConcentratePumpsOff( CONCENTRATEPUMPS_CP2 ); // UV off - resetReservoirLoadCellsOffset( RESERVOIR_1 ); - resetReservoirLoadCellsOffset( RESERVOIR_2 ); + resetReservoirLoadCellsOffset( DG_RESERVOIR_1 ); + resetReservoirLoadCellsOffset( DG_RESERVOIR_2 ); } /*********************************************************************//** Index: firmware/App/Services/Reservoirs.c =================================================================== diff -u -r6145c5d1a645646587fb077df3c61eef2354f744 -r484b185f0cf4b2ea0ba9de331573952b1b5124b4 --- firmware/App/Services/Reservoirs.c (.../Reservoirs.c) (revision 6145c5d1a645646587fb077df3c61eef2354f744) +++ firmware/App/Services/Reservoirs.c (.../Reservoirs.c) (revision 484b185f0cf4b2ea0ba9de331573952b1b5124b4) @@ -53,19 +53,19 @@ 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 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. +/// The reservoirs' associate load cell. +static LOAD_CELL_ID_T associatedLoadCell[ NUM_OF_DG_RESERVOIRS ] = { LOAD_CELL_RESERVOIR_1_PRIMARY, LOAD_CELL_RESERVOIR_2_PRIMARY }; +/// The reservoirs' associate redundant load cell. +static LOAD_CELL_ID_T redundantLoadCell[ NUM_OF_DG_RESERVOIRS ] = { LOAD_CELL_RESERVOIR_1_BACKUP, LOAD_CELL_RESERVOIR_2_BACKUP }; -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. +/// The reservoirs' lowest weight during draining. +static F32 reservoirLowestWeight[ NUM_OF_DG_RESERVOIRS ] = { MAX_RESERVOIR_WEIGHT, MAX_RESERVOIR_WEIGHT }; +static U32 reservoirWeightUnchangeStartTime[ NUM_OF_DG_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. // ********** private function prototypes ********** -static RESERVOIR_ID_T getActiveReservoir( void ); +static DG_RESERVOIR_ID_T getActiveReservoir( void ); static U32 getReservoirFillVolumeTargetMl( void ); static U32 getReservoirDrainVolumeTargetMl( void ); @@ -78,7 +78,7 @@ *************************************************************************/ void initReservoirs( void ) { - activeReservoir.data = RESERVOIR_2; + activeReservoir.data = DG_RESERVOIR_2; setValveState( VRF, VALVE_STATE_R1_C_TO_NC ); setValveState( VRD, VALVE_STATE_R1_C_TO_NC ); setValveState( VRO, VALVE_STATE_R2_C_TO_NC ); @@ -116,7 +116,7 @@ * @param resID ID of reservoir to set as active * @return none *************************************************************************/ -void setActiveReservoirCmd( RESERVOIR_ID_T resID ) +void setActiveReservoirCmd( DG_RESERVOIR_ID_T resID ) { DG_CMD_RESPONSE_T cmdResponse; @@ -129,7 +129,7 @@ { switch ( resID ) { - case RESERVOIR_1: + case DG_RESERVOIR_1: activeReservoir.data = (U32)resID; cmdResponse.rejected = FALSE; setValveState( VRF, VALVE_STATE_R2_C_TO_NO ); @@ -138,7 +138,7 @@ setValveState( VRI, VALVE_STATE_R1_C_TO_NO ); break; - case RESERVOIR_2: + case DG_RESERVOIR_2: activeReservoir.data = (U32)resID; cmdResponse.rejected = FALSE; setValveState( VRF, VALVE_STATE_R1_C_TO_NC ); @@ -170,7 +170,7 @@ * @param valveSettingID ID of valve setting to change valves to * @return none *************************************************************************/ -void changeValveSettingCmd( VALVE_SETTING_ID_T valveSettingID ) +void changeValveSettingCmd( DG_VALVE_SETTING_ID_T valveSettingID ) { DG_CMD_RESPONSE_T cmdResponse; @@ -183,13 +183,13 @@ { switch ( valveSettingID ) { - case VALVE_SETTING_R1_TO_R2: + case DG_VALVE_SETTING_R1_TO_R2: cmdResponse.rejected = FALSE; setValveState( VRO, VALVE_STATE_R1_C_TO_NO ); setValveState( VRI, VALVE_STATE_R2_C_TO_NC ); break; - case VALVE_SETTING_R2_TO_R1: + case DG_VALVE_SETTING_R2_TO_R1: cmdResponse.rejected = FALSE; setValveState( VRO, VALVE_STATE_R2_C_TO_NC ); setValveState( VRI, VALVE_STATE_R1_C_TO_NO ); @@ -356,30 +356,44 @@ * @details Outputs: none * @return the currently inactive reservoir. *************************************************************************/ -RESERVOIR_ID_T getInactiveReservoir( void ) +DG_RESERVOIR_ID_T getInactiveReservoir( void ) { - RESERVOIR_ID_T inactiveReservoir = RESERVOIR_1; + DG_RESERVOIR_ID_T inactiveReservoir = DG_RESERVOIR_1; - if ( RESERVOIR_1 == getActiveReservoir() ) + if ( DG_RESERVOIR_1 == getActiveReservoir() ) { - inactiveReservoir = RESERVOIR_2; + inactiveReservoir = DG_RESERVOIR_2; } return inactiveReservoir; } /*********************************************************************//** * @brief + * The getReservoirWeight function returns the large filtered weight + * of the reservoir's associated load cell. + * @details Inputs: associatedLoadCell[] + * @details Outputs: none + * @param reservoirId id of reservoir to get weight from + * @return large filtered weight + *************************************************************************/ +F32 getReservoirWeight( DG_RESERVOIR_ID_T reservoirId ) +{ + return getLoadCellLargeFilteredWeight( associatedLoadCell[ reservoirId ] ); +} + +/*********************************************************************//** + * @brief * The hasTargetFillVolumeReached function checks if the target fill volume * for specific reservoir has been reached. * @details Inputs: fillVolumeTargetMl * @details Outputs: none * @param reservoirId reservoir id * @return TRUE if target fill volume has been reached, FALSE if not. *************************************************************************/ -BOOL hasTargetFillVolumeBeenReached( RESERVOIR_ID_T reservoirId ) +BOOL hasTargetFillVolumeBeenReached( DG_RESERVOIR_ID_T reservoirId ) { - F32 const loadcellWeight = getLoadCellFilteredWeight( associatedLoadCell[ reservoirId ] ); + F32 const loadcellWeight = getLoadCellSmallFilteredWeight( associatedLoadCell[ reservoirId ] ); U32 const targetFillVolume = getReservoirFillVolumeTargetMl(); BOOL const hasTargetReached = ( loadcellWeight >= targetFillVolume ); @@ -396,10 +410,10 @@ * @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 hasTargetDrainVolumeBeenReached( RESERVOIR_ID_T reservoirId, U32 timeout ) +BOOL hasTargetDrainVolumeBeenReached( DG_RESERVOIR_ID_T reservoirId, U32 timeout ) { BOOL result = FALSE; - F32 const loadcellWeight = getLoadCellFilteredWeight( associatedLoadCell[ reservoirId ] ); + F32 const loadcellWeight = getLoadCellSmallFilteredWeight( associatedLoadCell[ reservoirId ] ); U32 const targetDrainVolume = getReservoirDrainVolumeTargetMl(); if ( loadcellWeight < reservoirLowestWeight[ reservoirId ] ) @@ -436,7 +450,7 @@ * @param reservoirId reservoir id * @return none *************************************************************************/ -void resetReservoirLoadCellsOffset( RESERVOIR_ID_T reservoirId ) +void resetReservoirLoadCellsOffset( DG_RESERVOIR_ID_T reservoirId ) { resetLoadCellOffset( associatedLoadCell[ reservoirId ] ); resetLoadCellOffset( redundantLoadCell[ reservoirId ] ); @@ -449,13 +463,13 @@ * @details Outputs: none * @return the currently active reservoir. *************************************************************************/ -static RESERVOIR_ID_T getActiveReservoir( void ) +static DG_RESERVOIR_ID_T getActiveReservoir( void ) { - RESERVOIR_ID_T result = (RESERVOIR_ID_T)activeReservoir.data; + DG_RESERVOIR_ID_T result = (DG_RESERVOIR_ID_T)activeReservoir.data; if ( OVERRIDE_KEY == activeReservoir.override ) { - result = (RESERVOIR_ID_T)activeReservoir.ovData; + result = (DG_RESERVOIR_ID_T)activeReservoir.ovData; } return result; @@ -513,7 +527,7 @@ * @param value override active reservoir ID * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testSetDGActiveReservoirOverride( RESERVOIR_ID_T value ) +BOOL testSetDGActiveReservoirOverride( DG_RESERVOIR_ID_T value ) { BOOL result = FALSE; Index: firmware/App/Services/Reservoirs.h =================================================================== diff -u -r6145c5d1a645646587fb077df3c61eef2354f744 -r484b185f0cf4b2ea0ba9de331573952b1b5124b4 --- firmware/App/Services/Reservoirs.h (.../Reservoirs.h) (revision 6145c5d1a645646587fb077df3c61eef2354f744) +++ firmware/App/Services/Reservoirs.h (.../Reservoirs.h) (revision 484b185f0cf4b2ea0ba9de331573952b1b5124b4) @@ -17,9 +17,10 @@ #ifndef __RESERVOIRS_H__ #define __RESERVOIRS_H__ + +#include "DGCommon.h" +#include "DGDefs.h" -#include "DGCommon.h" - /** * @defgroup Reservoirs Reservoirs * @brief Reservoirs service module. Maintains reservoir set points and handles reservoir related commands from the HD. @@ -29,23 +30,7 @@ */ // ********** public definitions ********** - -/// Enumeration of reservoirs. -typedef enum Reservoirs -{ - RESERVOIR_1 = 0, ///< Reservoir number 1 - RESERVOIR_2, ///< Reservoir number 2 - NUM_OF_RESERVOIRS ///< Number of reservoirs -} RESERVOIR_ID_T; -/// Enumeration of valve settings. -typedef enum Valve_Setting -{ - VALVE_SETTING_R1_TO_R2 = 0, ///< Valve setting for displacement from reservoir 1 to reservoir 2 - VALVE_SETTING_R2_TO_R1, ///< Valve setting for displacement from reservoir 2 to reservoir 1 - NUM_OF_VALVE_SETTTINGS ///< Number of valve settings -} VALVE_SETTING_ID_T; - #pragma pack(push,1) /// Drain command data structure. @@ -70,20 +55,22 @@ void initReservoirs( void ); void execReservoirs( void ); -void setActiveReservoirCmd( RESERVOIR_ID_T resID ); // handle switch reservoirs command from HD -void changeValveSettingCmd( VALVE_SETTING_ID_T valveSettingID ); // handle valve setting change command from HD +void setActiveReservoirCmd( DG_RESERVOIR_ID_T resID ); // handle switch reservoirs command from HD +void changeValveSettingCmd( DG_VALVE_SETTING_ID_T valveSettingID ); // handle valve setting change command from HD void startFillCmd( U32 fillToVolMl ); // handle fill command from HD void stopFillCmd( void ); // handle stop fill command from HD void startDrainCmd( DRAIN_CMD_T drainCmd ); // handle drain command from HD void stopDrainCmd( void ); // handle stop drain command from HD -RESERVOIR_ID_T getInactiveReservoir( void ); -BOOL hasTargetFillVolumeBeenReached( RESERVOIR_ID_T reservoirId ); -BOOL hasTargetDrainVolumeBeenReached( RESERVOIR_ID_T reservoirId , U32 timeout ); +DG_RESERVOIR_ID_T getInactiveReservoir( void ); +F32 getReservoirWeight( DG_RESERVOIR_ID_T reservoirId ); + +BOOL hasTargetFillVolumeBeenReached( DG_RESERVOIR_ID_T reservoirId ); +BOOL hasTargetDrainVolumeBeenReached( DG_RESERVOIR_ID_T reservoirId , U32 timeout ); -void resetReservoirLoadCellsOffset( RESERVOIR_ID_T reservoirId ); +void resetReservoirLoadCellsOffset( DG_RESERVOIR_ID_T reservoirId ); -BOOL testSetDGActiveReservoirOverride( RESERVOIR_ID_T value ); +BOOL testSetDGActiveReservoirOverride( DG_RESERVOIR_ID_T value ); BOOL testResetDGActiveReservoirOverride( void ); BOOL testSetReservoirFillVolumeMlOverride( U32 value ); BOOL testResetReservoirFillVolumeMlOverride( void ); Index: firmware/App/Services/SystemCommMessages.c =================================================================== diff -u -r6145c5d1a645646587fb077df3c61eef2354f744 -r484b185f0cf4b2ea0ba9de331573952b1b5124b4 --- firmware/App/Services/SystemCommMessages.c (.../SystemCommMessages.c) (revision 6145c5d1a645646587fb077df3c61eef2354f744) +++ firmware/App/Services/SystemCommMessages.c (.../SystemCommMessages.c) (revision 484b185f0cf4b2ea0ba9de331573952b1b5124b4) @@ -925,12 +925,12 @@ if ( message->hdr.payloadLen == sizeof( U32 ) ) { - RESERVOIR_ID_T reservoirID; + DG_RESERVOIR_ID_T reservoirID; U32 resID; result = TRUE; memcpy( &resID, message->payload, sizeof( U32 ) ); - reservoirID = (RESERVOIR_ID_T)resID; + reservoirID = (DG_RESERVOIR_ID_T)resID; setActiveReservoirCmd( reservoirID ); } @@ -953,7 +953,7 @@ if ( message->hdr.payloadLen == sizeof( U32 ) ) { - VALVE_SETTING_ID_T valveSettingID; + DG_VALVE_SETTING_ID_T valveSettingID; result = TRUE; memcpy( &valveSettingID, message->payload, sizeof( U32 ) );