Index: firmware/App/Controllers/DrainPump.c =================================================================== diff -u -rbc79ea1fc44ed327da7efcca54af9db15b8c88cd -rd820d5e017e04ee5a7060e367750df1bfe39d2ca --- firmware/App/Controllers/DrainPump.c (.../DrainPump.c) (revision bc79ea1fc44ed327da7efcca54af9db15b8c88cd) +++ firmware/App/Controllers/DrainPump.c (.../DrainPump.c) (revision d820d5e017e04ee5a7060e367750df1bfe39d2ca) @@ -1,14 +1,14 @@ /************************************************************************** * -* Copyright (c) 2020-2023 Diality Inc. - All Rights Reserved. +* Copyright (c) 2020-2024 Diality Inc. - All Rights Reserved. * * THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN * WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. * * @file DrainPump.c * * @author (last) Dara Navaei -* @date (last) 07-Mar-2023 +* @date (last) 18-Mar-2024 * * @author (original) Sean * @date (original) 08-Apr-2020 @@ -51,7 +51,7 @@ #define DRAIN_PUMP_DATA_PUB_INTERVAL ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) ///< Interval (ms/task time) at which the Drain Pump data is published on the CAN bus. #define DRP_CONTROL_INTERVAL ( 1000 / TASK_GENERAL_INTERVAL ) ///< Interval (ms/task time) at which the Drain pump is controlled. -#define DRP_CONTROL_MAX_ALLOWED_PPO_PSI 30.0F ///< Drain pump maximum allowed PPo pressure in psi. +#define DRP_CONTROL_MAX_ALLOWED_PPO_PSI CLEANING_MODE_HIGH_TEMP_MAX_RO_PRESSURE_PSI ///< Drain pump maximum allowed PPo pressure in psi. #define DRP_CONTROL_MAX_ALLOWED_PDR_PSI 40.0F ///< Drain pump maximum allowed PDr pressure in psi. #define DRP_CONTROL_PSI_TO_DAC_P_ONLY_TERM 0.2F ///< Drain pump psi to DAC conversion. #define DRP_CONTROL_FLOW_TO_DAC_P_ONLY_TERM 100.0F ///< Drain pump flow (L/min) to DAC conversion. @@ -87,8 +87,11 @@ #define DRAIN_PUMP_FORWARD_DIR 1 ///< Drain pump forward direction. #define DRAIN_PUMP_DIR_BIT_MASK 0x80 ///< Drain pump direction bit clear mask. #define DRAIN_PUMP_DIR_ERROR_CNT_BIT_MASK 0x3F ///< Drain pump direction error count bit mask. -#define DRAIN_PUMP_DIR_FPGA_ERROR_TIMEOUT_MS ( 2 * MS_PER_SECOND ) ///< Drain pump direction hall sensor FPGA error time out in milliseconds. +#define DRAIN_PUMP_MIN_RPM_FOR_DIR_CHECK 100 ///< Drain pump minimum RPM for direction check. +#define MAX_FPGA_DRAIN_PUMP_DIRECTION_FAULT_WINDOW_MS ( 1 * SEC_PER_MIN * MS_PER_SECOND ) ///< FPGA drain pump direction fault window +#define MAX_FPGA_DRAIN_PUMP_DIRECTION_FAULT_FAILURES 10 ///< FPGA drain pump direction fault failures per MAX_FPGA_DRAIN_PUMP_DIRECTION_FAULT_WINDOW_MS + /// Enumeration of drain pump states. typedef enum DrainPump_States { @@ -122,7 +125,8 @@ static F32 targetDrainPumpOutletFlowLPM; ///< Target outlet pressure for the drain pump. static U32 drainControlTimerCtr; ///< Determines when to perform control on drain pump. static BOOL hasClosedLoopBeenRequested; ///< Closed loop pump control flag. -static OVERRIDE_U32_T drainPumpMeasuredRPM = { 0, 0, 0, 0 }; ///< Measured drain pump RPM from feedback. +static OVERRIDE_U32_T drainPumpHallMeasuredRPM = { 0, 0, 0, 0 }; ///< Measured drain pump RPM from feedback. +static OVERRIDE_U32_T drainPumpMaxonMeasuredRPM = { 0, 0, 0, 0 }; ///< Measured Maxon drain pump RPM. static OVERRIDE_F32_T drainPumpMeasuredCurrentA = { 0.0F, 0.0F, 0.0F, 0 }; ///< Measured drain pump current feedback. static OVERRIDE_U32_T drainPumpMeasuredDir = { 0, 0, 0, 0 }; ///< Measured drain pump direction. static BOOL signalNewRPMRequest; ///< Signal flag the indicates there is a new RPM request. @@ -137,6 +141,9 @@ static const F32 RPM_CONVERSION_COEFF = (F32) SEC_PER_MIN / ( 2.0F * TOGGLE_PERIOD_RESOLUTION_SECONDS * ROTATIONAL_TO_TOGGLE_PERIOD_CONVERSION ); static const F32 CURRENT_CONVERSION_COEFF = (F32)( 2.5F / ( BITS_12_FULL_SCALE - 1.0F ) ); +/// Drain pump hall sensor failure count +static U32 lastDirHallSensorErrorCount = 0; ///< Last drain pump encoder errors for hal sensor + // ********** private function prototypes ********** static DRAIN_PUMP_STATE_T handleDrainPumpOffState( void ); @@ -155,7 +162,7 @@ * drainPumpControlMode, drainPumpControlModeSet, targetDrainPumpRPM, * targetDrainPumpOutletFlowLPM, drainControlTimerCtr, * pendingDrainPumpCmd, pendingDrainPumpCmdTarget, pendingDrainPumpCmdCountDown, - * hasClosedLoopBeenRequested, signalNewRPMRequest, + * hasClosedLoopBeenRequested, signalNewRPMRequest, lastDrainPumpEncoderErrors, * drainPumpDataPublicationTimerCounter, isDrainPumpControlInFlowMode * @return none *************************************************************************/ @@ -178,6 +185,7 @@ signalNewRPMRequest = FALSE; drainPumpDataPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; isDrainPumpControlInFlowMode = TRUE; + lastDirHallSensorErrorCount = 0; // Initialize the drain pump PI controller initializePIController( PI_CONTROLLER_ID_DRAIN_PUMP, DRAIN_PUMP_MIN_DAC, DRAIN_PUMP_P_COEFFICIENT, DRAIN_PUMP_I_COEFFICIENT, @@ -189,8 +197,8 @@ initPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_CURRENT_OUT_OF_RANGE, DRAIN_PUMP_CURRENT_OUT_OF_RANGE_TIMEOUT_MS, DRAIN_PUMP_CURRENT_OUT_OF_RANGE_TIMEOUT_MS ); initPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_DIRECTION_INVALID, DRAIN_PUMP_DIR_OF_RANGE_TIMEOUT_MS, DRAIN_PUMP_DIR_OF_RANGE_TIMEOUT_MS ); - initFPGAPersistentAlarm( FPGA_PERS_ERROR_DRAIN_PUMP_DIR_HALL_SENSOR, ALARM_ID_DG_DRAIN_PUMP_DIRECTION_FPGA_FAULT, - DRAIN_PUMP_DIR_FPGA_ERROR_TIMEOUT_MS, DRAIN_PUMP_DIR_FPGA_ERROR_TIMEOUT_MS ); + // initialize FPGA drain pump hall sensor error + initTimeWindowedCount( TIME_WINDOWED_COUNT_FPGA_DRAIN_PUMP_HALL_SENSOR_ERROR, MAX_FPGA_DRAIN_PUMP_DIRECTION_FAULT_FAILURES, MAX_FPGA_DRAIN_PUMP_DIRECTION_FAULT_WINDOW_MS); } /*********************************************************************//** @@ -333,102 +341,97 @@ *************************************************************************/ void execDrainPumpMonitor( void ) { - U16 fpgaADCSpeedCount = getFPGADrainPumpSpeed(); - U16 fpgaADCCurrentCount = getFPGADrainPumpCurrentFeedback(); - F32 currentA = getDrainPumpMeasuredCurrentA(); - U32 dirHallSensorErrorCount = (U32)( getFPGADrainPumpDirection() & DRAIN_PUMP_DIR_ERROR_CNT_BIT_MASK ); - drainPumpMeasuredRPM.data = ( DRAIN_PUMP_OFF_RPM_ADC_COUNT == fpgaADCSpeedCount ? 0 : (U32)( RPM_CONVERSION_COEFF / (F32)fpgaADCSpeedCount ) ); + U16 fpgaADCSpeedCount = getFPGADrainPumpSpeed(); + U16 fpgaMaxonADCSpeedCount = getFPGADrainPumpSpeedFeedback(); + U16 fpgaADCCurrentCount = getFPGADrainPumpCurrentFeedback(); + F32 currentA = getDrainPumpMeasuredCurrentA(); + U32 dirHallSensorErrorCount = (U32)( getFPGADrainPumpDirection() & DRAIN_PUMP_DIR_ERROR_CNT_BIT_MASK ); + BOOL isOffCurrentOut = FALSE; + BOOL isCurrentOutOfRange = FALSE; + + // Update the override variables + drainPumpMaxonMeasuredRPM.data = MAX_DRAIN_PUMP_RPM * ( (F32)fpgaMaxonADCSpeedCount / (F32)BITS_12_FULL_SCALE ); + drainPumpHallMeasuredRPM.data = ( DRAIN_PUMP_OFF_RPM_ADC_COUNT == fpgaADCSpeedCount ? 0 : (U32)( RPM_CONVERSION_COEFF / (F32)fpgaADCSpeedCount ) ); drainPumpMeasuredCurrentA.data = (F32)fpgaADCCurrentCount * CURRENT_CONVERSION_COEFF; drainPumpMeasuredDir.data = (U32)( ( getFPGADrainPumpDirection() & DRAIN_PUMP_DIR_BIT_MASK ) >> SHIFT_BITS_BY_7 ); #ifndef _RELEASE_ if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_DRAIN_PUMP_MONITOR ) != SW_CONFIG_ENABLE_VALUE ) #endif { -#ifndef _RELEASE_ - if ( ( getHardwareConfigStatus() != HW_CONFIG_BETA ) && ( getCurrentOperationMode() != DG_MODE_INIT ) ) -#endif + if ( dirHallSensorErrorCount != lastDirHallSensorErrorCount ) { - checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_DRAIN_PUMP_DIR_HALL_SENSOR, dirHallSensorErrorCount ); + if ( TRUE == incTimeWindowedCount( TIME_WINDOWED_COUNT_FPGA_DRAIN_PUMP_HALL_SENSOR_ERROR ) ) + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_DRAIN_PUMP_DIRECTION_FPGA_FAULT, MAX_FPGA_DRAIN_PUMP_DIRECTION_FAULT_FAILURES, dirHallSensorErrorCount ) + } + lastDirHallSensorErrorCount = dirHallSensorErrorCount; } switch( drainPumpState ) { case DRAIN_PUMP_OFF_STATE: { - BOOL isOffCurrentOut = ( currentA > DRAIN_PUMP_MAX_CURRENT_WHEN_OFF_A ? TRUE : FALSE ); - BOOL isRPMTooHigh = ( getDrainPumpMeasuredRPM() > MIN_DRAIN_PUMP_RPM ? TRUE : FALSE ); + BOOL isRPMTooHigh = FALSE; - checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_RPM_OUT_OF_RANGE, FALSE, getDrainPumpMeasuredRPM(), MAX_ALLOWED_OPEN_LOOP_RPM_OUT_OF_RANGE ); - checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_OFF_FAULT, isRPMTooHigh, getDrainPumpMeasuredRPM(), MIN_DRAIN_PUMP_RPM ); + isOffCurrentOut = ( currentA > DRAIN_PUMP_MAX_CURRENT_WHEN_OFF_A ? TRUE : FALSE ); + isRPMTooHigh |= ( getDrainPumpMeasuredRPM( DRAIN_PUMP_HALL_SNSR_FB ) > MIN_DRAIN_PUMP_RPM ? TRUE : FALSE ); + isRPMTooHigh |= ( getDrainPumpMeasuredRPM( DRAIN_PUMP_MAXON_SNSR_FB ) > MIN_DRAIN_PUMP_RPM ? TRUE : FALSE ); + checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_RPM_OUT_OF_RANGE, FALSE, getDrainPumpMeasuredRPM( DRAIN_PUMP_MAXON_SNSR_FB ), MAX_ALLOWED_OPEN_LOOP_RPM_OUT_OF_RANGE ); + checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_OFF_FAULT, isRPMTooHigh, getDrainPumpMeasuredRPM( DRAIN_PUMP_MAXON_SNSR_FB ), MIN_DRAIN_PUMP_RPM ); + checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_DIRECTION_INVALID, FALSE, getFPGADrainPumpDirection(), DRAIN_PUMP_FORWARD_DIR ); + // If the off fault alarm has become active, trigger the safety shutdown if ( TRUE == isAlarmActive( ALARM_ID_DG_DRAIN_PUMP_OFF_FAULT ) ) { activateSafetyShutdown(); } - -#ifndef _RELEASE_ - if ( ( getHardwareConfigStatus() != HW_CONFIG_BETA ) && ( getCurrentOperationMode() != DG_MODE_INIT ) ) -#endif - { - checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_CURRENT_OUT_OF_RANGE, isOffCurrentOut, currentA, DRAIN_PUMP_MAX_CURRENT_WHEN_OFF_A ); - checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_DIRECTION_INVALID, FALSE, getFPGADrainPumpDirection(), DRAIN_PUMP_FORWARD_DIR ); - } } break; // The RPM is only checked in open loop state that the pump is run at a fixed RPM. case DRAIN_PUMP_OPEN_LOOP_STATE: { + U32 rpmHall = getDrainPumpMeasuredRPM( DRAIN_PUMP_HALL_SNSR_FB ); + U32 rpmMaxon = getDrainPumpMeasuredRPM( DRAIN_PUMP_MAXON_SNSR_FB ); + BOOL isRPMOutOfRange = FALSE; U32 direction = getDrainPumpMeasuredDirection(); - BOOL isDirInvalid = ( direction != DRAIN_PUMP_FORWARD_DIR ? TRUE : FALSE ); - U32 rpmDiff = abs( getDrainPumpTargetRPM() - getDrainPumpMeasuredRPM() ); - BOOL isRPMOutOfRange = ( rpmDiff > MAX_ALLOWED_OPEN_LOOP_RPM_OUT_OF_RANGE ? TRUE : FALSE ); + BOOL isDirInvalid = ( ( direction != DRAIN_PUMP_FORWARD_DIR ) && ( rpmMaxon > DRAIN_PUMP_MIN_RPM_FOR_DIR_CHECK ) ? TRUE : FALSE ); // Make sure the pump is running prior to checking the direction error + U32 rpmHallDiff = abs( getDrainPumpTargetRPM() - rpmHall ); + U32 rpmMaxonDiff = abs( getDrainPumpTargetRPM() - rpmMaxon ); - checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_RPM_OUT_OF_RANGE, isRPMOutOfRange, getDrainPumpMeasuredRPM(), MAX_ALLOWED_OPEN_LOOP_RPM_OUT_OF_RANGE ); - checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_OFF_FAULT, FALSE, getDrainPumpMeasuredRPM(), MIN_DRAIN_PUMP_RPM ); + isRPMOutOfRange |= ( rpmHallDiff > MAX_ALLOWED_OPEN_LOOP_RPM_OUT_OF_RANGE ? TRUE : FALSE ); + isRPMOutOfRange |= ( rpmMaxonDiff > MAX_ALLOWED_OPEN_LOOP_RPM_OUT_OF_RANGE ? TRUE : FALSE ); -#ifndef _RELEASE_ - if ( ( getHardwareConfigStatus() != HW_CONFIG_BETA ) && ( getCurrentOperationMode() != DG_MODE_INIT ) ) -#endif - { - checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_DIRECTION_INVALID, isDirInvalid, (F32)direction, DRAIN_PUMP_FORWARD_DIR ); - } + checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_RPM_OUT_OF_RANGE, isRPMOutOfRange, rpmHall, MAX_ALLOWED_OPEN_LOOP_RPM_OUT_OF_RANGE ); + checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_OFF_FAULT, FALSE, rpmHall, MIN_DRAIN_PUMP_RPM ); + checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_DIRECTION_INVALID, isDirInvalid, (F32)direction, DRAIN_PUMP_FORWARD_DIR ); } break; case DRAIN_PUMP_CONTROL_TO_TARGET_STATE: { U32 direction = getDrainPumpMeasuredDirection(); - BOOL isDirInvalid = ( direction != DRAIN_PUMP_FORWARD_DIR ? TRUE : FALSE ); + U32 rpmMaxon = getDrainPumpMeasuredRPM( DRAIN_PUMP_MAXON_SNSR_FB ); + BOOL isDirInvalid = ( ( direction != DRAIN_PUMP_FORWARD_DIR ) && ( rpmMaxon > DRAIN_PUMP_MIN_RPM_FOR_DIR_CHECK ) ? TRUE : FALSE ); -#ifndef _RELEASE_ - if ( ( getHardwareConfigStatus() != HW_CONFIG_BETA ) && ( getCurrentOperationMode() != DG_MODE_INIT ) ) -#endif - { - checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_DIRECTION_INVALID, isDirInvalid, (F32)direction, DRAIN_PUMP_FORWARD_DIR ); - } + checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_DIRECTION_INVALID, isDirInvalid, (F32)direction, DRAIN_PUMP_FORWARD_DIR ); } break; default: // There are not out of range conditions, clear the alarms - checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_RPM_OUT_OF_RANGE, FALSE, getDrainPumpMeasuredRPM(), MAX_ALLOWED_OPEN_LOOP_RPM_OUT_OF_RANGE ); - checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_OFF_FAULT, FALSE, getDrainPumpMeasuredRPM(), MIN_DRAIN_PUMP_RPM ); + checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_RPM_OUT_OF_RANGE, FALSE, getDrainPumpMeasuredRPM( DRAIN_PUMP_HALL_SNSR_FB ), MAX_ALLOWED_OPEN_LOOP_RPM_OUT_OF_RANGE ); + checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_OFF_FAULT, FALSE, getDrainPumpMeasuredRPM( DRAIN_PUMP_HALL_SNSR_FB ), MIN_DRAIN_PUMP_RPM ); checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_DIRECTION_INVALID, FALSE, getFPGADrainPumpDirection(), DRAIN_PUMP_FORWARD_DIR ); break; } -#ifndef _RELEASE_ - if ( ( getHardwareConfigStatus() != HW_CONFIG_BETA ) && ( getCurrentOperationMode() != DG_MODE_INIT ) ) -#endif - { - // Check the persistent alarm for the maximum drain pump current - BOOL isCurrentOutOfRange = ( currentA > DRAIN_PUMP_MAX_CURRENT_A ? TRUE : FALSE ); + // Check the persistent alarm for the maximum drain pump current + isCurrentOutOfRange = ( currentA > DRAIN_PUMP_MAX_CURRENT_A ? TRUE : FALSE ) | isOffCurrentOut; - checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_CURRENT_OUT_OF_RANGE, isCurrentOutOfRange, currentA, DRAIN_PUMP_MAX_CURRENT_A ); - } + checkPersistentAlarm( ALARM_ID_DG_DRAIN_PUMP_CURRENT_OUT_OF_RANGE, isCurrentOutOfRange, currentA, DRAIN_PUMP_MAX_CURRENT_A ); } // Publish drain pump data on interval @@ -555,12 +558,22 @@ * pump RPM sensor. * @details Inputs: drainPumpMeasuredRPM * @details Outputs: none + * @param sensor to get its RPM from (Hall sensor or Maxon board in DVT) * @return drain pump RPM *************************************************************************/ -U32 getDrainPumpMeasuredRPM( void ) +U32 getDrainPumpMeasuredRPM( DRAIN_PUMP_SPEED_FB_SNSR_T sensor ) { - U32 rpm = getU32OverrideValue( &drainPumpMeasuredRPM ); + U32 rpm = 0; + if ( DRAIN_PUMP_HALL_SNSR_FB == sensor ) + { + rpm = getU32OverrideValue( &drainPumpHallMeasuredRPM ); + } + else if ( DRAIN_PUMP_MAXON_SNSR_FB == sensor ) + { + rpm = getU32OverrideValue( &drainPumpMaxonMeasuredRPM ); + } + return rpm; } @@ -670,10 +683,11 @@ if ( TRUE == isDrainPumpControlInFlowMode ) { - F32 dac = runPIController( PI_CONTROLLER_ID_DRAIN_PUMP, targetROFlowLPM, msrdROFlowLPM ); + F32 dac = runPIController( PI_CONTROLLER_ID_DRAIN_PUMP, targetROFlowLPM, msrdROFlowLPM ); + drainPumpDACSet = (U32)( dac + FLOAT_TO_INT_ROUNDUP_OFFSET ); - if ( ( drainPumpOutletPressurePSI > DRP_CONTROL_MAX_ALLOWED_PDR_PSI ) || ( roPumpOutletPressurePSI > DRP_CONTROL_MAX_ALLOWED_PPO_PSI ) ) + if ( ( drainPumpOutletPressurePSI > DRP_CONTROL_MAX_ALLOWED_PDR_PSI ) || ( roPumpOutletPressurePSI > (F32)DRP_CONTROL_MAX_ALLOWED_PPO_PSI ) ) { // If either of the pressure sensors are above range, transition to control to pressure isDrainPumpControlInFlowMode = FALSE; @@ -684,14 +698,14 @@ // If measured flow if greater than the target flow, adjust the DAC to lower the flow rate tempDACSet = (U32)( ( flowSubLPM * DRP_CONTROL_FLOW_TO_DAC_P_ONLY_TERM ) + FLOAT_TO_INT_ROUNDUP_OFFSET ); tempDACSet = ( tempDACSet > drainPumpDACSet ? DRAIN_PUMP_MIN_DAC : tempDACSet ); - drainPumpDACSet -= ( tempDACSet > 0.0F ? tempDACSet : DRP_CONTROL_MIN_DAC_CHANGE ); + drainPumpDACSet -= tempDACSet; } else { // Get the status of the current pressure readings with respect to their maximum pressures // Get the maximum of the pressure difference of PPo and PDr F32 pdrSubPSI = drainPumpOutletPressurePSI - DRP_CONTROL_MAX_ALLOWED_PDR_PSI; - F32 ppoSubPSI = roPumpOutletPressurePSI - DRP_CONTROL_MAX_ALLOWED_PPO_PSI; + F32 ppoSubPSI = roPumpOutletPressurePSI - (F32)DRP_CONTROL_MAX_ALLOWED_PPO_PSI; F32 maxPresPSI = MAX( pdrSubPSI, ppoSubPSI ); if ( ( pdrSubPSI > 0.0F ) || ( ppoSubPSI > 0.0F ) ) @@ -700,15 +714,15 @@ // If the calculated DAC value turned out to be 0, set it to 1 so it changes at least by 1 DAC tempDACSet = (U32)( ( maxPresPSI * DRP_CONTROL_PSI_TO_DAC_P_ONLY_TERM ) + FLOAT_TO_INT_ROUNDUP_OFFSET ); tempDACSet = ( tempDACSet > drainPumpDACSet ? DRAIN_PUMP_MIN_DAC : tempDACSet ); - drainPumpDACSet -= ( tempDACSet > 0.0F ? tempDACSet : DRP_CONTROL_MIN_DAC_CHANGE ); + drainPumpDACSet -= tempDACSet; } else if ( ( fabs(pdrSubPSI) > DRP_CONTROL_PRES_TO_MAX_THRESHOLD_PSI ) && ( fabs(ppoSubPSI) > DRP_CONTROL_PRES_TO_MAX_THRESHOLD_PSI ) ) { // If both of the DACs turned out to be less than their maximum pressure limits by more than the specified value, recalculate the // DAC. Using fabs for the subtraction means both pressure subtractions are negative so they are below their limits. // In the calculations use fabs for max pressure because it is negative so it will end of subtracting DAC but it should be adding tempDACSet = (U32)( ( fabs(maxPresPSI) * DRP_CONTROL_PSI_TO_DAC_P_ONLY_TERM ) + FLOAT_TO_INT_ROUNDUP_OFFSET ); - drainPumpDACSet += ( tempDACSet > 0.0F ? tempDACSet : DRP_CONTROL_MIN_DAC_CHANGE ); + drainPumpDACSet += tempDACSet; } } @@ -783,10 +797,11 @@ drainPumpData.rpmSetPoint = getDrainPumpTargetRPM(); drainPumpData.pumpDACSet = drainPumpDACSet; drainPumpData.drainPumpState = (U32)drainPumpState; - drainPumpData.drainPumpRPM = getDrainPumpMeasuredRPM(); + drainPumpData.drainPumpHallRPM = getDrainPumpMeasuredRPM( DRAIN_PUMP_HALL_SNSR_FB ); drainPumpData.trgtOutletFlowLPM = targetDrainPumpOutletFlowLPM; drainPumpData.drainPumpCurrentA = getDrainPumpMeasuredCurrentA(); drainPumpData.drainPumpDirection = getDrainPumpMeasuredDirection(); + drainPumpData.drainPumpMaxonRPM = getDrainPumpMeasuredRPM( DRAIN_PUMP_MAXON_SNSR_FB ); broadcastData( MSG_ID_DRAIN_PUMP_DATA, COMM_BUFFER_OUT_CAN_DG_BROADCAST, (U08*)&drainPumpData, sizeof( DRAIN_PUMP_DATA_T ) ); @@ -899,6 +914,7 @@ if ( 0 == value ) { + result = TRUE; signalDrainPumpHardStop(); } } @@ -936,21 +952,32 @@ * The testSetDrainPumpMeasuredRPMOverride function overrides the drain pump * measured RPM data. * @details Inputs: none - * @details Outputs: drainPumpMeasuredRPM + * @details Outputs: drainPumpHallMeasuredRPM, drainPumpMaxonMeasuredRPM + * @param sensor the type of sensor to pick (hall sensor or Maxon board) * @param value override drain pump measured data * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testSetDrainPumpMeasuredRPMOverride( U32 value ) +BOOL testSetDrainPumpMeasuredRPMOverride( U32 sensor, U32 value ) { BOOL status = FALSE; // Check if the user is logged in - if ( TRUE == isTestingActivated() ) + if ( ( TRUE == isTestingActivated() ) && ( (DRAIN_PUMP_SPEED_FB_SNSR_T)sensor < NUM_OF_DRAIN_PUMP_SNSR_FB ) ) { - drainPumpMeasuredRPM.ovData = value; - drainPumpMeasuredRPM.override = OVERRIDE_KEY; - drainPumpMeasuredRPM.ovInitData = drainPumpMeasuredRPM.data; - status = TRUE; + if ( DRAIN_PUMP_HALL_SNSR_FB == (DRAIN_PUMP_SPEED_FB_SNSR_T)sensor ) + { + drainPumpHallMeasuredRPM.ovData = value; + drainPumpHallMeasuredRPM.override = OVERRIDE_KEY; + drainPumpHallMeasuredRPM.ovInitData = drainPumpHallMeasuredRPM.data; + } + else + { + drainPumpMaxonMeasuredRPM.ovData = value; + drainPumpMaxonMeasuredRPM.override = OVERRIDE_KEY; + drainPumpMaxonMeasuredRPM.ovInitData = drainPumpMaxonMeasuredRPM.data; + } + + status = TRUE; } return status; @@ -962,18 +989,28 @@ * measured RPM data. * @details Inputs: none * @details Outputs: drainPumpMeasuredRPM + * @param sensor the type of sensor to pick (hall sensor or Maxon board) * @return TRUE if override reset successful, FALSE if not *************************************************************************/ -BOOL testResetDrainPumpMeasuredRPMOverride( void ) +BOOL testResetDrainPumpMeasuredRPMOverride( U32 sensor ) { BOOL status = FALSE; // Check if the user is logged in - if ( TRUE == isTestingActivated() ) + if ( ( TRUE == isTestingActivated() ) && ( (DRAIN_PUMP_SPEED_FB_SNSR_T)sensor < NUM_OF_DRAIN_PUMP_SNSR_FB ) ) { - drainPumpMeasuredRPM.ovData = drainPumpMeasuredRPM.ovInitData; - drainPumpMeasuredRPM.override = OVERRIDE_RESET; - status = TRUE; + if ( DRAIN_PUMP_HALL_SNSR_FB == (DRAIN_PUMP_SPEED_FB_SNSR_T)sensor ) + { + drainPumpHallMeasuredRPM.ovData = drainPumpHallMeasuredRPM.ovInitData; + drainPumpHallMeasuredRPM.override = OVERRIDE_RESET; + } + else + { + drainPumpMaxonMeasuredRPM.ovData = drainPumpMaxonMeasuredRPM.ovInitData; + drainPumpMaxonMeasuredRPM.override = OVERRIDE_RESET; + } + + status = TRUE; } return status;