Index: firmware/App/Controllers/Heaters.c =================================================================== diff -u -r417631131615f93f77d6d1bfe44c385a8eab6d5b -r59357d3831aa60f17ccdfbe0eef1a005935b9a58 --- firmware/App/Controllers/Heaters.c (.../Heaters.c) (revision 417631131615f93f77d6d1bfe44c385a8eab6d5b) +++ firmware/App/Controllers/Heaters.c (.../Heaters.c) (revision 59357d3831aa60f17ccdfbe0eef1a005935b9a58) @@ -7,8 +7,8 @@ * * @file Heaters.c * -* @author (last) Bill Bracken -* @date (last) 31-Mar-2023 +* @author (last) Dara Navaei +* @date (last) 20-May-2023 * * @author (original) Dara Navaei * @date (original) 23-Apr-2020 @@ -99,6 +99,7 @@ U32 controlIntervalCounter; ///< Heater control interval counter. BOOL isThisFirstControl; ///< Heater is this first control interval. BOOL useLastDutyCycle; ///< Heater has use previous duty cycle been requested flag. + F32 prevDiaTargetFlowLPM; ///< Heater previous target dialysate flow in L/min. } HEATER_STATUS_T; static HEATER_STATUS_T heatersStatus[ NUM_OF_DG_HEATERS ]; ///< Heaters status. @@ -156,14 +157,15 @@ heatersStatus[ heater ].controlIntervalCounter = 0; heatersStatus[ heater ].isThisFirstControl = TRUE; heatersStatus[ heater ].useLastDutyCycle = FALSE; + heatersStatus[ heater ].prevDiaTargetFlowLPM = 0.0F; } // Initialize the persistent alarms initPersistentAlarm( ALARM_ID_DG_MAIN_PRIMARY_HEATER_VOLTAGE_OUT_OF_RANGE, HEATERS_VOLTAGE_OUT_OF_RANGE_TIMEOUT_MS, HEATERS_VOLTAGE_OUT_OF_RANGE_TIMEOUT_MS ); initPersistentAlarm( ALARM_ID_DG_SMALL_PRIMARY_HEATER_VOLTAGE_OUT_OF_RANGE, HEATERS_VOLTAGE_OUT_OF_RANGE_TIMEOUT_MS, HEATERS_VOLTAGE_OUT_OF_RANGE_TIMEOUT_MS ); initPersistentAlarm( ALARM_ID_DG_TRIMMER_HEATER_VOLTAGE_OUT_OF_RANGE, HEATERS_VOLTAGE_OUT_OF_RANGE_TIMEOUT_MS, HEATERS_VOLTAGE_OUT_OF_RANGE_TIMEOUT_MS ); - initPersistentAlarm( ALARM_ID_RO_FLOW_TOO_LOW_WHILE_PRIMARY_HEATER_IS_ON, HEATERS_ON_NO_FLOW_TIMEOUT_MS, HEATERS_ON_NO_FLOW_TIMEOUT_MS ); - initPersistentAlarm( ALARM_ID_DIALYSATE_FLOW_TOO_LOW_WHILE_TRIMMER_HEATER_IS_ON, HEATERS_ON_NO_FLOW_TIMEOUT_MS, HEATERS_ON_NO_FLOW_TIMEOUT_MS ); + initPersistentAlarm( ALARM_ID_DG_RO_FLOW_TOO_LOW_WHILE_PRIMARY_HEATER_IS_ON, HEATERS_ON_NO_FLOW_TIMEOUT_MS, HEATERS_ON_NO_FLOW_TIMEOUT_MS ); + initPersistentAlarm( ALARM_ID_DG_DIALYSATE_FLOW_TOO_LOW_WHILE_TRIMMER_HEATER_IS_ON, HEATERS_ON_NO_FLOW_TIMEOUT_MS, HEATERS_ON_NO_FLOW_TIMEOUT_MS ); // Initialize the FPGA persistent alarm initFPGAPersistentAlarm( FPGA_PERS_ERROR_MAIN_PRIMARY_HEATER_VOLTAGE_ADC, ALARM_ID_DG_MAIN_PRIMARY_HEATER_FPGA_FAULT, @@ -372,14 +374,14 @@ if ( DG_PRIMARY_HEATER == heater ) { - alarm = ALARM_ID_RO_FLOW_TOO_LOW_WHILE_PRIMARY_HEATER_IS_ON; + alarm = ALARM_ID_DG_RO_FLOW_TOO_LOW_WHILE_PRIMARY_HEATER_IS_ON; measFlow = getMeasuredFlowRateLPM( RO_FLOW_SENSOR ); minFlow = MIN_RO_HEATER_FLOWRATE_LPM; isFlowLow = ( measFlow < minFlow ? TRUE : FALSE ); } else { - alarm = ALARM_ID_DIALYSATE_FLOW_TOO_LOW_WHILE_TRIMMER_HEATER_IS_ON; + alarm = ALARM_ID_DG_DIALYSATE_FLOW_TOO_LOW_WHILE_TRIMMER_HEATER_IS_ON; measFlow = getMeasuredRawFlowRateLPM( DIALYSATE_FLOW_SENSOR ); minFlow = TRIMMER_HEATER_MIN_DIALYSATE_FLOWRATE_LPM; isFlowLow = ( measFlow > minFlow ? FALSE : TRUE ); @@ -391,11 +393,11 @@ { if ( DG_PRIMARY_HEATER == heater ) { - checkPersistentAlarm( ALARM_ID_RO_FLOW_TOO_LOW_WHILE_PRIMARY_HEATER_IS_ON, FALSE, 0.0F, 0.0F ); + checkPersistentAlarm( ALARM_ID_DG_RO_FLOW_TOO_LOW_WHILE_PRIMARY_HEATER_IS_ON, FALSE, 0.0F, 0.0F ); } else { - checkPersistentAlarm( ALARM_ID_DIALYSATE_FLOW_TOO_LOW_WHILE_TRIMMER_HEATER_IS_ON, FALSE, 0.0F, 0.0F ); + checkPersistentAlarm( ALARM_ID_DG_DIALYSATE_FLOW_TOO_LOW_WHILE_TRIMMER_HEATER_IS_ON, FALSE, 0.0F, 0.0F ); } } } @@ -584,7 +586,7 @@ } else if ( TRUE == heatersStatus[ heater ].hasTargetTempChanged ) { - F32 inletTemperature = getTemperatureValue( (U32)TEMPSENSORS_HEAT_DISINFECT ); + F32 inletTemperature = getTemperatureValue( TEMPSENSORS_HEAT_DISINFECT ); F32 targetTemperature = heatersStatus[ heater ].targetTempC; F32 targetFlow = getTargetROPumpFlowRateLPM(); F32 dutyCycle = calculatePrimaryHeaterDutyCycle( targetTemperature, inletTemperature, targetFlow, TRUE ); @@ -677,28 +679,27 @@ // If the mode is heat disinfect, use the target flow rate instead of the avg. flow // Most of the times the heater should be running at 100% duty cycle since the target temperature is 81 C and // it is far from the inlet temperature. - currentTemperature = getTemperatureValue( (U32)TEMPSENSORS_HEAT_DISINFECT ); + currentTemperature = getTemperatureValue( TEMPSENSORS_HEAT_DISINFECT ); targetFlowLPM = getTargetROPumpFlowRateLPM(); dutyCycle = calculateTrimmerHeaterDutyCycle( targetTemperature, currentTemperature, targetFlowLPM, FALSE ); state = HEATER_EXEC_STATE_CONTROL_TO_DISINFECT_TARGET; } else { // If not any of the above modes, just calculate the energy equation based on TRo - currentTemperature = getTemperatureValue( (U32)TEMPSENSORS_OUTLET_REDUNDANT ); + currentTemperature = getTemperatureValue( TEMPSENSORS_OUTLET_REDUNDANT ); dutyCycle = calculateTrimmerHeaterDutyCycle( targetTemperature, currentTemperature, targetFlowLPM, TRUE ); state = HEATER_EXEC_STATE_TRIMMER_CONTROL_TO_TARGET; } // Update the calculated target temperature // Reset the duty cycle since the reservoir has been switched + // Cap the minimum duty cycle. So if it is calculated to negative, set it to 0 heatersStatus[ heater ].calculatedTemperatureC = currentTemperature; heatersStatus[ heater ].inactiveRsrvr = getInactiveReservoir(); heatersStatus[ heater ].targetFlowLPM = targetFlowLPM; heatersStatus[ heater ].isThisFirstControl = TRUE; - - // Cap the minimum duty cycle. So if it is calculated to negative, set it to 0 - heatersStatus[ heater ].dutyCycle.data = MAX( dutyCycle, HEATERS_MIN_DUTY_CYCLE ); + heatersStatus[ heater ].dutyCycle.data = MAX( dutyCycle, HEATERS_MIN_DUTY_CYCLE ); setHeaterDutyCycle( heater ); return state; @@ -717,35 +718,50 @@ HEATERS_STATE_T state = HEATER_EXEC_STATE_TRIMMER_CONTROL_TO_TARGET; F32 tempDutyCycle = 0.0F; DG_HEATERS_T heater = DG_TRIMMER_HEATER; + F32 targetFlowLPM = getTargetDialysateFlowLPM(); U32 controlInterval = ( TRUE == heatersStatus[ heater ].isThisFirstControl ? TRIMMER_HEATER_INITIAL_CONTROL_INTERVAL_COUNT : TRIMMER_HEATER_CONTROL_INTERVAL_COUNT ); - // If the inactive reservoir has changed from the last run transition to ramp state to recalculate the + // If the inactive reservoir has changed from the last run, transition to ramp state to recalculate the // duty cycle for the next delivery if ( heatersStatus[ heater ].inactiveRsrvr != getInactiveReservoir() ) { state = HEATER_EXEC_STATE_TRIMMER_RAMP_TO_TARGET; } - else if ( ++heatersStatus[ heater ].controlIntervalCounter > controlInterval ) + else if ( ( ++heatersStatus[ heater ].controlIntervalCounter > controlInterval ) || + ( fabs( heatersStatus[ heater ].prevDiaTargetFlowLPM - targetFlowLPM ) > NEARLY_ZERO ) ) { - // Reset the control counter + // Check if it is time for another control interval or the current target flow is different from the previous flow and + // we need to reset the control counter heatersStatus[ heater ].controlIntervalCounter = 0; heatersStatus[ heater ].isThisFirstControl = FALSE; // When the trimmer heater is on, its duty cycle is adjusted at the control interval. For this control check, // dialysate inlet temperature sensor is used rather than the theoretical calculations. - F32 outletRedundantTemperature = getTemperatureValue( TEMPSENSORS_OUTLET_REDUNDANT ); - F32 targetTemperature = heatersStatus[ heater ].targetTempC; - F32 targetFlowLPM = heatersStatus[ heater ].targetFlowLPM; - F32 dutyCycle = calculateTrimmerHeaterDutyCycle( targetTemperature, outletRedundantTemperature, targetFlowLPM, TRUE ); + F32 dialysateInletTemperature = getTemperatureValue( TEMPSENSORS_OUTLET_REDUNDANT ); + F32 targetTemperature = heatersStatus[ heater ].targetTempC; + F32 dutyCycle = calculateTrimmerHeaterDutyCycle( targetTemperature, dialysateInletTemperature, targetFlowLPM, TRUE ); - tempDutyCycle = heatersStatus[ heater ].dutyCycle.data + dutyCycle; + if ( fabs( heatersStatus[ heater ].prevDiaTargetFlowLPM - targetFlowLPM ) > NEARLY_ZERO ) + { + // If the current flow is different from the previous flow, restart the duty cycle as the controller is restarting itself + // Set it as it is the first control so the control interval is shorter since it is the first guess with the new dialysate flow + tempDutyCycle = dutyCycle; + heatersStatus[ heater ].isThisFirstControl = TRUE; + } + else + { + tempDutyCycle = heatersStatus[ heater ].dutyCycle.data + dutyCycle; + } + tempDutyCycle = MIN( tempDutyCycle, HEATERS_MAX_DUTY_CYCLE ); tempDutyCycle = MAX( tempDutyCycle, HEATERS_MIN_DUTY_CYCLE ); heatersStatus[ heater ].dutyCycle.data = tempDutyCycle; setHeaterDutyCycle( heater ); } + heatersStatus[ heater ].prevDiaTargetFlowLPM = targetFlowLPM; + return state; } @@ -974,6 +990,8 @@ data.primaryCalcTargetTemp = heatersStatus[ DG_PRIMARY_HEATER ].calculatedTemperatureC; data.trimmerCalcCurrentTemp = heatersStatus[ DG_TRIMMER_HEATER ].calculatedTemperatureC; data.trimmerUseLastDC = (U32)heatersStatus[ DG_TRIMMER_HEATER ].useLastDutyCycle; + data.previsouFlow = heatersStatus[ DG_TRIMMER_HEATER ].prevDiaTargetFlowLPM; + data.controlCounter = heatersStatus[ DG_TRIMMER_HEATER ].controlIntervalCounter; dataPublicationTimerCounter = 0; broadcastData( MSG_ID_DG_HEATERS_DATA, COMM_BUFFER_OUT_CAN_DG_BROADCAST, (U08*)&data, sizeof( HEATERS_DATA_T ) );