Index: firmware/App/Controllers/BalancingChamber.c =================================================================== diff -u -reaeff603027c54d0be5171d519710942672ef623 -r520b5b97e2a1a6d7af037e1144f1ffeb39153e3e --- firmware/App/Controllers/BalancingChamber.c (.../BalancingChamber.c) (revision eaeff603027c54d0be5171d519710942672ef623) +++ firmware/App/Controllers/BalancingChamber.c (.../BalancingChamber.c) (revision 520b5b97e2a1a6d7af037e1144f1ffeb39153e3e) @@ -7,8 +7,8 @@ * * @file BalancingChamber.c * -* @author (last) Jashwant Gantyada -* @date (last) 10-Apr-2026 +* @author (last) Vinayakam Mani +* @date (last) 14-Apr-2026 * * @author (original) Vinayakam Mani * @date (original) 28-Jan-2025 @@ -57,7 +57,8 @@ #define SPENT_DIFF_COUNT_ZERO 0 ///< Zero count difference for spent side fill comparing target count #define D48_SPEED_ADJUST_FACTOR 0.5F ///< D48 speed adjustment factor ( 50% of speed adjustment = 0.5) #define D48_SPEED_RANGE_LIMIT 0.25F ///< D48 speed adjustment range check limit ( D48 speed can vary +/-25% of initial calculated speed) -#define BICARB_CHAMBER_PERIODIC_FILL_TIME ( 1 * SEC_PER_MIN * ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) ) ///< Periodic bicarb chamber fill request 60 sec x 20 = 1200 +#define BICARB_CHAMBER_PERIODIC_FILL_TIME ( 1 * SEC_PER_MIN * \ + ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) ) ///< Periodic bicarb chamber fill request 60 sec x 20 = 1200 #define BAL_CHAMBER_FILL_TIMEOUT_FACTOR 1.5 ///< Balancing Chamber fill timeout factor (150% of observed fill count) /// Payload record structure for balancing chamber switch only request @@ -259,7 +260,7 @@ currentBalChamberSwitchingCounter += 1; currentBalChamberFillCounter += 1; - if ( getTestConfigStatus( TEST_CONFIG_DD_ENABLE_DRY_BICARB ) == TRUE && balChamberExecState > BAL_CHAMBER_STATE_IDLE) + if ( ( getTestConfigStatus( TEST_CONFIG_DD_ENABLE_DRY_BICARB ) == TRUE ) && ( balChamberExecState > BAL_CHAMBER_STATE_IDLE ) ) { // Increment counter for dry bicarb chamber fill bicarbChamberPeriodicFillCounter += 1; @@ -510,6 +511,7 @@ F32 acidVolume; F32 bicarbVolume; BAL_CHAMBER_EXEC_STATE_T state = BAL_CHAMBER_STATE1_FILL_START; + balChamberSWState = BAL_CHAMBER_SW_STATE1; balChamberFillTimeoutCount = 0; isBalChamberFillInProgress = FALSE; @@ -525,10 +527,10 @@ if ( getTestConfigStatus( TEST_CONFIG_DD_ENABLE_DRY_BICARB ) == TRUE ) { - bicarbVolume = getBicarbDoseVol(); - acidVolume = getAcidDoseVol(); + bicarbVolume = getBicarbMixVol(); + acidVolume = getAcidMixVol(); } - else + else // wet bicarb { acidVolume = getF32OverrideValue( &acidDoseVolume ); bicarbVolume = getF32OverrideValue( &bicarbDoseVolume ); @@ -596,6 +598,7 @@ static BAL_CHAMBER_EXEC_STATE_T handleBalChamberConcentrateControl( void ) { BAL_CHAMBER_EXEC_STATE_T state; + freshDialPressure = getFilteredPressure( D18_PRES ); spentDialPressure = getFilteredPressure( D51_PRES ); lastPrevSpentDialPressure = prevSpentDialPressure; @@ -652,12 +655,13 @@ static BAL_CHAMBER_EXEC_STATE_T handleBalChamberState1ValvesClose( void ) { BAL_CHAMBER_EXEC_STATE_T state = BAL_CHAMBER_STATE1_VALVES_CLOSE; - freshDialPressure = getFilteredPressure( D18_PRES ); - spentDialPressure = getFilteredPressure( D51_PRES ); BOOL isBothFillsComplete = FALSE; BOOL isFirstCycleNotDone = FALSE; BOOL isFillCompleteOrFirstCycle = FALSE; + freshDialPressure = getFilteredPressure( D18_PRES ); + spentDialPressure = getFilteredPressure( D51_PRES ); + // If fill is taking too long, set an alarm for fill timeout if ( ( balChamberFillTimeoutCount > 0 ) && ( currentBalChamberFillCounter > balChamberFillTimeoutCount ) ) { @@ -813,6 +817,7 @@ F32 acidVolume; F32 bicarbVolume; BAL_CHAMBER_EXEC_STATE_T state = BAL_CHAMBER_STATE2_FILL_START; + isBalChamberFillInProgress = FALSE; isPressureStabilizedDuringFill = FALSE; isPressureDroppedDuringFill = FALSE; @@ -826,10 +831,10 @@ spentFillRiseMissCounter = 0; isSpentFillComplete = FALSE; - if ( getTestConfigStatus( TEST_CONFIG_DD_ENABLE_DRY_BICARB ) == TRUE ) + if ( getTestConfigStatus( TEST_CONFIG_DD_ENABLE_DRY_BICARB ) == TRUE ) { - bicarbVolume = getBicarbDoseVol(); - acidVolume = getAcidDoseVol(); + bicarbVolume = getBicarbMixVol(); + acidVolume = getAcidMixVol(); } else { @@ -899,12 +904,13 @@ static BAL_CHAMBER_EXEC_STATE_T handleBalChamberState2ValvesClose( void ) { BAL_CHAMBER_EXEC_STATE_T state = BAL_CHAMBER_STATE2_VALVES_CLOSE; - freshDialPressure = getFilteredPressure( D18_PRES ); - spentDialPressure = getFilteredPressure( D51_PRES ); BOOL isBothFillsComplete = FALSE; BOOL isFirstCycleNotDone = FALSE; BOOL isFillCompleteOrFirstCycle = FALSE; + freshDialPressure = getFilteredPressure( D18_PRES ); + spentDialPressure = getFilteredPressure( D51_PRES ); + // Check fresh dialysate pressure back in range to indicate fill complete. if ( ( freshDialPressure >= FRESH_DIAL_PRESSURE_MIN_PSIG ) && ( freshDialPressure <= FRESH_DIAL_PRESSURE_MAX_PSIG ) ) { Index: firmware/App/Controllers/DryBiCart.c =================================================================== diff -u -re6de057461dd170e037e94f55d8e4b1c5a4b6db5 -r520b5b97e2a1a6d7af037e1144f1ffeb39153e3e --- firmware/App/Controllers/DryBiCart.c (.../DryBiCart.c) (revision e6de057461dd170e037e94f55d8e4b1c5a4b6db5) +++ firmware/App/Controllers/DryBiCart.c (.../DryBiCart.c) (revision 520b5b97e2a1a6d7af037e1144f1ffeb39153e3e) @@ -45,13 +45,14 @@ #define DRY_BICART_DATA_PUBLISH_INTERVAL ( 250 / TASK_GENERAL_INTERVAL ) ///< Interval (ms/task time) at which the balancing chamber data published. // Dry Bicart Fill -#define DRY_BICART_FILL_DURATION_MIN_MS (2 * MS_PER_SECOND) ///< Minimum fill duration to be met to end the fill cycle. +#define DRY_BICART_FILL_DURATION_MIN_MS ( 2 * MS_PER_SECOND ) ///< Minimum fill duration to be met to end the fill cycle. #define DRY_BICART_FILL_COMPLETE_TIME_MS ( 1 * MS_PER_SECOND ) ///< Wait time to reset the request flag after fill complete #define DRY_BICART_FILL_DURATION_DIFF_MS 750 ///< Fill duration difference between last and current fill cycle. -#define DRY_BICART_FILL_COMPLETE_PRESSURE 12.0F ///< Maximum pressure reached to indicate the dry bicart fill being completed. -#define DRY_BICART_FILL_INITIATE_PRESSURE 7.5F ///< Minimum pressure required to initiate the dry bicart fill process. -#define DRY_BICART_FILL_COMPLETE_SUPPLY_PRESSURE 7.0F ///< Maximum pressure reached to indicate the dry bicart fill being completed. -#define DRY_BICART_FILL_INITIATE_SUPPLY_PRESSURE 5.0F ///< Minimum pressure required to initiate the dry bicart fill process. +#define PRESSURE_OFFSET 2 ///< Dry bicart pressure offset +#define DRY_BICART_FILL_COMPLETE_PRESSURE ( 10.0F + PRESSURE_OFFSET ) ///< Maximum pressure reached to indicate the dry bicart fill being completed. +#define DRY_BICART_FILL_INITIATE_PRESSURE 1.5F ///< Minimum pressure required to initiate the dry bicart fill process. +#define DRY_BICART_FILL_COMPLETE_SUPPLY_PRESSURE 6.0F ///< Maximum pressure allowed at bicart fill during supply process/state +#define DRY_BICART_FILL_INITIATE_SUPPLY_PRESSURE 3.0F ///< Minimum pressure required to initiate the dry bicart fill during supply process/state #define DRY_BICART_DEFAULT_MAX_FILL_CYCLE_CNT 10 ///< Default max fill cycle allowed for dry bicart fill/mix with water. #define DRY_BICART_MAX_FILL_CYCLE_CNT 30 ///< Max fill cycle allowed (by override) for dry bicart fill/mix with water. @@ -63,7 +64,7 @@ // Bicarb chamber fill/Supply #define DRY_BICART_SUPPLY_VALVE_D80_OPEN_TIME_MS ( 3 * MS_PER_SECOND ) ///< Max time allowed for supply (opening D80 valve) during bicarb chamber (F) fill. #define DRY_BICART_SUPPLY_VENT_TIME_MS ( 1 * MS_PER_SECOND ) ///< Wait time to vent dry bicart gas before actuating Bicarb chamber(F) venting. -#define DRY_BICART_SUPPLY_VENT_MAX_TIME_MS ( 1.2 * MS_PER_SECOND ) ///< Max time to vent both dry bicart and Chamber F. +#define DRY_BICART_SUPPLY_VENT_MAX_TIME_MS ( 1.1 * MS_PER_SECOND ) ///< Max time to vent both dry bicart and Chamber F. // Dry Bicart Drain #define LARGE_DRY_BICART_MAX_DRAIN_TIME_MS ( 8 * SEC_PER_MIN * MS_PER_SECOND ) ///< Max drain time for large dry bicart in ms. @@ -75,26 +76,16 @@ #define DRY_BICART_DRAIN_COND_STABLE_SAMPLES 10U ///< Debounce samples (10*50ms=500ms) // drybicarb mixing -#define DEFAULT_ACID_VOLUME_ML 0.67F ///< Acid concentrate volume in ml. -#define DEFAULT_BICARB_VOLUME_ML 1.15F ///< Bicarb concentrate volume in ml. +#define BICARB_VOL_CONTROL_P_COEFFICIENT 0.00008484 ///< Bicarb proportional gain (kp) +#define BICARB_VOL_CONTROL_I_COEFFICIENT 0.00033936 ///< Bicarb integral gain. (ki) +#define MIN_BICARB_VOLUME_ML 0.868686869 ///< Minimum bicarb volume in mL +#define MAX_BICARB_VOLUME_ML 1.8 ///< Maximum bicarb volume in mL -#define KP_SCALE_FACTOR 1 -#define KI_SCALE_FACTOR 1 +#define ACID_VOL_CONTROL_P_COEFFICIENT (0.00000997/2) ///< Acid proportional gain (kp) +#define ACID_VOL_CONTROL_I_COEFFICIENT (0.00003988/2) ///< Acid integral gain. (ki) +#define MIN_ACID_VOLUME_ML 0.3 ///< Minimum acid volume in mL +#define MAX_ACID_VOLUME_ML 1.0 ///< Maximum acid volume in mL/min. -#define BICARB_VOL_CONTROL_P_COEFFICIENT 0.00008484 ///< Propotional gain (kp) -#define BICARB_VOL_CONTROL_I_COEFFICIENT 0.00033936 ///< Integral gain. (ki) -#define MIN_BICARB_VOLUME_MLPM 0.868686869 ///< Minimum target bicarb in mL/min. -#define MAX_BICARB_VOLUME_MLPM 1.8 ///< Maximum target bicarb volume in mL/min. - -#define ACID_VOL_CONTROL_P_COEFFICIENT (0.00000997/2) ///< Propotional gain (kp) -#define ACID_VOL_CONTROL_I_COEFFICIENT (0.00003988/2) ///< Integral gain. (ki) -#define MIN_ACID_VOLUME_MLPM 0.3 ///< Minimum target acid volume in mL/min. -#define MAX_ACID_VOLUME_MLPM 1.0 ///< Maximum target acid volume in mL/min. - - -#define STD_BICARB_DOSING 1.146666667F ///< Standard bicarb dosing volume -#define STD_ACID_DOSING 0.666666667F ///< Standard acid dosing volume - #define DRY_BICARB_TARGET_CONDUCTIVITY 2714.0F ///< Target bicarb conductivity #define DRY_BICARB_DELTA_CONDUCTIVITY 500.0F ///< Delta bicarb conductivity @@ -108,11 +99,11 @@ #define MIN_BICARB_CONDUCTIVITY 2000 ///< Minimum Bicarb conductivity limit #define MAX_BICARB_CONDUCTIVITY 4000 ///< Maximum Bicarb conductivity limit -#define DOSING_NO_FEED_FORWARD 0.0F ///< Feedforward term for dialysate pump control +#define MIX_NO_FEED_FORWARD 0.0F ///< Feedforward term for dialysate closed loop control -#define DOSE_CONTROL_INTERVAL_MS ( 15 * MS_PER_SECOND ) ///< Dialysate dosing control interval in ms -#define DOSE_CONTROL_INTERVAL ( DOSE_CONTROL_INTERVAL_MS /\ - TASK_GENERAL_INTERVAL ) ///< Interval (ms/task time) at which the dialysate dose is controlled. +#define MIXING_CONTROL_INTERVAL_MS ( 15 * MS_PER_SECOND ) ///< Dialysate mixing control interval in ms +#define MIXING_CONTROL_INTERVAL ( MIXING_CONTROL_INTERVAL_MS /\ + TASK_GENERAL_INTERVAL ) ///< Interval (ms/task time) at which the dialysate mixing is controlled. /// Payload record structure for dry bicart fill request typedef struct @@ -145,15 +136,15 @@ DIALYSATE_MIXING_OPEN_LOOP_STATE = 0, ///< Dialysate open loop state DIALYSATE_MIXING_RAMP_UP_STATE, ///< Dialysate mixing ramp up state DIALYSATE_MIXING_CONTROL_TO_TARGET_STATE, ///< Dialysate mixing control to target state - NUM_OF_DIALYSATE_MIXING_STATES ///< Number of dialysate mixingstates + NUM_OF_DIALYSATE_MIXING_STATES ///< Number of dialysate mixing states } DIALYSATE_MIXING_STATE_T; /// Dialysate Mixing state machine data structure typedef struct { - U32 controlTimerCounter; ///< Timer counter to perform control on dialysate dose. + U32 controlTimerCounter; ///< Timer counter to perform control on dialysate mixing. DIALYSATE_MIXING_STATE_T dialysateMixingState; ///< Current state of dialysate mixing controller state machine. -} DIALYSATE_DOSE_DATA_T; +} DIALYSATE_MIXING_DATA_T; // ********** private data ********** @@ -166,6 +157,9 @@ static U32 lastFillDurationInMS; ///< Previous time duration to fill the bicart fill. static U32 currentFillDurationInMS; ///< Current time duration to fill the bicart fill. static OVERRIDE_U32_T biCartMaxFillCycleCount; ///< Maximum number of drybicart fill cycle ( overrideable) +static OVERRIDE_F32_T dryBiCartUpperCartPressure; ///< Upper cart pressure +static OVERRIDE_F32_T dryBiCartLowerCartPressure; ///< Lower cart pressure + // initiate the fill/supply/drain static OVERRIDE_U32_T dryBiCartFillRequested; ///< Start/stop dry bicart fill. static OVERRIDE_U32_T bicarbChamberFillRequested; ///< Start/stop bicarb chamber fill. @@ -188,29 +182,28 @@ static DRY_BICART_OPERATION_T dryBicartStartRequest; ///< Dry bicart operation, fill or supply or drain request // drybicart mixing -static OVERRIDE_F32_T dryBiCartAcidDoseVolume; ///< Acid concentrate volume in ml ( overrideable). -static OVERRIDE_F32_T dryBiCartBicarbDoseVolume; ///< Bicarb concentrate volume in ml ( overrideable). +static OVERRIDE_F32_T dryBiCartAcidMixVolume; ///< Acid concentrate volume in ml ( overrideable). +static OVERRIDE_F32_T dryBiCartBicarbMixVolume; ///< Bicarb concentrate volume in ml ( overrideable). -static OVERRIDE_F32_T dryBiCartAcidDoseVolumeKpGain; ///< Acid kp gain. -static OVERRIDE_F32_T dryBiCartAcidDoseVolumeKiGain; ///< Acid ki gain. +static OVERRIDE_F32_T dryBiCartAcidMixVolumeKpGain; ///< Acid kp gain. +static OVERRIDE_F32_T dryBiCartAcidMixVolumeKiGain; ///< Acid ki gain. -static OVERRIDE_F32_T dryBiCartBicarbDoseVolumeKpGain; ///< Bicarb kp gain -static OVERRIDE_F32_T dryBiCartBicarbDoseVolumeKiGain; ///< Acid ki gain. +static OVERRIDE_F32_T dryBiCartBicarbMixVolumeKpGain; ///< Bicarb kp gain +static OVERRIDE_F32_T dryBiCartBicarbMixVolumeKiGain; ///< Acid ki gain. -static DIALYSATE_DOSE_DATA_T dialysateMix[ NUM_OF_DIALYSATE_MIXING_ID ]; ///< Array of dialysate mixing data structure. +static DIALYSATE_MIXING_DATA_T dialysateMix[ NUM_OF_DIALYSATE_MIXING_ID ]; ///< Array of dialysate mixing data structure. static OVERRIDE_F32_T dryBiCartBicarbTargetConductivity; ///< Target bicarb conductivity static OVERRIDE_F32_T dryBiCartBicarbDeltaConductivity; ///< Target delta conductivity -static OVERRIDE_F32_T dryBiCartAcidBicarbMixTargetConductivity; ///< Acid bicarb mix conductivity -static OVERRIDE_F32_T dryBiCartAcidBicarbMixDeltaConductivity; ///< Acid bicarb delta conductivity +static OVERRIDE_F32_T dryBiCartDialysateTargetConductivity; ///< Acid bicarb mix conductivity +static OVERRIDE_F32_T dryBiCartDialysateDeltaConductivity; ///< Acid bicarb delta conductivity +static OVERRIDE_F32_T dryBiCartMixControlInterval; ///< Mix control interval + static PI_CONTROLLER_SIGNALS_DATA bicarbControlSignals; ///< Bicarb closed loop control signal data static PI_CONTROLLER_SIGNALS_DATA acidControlSignals; ///< Acid closed loop control signal data -//For testing -static F32 pIControlSignal[ NUM_OF_CONTROLLER_SIGNAL ]; - // ********** private function prototypes ********** static void updateDrybicartOperation(void); @@ -238,10 +231,24 @@ static DRY_BICART_DRAIN_EXEC_STATE_T handleDryBicartFluidDrainEndState( void ); // dosing control loop -static DIALYSATE_MIXING_STATE_T handleDialysateOpenLoopState( DIALYSATE_MIXING_ID_T doseId ); -static DIALYSATE_MIXING_STATE_T handleDialysateDoseRampToTargetState( DIALYSATE_MIXING_ID_T doseId ); -static DIALYSATE_MIXING_STATE_T handleDialysateDoseControlToTargetState( DIALYSATE_MIXING_ID_T doseId ); +static DIALYSATE_MIXING_STATE_T handleDialysateMixOpenLoopState( DIALYSATE_MIXING_ID_T mixId ); +static DIALYSATE_MIXING_STATE_T handleDialysateMixRampToTargetState( DIALYSATE_MIXING_ID_T mixId ); +static DIALYSATE_MIXING_STATE_T handleDialysateMixControlToTargetState( DIALYSATE_MIXING_ID_T mixId ); +static void setBicarbMixVol( F32 targetValue ); +static void setAcidMixVol( F32 targetValue ); +static F32 getBicarbDeltaConductivity( void ); +static F32 getBicarbTargetConductivity( void ); +static F32 getAcidBicarbDeltaConductivity( void ); +static F32 getAcidBicarbTargetConductivity( void ); +static F32 getBicarbKpGainCoefficient( void ); +static F32 getBicarbKiGainCoefficient( void ); +static F32 getAcidKpGainCoefficient( void ); +static F32 getAcidKiGainCoefficient( void ); +static F32 getDryBicartLowerCartPressure( void ); +static F32 getDryBicartUpperCartPressure( void ); +static F32 getDryBicartMixControlInterval( void ); + // publish the status static void publishDryBicartData( void ); static U32 getDryBicartFillDataPublishInterval( void ); @@ -265,8 +272,8 @@ for ( mixId = DIALYSATE_MIX_ID_FIRST; mixId < NUM_OF_DIALYSATE_MIXING_ID; mixId++ ) { - dialysateMix[ mixId ].dialysateMixingState = DIALYSATE_MIXING_OPEN_LOOP_STATE; - dialysateMix[ mixId ].controlTimerCounter = 0; + dialysateMix[ mixId ].dialysateMixingState = DIALYSATE_MIXING_OPEN_LOOP_STATE; + dialysateMix[ mixId ].controlTimerCounter = 0; } dryBiCartDataPublishInterval.data = DRY_BICART_DATA_PUBLISH_INTERVAL; @@ -299,35 +306,35 @@ dryBiCartType.ovInitData = 0; dryBiCartType.override = OVERRIDE_RESET; - dryBiCartAcidDoseVolume.data = DEFAULT_ACID_VOLUME_ML; - dryBiCartAcidDoseVolume.ovData = DEFAULT_ACID_VOLUME_ML; - dryBiCartAcidDoseVolume.ovInitData = 0.0F; - dryBiCartAcidDoseVolume.override = OVERRIDE_RESET; + dryBiCartAcidMixVolume.data = DEFAULT_ACID_VOLUME_ML; + dryBiCartAcidMixVolume.ovData = DEFAULT_ACID_VOLUME_ML; + dryBiCartAcidMixVolume.ovInitData = 0.0F; + dryBiCartAcidMixVolume.override = OVERRIDE_RESET; - dryBiCartBicarbDoseVolume.data = DEFAULT_BICARB_VOLUME_ML; - dryBiCartBicarbDoseVolume.ovData = DEFAULT_BICARB_VOLUME_ML; - dryBiCartBicarbDoseVolume.ovInitData = 0.0F; - dryBiCartBicarbDoseVolume.override = OVERRIDE_RESET; + dryBiCartBicarbMixVolume.data = DEFAULT_BICARB_VOLUME_ML; + dryBiCartBicarbMixVolume.ovData = DEFAULT_BICARB_VOLUME_ML; + dryBiCartBicarbMixVolume.ovInitData = 0.0F; + dryBiCartBicarbMixVolume.override = OVERRIDE_RESET; - dryBiCartAcidDoseVolumeKpGain.data = ACID_VOL_CONTROL_P_COEFFICIENT; - dryBiCartAcidDoseVolumeKpGain.ovData = ACID_VOL_CONTROL_P_COEFFICIENT; - dryBiCartAcidDoseVolumeKpGain.ovInitData = 0.0F; - dryBiCartAcidDoseVolumeKpGain.override = OVERRIDE_RESET; + dryBiCartAcidMixVolumeKpGain.data = ACID_VOL_CONTROL_P_COEFFICIENT; + dryBiCartAcidMixVolumeKpGain.ovData = ACID_VOL_CONTROL_P_COEFFICIENT; + dryBiCartAcidMixVolumeKpGain.ovInitData = 0.0F; + dryBiCartAcidMixVolumeKpGain.override = OVERRIDE_RESET; - dryBiCartAcidDoseVolumeKiGain.data = ACID_VOL_CONTROL_I_COEFFICIENT; - dryBiCartAcidDoseVolumeKiGain.ovData = ACID_VOL_CONTROL_I_COEFFICIENT; - dryBiCartAcidDoseVolumeKiGain.ovInitData = 0.0F; - dryBiCartAcidDoseVolumeKiGain.override = OVERRIDE_RESET; + dryBiCartAcidMixVolumeKiGain.data = ACID_VOL_CONTROL_I_COEFFICIENT; + dryBiCartAcidMixVolumeKiGain.ovData = ACID_VOL_CONTROL_I_COEFFICIENT; + dryBiCartAcidMixVolumeKiGain.ovInitData = 0.0F; + dryBiCartAcidMixVolumeKiGain.override = OVERRIDE_RESET; - dryBiCartBicarbDoseVolumeKpGain.data = BICARB_VOL_CONTROL_P_COEFFICIENT; - dryBiCartBicarbDoseVolumeKpGain.ovData = BICARB_VOL_CONTROL_P_COEFFICIENT; - dryBiCartBicarbDoseVolumeKpGain.ovInitData = 0.0F; - dryBiCartBicarbDoseVolumeKpGain.override = OVERRIDE_RESET; + dryBiCartBicarbMixVolumeKpGain.data = BICARB_VOL_CONTROL_P_COEFFICIENT; + dryBiCartBicarbMixVolumeKpGain.ovData = BICARB_VOL_CONTROL_P_COEFFICIENT; + dryBiCartBicarbMixVolumeKpGain.ovInitData = 0.0F; + dryBiCartBicarbMixVolumeKpGain.override = OVERRIDE_RESET; - dryBiCartBicarbDoseVolumeKiGain.data = BICARB_VOL_CONTROL_I_COEFFICIENT; - dryBiCartBicarbDoseVolumeKiGain.ovData = BICARB_VOL_CONTROL_I_COEFFICIENT; - dryBiCartBicarbDoseVolumeKiGain.ovInitData = 0.0F; - dryBiCartBicarbDoseVolumeKiGain.override = OVERRIDE_RESET; + dryBiCartBicarbMixVolumeKiGain.data = BICARB_VOL_CONTROL_I_COEFFICIENT; + dryBiCartBicarbMixVolumeKiGain.ovData = BICARB_VOL_CONTROL_I_COEFFICIENT; + dryBiCartBicarbMixVolumeKiGain.ovInitData = 0.0F; + dryBiCartBicarbMixVolumeKiGain.override = OVERRIDE_RESET; dryBiCartBicarbTargetConductivity.data = DRY_BICARB_TARGET_CONDUCTIVITY; dryBiCartBicarbTargetConductivity.ovData = DRY_BICARB_TARGET_CONDUCTIVITY; @@ -339,16 +346,31 @@ dryBiCartBicarbDeltaConductivity.ovInitData = 0.0F; dryBiCartBicarbDeltaConductivity.override = OVERRIDE_RESET; - dryBiCartAcidBicarbMixTargetConductivity.data = DRY_ACID_BICARB_TARGET_CONDUCTIVITY; - dryBiCartAcidBicarbMixTargetConductivity.ovData = DRY_ACID_BICARB_TARGET_CONDUCTIVITY; - dryBiCartAcidBicarbMixTargetConductivity.ovInitData = 0.0F; - dryBiCartAcidBicarbMixTargetConductivity.override = OVERRIDE_RESET; + dryBiCartDialysateTargetConductivity.data = DRY_ACID_BICARB_TARGET_CONDUCTIVITY; + dryBiCartDialysateTargetConductivity.ovData = DRY_ACID_BICARB_TARGET_CONDUCTIVITY; + dryBiCartDialysateTargetConductivity.ovInitData = 0.0F; + dryBiCartDialysateTargetConductivity.override = OVERRIDE_RESET; - dryBiCartAcidBicarbMixDeltaConductivity.data = DRY_ACID_BICARB_DELTA_CONDUCTIVITY; - dryBiCartAcidBicarbMixDeltaConductivity.ovData = DRY_ACID_BICARB_DELTA_CONDUCTIVITY; - dryBiCartAcidBicarbMixDeltaConductivity.ovInitData = 0.0F; - dryBiCartAcidBicarbMixDeltaConductivity.override = OVERRIDE_RESET; + dryBiCartDialysateDeltaConductivity.data = DRY_ACID_BICARB_DELTA_CONDUCTIVITY; + dryBiCartDialysateDeltaConductivity.ovData = DRY_ACID_BICARB_DELTA_CONDUCTIVITY; + dryBiCartDialysateDeltaConductivity.ovInitData = 0.0F; + dryBiCartDialysateDeltaConductivity.override = OVERRIDE_RESET; + dryBiCartUpperCartPressure.data = DRY_BICART_FILL_COMPLETE_SUPPLY_PRESSURE; + dryBiCartUpperCartPressure.ovData = DRY_BICART_FILL_COMPLETE_SUPPLY_PRESSURE; + dryBiCartUpperCartPressure.ovInitData = 0.0F; + dryBiCartUpperCartPressure.override = OVERRIDE_RESET; + + dryBiCartLowerCartPressure.data = DRY_BICART_FILL_INITIATE_SUPPLY_PRESSURE; + dryBiCartLowerCartPressure.ovData = DRY_BICART_FILL_INITIATE_SUPPLY_PRESSURE; + dryBiCartLowerCartPressure.ovInitData = 0.0F; + dryBiCartLowerCartPressure.override = OVERRIDE_RESET; + + dryBiCartMixControlInterval.data = MIXING_CONTROL_INTERVAL; + dryBiCartMixControlInterval.ovData = MIXING_CONTROL_INTERVAL; + dryBiCartMixControlInterval.ovInitData = 0.0F; + dryBiCartMixControlInterval.override = OVERRIDE_RESET; + dryBiCartFillStartTime = 0; lastFillDurationInMS = 0; currentFillDurationInMS = 0; @@ -361,17 +383,13 @@ dryBiCartDrainCondStableCount = 0; dryBiCartDrainTimePeriod = 0; - initializePIController(PI_CONTROLLER_ID_BICARB_VOL, 0.0F,\ + initializePIController( PI_CONTROLLER_ID_BICARB_VOL, 0.0F,\ getBicarbKpGainCoefficient(), getBicarbKiGainCoefficient(),\ - MIN_BICARB_VOLUME_MLPM, MAX_BICARB_VOLUME_MLPM, FALSE, DOSING_NO_FEED_FORWARD ); + MIN_BICARB_VOLUME_ML, MAX_BICARB_VOLUME_ML, FALSE, MIX_NO_FEED_FORWARD ); - resetPIController(PI_CONTROLLER_ID_BICARB_VOL, STD_BICARB_DOSING, DOSING_NO_FEED_FORWARD); - - initializePIController(PI_CONTROLLER_ID_ACID_VOL, 0.0F, \ + initializePIController( PI_CONTROLLER_ID_ACID_VOL, 0.0F, \ getAcidKpGainCoefficient(), getAcidKiGainCoefficient(),\ - MIN_ACID_VOLUME_MLPM, MAX_ACID_VOLUME_MLPM, FALSE, DOSING_NO_FEED_FORWARD ); - - resetPIController(PI_CONTROLLER_ID_ACID_VOL, STD_ACID_DOSING, DOSING_NO_FEED_FORWARD); + MIN_ACID_VOLUME_ML, MAX_ACID_VOLUME_ML, FALSE, MIX_NO_FEED_FORWARD ); } /*********************************************************************//** @@ -405,19 +423,19 @@ switch ( dialysateMix[ mixId ].dialysateMixingState ) { case DIALYSATE_MIXING_OPEN_LOOP_STATE: - dialysateMix[ mixId ].dialysateMixingState = handleDialysateOpenLoopState( mixId ); + dialysateMix[ mixId ].dialysateMixingState = handleDialysateMixOpenLoopState( mixId ); break; case DIALYSATE_MIXING_RAMP_UP_STATE: - dialysateMix[ mixId ].dialysateMixingState = handleDialysateDoseRampToTargetState( mixId ); + dialysateMix[ mixId ].dialysateMixingState = handleDialysateMixRampToTargetState( mixId ); break; case DIALYSATE_MIXING_CONTROL_TO_TARGET_STATE: - dialysateMix[ mixId ].dialysateMixingState = handleDialysateDoseControlToTargetState( mixId ); + dialysateMix[ mixId ].dialysateMixingState = handleDialysateMixControlToTargetState( mixId ); break; default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_DIALYSATE_DOSE_EXEC_INVALID_STATE, mixId ) + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_DIALYSATE_MIX_EXEC_INVALID_STATE, mixId ) dialysateMix[ mixId ].dialysateMixingState = DIALYSATE_MIXING_OPEN_LOOP_STATE; break; } @@ -434,6 +452,13 @@ *************************************************************************/ void execDryBicart( void ) { + //( TRUE == getBicarbChamberFillRequested() ) + //supply dryBicartStartRequest = DRY_BICART_SUPPLY ; + //( TRUE == getBicartFillRequested() ) + //fill dryBicartStartRequest = DRY_BICART_INITIAL_FILL; + //( TRUE == getBicartDrainRequested() ) + //drain dryBicartStartRequest = DRY_BICART_DRAIN; + //else idle dryBicartStartRequest = DRY_BICART_IDLE; updateDrybicartOperation(); if( getCurrentBalancingChamberExecState() > BAL_CHAMBER_STATE_IDLE ) @@ -450,27 +475,25 @@ { case DRY_BICART_IDLE: // run as idle state - dryBicartSubstate = 0x0; break; case DRY_BICART_INITIAL_FILL: // Dry bicart fill exec - dryBicartSubstate = execDryBicartFillMode(); + execDryBicartFillMode(); break; case DRY_BICART_SUPPLY: // Fill Bicarb chamber F exec - dryBicartSubstate = execBicarbChamberFillMode(); + execBicarbChamberFillMode(); break; case DRY_BICART_DRAIN: // Dry bicart drain exec - dryBicartSubstate = execDryBicartDrainMode(); + execDryBicartDrainMode(); break; default: // software fault, - dryBicartSubstate = 0x0; dryBicartStartRequest = DRY_BICART_IDLE; SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_DRY_BICART_FILL_INVALID_EXEC_STATE, dryBicartStartRequest ); break; @@ -630,395 +653,376 @@ /*********************************************************************//** * @brief - * The setBicarbDoseVol function sets bicarb dose volume provided by the controller - * @details \b Inputs: none - * @details \b Outputs: dryBiCartBicarbDoseVolume - * @param targetValue bicarb dose volume + * TThe getBicarbMixVol function gets the bicarb mix volume provided by the controller + * @details \b Inputs: dryBiCartBicarbMixVolume + * @details \b Outputs: none * @return TRUE if successful, FALSE if not. *************************************************************************/ -void setBicarbDoseVol( F32 targetValue ) +F32 getBicarbMixVol( void ) { - dryBiCartBicarbDoseVolume.data = targetValue; + F32 result = getF32OverrideValue( &dryBiCartBicarbMixVolume ); + + return result; } /*********************************************************************//** * @brief - * TThe getBicarbDoseVol function gets the bicarb dose volume provided by the controller - * @details \b Inputs: dryBiCartBicarbDoseVolume + * The getAcidMixVol function gets acid mix volume provided by the controller + * @details \b Inputs: dryBiCartAcidMixVolume * @details \b Outputs: none * @return TRUE if successful, FALSE if not. *************************************************************************/ -F32 getBicarbDoseVol( void ) +F32 getAcidMixVol( void ) { - F32 result = dryBiCartBicarbDoseVolume.data; + F32 result = getF32OverrideValue( &dryBiCartAcidMixVolume ); - if ( OVERRIDE_KEY == dryBiCartBicarbDoseVolume.override ) - { - result = dryBiCartBicarbDoseVolume.ovData; - } - return result; } /*********************************************************************//** * @brief - * The setAcidDoseVol function sets acid dose volume provided by the controller + * The setBicarbChamberFillRequested function sets the chmaberFillRequest * flag value to be True. - * @details \b Inputs: none - * @details \b Outputs: dryBiCartAcidDoseVolume - * @param targetValue acid dose volume + * @details \b Inputs: dryBiCartFillRequested, dryBiCartDrainRequested + * @details \b Outputs: bicarbChamberFillRequested * @return TRUE if successful, FALSE if not. *************************************************************************/ -void setAcidDoseVol( F32 targetValue ) +BOOL setBicarbChamberFillRequested( void ) { - dryBiCartAcidDoseVolume.data = targetValue; + BOOL result = FALSE; + BOOL requestStatus = getU32OverrideValue( &dryBiCartFillRequested ) || getU32OverrideValue( &dryBiCartDrainRequested ); + + // ensure that there is no other operation in progress before new request set to true + if ( FALSE == requestStatus ) + { + bicarbChamberFillRequested.data = TRUE; + result = TRUE; + } + + return result; } /*********************************************************************//** * @brief - * The getBicarbAcidDoseVol function gets acid dose volume provided by the controller + * The getBicarbChamberFillRequested function gets the chmaberFillRequest * flag values - * @details \b Inputs: dryBiCartAcidDoseVolume + * @details \b Inputs: bicarbChamberFillRequested * @details \b Outputs: none * @return TRUE if successful, FALSE if not. *************************************************************************/ -F32 getAcidDoseVol( void ) +BOOL getBicarbChamberFillRequested( void ) { - F32 result = dryBiCartAcidDoseVolume.data; + BOOL result = FALSE; - if ( OVERRIDE_KEY == dryBiCartAcidDoseVolume.override ) + if ( (TRUE == getU32OverrideValue( &bicarbChamberFillRequested ) ) ) { - result = dryBiCartAcidDoseVolume.ovData; + result = TRUE; } return result; } /*********************************************************************//** * @brief - * The getBicarbDeltaConductivity function gets the delta target conductivity - * @details \b Inputs: dryBiCartBicarbDeltaConductivity - * @details \b Outputs: none + * The setBicartFillRequested function sets the bicart fill request + * flag value to be True. + * @details \b Inputs: bicarbChamberFillRequested, dryBiCartDrainRequested + * @details \b Outputs: dryBiCartFillRequested * @return TRUE if successful, FALSE if not. *************************************************************************/ -F32 getBicarbDeltaConductivity( void ) +BOOL setBicartFillRequested( void ) { - F32 result = dryBiCartBicarbDeltaConductivity.data; + BOOL result = FALSE; + BOOL requestStatus = getU32OverrideValue( &bicarbChamberFillRequested ) || getU32OverrideValue( &dryBiCartDrainRequested ); - if ( OVERRIDE_KEY == dryBiCartBicarbDeltaConductivity.override ) + //ensure that there is no other operation in progress before new request set to true + if ( FALSE == requestStatus ) { - result = dryBiCartBicarbDeltaConductivity.ovData; + dryBiCartFillRequested.data = TRUE; + result = TRUE; } return result; } /*********************************************************************//** * @brief - * The getBicarbTargetConductivity function gets the target conductivity - * @details \b Inputs: dryBiCartBicarbTargetConductivity + * The getBicartFillRequested function gets the bicart fill request + * flag value + * @details \b Inputs: dryBiCartFillRequested * @details \b Outputs: none * @return TRUE if successful, FALSE if not. *************************************************************************/ -F32 getBicarbTargetConductivity( void ) +BOOL getBicartFillRequested( void ) { - F32 result = dryBiCartBicarbTargetConductivity.data; + BOOL result = FALSE; - if ( OVERRIDE_KEY == dryBiCartBicarbTargetConductivity.override ) + if ( ( TRUE == getU32OverrideValue( &dryBiCartFillRequested ) ) ) { - result = dryBiCartBicarbTargetConductivity.ovData; + result = TRUE; } return result; } /*********************************************************************//** * @brief - * The getAcidBicarbDeltaConductivity function gets the acid bicarb delta target conductivity - * flag values - * @details \b Inputs: dryBiCartAcidBicarbMixDeltaConductivity - * @details \b Outputs: none + * The setBicartDrainRequested function sets the bicart drain request + * flag value to be True. + * @details \b Inputs: bicarbChamberFillRequested,dryBiCartFillRequested + * @details \b Outputs: dryBiCartDrainRequested * @return TRUE if successful, FALSE if not. *************************************************************************/ -F32 getAcidBicarbDeltaConductivity( void ) +BOOL setBicartDrainRequested( void ) { - F32 result = dryBiCartAcidBicarbMixDeltaConductivity.data; + BOOL result = FALSE; + BOOL requestStatus = getU32OverrideValue( &bicarbChamberFillRequested ) || getU32OverrideValue( &dryBiCartFillRequested ); - if ( OVERRIDE_KEY == dryBiCartAcidBicarbMixDeltaConductivity.override ) + //ensure that there is no other operation in progress before new request set to true + if ( FALSE == requestStatus ) { - result = dryBiCartAcidBicarbMixDeltaConductivity.ovData; + dryBiCartDrainRequested.data = TRUE; + result = TRUE; } return result; } /*********************************************************************//** * @brief - * The getAcidBicarbTargetConductivity function gets the acid bicarb delta target conductivity - * flag values - * @details \b Inputs: dryBiCartAcidBicarbMixTargetConductivity + * The getBicartDrainRequested function gets the bicart drain request + * flag value + * @details \b Inputs: dryBiCartDrainRequested * @details \b Outputs: none * @return TRUE if successful, FALSE if not. *************************************************************************/ -F32 getAcidBicarbTargetConductivity( void ) +BOOL getBicartDrainRequested( void ) { - F32 result = dryBiCartAcidBicarbMixTargetConductivity.data; + BOOL result = FALSE; - if ( OVERRIDE_KEY == dryBiCartAcidBicarbMixTargetConductivity.override ) + if ( ( TRUE == getU32OverrideValue( &dryBiCartDrainRequested ) ) ) { - result = dryBiCartAcidBicarbMixTargetConductivity.ovData; + result = TRUE; } return result; } /*********************************************************************//** * @brief - * The getBicarbKpGainCoefficient function gets the Kp Gain for closed loop - * bicarb dose volume control - * flag values - * @details \b Inputs: dryBiCartBicarbDoseVolumeKpGain + * The getCurrentDryBiCartFillExecState function returns the current state + * of the dry bicart fill state. + * @details \b Inputs: dryBiCartFillExecState * @details \b Outputs: none + * @return the current state of dry bicart fill exec state. + *************************************************************************/ +DRY_BICART_FILL_EXEC_STATE_T getCurrentDryBiCartFillExecState( void ) +{ + return dryBiCartFillExecState; +} + +/*********************************************************************//** + * @brief + * The setAcidMixVol function sets acid mix volume provided by the controller + * flag value to be True. + * @details \b Inputs: none + * @details \b Outputs: dryBiCartAcidMixVolume + * @param targetValue acid mix volume * @return TRUE if successful, FALSE if not. *************************************************************************/ -F32 getBicarbKpGainCoefficient( void ) +static void setAcidMixVol( F32 targetValue ) { - F32 result = dryBiCartBicarbDoseVolumeKpGain.data; + dryBiCartAcidMixVolume.data = targetValue; +} - if ( OVERRIDE_KEY == dryBiCartBicarbDoseVolumeKpGain.override ) - { - result = dryBiCartBicarbDoseVolumeKpGain.ovData; - } +/*********************************************************************//** + * @brief + * The setBicarbMixVol function sets bicarb Mix volume provided by the controller + * @details \b Inputs: none + * @details \b Outputs: dryBiCartBicarbMixVolume + * @param targetValue bicarb Mix volume + * @return TRUE if successful, FALSE if not. + *************************************************************************/ +static void setBicarbMixVol( F32 targetValue ) +{ + dryBiCartBicarbMixVolume.data = targetValue; +} +/*********************************************************************//** + * @brief + * The getBicarbDeltaConductivity function gets the delta target conductivity + * @details \b Inputs: dryBiCartBicarbDeltaConductivity + * @details \b Outputs: none + * @return TRUE if successful, FALSE if not. + *************************************************************************/ +static F32 getBicarbDeltaConductivity( void ) +{ + F32 result = getF32OverrideValue( &dryBiCartBicarbDeltaConductivity ); + return result; } /*********************************************************************//** * @brief - * The getBicarbKiGainCoefficient function gets the Kp Gain for closed loop - * bicarb dose volume control - * flag values - * @details \b Inputs: dryBiCartBicarbDoseVolumeKiGain + * The getBicarbTargetConductivity function gets the target conductivity + * @details \b Inputs: dryBiCartBicarbTargetConductivity * @details \b Outputs: none * @return TRUE if successful, FALSE if not. *************************************************************************/ -F32 getBicarbKiGainCoefficient( void ) +static F32 getBicarbTargetConductivity( void ) { - F32 result = dryBiCartBicarbDoseVolumeKiGain.data; + F32 result = getF32OverrideValue( &dryBiCartBicarbTargetConductivity ); - if ( OVERRIDE_KEY == dryBiCartBicarbDoseVolumeKiGain.override ) - { - result = dryBiCartBicarbDoseVolumeKiGain.ovData; - } - return result; } /*********************************************************************//** * @brief - * The getAcidKpGainCoefficient function gets the Kp Gain for closed loop - * acid dose volume control - * flag values - * @details \b Inputs: dryBiCartAcidDoseVolumeKpGain + * The getAcidBicarbDeltaConductivity function gets the acid bicarb delta target conductivity + * @details \b Inputs: dryBiCartAcidBicarbMixDeltaConductivity * @details \b Outputs: none * @return TRUE if successful, FALSE if not. *************************************************************************/ -F32 getAcidKpGainCoefficient( void ) +static F32 getAcidBicarbDeltaConductivity( void ) { - F32 result = dryBiCartAcidDoseVolumeKpGain.data; + F32 result = getF32OverrideValue( &dryBiCartDialysateDeltaConductivity ); - if ( OVERRIDE_KEY == dryBiCartAcidDoseVolumeKpGain.override ) - { - result = dryBiCartAcidDoseVolumeKpGain.ovData; - } - return result; } /*********************************************************************//** * @brief - * The getAcidKiGainCoefficient function gets the Ki Gain for closed loop - * acid dose volume control - * flag values - * @details \b Inputs: dryBiCartAcidDoseVolumeKiGain + * The getAcidBicarbTargetConductivity function gets the acid bicarb delta target conductivity + * @details \b Inputs: dryBiCartAcidBicarbMixTargetConductivity * @details \b Outputs: none * @return TRUE if successful, FALSE if not. *************************************************************************/ -F32 getAcidKiGainCoefficient( void ) +static F32 getAcidBicarbTargetConductivity( void ) { - F32 result = dryBiCartAcidDoseVolumeKiGain.data; + F32 result = getF32OverrideValue( &dryBiCartDialysateTargetConductivity ); - if ( OVERRIDE_KEY == dryBiCartAcidDoseVolumeKiGain.override ) - { - result = dryBiCartAcidDoseVolumeKiGain.ovData; - } - return result; } /*********************************************************************//** * @brief - * The setBicarbChamberFillRequested function sets the chmaberFillRequest - * flag value to be True. - * @details \b Inputs: dryBiCartFillRequested, dryBiCartDrainRequested - * @details \b Outputs: bicarbChamberFillRequested + * The getBicarbKpGainCoefficient function gets the Kp Gain for closed loop + * bicarb mix volume control + * @details \b Inputs: dryBiCartBicarbMixVolumeKpGain + * @details \b Outputs: none * @return TRUE if successful, FALSE if not. *************************************************************************/ -BOOL setBicarbChamberFillRequested( void ) +static F32 getBicarbKpGainCoefficient( void ) { - BOOL result = FALSE; - BOOL requestStatus = getU32OverrideValue( &dryBiCartFillRequested ) || getU32OverrideValue( &dryBiCartDrainRequested ); + F32 result = getF32OverrideValue( &dryBiCartBicarbMixVolumeKpGain ); - // ensure that there is no other operation in progress before new request set to true - if ( FALSE == requestStatus ) - { - bicarbChamberFillRequested.data = TRUE; - result = TRUE; - } - return result; } /*********************************************************************//** * @brief - * The getBicarbChamberFillRequested function gets the chmaberFillRequest - * flag values - * @details \b Inputs: bicarbChamberFillRequested + * The getBicarbKiGainCoefficient function gets the Kp Gain for closed loop + * bicarb mix volume control + * @details \b Inputs: dryBiCartBicarbMixVolumeKiGain * @details \b Outputs: none * @return TRUE if successful, FALSE if not. *************************************************************************/ -BOOL getBicarbChamberFillRequested( void ) +static F32 getBicarbKiGainCoefficient( void ) { - BOOL result = FALSE; + F32 result = getF32OverrideValue( &dryBiCartBicarbMixVolumeKiGain ); - if ( (TRUE == getU32OverrideValue( &bicarbChamberFillRequested ) ) ) - { - result = TRUE; - } - return result; } /*********************************************************************//** * @brief - * The setBicartFillRequested function sets the bicart fill request - * flag value to be True. - * @details \b Inputs: bicarbChamberFillRequested, dryBiCartDrainRequested - * @details \b Outputs: dryBiCartFillRequested + * The getAcidKpGainCoefficient function gets the Kp Gain for closed loop + * acid mix volume control + * @details \b Inputs: dryBiCartAcidMixVolumeKpGain + * @details \b Outputs: none * @return TRUE if successful, FALSE if not. *************************************************************************/ -BOOL setBicartFillRequested( void ) +static F32 getAcidKpGainCoefficient( void ) { - BOOL result = FALSE; - BOOL requestStatus = getU32OverrideValue( &bicarbChamberFillRequested ) || getU32OverrideValue( &dryBiCartDrainRequested ); + F32 result = getF32OverrideValue( &dryBiCartAcidMixVolumeKpGain ); - //ensure that there is no other operation in progress before new request set to true - if ( FALSE == requestStatus ) - { - dryBiCartFillRequested.data = TRUE; - result = TRUE; - } - return result; } /*********************************************************************//** * @brief - * The getBicartFillRequested function gets the bicart fill request - * flag value - * @details \b Inputs: dryBiCartFillRequested + * The getAcidKiGainCoefficient function gets the Ki Gain for closed loop + * acid mix volume control + * @details \b Inputs: dryBiCartAcidMixVolumeKiGain * @details \b Outputs: none * @return TRUE if successful, FALSE if not. *************************************************************************/ -BOOL getBicartFillRequested( void ) +static F32 getAcidKiGainCoefficient( void ) { - BOOL result = FALSE; + F32 result = getF32OverrideValue( &dryBiCartAcidMixVolumeKiGain ); - if ( ( TRUE == getU32OverrideValue( &dryBiCartFillRequested ) ) ) - { - result = TRUE; - } - return result; } /*********************************************************************//** * @brief - * The setBicartDrainRequested function sets the bicart drain request - * flag value to be True. - * @details \b Inputs: bicarbChamberFillRequested,dryBiCartFillRequested - * @details \b Outputs: dryBiCartDrainRequested + * The getDryBicartUpperCartPressure function gets the bicart upper threshold pressure + * @details \b Inputs: dryBiCartUpperCartPressure + * @details \b Outputs: none * @return TRUE if successful, FALSE if not. *************************************************************************/ -BOOL setBicartDrainRequested( void ) +static F32 getDryBicartUpperCartPressure( void ) { - BOOL result = FALSE; - BOOL requestStatus = getU32OverrideValue( &bicarbChamberFillRequested ) || getU32OverrideValue( &dryBiCartFillRequested ); + F32 result = getF32OverrideValue( &dryBiCartUpperCartPressure ); - //ensure that there is no other operation in progress before new request set to true - if ( FALSE == requestStatus ) - { - dryBiCartDrainRequested.data = TRUE; - result = TRUE; - } - return result; } /*********************************************************************//** * @brief - * The getBicartDrainRequested function gets the bicart drain request - * flag value - * @details \b Inputs: dryBiCartDrainRequested + * The getDryBicartLowerCartPressure function gets the bicart lower threshold pressure + * @details \b Inputs: dryBiCartLowerCartPressure * @details \b Outputs: none * @return TRUE if successful, FALSE if not. *************************************************************************/ -BOOL getBicartDrainRequested( void ) +static F32 getDryBicartLowerCartPressure( void ) { - BOOL result = FALSE; + F32 result = getF32OverrideValue( &dryBiCartLowerCartPressure ); - if ( ( TRUE == getU32OverrideValue( &dryBiCartDrainRequested ) ) ) - { - result = TRUE; - } - return result; } /*********************************************************************//** * @brief - * The getCurrentDryBiCartFillExecState function returns the current state - * of the dry bicart fill state. - * @details \b Inputs: dryBiCartFillExecState + * The getDryBicartMixControlInterval function gets the bicart mix control interval + * @details \b Inputs: dryBiCartMixControlInterval * @details \b Outputs: none - * @return the current state of dry bicart fill exec state. + * @return TRUE if successful, FALSE if not. *************************************************************************/ -DRY_BICART_FILL_EXEC_STATE_T getCurrentDryBiCartFillExecState( void ) +static F32 getDryBicartMixControlInterval( void ) { - return dryBiCartFillExecState; + F32 result = getF32OverrideValue( &dryBiCartMixControlInterval ); + + return result; } /*********************************************************************//** * @brief * The handleDialysateOpenLoopState function handles the dialysate open loop state of - * the dialysate dose controller state machine. + * the dialysate mix controller state machine. * @details \b Inputs: D17_COND, D29_COND * @details \b Outputs: none - * @param doseId dialysate dose id to run the dialysate dose + * @param mixId dialysate mix id to run the dialysate mix * @return next state for the controller state machine *************************************************************************/ -static DIALYSATE_MIXING_STATE_T handleDialysateOpenLoopState( DIALYSATE_MIXING_ID_T mixId ) +static DIALYSATE_MIXING_STATE_T handleDialysateMixOpenLoopState( DIALYSATE_MIXING_ID_T mixId ) { DIALYSATE_MIXING_STATE_T result; if ( BICARB_MIX_ID == mixId ) { result = DIALYSATE_MIXING_OPEN_LOOP_STATE; -#ifdef __TEENSY_CONDUCTIVITY_DRIVER__ F32 measuredBicarbConductivity = getFilteredConductivity( D17_COND ); -#else - F32 measuredBicarbConductivity = getFilteredConductivity( D17_COND ); -#endif // if measured conductivity crossed (targetConductivity- deltaConuctivity) , switch to closed loop if ( measuredBicarbConductivity >= ( getBicarbTargetConductivity() - getBicarbDeltaConductivity() ) ) { @@ -1028,11 +1032,8 @@ else if ( ACID_MIX_ID == mixId ) { result = DIALYSATE_MIXING_OPEN_LOOP_STATE; -#ifdef __TEENSY_CONDUCTIVITY_DRIVER__ F32 measuredAcidBicarbMixConductivity = getFilteredConductivity( D27_COND ); -#else - F32 measuredAcidBicarbMixConductivity = getFilteredConductivity( D27_COND ); -#endif + // if measured conductivity crossed (targetConductivity- deltaConuctivity) , switch to closed loop if ( measuredAcidBicarbMixConductivity >= ( getAcidBicarbTargetConductivity() - getAcidBicarbDeltaConductivity() ) ) { @@ -1046,30 +1047,27 @@ /*********************************************************************//** * @brief * The handleDialysatePumpRampToTargetState function handles the dialysate ramp to target state of - * the dialysate dose controller state machine. + * the dialysate mix controller state machine. * @details \b Inputs: none * @details \b Outputs: none - * @param doseId dose id to + * @param mixId mix id to * @return next state for the controller state machine *************************************************************************/ -static DIALYSATE_MIXING_STATE_T handleDialysateDoseRampToTargetState( DIALYSATE_MIXING_ID_T mixId ) +static DIALYSATE_MIXING_STATE_T handleDialysateMixRampToTargetState( DIALYSATE_MIXING_ID_T mixId ) { DIALYSATE_MIXING_STATE_T state = DIALYSATE_MIXING_RAMP_UP_STATE; - //if ( TRUE == stepDialysatePumpToTargetSpeed( pumpId ) ) + if ( BICARB_MIX_ID == mixId ) { - if ( BICARB_MIX_ID == mixId ) - { - resetPIController( PI_CONTROLLER_ID_BICARB_VOL, STD_BICARB_DOSING, DOSING_NO_FEED_FORWARD ); + resetPIController( PI_CONTROLLER_ID_BICARB_VOL, DEFAULT_BICARB_VOLUME_ML, MIX_NO_FEED_FORWARD ); - state = DIALYSATE_MIXING_CONTROL_TO_TARGET_STATE; - } - else if ( ACID_MIX_ID == mixId ) - { - resetPIController( PI_CONTROLLER_ID_ACID_VOL, STD_ACID_DOSING, DOSING_NO_FEED_FORWARD ); + state = DIALYSATE_MIXING_CONTROL_TO_TARGET_STATE; + } + else if ( ACID_MIX_ID == mixId ) + { + resetPIController( PI_CONTROLLER_ID_ACID_VOL, DEFAULT_ACID_VOLUME_ML, MIX_NO_FEED_FORWARD ); - state = DIALYSATE_MIXING_CONTROL_TO_TARGET_STATE; - } + state = DIALYSATE_MIXING_CONTROL_TO_TARGET_STATE; } return state; @@ -1078,76 +1076,50 @@ /*********************************************************************//** * @brief * The handleDialysatePumpControlToTargetState function handles the control to - * target state of the dialysate dose controller state machine.. + * target state of the dialysate mix controller state machine.. * @details \b Inputs: D17_COND, D29_COND, controlTimerCounter * @details \b Outputs:none * @return next state of the controller state machine *************************************************************************/ -static DIALYSATE_MIXING_STATE_T handleDialysateDoseControlToTargetState( DIALYSATE_MIXING_ID_T mixId ) +static DIALYSATE_MIXING_STATE_T handleDialysateMixControlToTargetState( DIALYSATE_MIXING_ID_T mixId ) { DIALYSATE_MIXING_STATE_T state = DIALYSATE_MIXING_CONTROL_TO_TARGET_STATE; // control at set minimum interval or interval is expired and balance chamber fill is complete - if ( ( ( ++dialysateMix[ mixId ].controlTimerCounter >= DOSE_CONTROL_INTERVAL ) ) ) + if ( ( ++dialysateMix[ mixId ].controlTimerCounter >= getDryBicartMixControlInterval() ) ) { dialysateMix[ mixId ].controlTimerCounter = 0; - // Control happen only when balancing chamber fill is complete. - //if ( FALSE == getBalancingChamberFillinProgressStatus() ) + // Control based on the measured and target conductivity + if ( BICARB_MIX_ID == mixId ) { - // Control based on the measured and target conductivity - if ( BICARB_MIX_ID == mixId ) - { - PI_CONTROLLER_SIGNALS_DATA debugBicarbControl; - F32 measuredBicarbConductivity; - //U32 i; + PI_CONTROLLER_SIGNALS_DATA debugBicarbControl; + F32 measuredBicarbConductivity; -#ifdef __TEENSY_CONDUCTIVITY_DRIVER__ - easuredBicarbConductivity = getFilteredConductivity( D17_COND ); -#else - measuredBicarbConductivity = getFilteredConductivity( D17_COND ); -#endif - F32 bicarbDoseVol = runPIController(PI_CONTROLLER_ID_BICARB_VOL, getBicarbTargetConductivity(), measuredBicarbConductivity); - //Set bicarb dosing vol - setBicarbDoseVol( bicarbDoseVol ); - //U32 i; + measuredBicarbConductivity = getFilteredConductivity( D17_COND ); + F32 bicarbMixVol = runPIController( PI_CONTROLLER_ID_BICARB_VOL, getBicarbTargetConductivity(), measuredBicarbConductivity ); + //Set bicarb dosing vol + setBicarbMixVol( bicarbMixVol ); -#if 0 - for ( i = 0; i < NUM_OF_CONTROLLER_SIGNAL; i++ ) - { - pIControlSignal[ i ] = getPIControllerSignals( PI_CONTROLLER_ID_BICARB_VOL, (PI_CONTROLLER_SIGNALS_ID)i ); - } -#endif - debugBicarbControl = getDebugPIControllerSignals( PI_CONTROLLER_ID_BICARB_VOL ); + debugBicarbControl = getDebugPIControllerSignals( PI_CONTROLLER_ID_BICARB_VOL ); - memcpy((void*)&bicarbControlSignals, (void*)&debugBicarbControl, sizeof(PI_CONTROLLER_SIGNALS_DATA)); - } - // ACID dose - else if ( ACID_MIX_ID == mixId ) - { - F32 measuredAcidBicarbMixConductivity; - //U32 i; - PI_CONTROLLER_SIGNALS_DATA debugAcidControl; + memcpy( (void*)&bicarbControlSignals, (void*)&debugBicarbControl, sizeof(PI_CONTROLLER_SIGNALS_DATA) ); + } + // ACID Mix + else if ( ACID_MIX_ID == mixId ) + { + F32 measuredAcidBicarbMixConductivity; + PI_CONTROLLER_SIGNALS_DATA debugAcidControl; -#ifdef __TEENSY_CONDUCTIVITY_DRIVER__ - measuredAcidBicarbMixConductivity = getFilteredConductivity( D27_COND ); -#else - measuredAcidBicarbMixConductivity = getFilteredConductivity( D27_COND ); -#endif - F32 acidDoseVol = runPIController(PI_CONTROLLER_ID_ACID_VOL, getAcidBicarbTargetConductivity(), measuredAcidBicarbMixConductivity); - //Set acid dosing vol - setAcidDoseVol( acidDoseVol ); - //U32 i; + measuredAcidBicarbMixConductivity = getFilteredConductivity( D27_COND ); -#if 0 - for ( i = 0; i < NUM_OF_CONTROLLER_SIGNAL; i++ ) - { - pIControlSignal[ i ] = getPIControllerSignals( PI_CONTROLLER_ID_ACID_VOL, (PI_CONTROLLER_SIGNALS_ID)i ); - } -#endif - debugAcidControl = getDebugPIControllerSignals( PI_CONTROLLER_ID_ACID_VOL ); - memcpy((void*)&acidControlSignals, (void*)&debugAcidControl, sizeof(PI_CONTROLLER_SIGNALS_DATA)); - } + F32 acidMixVol = runPIController( PI_CONTROLLER_ID_ACID_VOL, getAcidBicarbTargetConductivity(), measuredAcidBicarbMixConductivity ); + //Set acid dosing vol + setAcidMixVol( acidMixVol ); + + debugAcidControl = getDebugPIControllerSignals( PI_CONTROLLER_ID_ACID_VOL ); + + memcpy( (void*)&acidControlSignals, (void*)&debugAcidControl, sizeof(PI_CONTROLLER_SIGNALS_DATA) ); } } @@ -1203,8 +1175,8 @@ //if(FP_MODE_GENP == getCurrentFPOperationMode()) { // TODO: pre gen should start the D12 pump and D14 valve - setValveState( D14_VALV, VALVE_STATE_OPEN ); - setDialysatePumpTargetRPM( D12_PUMP, FRESH_DIAL_PUMP_INITIAL_RPM, TRUE ); + //setValveState( D14_VALV, VALVE_STATE_OPEN ); + setDialysatePumpTargetRPM( D12_PUMP, FRESH_DIAL_PUMP_INITIAL_RPM_B1_9_B2_0, TRUE ); state = DRY_BICART_FILL_WATER_START_STATE; } @@ -1399,6 +1371,9 @@ // TODO: implement the broadcast message for fill complete if ( TRUE == didTimeout( dryBiCartFillStartTime, DRY_BICART_FILL_COMPLETE_TIME_MS ) ) { + currentFillDurationInMS = 0; + lastFillDurationInMS = 0; + biCartFillCycleCounter = 0; // Go idle dryBiCartFillRequested.data = FALSE; // for this request override also cleared @@ -1477,7 +1452,7 @@ BICARB_CHAMBER_FILL_EXEC_STATE_T state = BICARB_CARTRIDGE_FILL_WATER_END_STATE; F32 d66Pressure = getFilteredPressure( D66_PRES ); - if ( d66Pressure >= DRY_BICART_FILL_COMPLETE_PRESSURE ) + if ( d66Pressure >= getDryBicartUpperCartPressure() ) { // Close water inlet valve as D66 pressure reaches 15 PSI. setValveState( D65_VALV, VALVE_STATE_CLOSED ); @@ -1532,7 +1507,7 @@ { BICARB_CHAMBER_FILL_EXEC_STATE_T state = BICARB_CHAMBER_FILL_STATE; F32 d66Pressure = getFilteredPressure( D66_PRES ); - LEVEL_STATE_T bicarbChamberLevel = getBicarbChamberLevelStatus(); + LEVEL_STATE_T bicarbChamberLevel = getBicarbChamberLevelStatus(); // Once level reached, close the valve if ( LEVEL_STATE_HIGH == bicarbChamberLevel ) @@ -1541,7 +1516,7 @@ state = BICARB_CHAMBER_PRESSURE_CHECK_STATE; } // Open water inlet valve to fill the bicart - else if ( d66Pressure <= DRY_BICART_FILL_INITIATE_SUPPLY_PRESSURE ) + else if ( d66Pressure <= getDryBicartLowerCartPressure() ) { setValveState( D65_VALV, VALVE_STATE_OPEN ); state = BICARB_CHAMBER_PRESSURE_CHECK_STATE; @@ -1578,15 +1553,14 @@ dryBiCarbSypplyVentStartTime = getMSTimerCount(); state = BICARB_SUPPLY_VENT_START_STATE; } - else if ( d66Pressure <= DRY_BICART_FILL_INITIATE_SUPPLY_PRESSURE ) + /*else if ( d66Pressure <= getDryBicartLowerCartPressure() ) { - setValveState( D65_VALV, VALVE_STATE_OPEN ); - } + setValveState( D65_VALV, VALVE_STATE_OPEN ); } // Close water inlet valve as fill is complete. - else if ( d66Pressure >= DRY_BICART_FILL_COMPLETE_SUPPLY_PRESSURE ) + else if ( d66Pressure >= getDryBicartUpperCartPressure() ) { setValveState( D65_VALV, VALVE_STATE_CLOSED ); - } + }*/ return state; } @@ -1602,19 +1576,64 @@ static BICARB_CHAMBER_FILL_EXEC_STATE_T handleBicarbChamberSupplyVentStartState(void) { BICARB_CHAMBER_FILL_EXEC_STATE_T state = BICARB_SUPPLY_VENT_START_STATE; + float setpoint; + U32 startTime; + F32 d66Pressure = getFilteredPressure( D66_PRES ); + F32 tmpD66Pressure = getFilteredPressure( D66_PRES ); - if ( TRUE == didTimeout( dryBiCarbSypplyVentStartTime, DRY_BICART_SUPPLY_VENT_TIME_MS ) ) + setpoint = d66Pressure - 1.0; + + if ( ( d66Pressure > DRY_BICART_FILL_INITIATE_SUPPLY_PRESSURE ) ) { + setValveState( D64_VALV, VALVE_STATE_OPEN ); + state = BICARB_SUPPLY_VENT_END_STATE; + } + + //if ( TRUE == didTimeout( dryBiCarbSupplyStartTime, 10 ) ) +#if 0 + while ( tmpD66Pressure >= getDryBicartLowerCartPressure() && tmpD66Pressure >= setpoint ) { + //setpoint = d66Pressure - 1.0; + + // Venting loop: stay open until target PSI is reached + setValveState( D64_VALV, VALVE_STATE_CLOSED ); + setValveState( D85_VALV, VALVE_STATE_OPEN ); + startTime = getMSTimerCount(); + while ( TRUE != didTimeout( startTime, 12 ) ) + { + } + // close the vallve + setValveState( D85_VALV, VALVE_STATE_CLOSED ); + setValveState( D64_VALV, VALVE_STATE_OPEN ); + startTime = getMSTimerCount(); + while ( TRUE != didTimeout( startTime, 100 ) ) + { + } + tmpD66Pressure = getFilteredPressure( D66_PRES ); + //sleep + } +#endif + else if ( TRUE == didTimeout( dryBiCarbSypplyVentStartTime, DRY_BICART_SUPPLY_VENT_TIME_MS ) ) + { //Vent bicart after 1 sec setValveState( D85_VALV, VALVE_STATE_OPEN ); } - if ( TRUE == didTimeout( dryBiCarbSypplyVentStartTime, DRY_BICART_SUPPLY_VENT_MAX_TIME_MS ) ) + else if ( TRUE == didTimeout( dryBiCarbSypplyVentStartTime, DRY_BICART_SUPPLY_VENT_MAX_TIME_MS ) ) { setValveState( D85_VALV, VALVE_STATE_CLOSED ); //Vent chamber F after 200 ms setValveState( D64_VALV, VALVE_STATE_OPEN ); dryBiCarbSypplyVentStartTime = getMSTimerCount(); + //state = BICARB_SUPPLY_VENT_END_STATE; + } + + // D66 pressure drops or time out + else if ( ( d66Pressure <= DRY_BICART_FILL_INITIATE_SUPPLY_PRESSURE ) /*|| + ( TRUE == didTimeout( dryBiCarbSypplyVentStartTime, DRY_BICART_FILL_VENT_MAX_TIME_MS ) )*/ ) + { + setValveState( D64_VALV, VALVE_STATE_OPEN ); + setValveState( D85_VALV, VALVE_STATE_CLOSED ); + dryBiCarbSypplyVentStartTime = getMSTimerCount(); state = BICARB_SUPPLY_VENT_END_STATE; } @@ -1633,13 +1652,12 @@ { BICARB_CHAMBER_FILL_EXEC_STATE_T state = BICARB_SUPPLY_VENT_END_STATE; - // close bicart vent and chamber f vent after 2 sec + // close bicart vent and chamber f vent after 1 sec if ( TRUE == didTimeout( dryBiCarbSypplyVentStartTime, DRY_BICART_SUPPLY_VENT_TIME_MS ) ) { setValveState( D85_VALV, VALVE_STATE_CLOSED ); - setValveState( D64_VALV, VALVE_STATE_CLOSED); - //setValveState( D3_VALV, VALVE_STATE_CLOSED ); - + //setValveState( D64_VALV, VALVE_STATE_CLOSED); + bicarbChamberFillRequested.data = FALSE; // for this request override also cleared bicarbChamberFillRequested.ovData = FALSE; @@ -1841,8 +1859,6 @@ data.dryBiCartFillExecState = (U32)dryBiCartFillExecState; data.bicarbChamberFillExecState = (U32)bicarbChamberFillExecState; - // TODO : temporarily disabled. restore it after testing -#if 0 data.dryBiCartDrainExecState = (U32)dryBiCartDrainExecState; data.dryBiCartFillCycleCounter = biCartFillCycleCounter; data.dryBiCartMaxFillCycleCount = getU32OverrideValue( &biCartMaxFillCycleCount ); @@ -1853,21 +1869,23 @@ data.dryBiCartCurrentFillTime = currentFillDurationInMS; data.dryBiCartType = getU32OverrideValue( &dryBiCartType ); data.dryBiCartDrainTimePeriod = dryBiCartDrainTimePeriod; -#endif // TODO: remove after feature testing memcpy( &data.dryBiCartBicarbDosingControl, &bicarbControlSignals, sizeof( PI_CONTROLLER_SIGNALS_DATA ) ); // TODO: remove after feature testing memcpy( &data.dryBiCartAcidDosingControl , &acidControlSignals , sizeof( PI_CONTROLLER_SIGNALS_DATA ) ); - data.dryBiCartAcidDoseVolume = getAcidDoseVol(); - data.dryBiCartBicarbDoseVolume = getBicarbDoseVol(); + data.dryBiCartAcidMixVolume = getAcidMixVol(); + data.dryBiCartBicarbMixVolume = getBicarbMixVol(); // TODO: remove after feature testing data.dryBiCartBicarbDosingKPgain = getBicarbKpGainCoefficient(); // TODO: remove after feature testing data.dryBiCartBicarbDosingKIgain = getBicarbKiGainCoefficient(); - + + data.dryBiCartAcidDosingKPgain = getAcidKpGainCoefficient(); + data.dryBiCartAcidDosingKIgain = getAcidKiGainCoefficient(); + broadcastData( MSG_ID_DD_DRY_BICART_DATA, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&data, sizeof( DRY_BICART_DATA_T ) ); dryBiCartDataPublicationTimerCounter = 0; @@ -1982,123 +2000,118 @@ /*********************************************************************//** * @brief - * The testAcidDoseVolumeOverride function sets the override value + * The testDryBiCartAcidMixVolumeOverride function sets the override value * of the acid concentrate dosing volume. - * @details Inputs: dryBiCartAcidDoseVolume - * @details Outputs: dryBiCartAcidDoseVolume + * @details Inputs: dryBiCartAcidMixVolume + * @details Outputs: dryBiCartAcidMixVolume * @param message Override message from Dialin which includes the override * value to override the acid concentrate dosing volume. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testDryBiCartAcidDoseVolumeOverride( MESSAGE_T *message ) +BOOL testDryBiCartAcidMixVolumeOverride( MESSAGE_T *message ) { - BOOL result = f32Override( message, &dryBiCartAcidDoseVolume ); + BOOL result = f32Override( message, &dryBiCartAcidMixVolume ); return result; } /*********************************************************************//** * @brief - * The testBicarbDoseVolumeOverride function sets the override value + * The testDryBiCartBicarbMixVolumeOverride function sets the override value * of the bicarb concentrate dosing volume. - * @details Inputs: dryBiCartBicarbDoseVolume - * @details Outputs: dryBiCartBicarbDoseVolume + * @details Inputs: dryBiCartBicarbMixVolume + * @details Outputs: dryBiCartBicarbMixVolume * @param message Override message from Dialin which includes the override * value to override the bicarb concentrate dosing volume. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testDryBiCartBicarbDoseVolumeOverride( MESSAGE_T *message ) +BOOL testDryBiCartBicarbMixVolumeOverride( MESSAGE_T *message ) { - BOOL result = f32Override( message, &dryBiCartBicarbDoseVolume ); + BOOL result = f32Override( message, &dryBiCartBicarbMixVolume ); return result; } /*********************************************************************//** * @brief - * The testDryBiCartBicarbKpGainBicarbDoseVolumeOverride function sets the override value + * The testDryBiCartBicarbMixVolControlKpGainOverride function sets the override value * of the Kp gain coefficient for closed loop bicarb dosing volume control - * @details Inputs: dryBiCartBicarbDoseVolumeKpGain - * @details Outputs: dryBiCartBicarbDoseVolumeKpGain + * @details Inputs: dryBiCartBicarbMixVolumeKpGain + * @details Outputs: dryBiCartBicarbMixVolumeKpGain * @param message Override message from Dialin which includes the override * value to override the bicarb concentrate dosing volume kp gain. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testDryBiCartBicarbDoseVolControlKpGainOverride( MESSAGE_T *message ) +BOOL testDryBiCartBicarbMixVolControlKpGainOverride( MESSAGE_T *message ) { - BOOL result = f32Override( message, &dryBiCartBicarbDoseVolumeKpGain ); + BOOL result = f32Override( message, &dryBiCartBicarbMixVolumeKpGain ); - initializePIController(PI_CONTROLLER_ID_BICARB_VOL, MIN_BICARB_VOLUME_MLPM,\ + initializePIController( PI_CONTROLLER_ID_BICARB_VOL, 0.0F,\ getBicarbKpGainCoefficient(), getBicarbKiGainCoefficient(),\ - MIN_BICARB_VOLUME_MLPM, MAX_BICARB_VOLUME_MLPM, FALSE, DOSING_NO_FEED_FORWARD ); + MIN_BICARB_VOLUME_ML, MAX_BICARB_VOLUME_ML, FALSE, MIX_NO_FEED_FORWARD ); - resetPIController(PI_CONTROLLER_ID_BICARB_VOL, STD_BICARB_DOSING, DOSING_NO_FEED_FORWARD); - return result; } /*********************************************************************//** * @brief - * The testDryBiCartBicarbKiGainBicarbDoseVolumeOverride function sets the override value + * The testDryBiCartBicarbMixVolControlKiGainOverride function sets the override value * of the Ki gain coefficient for closed loop bicarb concentrate dosing volume control - * @details Inputs: dryBiCartBicarbDoseVolumeKiGain - * @details Outputs: dryBiCartBicarbDoseVolumeKiGain + * @details Inputs: dryBiCartBicarbMixVolumeKiGain + * @details Outputs: dryBiCartBicarbMixVolumeKiGain * @param message Override message from Dialin which includes the override * value to override the bicarb concentrate dosing volume ki gain. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testDryBiCartBicarbDoseVolControlKiGainOverride( MESSAGE_T *message ) +BOOL testDryBiCartBicarbMixVolControlKiGainOverride( MESSAGE_T *message ) { - BOOL result = f32Override( message, &dryBiCartBicarbDoseVolumeKiGain ); + BOOL result = f32Override( message, &dryBiCartBicarbMixVolumeKiGain ); - initializePIController(PI_CONTROLLER_ID_BICARB_VOL, MIN_BICARB_VOLUME_MLPM,\ + initializePIController( PI_CONTROLLER_ID_BICARB_VOL, 0.0F,\ getBicarbKpGainCoefficient(), getBicarbKiGainCoefficient(),\ - MIN_BICARB_VOLUME_MLPM, MAX_BICARB_VOLUME_MLPM, FALSE, DOSING_NO_FEED_FORWARD ); - resetPIController(PI_CONTROLLER_ID_BICARB_VOL, STD_BICARB_DOSING, DOSING_NO_FEED_FORWARD); + MIN_BICARB_VOLUME_ML, MAX_BICARB_VOLUME_ML, FALSE, MIX_NO_FEED_FORWARD ); return result; } /*********************************************************************//** * @brief - * The testDryBiCartBicarbKpGainBicarbDoseVolumeOverride function sets the override value + * The testDryBiCartAcidMoxVolControlKpGainOverride function sets the override value * of the Kp gain coefficient for closed loop acid concentrate dosing volume control - * @details Inputs: dryBiCartAcidDoseVolumeKpGain - * @details Outputs: dryBiCartAcidDoseVolumeKpGain + * @details Inputs: dryBiCartAcidMixVolumeKpGain + * @details Outputs: dryBiCartAcidMixVolumeKpGain * @param message Override message from Dialin which includes the override * value to override the acid concentrate dosing volume kp gain. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testDryBiCartAcidDoseVolControlKpGainOverride( MESSAGE_T *message ) +BOOL testDryBiCartAcidMixVolControlKpGainOverride( MESSAGE_T *message ) { - BOOL result = f32Override( message, &dryBiCartAcidDoseVolumeKpGain ); + BOOL result = f32Override( message, &dryBiCartAcidMixVolumeKpGain ); - initializePIController(PI_CONTROLLER_ID_ACID_VOL, MIN_ACID_VOLUME_MLPM, \ + initializePIController( PI_CONTROLLER_ID_ACID_VOL, 0.0F, \ getAcidKpGainCoefficient(), getAcidKiGainCoefficient(),\ - MIN_ACID_VOLUME_MLPM, MAX_ACID_VOLUME_MLPM, FALSE, DOSING_NO_FEED_FORWARD ); - resetPIController(PI_CONTROLLER_ID_ACID_VOL, STD_ACID_DOSING, DOSING_NO_FEED_FORWARD); + MIN_ACID_VOLUME_ML, MAX_ACID_VOLUME_ML, FALSE, MIX_NO_FEED_FORWARD ); return result; } /*********************************************************************//** * @brief - * The testDryBiCartBicarbKiGainBicarbDoseVolumeOverride function sets the override value + * The testDryBiCartAcidMixVolControlKiGainOverride function sets the override value * of the Ki gain coefficient for closed loop acid concentrate dosing volume control - * @details Inputs: dryBiCartAcidDoseVolumeKiGain - * @details Outputs: dryBiCartAcidDoseVolumeKiGain + * @details Inputs: dryBiCartAcidMixVolumeKiGain + * @details Outputs: dryBiCartAcidMixVolumeKiGain * @param message Override message from Dialin which includes the override * value to override the bicarb concentrate dosing volume ki gain. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testDryBiCartAcidDoseVolControlKiGainOverride( MESSAGE_T *message ) +BOOL testDryBiCartAcidMixVolControlKiGainOverride( MESSAGE_T *message ) { - BOOL result = f32Override( message, &dryBiCartAcidDoseVolumeKiGain ); + BOOL result = f32Override( message, &dryBiCartAcidMixVolumeKiGain ); - initializePIController(PI_CONTROLLER_ID_ACID_VOL, MIN_ACID_VOLUME_MLPM, \ + initializePIController( PI_CONTROLLER_ID_ACID_VOL, 0.0F, \ getAcidKpGainCoefficient(), getAcidKiGainCoefficient(),\ - MIN_ACID_VOLUME_MLPM, MAX_ACID_VOLUME_MLPM, FALSE, DOSING_NO_FEED_FORWARD ); - resetPIController(PI_CONTROLLER_ID_ACID_VOL, STD_ACID_DOSING, DOSING_NO_FEED_FORWARD); + MIN_ACID_VOLUME_ML, MAX_ACID_VOLUME_ML, FALSE, MIX_NO_FEED_FORWARD ); return result; } @@ -2149,7 +2162,7 @@ *************************************************************************/ BOOL testDryBiCartAcidBicarbTargetConductivityOverride( MESSAGE_T *message ) { - BOOL result = f32Override( message, &dryBiCartAcidBicarbMixTargetConductivity ); + BOOL result = f32Override( message, &dryBiCartDialysateTargetConductivity ); return result; } @@ -2167,9 +2180,43 @@ *************************************************************************/ BOOL testDryBiCartAcidBicarbDeltaConductivityOverride( MESSAGE_T *message ) { - BOOL result = f32Override( message, &dryBiCartAcidBicarbMixDeltaConductivity ); + BOOL result = f32Override( message, &dryBiCartDialysateDeltaConductivity ); return result; } +/*********************************************************************//** + * @brief + * The testDryBiCartUpperCartPressureOverride function sets the override value + * of bicart upper cart pressure + * @details Inputs: dryBiCartUpperCartPressure + * @details Outputs: dryBiCartUpperCartPressure + * @param message Override message from Dialin which includes the override + * value to override the bicart upper cart pressure + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testDryBiCartUpperCartPressureOverride( MESSAGE_T *message ) +{ + BOOL result = f32Override( message, &dryBiCartUpperCartPressure ); + + return result; +} + +/*********************************************************************//** + * @brief + * The testDryBiCartLowerCartPressureOverride function sets the override value + * of Lowercart pressure + * @details Inputs: dryBiCartLowerCartPressure + * @details Outputs: dryBiCartLowerCartPressure + * @param message Override message from Dialin which includes the override + * value to override the bicart lower pressure. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testDryBiCartLowerCartPressureOverride( MESSAGE_T *message ) +{ + BOOL result = f32Override( message, &dryBiCartLowerCartPressure ); + + return result; +} + /**@}*/ Index: firmware/App/Controllers/Heaters.c =================================================================== diff -u -r94789b2f2324d5901685b6ff7b6224d4af3a0276 -r520b5b97e2a1a6d7af037e1144f1ffeb39153e3e --- firmware/App/Controllers/Heaters.c (.../Heaters.c) (revision 94789b2f2324d5901685b6ff7b6224d4af3a0276) +++ firmware/App/Controllers/Heaters.c (.../Heaters.c) (revision 520b5b97e2a1a6d7af037e1144f1ffeb39153e3e) @@ -79,6 +79,7 @@ #define D5_HEATER_PWM_ADJ_SLOPE_FACTOR 0.00005F ///< AC heater close loop PWM adjustment slope factor #define D5_HEATER_PWM_INTERCEPT_FACTOR 0.0055F ///< AC heater close loop PWM adjustment intercept factor +//#define D5_HEAT_CONTROL_INTERVAL_MS 30000 /// Primary heater control interval in milli seconds #define D5_HEAT_CONTROL_INTERVAL_MS 3000 /// Primary heater control interval in milli seconds #define D5_HEAT_CONTROL_INTERVAL_COUNT ( D5_HEAT_CONTROL_INTERVAL_MS / TASK_GENERAL_INTERVAL ) ///< Primary heater control interval count. #define D45_HEAT_CONTROL_INTERVAL_MS ( 3 * MS_PER_SECOND ) ///< Trimmer heater control interval in milli seconds @@ -527,7 +528,7 @@ } else { - measuredTempAtDialyzer = getConductivityTemperature( D27_COND ); + measuredTempAtDialyzer = getFilteredConductivitySensorTemperature( D27_COND ); } F32 calcTargetTemp = getHeaterTargetTemperature( D5_HEAT ); Index: firmware/App/Controllers/Ultrafiltration.c =================================================================== diff -u -r94789b2f2324d5901685b6ff7b6224d4af3a0276 -r520b5b97e2a1a6d7af037e1144f1ffeb39153e3e --- firmware/App/Controllers/Ultrafiltration.c (.../Ultrafiltration.c) (revision 94789b2f2324d5901685b6ff7b6224d4af3a0276) +++ firmware/App/Controllers/Ultrafiltration.c (.../Ultrafiltration.c) (revision 520b5b97e2a1a6d7af037e1144f1ffeb39153e3e) @@ -240,14 +240,14 @@ { if ( ( ++currentUFCompCounter >= UF_COMP_INTERVAL ) || ( TRUE == isUFRateUpdated ) ) { - F32 freshDensity = 0.0F; - F32 spentDensity = 0.0F; - F32 compFreshFlowrate = 0.0F; - F32 compSpentFlowrate = 0.0F; - F32 balancingError = 0.0F; + F32 freshDensity; + F32 spentDensity; + F32 compFreshFlowrate; + F32 compSpentFlowrate; + F32 balancingError; // Fresh side dialysate density - if ( getTestConfigStatus( TEST_CONFIG_DD_FP_ENABLE_BETA_1_0_HW ) == TRUE ) + if ( TRUE == getTestConfigStatus( TEST_CONFIG_DD_FP_ENABLE_BETA_1_0_HW ) ) { freshDensity = ( COMP_SLOPE * getFilteredTemperatureValue( D4_TEMP ) ) + COMP_INTERCEPT; } Index: firmware/App/Controllers/Valves.c =================================================================== diff -u -r99e5d1b4d1e3627576d680318887ac23cd1f34ce -r520b5b97e2a1a6d7af037e1144f1ffeb39153e3e --- firmware/App/Controllers/Valves.c (.../Valves.c) (revision 99e5d1b4d1e3627576d680318887ac23cd1f34ce) +++ firmware/App/Controllers/Valves.c (.../Valves.c) (revision 520b5b97e2a1a6d7af037e1144f1ffeb39153e3e) @@ -7,8 +7,8 @@ * * @file Valves.c * -* @author (last) Jashwant Gantyada -* @date (last) 30-Mar-2026 +* @author (last) Michael Garthwaite +* @date (last) 15-Apr-2026 * * @author (original) Vinayakam Mani * @date (original) 26-Aug-2024 @@ -579,9 +579,9 @@ * @param recovery state to set valve config. * @return none. *************************************************************************/ -void setRecoveryStatesConfig( U32 recovery ) +void setRecoveryStatesConfig( RECOVERY_STATE_T recovery ) { - recoveryState = (RECOVERY_STATE_T)recovery; + recoveryState = recovery; } /*********************************************************************//** * @brief @@ -918,6 +918,7 @@ BOOL testIOFPSetValveRecoveryConfig( MESSAGE_T *message ) { BOOL result = FALSE; + // Verify tester has logged in with DD if ( TRUE == isTestingActivated() ) { @@ -930,7 +931,7 @@ if (payload < NUM_OF_RECOVERY_STATES ) { - setRecoveryStatesConfig(payload); + setRecoveryStatesConfig((RECOVERY_STATE_T)payload); result = TRUE; } } Index: firmware/App/DDCommon.h =================================================================== diff -u -rb3dcab00dd3dc167d1ea772c5fcf946e3805c96a -r520b5b97e2a1a6d7af037e1144f1ffeb39153e3e --- firmware/App/DDCommon.h (.../DDCommon.h) (revision b3dcab00dd3dc167d1ea772c5fcf946e3805c96a) +++ firmware/App/DDCommon.h (.../DDCommon.h) (revision 520b5b97e2a1a6d7af037e1144f1ffeb39153e3e) @@ -7,7 +7,7 @@ * * @file DDCommon.h * -* @author (last) Michael Garthwaite +* @author (last) Vinayakam Mani * @date (last) 14-Apr-2026 * * @author (original) Vinayakam Mani @@ -25,7 +25,7 @@ #define DD_VERSION_MAJOR 0 #define DD_VERSION_MINOR 0 #define DD_VERSION_MICRO 0 -#define DD_VERSION_BUILD 117 +#define DD_VERSION_BUILD 73 // ********** development build switches ********** Index: firmware/App/Drivers/ConductivitySensors.c =================================================================== diff -u -reaeff603027c54d0be5171d519710942672ef623 -r520b5b97e2a1a6d7af037e1144f1ffeb39153e3e --- firmware/App/Drivers/ConductivitySensors.c (.../ConductivitySensors.c) (revision eaeff603027c54d0be5171d519710942672ef623) +++ firmware/App/Drivers/ConductivitySensors.c (.../ConductivitySensors.c) (revision 520b5b97e2a1a6d7af037e1144f1ffeb39153e3e) @@ -8,7 +8,7 @@ * @file ConductivitySensors.c * * @author (last) Michael Garthwaite -* @date (last) 14-Apr-2026 +* @date (last) 15-Apr-2026 * * @author (original) Vinayakam Mani * @date (original) 13-Sep-2024 @@ -74,7 +74,7 @@ F32 rawTemperature; ///< Raw Temperature in C from the conductivity sensor. F32 rawResistance; ///< Raw Resistance in kOhms from the conductivity sensor. F32 calculatedTemperature; ///< Calculated temperature in C. - F32 calculatedResistance; ///< Calculated resistance in Ohms + F32 calculatedResistance; ///< Calculated resistance in Ohms. U08 condReadCount; ///< Last conductivity read count. U08 condErrorCount; ///< Last conductivity error count. U08 tempReadCount; ///< Last temperature read count. @@ -972,7 +972,97 @@ currentTemperatureReadings[ sensorNum ].data = calculatedTemperature; } +/*********************************************************************//** + * @brief + * The getConductivityReadCount function gets the conductivity read count + * for a given conductivity sensor id. + * @details \b Inputs: FPGA + * @details \b Outputs: none + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @param sensorId conductivity sensor id + * @return last known read count. + *************************************************************************/ +U08 getConductivityReadCount( CONDUCTIVITY_SENSORS_T sensor ) +{ + U08 readCount = 0; + switch( sensor ) + { + case D17_COND: + readCount = getFPGAD17CondReadCount(); + break; + case D27_COND: + readCount = getFPGAD27CondReadCount(); + break; + case D29_COND: + readCount = getFPGAD29CondReadCount(); + break; + case D43_COND: + readCount = getFPGAD43CondReadCount(); + break; + case D74_COND: + readCount = getFPGAD74CondReadCount(); + break; + case P9_COND: + readCount = getFPGAP9CondReadCount(); + break; + case P18_COND: + readCount = getFPGAP18CondReadCount(); + break; + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID1, sensor ) + break; + } + + return readCount; +} + +/*********************************************************************//** + * @brief + * The getConductivityTemperatureReadCount function gets the temperature + * read count for a given conductivity sensor id. + * @details \b Inputs: FPGA + * @details \b Outputs: none + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @param sensorId conductivity sensor id + * @return last known read count. + *************************************************************************/ +U08 getConductivityTemperatureReadCount( CONDUCTIVITY_SENSORS_T sensor ) +{ + U08 readCount = 0; + + switch( sensor ) + { + case D17_COND: + readCount = getFPGAD17TempReadCount(); + break; + case D27_COND: + readCount = getFPGAD27TempReadCount(); + break; + case D29_COND: + readCount = getFPGAD29TempReadCount(); + break; + case D43_COND: + readCount = getFPGAD43TempReadCount(); + break; + case D74_COND: + readCount = getFPGAD74TempReadCount(); + break; + case P9_COND: + readCount = getFPGAP9TempReadCount(); + break; + case P18_COND: + readCount = getFPGAP18TempReadCount(); + break; + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID1, sensor ) + break; + } + + return readCount; +} + + /************************************************************************* * TEST SUPPORT FUNCTIONS *************************************************************************/ Index: firmware/App/Modes/ModeGenDialysate.c =================================================================== diff -u -r94789b2f2324d5901685b6ff7b6224d4af3a0276 -r520b5b97e2a1a6d7af037e1144f1ffeb39153e3e --- firmware/App/Modes/ModeGenDialysate.c (.../ModeGenDialysate.c) (revision 94789b2f2324d5901685b6ff7b6224d4af3a0276) +++ firmware/App/Modes/ModeGenDialysate.c (.../ModeGenDialysate.c) (revision 520b5b97e2a1a6d7af037e1144f1ffeb39153e3e) @@ -60,11 +60,11 @@ #define ZERO_DIAL_FLOW_RATE 0.0F ///< Zero dialysate flow rate #define SPENT_CHAMBER_FILL_MAX_COUNT 10 ///< Total number of spent chamber fill allowed. #define BICARB_CHAMBER_FILL_TIMEOUT ( 1 * MS_PER_SECOND ) ///< Bicarb chamber fill timeout. - #define PUMP_SPEED_SLOPE_FACTOR_DIENER_2000 1.24F ///< D48 Diener 2000 pump speed slope (y = 1.24x + 30). #define PUMP_SPEED_INTERCEPT_FACTOR_DIENER_2000 30.0F ///< D48 Diener 2000 pump speed intercept. #define PUMP_SPEED_SLOPE_FACTOR_DIENER_1000 2.869F ///< D48 Diener 1000 pump speed slope (y = 2.869x + 25.956). #define PUMP_SPEED_INTERCEPT_FACTOR_DIENER_1000 25.956F ///< D48 Diener 1000 pump speed intercept. + #define BICARB_CHAMBER_FILL_TIMEOUT ( 1 * MS_PER_SECOND ) ///< Bicarb chamber fill timeout. //Testing @@ -269,7 +269,7 @@ startHeater( D5_HEAT ); //Turn on Trimmer heater - if ( getTestConfigStatus( TEST_CONFIG_DD_FP_ENABLE_BETA_1_0_HW ) == TRUE ) + if ( TRUE == getTestConfigStatus( TEST_CONFIG_DD_FP_ENABLE_BETA_1_0_HW ) ) { setHeaterTargetTemperature( D45_HEAT, getFilteredTemperatureValue( D4_TEMP ) ); } @@ -318,7 +318,7 @@ startHeater( D5_HEAT ); //Turn on Trimmer heater - if ( getTestConfigStatus( TEST_CONFIG_DD_FP_ENABLE_BETA_1_0_HW ) == TRUE ) + if ( TRUE == getTestConfigStatus( TEST_CONFIG_DD_FP_ENABLE_BETA_1_0_HW ) ) { setHeaterTargetTemperature( D45_HEAT, getFilteredTemperatureValue( D4_TEMP ) ); }