Index: firmware/App/Controllers/ConcentratePumps.c =================================================================== diff -u -rb43c9f8a4e0338eed6c2f4b48740fc60d74deeb6 -red39129abdca4ec343369d83494530b23621e052 --- firmware/App/Controllers/ConcentratePumps.c (.../ConcentratePumps.c) (revision b43c9f8a4e0338eed6c2f4b48740fc60d74deeb6) +++ firmware/App/Controllers/ConcentratePumps.c (.../ConcentratePumps.c) (revision ed39129abdca4ec343369d83494530b23621e052) @@ -35,22 +35,32 @@ #define CONCENTRATE_PUMP_FORWARD_DIR 0x1 ///< Concentrate pump forward direction configuration. #define CONCENTRATE_PUMP_REVERSE_DIR 0x0 ///< Concentrate pump reverse direction configuration. -#define CONCENTRATE_PUMP_SPEED_INCREMENT 2.0F ///< Speed increase (mL/min) when controlling concentrate pump to target step speed. -#define CONCENTRATE_PUMP_MIN_SPEED 0.1F ///< Minimum speed for concentrate pump in mL per min. +#define CONCENTRATE_PUMP_SPEED_INCREMENT 10.0F ///< Speed increase (mL/min) when controlling concentrate pump to target step speed. +#define CONCENTRATE_PUMP_MIN_SPEED 3.0F ///< Minimum speed for concentrate pump in mL per min. #define CONCENTRATE_PUMP_SPD_OUT_OF_RANGE_TOL_WHEN_ON_PCT 0.02F ///< Concentrate pump speed out of range tolerance when on in percentage. #define CONCENTRATE_PUMP_SPD_OUT_OF_RANGE_TOL_WHEN_SLOW_MLPM 1.0F ///< Concentrate pump speed out of range tolerance when slow in mL/min. #define CONCENTRATE_PUMP_LOW_SPEED_THRESHOLD_MLPM 10.0F ///< Concentrate pump low speed threshold in mL/min. #define CONCENTRATE_PUMP_ZERO_FLOW_RATE 0xFFFF ///< Pulse width value when zero flow rate or pump is off. - +#ifndef __PUMPTEST__ #define CONCENTRATE_PUMP_VOLUME_PER_REV 0.1F ///< Volume output every revolution (mL). +#else +#define PISTON_PUMP_STEPS_PER_ML 342.0F ///< Revolution count for 1ml volume delivery. +#define CONCENTRATE_PUMP_VOLUME_PER_REV ( CONCENTRATE_PUMP_STEP_PER_REV / PISTON_PUMP_STEPS_PER_ML ) ///< Volume output every revolution (mL). +#endif #define CONCENTRATE_PUMP_PULSE_PER_REV 2.0F ///< Number of pulses generate for every revolution. #define CONCENTRATE_PUMP_STEP_PER_REV 200.0F ///< Number of steps for every revolution. #define CONCENTRATE_PUMP_HALL_SENSE_PERIOD_RESOLUTION 100.0F ///< Hall sense period resolution in microseconds. #define CONCENTRATE_PUMP_MIN_ALLOWED_HALL_SENSOR_COUNT 1000 ///< Hall sensors minimum allowed value. #define CONCENTRATE_PUMP_HALL_SENSORS_OUT_OF_RANGE_TIME_MS ( 5 * MS_PER_SECOND ) ///< Hall sensors out of range time in milliseconds. #define CONCENTRATE_PUMP_MICRO_STEPS_PER_STEP 8.0F ///< Number of micro-steps ( fractions of step) per step. -#define CONCENTRATE_PUMP_STEP_PERIOD_RESOLUTION ( 0.25F / ( US_PER_SECOND * SEC_PER_MIN ) ) ///< Convert step period resolution (0.25 us) to minute. +#define CONCENTRATE_PUMP_VOLUME_TO_REVOLUTION ( ( 1 / CONCENTRATE_PUMP_VOLUME_PER_REV ) * \ + ( CONCENTRATE_PUMP_STEP_PER_REV * \ + CONCENTRATE_PUMP_MICRO_STEPS_PER_STEP ) ) ///< Convert volume in to number of revolutions needed. +#ifdef __PUMPTEST__ +#define PISTON_PUMP_VOLUME_TO_REVOLUTION ( PISTON_PUMP_STEPS_PER_ML * CONCENTRATE_PUMP_MICRO_STEPS_PER_STEP ) ///< Convert volume in to number of revolutions needed. +#endif +#define CONCENTRATE_PUMP_STEP_PERIOD_RESOLUTION ( 0.50F / ( US_PER_SECOND * SEC_PER_MIN ) ) ///< Convert step period resolution (0.50 us) to minute. /// Volume output per pulse. #define CONCENTRATE_PUMP_VOLUME_PER_PULSE ( CONCENTRATE_PUMP_VOLUME_PER_REV / CONCENTRATE_PUMP_PULSE_PER_REV ) @@ -64,7 +74,7 @@ #define DATA_PUBLISH_COUNTER_START_COUNT 0 ///< Data publish counter start count. #define CONCENTRATE_PUMP_FAULT_PERSISTENCE_PERIOD 500 ///< Concentrate pump fault persistence period in milliseconds. -#define CONCENTRATE_PUMP_TRANS_TO_RAMP_SPEED_THRESHOLD_MLPM 5.0F ///< Concentrate pump transition to ramp to target speed threshold in mL/min. +#define CONCENTRATE_PUMP_TRANS_TO_RAMP_SPEED_THRESHOLD_MLPM 20.0F ///< Concentrate pump transition to ramp to target speed threshold in mL/min. #define CONCENTRATE_PUMP_CONTROL_EIGHTH_STEP 0x07 ///< Concentrate pump control 1/8th step. #define CONCENTRATE_PUMP_CONTROL_REVERSE_DIR 0x00 ///< Concentrate pump control reverse direction. @@ -73,7 +83,9 @@ #define CONCENTRATE_PUMP_CONTROL_DISABLE 0x01 ///< Concentrate pump control disable pump. #define CONCENTRATE_PUMP_CONTROL_NOT_RESET 0x20 ///< Concentrate pump control not reset. #define CONCENTRATE_PUMP_CONTROL_SLEEP_OFF 0x40 ///< Concentrate pump control sleep off. +#define CONCENTRATE_PUMP_CONTROL_ENABLE_MASK 0x10 ///< Concentrate pump control enable bit mask. + static const U32 CONCENTRATE_PUMP_CONTROL_FORWARD = CONCENTRATE_PUMP_CONTROL_SLEEP_OFF | CONCENTRATE_PUMP_CONTROL_NOT_RESET | CONCENTRATE_PUMP_CONTROL_ENABLE | @@ -102,16 +114,11 @@ U32 controlTimerCounter; ///< Timer counter to perform control on concentrate pump. CONCENTRATE_PUMP_STATE_T execState; ///< Concentrate pump execute current state. BOOL hasTurnOnPumpsBeenRequested; ///< Flag indicates a request to turn concentrate pumps on. - OVERRIDE_U32_T hasParkBeenRequested; ///< Flag indicates a request to park the pump. - OVERRIDE_F32_T pumpTargetSpeed; ///< Target concentrate pumps' speed (mL/min). F32 currentPumpSpeed; ///< Current controlled concentrate pumps' speed (mL/min). - OVERRIDE_F32_T measuredPumpSpeed; ///< Measured concentrate pump speed (mL/min). U16 togglePeriodCount; ///< Converted pump speed (mL/min) to toggle period counts (0.5 uS increment counts per step). U08 direction; ///< Concentrate pump motor direction. U08 controlSet; ///< Concentrate pump control set. (Used in DVT) F32 pulseWidthUS; ///< Concentrate pump pulse width in microseconds. - OVERRIDE_U32_T parked; ///< Concentrate pump is currently parked (T/F). - OVERRIDE_U32_T parkFaulted; ///< Concentrate pump park command has faulted (T/F). BOOL isConcPumpParkInProgress; ///< Concentrate pump park progress boolean flag (T/F). } CONCENTRATE_PUMP_T; @@ -121,6 +128,7 @@ U32 pumpID; ///< Concentrate pump ID (0:Acid ,1:Bicarb) U32 startStop; ///< Concentrate pump start:1,stop :0. F32 speed; ///< Speed range from 0.1 ml/min to 48.0 ml/min. + F32 volume; ///< Target volume in ml } CONC_PUMP_START_STOP_CMD_PAYLOAD_T; // ********** private data ********** @@ -133,6 +141,14 @@ static OVERRIDE_U32_T concentratePumpDataPublishInterval = { CONCENTRATE_PUMP_DATA_PUBLISH_INTERVAL, CONCENTRATE_PUMP_DATA_PUBLISH_INTERVAL, 0, 0 }; static CONCENTRATE_PUMP_T concentratePumps[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Array of concentrate pumps' data structure. +static OVERRIDE_U32_T hasParkBeenRequested[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Flag indicates a request to park the pump. +static OVERRIDE_F32_T pumpTargetSpeed[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Target concentrate pumps' speed (mL/min). +static OVERRIDE_U32_T pumpTargetRevCnt[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Target concentrate pump revolution count +static OVERRIDE_U32_T pumpMesauredRevCnt[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Current measured concentrate pump revolution count +static OVERRIDE_F32_T measuredPumpSpeed[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Measured concentrate pump speed (mL/min). +static OVERRIDE_U32_T parked[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Concentrate pump is currently parked (T/F). +static OVERRIDE_U32_T parkFaulted[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Concentrate pump park command has faulted (T/F). + //static DD_ACID_CONCENTRATES_RECORD_T acidConcentrateCalRecord; ///< Acid concentrate calibration record. //static DD_BICARB_CONCENTRATES_RECORD_T bicarbConcentrateCalRecord; ///< Bicarb concentrate calibration record. //static DD_CONC_PUMPS_CAL_RECORD_T concentratePumpsCalRecord; ///< Concentrate pumps calibration record. @@ -164,29 +180,47 @@ acidConcentratePumpParkPersistenceClear = FALSE; bicarbConcentratePumpParkPersistenceClear = FALSE; - for ( pumpId = CONCENTRATEPUMPS_CP1_ACID; pumpId < NUM_OF_CONCENTRATE_PUMPS; pumpId++ ) + for ( pumpId = CONCENTRATEPUMPS_FIRST; pumpId < NUM_OF_CONCENTRATE_PUMPS; pumpId++ ) { concentratePumps[ pumpId ].controlTimerCounter = 0; concentratePumps[ pumpId ].execState = CONCENTRATE_PUMP_OFF_STATE; - concentratePumps[ pumpId ].measuredPumpSpeed.data = 0.0F; - concentratePumps[ pumpId ].measuredPumpSpeed.ovInitData = 0.0F; + measuredPumpSpeed[ pumpId ].data = 0.0F; + measuredPumpSpeed[ pumpId ].ovInitData = 0.0F; + measuredPumpSpeed[ pumpId ].ovData = 0.0F; + measuredPumpSpeed[ pumpId ].override = OVERRIDE_RESET; concentratePumps[ pumpId ].hasTurnOnPumpsBeenRequested = FALSE; - concentratePumps[ pumpId ].hasParkBeenRequested.data = FALSE; - concentratePumps[ pumpId ].hasParkBeenRequested.ovInitData = FALSE; - concentratePumps[ pumpId ].parked.data = FALSE; - concentratePumps[ pumpId ].parked.ovInitData = FALSE; - concentratePumps[ pumpId ].parkFaulted.data = FALSE; - concentratePumps[ pumpId ].parkFaulted.ovInitData = FALSE; - concentratePumps[ pumpId ].pumpTargetSpeed.data = 0.0F; - concentratePumps[ pumpId ].pumpTargetSpeed.ovInitData = 0.0F; + hasParkBeenRequested[ pumpId ].data = FALSE; + hasParkBeenRequested[ pumpId ].ovInitData = FALSE; + hasParkBeenRequested[ pumpId ].ovData = FALSE; + hasParkBeenRequested[ pumpId ].override = OVERRIDE_RESET; + parked[ pumpId ].data = FALSE; + parked[ pumpId ].ovInitData = FALSE; + parked[ pumpId ].ovData = FALSE; + parked[ pumpId ].override = OVERRIDE_RESET; + parkFaulted[ pumpId ].data = FALSE; + parkFaulted[ pumpId ].ovInitData = FALSE; + parkFaulted[ pumpId ].ovData = FALSE; + parkFaulted[ pumpId ].override = OVERRIDE_RESET; + pumpTargetSpeed[ pumpId ].data = 0.0F; + pumpTargetSpeed[ pumpId ].ovInitData = 0.0F; + pumpTargetSpeed[ pumpId ].ovData = 0.0F; + pumpTargetSpeed[ pumpId ].override = OVERRIDE_RESET; + pumpTargetRevCnt[ pumpId ].data = 0; + pumpTargetRevCnt[ pumpId ].ovInitData = 0; + pumpTargetRevCnt[ pumpId ].ovData = 0; + pumpTargetRevCnt[ pumpId ].override = OVERRIDE_RESET; + pumpMesauredRevCnt[ pumpId ].data = 0; + pumpMesauredRevCnt[ pumpId ].ovInitData = 0; + pumpMesauredRevCnt[ pumpId ].ovData = 0; + pumpMesauredRevCnt[ pumpId ].override = OVERRIDE_RESET; concentratePumps[ pumpId ].direction = CONCENTRATE_PUMP_FORWARD_DIR; concentratePumps[ pumpId ].controlSet = CONCENTRATE_PUMP_CONTROL_FORWARD; concentratePumps[ pumpId ].isConcPumpParkInProgress = FALSE; stopConcentratePump( pumpId ); } - initPersistentAlarm( ALARM_ID_DD_CP1_SPEED_CONTROL_ERROR, 0, CONCENTRATE_PUMP_SPEED_OUT_OF_RANGE_TIMEOUT_MS ); - initPersistentAlarm( ALARM_ID_DD_CP2_SPEED_CONTROL_ERROR, 0, CONCENTRATE_PUMP_SPEED_OUT_OF_RANGE_TIMEOUT_MS ); + initPersistentAlarm( ALARM_ID_DD_D11_PUMP_SPEED_CONTROL_ERROR, 0, CONCENTRATE_PUMP_SPEED_OUT_OF_RANGE_TIMEOUT_MS ); + initPersistentAlarm( ALARM_ID_DD_D10_PUMP_SPEED_CONTROL_ERROR, 0, CONCENTRATE_PUMP_SPEED_OUT_OF_RANGE_TIMEOUT_MS ); initPersistentAlarm( ALARM_ID_DD_CONC_PUMP_HALL_SENSOR_OUT_OF_RANGE, CONCENTRATE_PUMP_HALL_SENSORS_OUT_OF_RANGE_TIME_MS, CONCENTRATE_PUMP_HALL_SENSORS_OUT_OF_RANGE_TIME_MS ); initPersistentAlarm( ALARM_ID_DD_CONCENTRATE_PUMP_FAULT, CONCENTRATE_PUMP_FAULT_PERSISTENCE_PERIOD, CONCENTRATE_PUMP_FAULT_PERSISTENCE_PERIOD ); } @@ -218,50 +252,53 @@ // Calculate pump speed for each defined pump calcMeasuredPumpsSpeed(); - concentratePumps[ CONCENTRATEPUMPS_CP1_ACID ].parked.data = (U32)getFPGAAcidPumpIsParked(); - concentratePumps[ CONCENTRATEPUMPS_CP2_BICARB ].parked.data = (U32)getFPGABicarbPumpIsParked(); - concentratePumps[ CONCENTRATEPUMPS_CP1_ACID ].parkFaulted.data = (U32)getFPGAAcidPumpParkFault(); - concentratePumps[ CONCENTRATEPUMPS_CP2_BICARB ].parkFaulted.data = (U32)getFPGABicarbPumpParkFault(); + parked[ D11_PUMP ].data = (U32)getFPGAD11PumpIsParked(); + parked[ D10_PUMP ].data = (U32)getFPGAD10PumpIsParked(); + parkFaulted[ D11_PUMP ].data = (U32)getFPGAD11PumpParkFault(); + parkFaulted[ D10_PUMP ].data = (U32)getFPGAD10PumpParkFault(); - if ( ( TRUE == getConcPumpIsParked( CONCENTRATEPUMPS_CP1_ACID ) ) || ( TRUE == getConcPumpParkIsFaulted( CONCENTRATEPUMPS_CP1_ACID ) ) ) + pumpMesauredRevCnt[ D11_PUMP ].data = (U32)getFPGAD11PumpRevolutionCountStatus(); + pumpMesauredRevCnt[ D10_PUMP ].data = (U32)getFPGAD10PumpRevolutionCountStatus(); + + if ( ( TRUE == getConcPumpIsParked( D11_PUMP ) ) || ( TRUE == getConcPumpParkIsFaulted( D11_PUMP ) ) ) { // If the pump has parked or faulted during the park, then it is not in progress - concentratePumps[ CONCENTRATEPUMPS_CP1_ACID ].isConcPumpParkInProgress = FALSE; + concentratePumps[ D11_PUMP ].isConcPumpParkInProgress = FALSE; } - if ( ( TRUE == getConcPumpIsParked( CONCENTRATEPUMPS_CP2_BICARB ) ) || ( TRUE == getConcPumpParkIsFaulted( CONCENTRATEPUMPS_CP2_BICARB ) ) ) + if ( ( TRUE == getConcPumpIsParked( D10_PUMP ) ) || ( TRUE == getConcPumpParkIsFaulted( D10_PUMP ) ) ) { - concentratePumps[ CONCENTRATEPUMPS_CP2_BICARB ].isConcPumpParkInProgress = FALSE; + concentratePumps[ D10_PUMP ].isConcPumpParkInProgress = FALSE; } // Don't monitor persistence for cp speed alarms if we are parked. if ( TRUE == acidConcentratePumpParkPersistenceClear ) { // Clear flag and resume persistence checking once park bit is set. - if ( TRUE == getConcPumpIsParked( CONCENTRATEPUMPS_CP1_ACID ) ) + if ( TRUE == getConcPumpIsParked( D11_PUMP ) ) { acidConcentratePumpParkPersistenceClear = FALSE; } else { - resetPersistentAlarmTimer( ALARM_ID_DD_CP1_SPEED_CONTROL_ERROR ); + resetPersistentAlarmTimer( ALARM_ID_DD_D11_PUMP_SPEED_CONTROL_ERROR ); } } if ( TRUE == bicarbConcentratePumpParkPersistenceClear ) { // Clear flag and resume persistence checking once park bit is set. - if ( TRUE == getConcPumpIsParked( CONCENTRATEPUMPS_CP2_BICARB ) ) + if ( TRUE == getConcPumpIsParked( D10_PUMP ) ) { bicarbConcentratePumpParkPersistenceClear = FALSE; } else { - resetPersistentAlarmTimer( ALARM_ID_DD_CP2_SPEED_CONTROL_ERROR ); + resetPersistentAlarmTimer( ALARM_ID_DD_D10_PUMP_SPEED_CONTROL_ERROR ); } } - monitorPumpSpeed( CONCENTRATEPUMPS_CP1_ACID, ALARM_ID_DD_CP1_SPEED_CONTROL_ERROR ); - monitorPumpSpeed( CONCENTRATEPUMPS_CP2_BICARB, ALARM_ID_DD_CP2_SPEED_CONTROL_ERROR ); + monitorPumpSpeed( D11_PUMP, ALARM_ID_DD_D11_PUMP_SPEED_CONTROL_ERROR ); + monitorPumpSpeed( D10_PUMP, ALARM_ID_DD_D10_PUMP_SPEED_CONTROL_ERROR ); checkPersistentAlarm( ALARM_ID_DD_CONCENTRATE_PUMP_FAULT, isConcPumpFault, fpgaConcPumpsFault, CONCENTRATE_PUMP_FAULT_PERSISTENCE_PERIOD ); @@ -374,14 +411,14 @@ DD_OP_MODE_T opMode = getCurrentOperationMode(); // pumps should be not ON and DD operation mode is not in fault mode - if ( ( concentratePumps[CONCENTRATEPUMPS_CP1_ACID].execState == CONCENTRATE_PUMP_OFF_STATE ) && - ( concentratePumps[CONCENTRATEPUMPS_CP2_BICARB].execState == CONCENTRATE_PUMP_OFF_STATE ) && + if ( ( concentratePumps[D11_PUMP].execState == CONCENTRATE_PUMP_OFF_STATE ) && + ( concentratePumps[D10_PUMP].execState == CONCENTRATE_PUMP_OFF_STATE ) && //( DD_MODE_FILL != opMode ) && ( DD_MODE_FAUL != opMode ) ) { // Park concentrate pump - requestConcentratePumpOff( CONCENTRATEPUMPS_CP1_ACID, PARK_CONC_PUMPS ); - requestConcentratePumpOff( CONCENTRATEPUMPS_CP2_BICARB, PARK_CONC_PUMPS ); + requestConcentratePumpOff( D11_PUMP, PARK_CONC_PUMPS ); + requestConcentratePumpOff( D10_PUMP, PARK_CONC_PUMPS ); result = TRUE; } @@ -430,8 +467,7 @@ if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) { concentratePumps[ pumpId ].hasTurnOnPumpsBeenRequested = FALSE; - concentratePumps[ pumpId ].hasParkBeenRequested.data = park; - concentratePumps[ pumpId ].pumpTargetSpeed.data = 0.0F; + hasParkBeenRequested[ pumpId ].data = park; } else { @@ -450,7 +486,7 @@ * @param targetSpeed_ml_min target speed in mL/min * @return none *************************************************************************/ -void setConcentratePumpTargetSpeed( CONCENTRATE_PUMPS_T pumpId, F32 targetSpeed_ml_min ) +void setConcentratePumpTargetSpeed( CONCENTRATE_PUMPS_T pumpId, F32 targetSpeed_ml_min, F32 targetVolume_ml ) { if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) { @@ -466,22 +502,40 @@ targetSpeed_ml_min *= -1.0; } + //Update target revolution count + if ( targetVolume_ml > 0.0 ) + { +#ifndef __PUMPTEST__ + pumpTargetRevCnt[ pumpId ].data = (U32)( targetVolume_ml * CONCENTRATE_PUMP_VOLUME_TO_REVOLUTION ); +#else + pumpTargetRevCnt[ pumpId ].data = (U32)( targetVolume_ml * PISTON_PUMP_VOLUME_TO_REVOLUTION ); +#endif + if ( D11_PUMP == pumpId ) + { + setFPGAD11PumpRevolutionCount( getConcPumpTargetRevolutionCount( pumpId ) ); + } + else + { + setFPGAD10PumpRevolutionCount( getConcPumpTargetRevolutionCount( pumpId ) ); + } + } + /* - * If 0.1 <= speed <= 48 set it - * If speed < 0.1 set to 0 + * If 3.0 <= speed <= 48 set it + * If speed < 3.0 set to 0 * else speed > 48 set to 48 */ if ( ( CONCENTRATE_PUMP_MIN_SPEED <= targetSpeed_ml_min ) && ( targetSpeed_ml_min <= CONCENTRATE_PUMP_MAX_SPEED ) ) { - concentratePumps[ pumpId ].pumpTargetSpeed.data = targetSpeed_ml_min; + pumpTargetSpeed[ pumpId ].data = targetSpeed_ml_min; } else if ( targetSpeed_ml_min < CONCENTRATE_PUMP_MIN_SPEED ) { - concentratePumps[ pumpId ].pumpTargetSpeed.data = 0.0; + pumpTargetSpeed[ pumpId ].data = 0.0; } else { - concentratePumps[ pumpId ].pumpTargetSpeed.data = CONCENTRATE_PUMP_MAX_SPEED; + pumpTargetSpeed[ pumpId ].data = CONCENTRATE_PUMP_MAX_SPEED; } } else @@ -532,7 +586,7 @@ if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) { - speed = getF32OverrideValue( &concentratePumps[ pumpId ].pumpTargetSpeed ); + speed = getF32OverrideValue( &pumpTargetSpeed[ pumpId ] ); } else { @@ -561,7 +615,7 @@ if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) { - speed = getF32OverrideValue( &concentratePumps[ pumpId ].measuredPumpSpeed ); + speed = getF32OverrideValue( &measuredPumpSpeed[ pumpId ] ); speed = ( CONCENTRATE_PUMP_REVERSE_DIR == concentratePumps[ pumpId ].direction ? speed * -1.0F : speed ); } else @@ -589,7 +643,7 @@ if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) { - result = (BOOL)getU32OverrideValue( &concentratePumps[ pumpId ].hasParkBeenRequested ); + result = (BOOL)getU32OverrideValue( &hasParkBeenRequested[ pumpId ] ); } else { @@ -601,6 +655,58 @@ /*********************************************************************//** * @brief + * The getConcPumpTargetRevolutionCount function gets the concentrate pump + * target revolution count. + * @details \b Inputs: pumpTargetRevCnt + * @details \b Outputs: none + * @details \b Alarms: ALARM_ID_DD_SOFTWARE_FAULT when invalid pump ID is seen. + * @param pumpId concentrate pump id to get target revolution count + * @return the target revolution count for the given concentrate pump + *************************************************************************/ +U16 getConcPumpTargetRevolutionCount( CONCENTRATE_PUMPS_T pumpId ) +{ + BOOL result = FALSE; + + if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) + { + result = (U16)getU32OverrideValue( &pumpTargetRevCnt[ pumpId ] ); + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_CONCENTRATE_PUMP_INVALID_PUMP_ID, pumpId ); + } + + return result; +} + +/*********************************************************************//** + * @brief + * The getConcPumpCurrentMeasuredRevolutionCount function gets the concentrate pump + * current measured revolution count. + * @details \b Inputs: pumpMesauredRevCnt + * @details \b Outputs: none + * @details \b Alarms: ALARM_ID_DD_SOFTWARE_FAULT when invalid pump ID is seen. + * @param pumpId concentrate pump id to get current measured revolution count + * @return the current revolution count for the given concentrate pump + *************************************************************************/ +U16 getConcPumpCurrentMeasuredRevolutionCount( CONCENTRATE_PUMPS_T pumpId ) +{ + BOOL result = FALSE; + + if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) + { + result = (U16)getU32OverrideValue( &pumpMesauredRevCnt[ pumpId ] ); + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_CONCENTRATE_PUMP_INVALID_PUMP_ID, pumpId ); + } + + return result; +} + +/*********************************************************************//** + * @brief * The getConcPumpIsParked function gets the current parked state for a * given pump. * @details \b Inputs: parked @@ -615,7 +721,7 @@ if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) { - result = (BOOL)getU32OverrideValue( &concentratePumps[ pumpId ].parked ); + result = (BOOL)getU32OverrideValue( &parked[ pumpId ] ); } else { @@ -641,7 +747,7 @@ if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) { - result = (BOOL)getU32OverrideValue( &concentratePumps[ pumpId ].parkFaulted ); + result = (BOOL)getU32OverrideValue( &parkFaulted[ pumpId ] ); } else { @@ -664,34 +770,43 @@ { BOOL parkPump = getConcPumpParkRequest( pumpId ); - concentratePumps[ pumpId ].hasParkBeenRequested.data = FALSE; // reset park request for next time + hasParkBeenRequested[ pumpId ].data = FALSE; // reset park request for next time + concentratePumps[ pumpId ].hasTurnOnPumpsBeenRequested = FALSE; // Just to make sure pump is in Off state. concentratePumps[ pumpId ].currentPumpSpeed = 0.0F; // set target rate to zero + pumpTargetSpeed[ pumpId ].data = 0.0F; + pumpTargetRevCnt[ pumpId ].data = 0; + // Disable the motor when stopping, to take next revolution count // Send zero rate command to stop the pump - if ( CONCENTRATEPUMPS_CP1_ACID == pumpId ) + if ( D11_PUMP == pumpId ) { - setFPGAAcidPumpSetStepSpeed( CONCENTRATE_PUMP_ZERO_FLOW_RATE ); + setFPGAD11PumpSetStepSpeed( CONCENTRATE_PUMP_ZERO_FLOW_RATE ); + //concentratePumps[ D11_PUMP ].controlSet |= CONCENTRATE_PUMP_CONTROL_ENABLE_MASK; + //setFPGAD11PumpControl( concentratePumps[ D11_PUMP ].controlSet ); } else { - setFPGABicarbSetStepSpeed( CONCENTRATE_PUMP_ZERO_FLOW_RATE ); + setFPGAD10PumpSetStepSpeed( CONCENTRATE_PUMP_ZERO_FLOW_RATE ); + //concentratePumps[ D10_PUMP ].controlSet |= CONCENTRATE_PUMP_CONTROL_ENABLE_MASK; + //setFPGAD10PumpControl( concentratePumps[ D10_PUMP ].controlSet ); } - +#ifndef __PUMPTEST__ // Park concentrate pump too if requested if ( TRUE == parkPump ) { - if ( CONCENTRATEPUMPS_CP1_ACID == pumpId ) + if ( D11_PUMP == pumpId ) { - setFPGAAcidPumpParkCmd(); + setFPGAD11PumpParkCmd(); acidConcentratePumpParkPersistenceClear = TRUE; } else { - setFPGABicarbPumpParkCmd(); + setFPGAD10PumpParkCmd(); bicarbConcentratePumpParkPersistenceClear = TRUE; } concentratePumps[ pumpId ].isConcPumpParkInProgress = TRUE; } +#endif } /*********************************************************************//** @@ -711,13 +826,13 @@ { U08 controlSet = concentratePumps[ pumpId ].controlSet; - if ( CONCENTRATEPUMPS_CP1_ACID == pumpId ) + if ( D11_PUMP == pumpId ) { - setFPGAAcidPumpControl( controlSet ); + setFPGAD11PumpControl( controlSet ); } else { - setFPGABicarbPumpControl( controlSet ); + setFPGAD10PumpControl( controlSet ); } state = CONCENTRATE_PUMP_RAMP_TO_TARGET_SPEED_STATE; @@ -746,12 +861,14 @@ static CONCENTRATE_PUMP_STATE_T handleConcentratePumpRampToTargetSpeedState( CONCENTRATE_PUMPS_T pumpId ) { CONCENTRATE_PUMP_STATE_T state = CONCENTRATE_PUMP_RAMP_TO_TARGET_SPEED_STATE; + //U16 currentMeasuredRev = getConcPumpCurrentMeasuredRevolutionCount( pumpId ); if ( TRUE == stepConcentratePumpToTargetSpeed( pumpId ) ) { state = CONCENTRATE_PUMP_CONTROL_TARGET_SPEED_STATE; } + //Stop the pump if measured rev count reaches zero if ( FALSE == concentratePumps[ pumpId ].hasTurnOnPumpsBeenRequested ) { state = CONCENTRATE_PUMP_OFF_STATE; @@ -774,6 +891,7 @@ static CONCENTRATE_PUMP_STATE_T handleConcentratePumpControlTargetSpeedState( CONCENTRATE_PUMPS_T pumpId ) { CONCENTRATE_PUMP_STATE_T state = CONCENTRATE_PUMP_CONTROL_TARGET_SPEED_STATE; + //U16 currentMeasuredRev = getConcPumpCurrentMeasuredRevolutionCount( pumpId ); F32 targetToCurreSpeedDiffMLPM = fabs( getPumpTargetSpeed( pumpId ) - concentratePumps[ pumpId ].currentPumpSpeed ); if ( ++concentratePumps[ pumpId ].controlTimerCounter >= CONCENTRATE_PUMP_CONTROL_INTERVAL ) @@ -790,6 +908,7 @@ state = CONCENTRATE_PUMP_RAMP_TO_TARGET_SPEED_STATE; } + //Stop the pump if measured rev count reaches zero if ( FALSE == concentratePumps[ pumpId ].hasTurnOnPumpsBeenRequested ) { state = CONCENTRATE_PUMP_OFF_STATE; @@ -856,13 +975,13 @@ // Check if the control set bit is set as desired and if not, correct it checkConcentratePumpControlSet( pumpId ); - if ( CONCENTRATEPUMPS_CP1_ACID == pumpId ) + if ( D11_PUMP == pumpId ) { - setFPGAAcidPumpSetStepSpeed( concentratePumps[ pumpId ].togglePeriodCount ); + setFPGAD11PumpSetStepSpeed( concentratePumps[ pumpId ].togglePeriodCount ); } else { - setFPGABicarbSetStepSpeed( concentratePumps[ pumpId ].togglePeriodCount ); + setFPGAD10PumpSetStepSpeed( concentratePumps[ pumpId ].togglePeriodCount ); } return hasTgtBeenReached; @@ -893,12 +1012,12 @@ { switch ( pumpId ) { - case CONCENTRATEPUMPS_CP1_ACID: - pulseWidthCount = getFPGACPAHallSensePulseWidth(); + case D11_PUMP: + pulseWidthCount = getFPGAD11PumpHallSensePulseWidth(); break; - case CONCENTRATEPUMPS_CP2_BICARB: - pulseWidthCount = getFPGACPBHallSensePulseWidth(); + case D10_PUMP: + pulseWidthCount = getFPGAD10PumpHallSensePulseWidth(); break; #ifndef _VECTORCAST_ @@ -916,11 +1035,11 @@ // Determine measured speed for the pump if ( CONCENTRATE_PUMP_ZERO_FLOW_RATE == pulseWidthCount ) { - concentratePumps[ pumpId ].measuredPumpSpeed.data = 0.0F; + measuredPumpSpeed[ pumpId ].data = 0.0F; } else if ( FALSE == isPumpPulseWidthOut ) { - concentratePumps[ pumpId ].measuredPumpSpeed.data = ( US_PER_SECOND / pulseWidthInMicroSeconds ) * CONCENTRATE_PUMP_VOLUME_PER_PULSE * SEC_PER_MIN; + measuredPumpSpeed[ pumpId ].data = ( US_PER_SECOND / pulseWidthInMicroSeconds ) * CONCENTRATE_PUMP_VOLUME_PER_PULSE * SEC_PER_MIN; } // If pulse width is out of range capture pump out of range, pumpId and pulse width @@ -942,9 +1061,9 @@ * triggers the alarms if they are out of range. * @details \b Inputs: concentratePumps * @details \b Outputs: none - * @details \b Alarm: ALARM_ID_DD_CP1_SPEED_CONTROL_ERROR when the speed difference + * @details \b Alarm: ALARM_ID_DD_D11_PUMP_SPEED_CONTROL_ERROR when the speed difference * between requested and measured is not in range. - * @details \b Alarm: ALARM_ID_DD_CP2_SPEED_CONTROL_ERROR when the speed difference + * @details \b Alarm: ALARM_ID_DD_D10_PUMP_SPEED_CONTROL_ERROR when the speed difference * between requested and measured is not in range. * @param pumpId pump id to check the difference between requested and measured speed * @param alarm which the corresponding alarm of the concentrate pump @@ -987,21 +1106,21 @@ switch ( pumpId ) { - case CONCENTRATEPUMPS_CP1_ACID: - controlSetBits = getFPGAAcidPumpControlStatus(); + case D11_PUMP: + controlSetBits = getFPGAD11PumpControlStatus(); if ( controlSetBits != concentratePumps[ pumpId ].controlSet ) { - setFPGAAcidPumpControl( concentratePumps[ pumpId ].controlSet ); + setFPGAD11PumpControl( concentratePumps[ pumpId ].controlSet ); } break; - case CONCENTRATEPUMPS_CP2_BICARB: - controlSetBits = getFPGABicarbPumpControlStatus(); + case D10_PUMP: + controlSetBits = getFPGAD10PumpControlStatus(); if ( controlSetBits != concentratePumps[ pumpId ].controlSet ) { - setFPGABicarbPumpControl( concentratePumps[ pumpId ].controlSet ); + setFPGAD10PumpControl( concentratePumps[ pumpId ].controlSet ); } break; @@ -1026,28 +1145,32 @@ { CONCENTRATE_PUMP_DATA_T data; - U08 cp1Direction = concentratePumps[ CONCENTRATEPUMPS_CP1_ACID ].direction; - F32 cp1SetSpeed = concentratePumps[ CONCENTRATEPUMPS_CP1_ACID ].currentPumpSpeed; - F32 cp1TgtSpeed = getPumpTargetSpeed( CONCENTRATEPUMPS_CP1_ACID ); - U08 cp2Direction = concentratePumps[ CONCENTRATEPUMPS_CP2_BICARB ].direction; - F32 cp2SetSpeed = concentratePumps[ CONCENTRATEPUMPS_CP2_BICARB ].currentPumpSpeed; - F32 cp2TgtSpeed = getPumpTargetSpeed( CONCENTRATEPUMPS_CP2_BICARB ); + U08 d11_PumpDirection = concentratePumps[ D11_PUMP ].direction; + F32 d11_PumpSetSpeed = concentratePumps[ D11_PUMP ].currentPumpSpeed; + F32 d11_PumpTgtSpeed = getPumpTargetSpeed( D11_PUMP ); + U08 d10_PumpDirection = concentratePumps[ D10_PUMP ].direction; + F32 d10_PumpSetSpeed = concentratePumps[ D10_PUMP ].currentPumpSpeed; + F32 d10_PumpTgtSpeed = getPumpTargetSpeed( D10_PUMP ); // Use the above values to prepare the broadcast data - data.cp1CurrentSetSpeed = ( CONCENTRATE_PUMP_REVERSE_DIR == cp1Direction ? cp1SetSpeed * -1.0F : cp1SetSpeed ); - data.cp1MeasuredSpeed = getMeasuredPumpSpeedMLPM( CONCENTRATEPUMPS_CP1_ACID ); - data.cp1TargetSpeed = ( CONCENTRATE_PUMP_REVERSE_DIR == cp1Direction ? cp1TgtSpeed * -1.0F : cp1TgtSpeed ); - data.cp2CurrentSetSpeed = ( CONCENTRATE_PUMP_REVERSE_DIR == cp2Direction ? cp2SetSpeed * -1.0F : cp2SetSpeed ); - data.cp2MeasuredSpeed = getMeasuredPumpSpeedMLPM( CONCENTRATEPUMPS_CP2_BICARB ); - data.cp2TargetSpeed = ( CONCENTRATE_PUMP_REVERSE_DIR == cp2Direction ? cp2TgtSpeed * -1.0F : cp2TgtSpeed ); - data.cp1State = concentratePumps[ CONCENTRATEPUMPS_CP1_ACID ].execState; - data.cp2State = concentratePumps[ CONCENTRATEPUMPS_CP2_BICARB ].execState; - data.cp1PulseUS = concentratePumps[ CONCENTRATEPUMPS_CP1_ACID ].pulseWidthUS; - data.cp2PulseUS = concentratePumps[ CONCENTRATEPUMPS_CP2_BICARB ].pulseWidthUS; - data.cp1Parked = getConcPumpIsParked( CONCENTRATEPUMPS_CP1_ACID ); - data.cp2Parked = getConcPumpIsParked( CONCENTRATEPUMPS_CP2_BICARB ); - data.cp1ParkFault = getConcPumpParkIsFaulted( CONCENTRATEPUMPS_CP1_ACID ); - data.cp2ParkFault = getConcPumpParkIsFaulted( CONCENTRATEPUMPS_CP2_BICARB ); + data.d11_PumpCurrentSetSpeed = ( CONCENTRATE_PUMP_REVERSE_DIR == d11_PumpDirection ? d11_PumpSetSpeed * -1.0F : d11_PumpSetSpeed ); + data.d11_PumpMeasuredSpeed = getMeasuredPumpSpeedMLPM( D11_PUMP ); + data.d11_PumpTargetSpeed = ( CONCENTRATE_PUMP_REVERSE_DIR == d11_PumpDirection ? d11_PumpTgtSpeed * -1.0F : d11_PumpTgtSpeed ); + data.d10_PumpCurrentSetSpeed = ( CONCENTRATE_PUMP_REVERSE_DIR == d10_PumpDirection ? d10_PumpSetSpeed * -1.0F : d10_PumpSetSpeed ); + data.d10_PumpMeasuredSpeed = getMeasuredPumpSpeedMLPM( D10_PUMP ); + data.d10_PumpTargetSpeed = ( CONCENTRATE_PUMP_REVERSE_DIR == d10_PumpDirection ? d10_PumpTgtSpeed * -1.0F : d10_PumpTgtSpeed ); + data.d11_PumpTargetRevCount = (U32)getConcPumpTargetRevolutionCount( D11_PUMP ); + data.d11_PumpMeasuredRevCount= getFPGAD11PumpRevolutionCountStatus(); + data.d10_PumpTargetRevCount = (U32)getConcPumpTargetRevolutionCount( D10_PUMP ); + data.d11_PumpMeasuredRevCount= getFPGAD10PumpRevolutionCountStatus(); + data.d11_PumpState = concentratePumps[ D11_PUMP ].execState; + data.d10_PumpState = concentratePumps[ D10_PUMP ].execState; + data.d11_PumpPulseUS = concentratePumps[ D11_PUMP ].pulseWidthUS; + data.d10_PumpPulseUS = concentratePumps[ D10_PUMP ].pulseWidthUS; + data.d11_PumpParked = getConcPumpIsParked( D11_PUMP ); + data.d10_PumpParked = getConcPumpIsParked( D10_PUMP ); + data.d11_PumpParkFault = getConcPumpParkIsFaulted( D11_PUMP ); + data.d10_PumpParkFault = getConcPumpParkIsFaulted( D10_PUMP ); concentratePumpMonitorTimerCounter = 0; broadcastData( MSG_ID_DD_CONCENTRATE_PUMP_DATA, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&data, sizeof( CONCENTRATE_PUMP_DATA_T ) ); @@ -1090,7 +1213,7 @@ *************************************************************************/ BOOL testConcentratePumpTargetSpeedOverride( MESSAGE_T *message ) { - BOOL result = f32ArrayOverride( message, &concentratePumps[0].pumpTargetSpeed, NUM_OF_CONCENTRATE_PUMPS - 1 ); + BOOL result = f32ArrayOverride( message, &pumpTargetSpeed[ 0 ], NUM_OF_CONCENTRATE_PUMPS - 1 ); return result; } @@ -1107,7 +1230,7 @@ *************************************************************************/ BOOL testConcentratePumpMeasuredSpeedOverride( MESSAGE_T *message ) { - BOOL result = f32ArrayOverride( message, &concentratePumps[0].measuredPumpSpeed, NUM_OF_CONCENTRATE_PUMPS - 1 ); + BOOL result = f32ArrayOverride( message, &measuredPumpSpeed[ 0 ], NUM_OF_CONCENTRATE_PUMPS - 1 ); return result; } @@ -1124,13 +1247,30 @@ *************************************************************************/ BOOL testConcentratePumpParkedOverride( MESSAGE_T *message ) { - BOOL result = u32ArrayOverride( message, &concentratePumps[0].parked, NUM_OF_CONCENTRATE_PUMPS - 1, FALSE, TRUE ); + BOOL result = u32ArrayOverride( message, &parked[ 0 ], NUM_OF_CONCENTRATE_PUMPS - 1, FALSE, TRUE ); return result; } /*********************************************************************//** * @brief + * The testConcentratePumpTargetRevCountOverride function overrides the + * target revolution count of given concentrate pump id. + * @details \b Inputs: none + * @details \b Outputs: pumpTargetRevCnt + * @param message Override message from Dialin which includes an ID of + * the pump to override and the target revolution count of the pump to. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testConcentratePumpTargetRevCountOverride( MESSAGE_T *message ) +{ + BOOL result = u32ArrayOverride( message, &pumpTargetRevCnt[ 0 ], NUM_OF_CONCENTRATE_PUMPS - 1, 0, 65535 ); + + return result; +} + +/*********************************************************************//** + * @brief * The testConcentratePumpParkCmdFaultedOverride function overrides the * park command fault status of given concentrate pump id. * @details \b Inputs: none @@ -1141,7 +1281,7 @@ *************************************************************************/ BOOL testConcentratePumpParkCmdFaultedOverride( MESSAGE_T *message ) { - BOOL result = u32ArrayOverride( message, &concentratePumps[0].parkFaulted, NUM_OF_CONCENTRATE_PUMPS - 1, FALSE, TRUE ); + BOOL result = u32ArrayOverride( message, &parkFaulted[ 0 ], NUM_OF_CONCENTRATE_PUMPS - 1, FALSE, TRUE ); return result; } @@ -1174,17 +1314,20 @@ { // Handle start command if ( ( TRUE == payload.startStop ) && - ( ( payload.speed >= CONCENTRATE_PUMP_MIN_SPEED ) && ( payload.speed <= CONCENTRATE_PUMP_MAX_SPEED ) ) ) +#ifndef __PUMPTEST__ + ( ( payload.speed >= CONCENTRATE_PUMP_MIN_SPEED ) && ( payload.speed <= CONCENTRATE_PUMP_MAX_SPEED ) ) && +#endif + ( payload.volume > 0.0 ) ) { - setConcentratePumpTargetSpeed( (CONCENTRATE_PUMPS_T)payload.pumpID, payload.speed ); + setConcentratePumpTargetSpeed( (CONCENTRATE_PUMPS_T)payload.pumpID, payload.speed, payload.volume ); requestConcentratePumpOn ( (CONCENTRATE_PUMPS_T)payload.pumpID ); result = TRUE; } //Handle stop command if ( FALSE == payload.startStop ) { - stopConcentratePump( (CONCENTRATE_PUMPS_T)payload.pumpID ); + requestConcentratePumpOff( (CONCENTRATE_PUMPS_T)payload.pumpID, FALSE ); result = TRUE; } } @@ -1222,10 +1365,10 @@ { U32 value = override.state.u32; - concentratePumps[ pumpId ].hasParkBeenRequested.ovData = value; - concentratePumps[ pumpId ].hasParkBeenRequested.override = OVERRIDE_KEY; + hasParkBeenRequested[ pumpId ].ovData = value; + hasParkBeenRequested[ pumpId ].override = OVERRIDE_KEY; - if ( TRUE == concentratePumps[ pumpId ].hasParkBeenRequested.ovData ) + if ( TRUE == hasParkBeenRequested[ pumpId ].ovData ) { // If pump is running, stop it w/ park option if ( TRUE == concentratePumps[ pumpId ].hasTurnOnPumpsBeenRequested ) @@ -1241,8 +1384,8 @@ } else { - concentratePumps[ pumpId ].hasParkBeenRequested.override = OVERRIDE_RESET; - concentratePumps[ pumpId ].hasParkBeenRequested.ovData = concentratePumps[ pumpId ].hasParkBeenRequested.ovInitData; + hasParkBeenRequested[ pumpId ].override = OVERRIDE_RESET; + hasParkBeenRequested[ pumpId ].ovData = hasParkBeenRequested[ pumpId ].ovInitData; } result = TRUE; Index: firmware/App/Controllers/ConcentratePumps.h =================================================================== diff -u -rb6d20d9e5c704a9f7ebceea9bb12731dac61fc2a -red39129abdca4ec343369d83494530b23621e052 --- firmware/App/Controllers/ConcentratePumps.h (.../ConcentratePumps.h) (revision b6d20d9e5c704a9f7ebceea9bb12731dac61fc2a) +++ firmware/App/Controllers/ConcentratePumps.h (.../ConcentratePumps.h) (revision ed39129abdca4ec343369d83494530b23621e052) @@ -31,37 +31,41 @@ // ********** public definitions ********** -#define CONCENTRATE_PUMP_MAX_SPEED 48.0F ///< Maximum speed for concentrate pump in mL/min +#define CONCENTRATE_PUMP_MAX_SPEED 48.0F ///< Maximum speed for concentrate pump in mL/min -#define PARK_CONC_PUMPS TRUE ///< For park parameter to requestConcentratePumpOff(). -#define NO_PARK_CONC_PUMPS FALSE ///< For park parameter to requestConcentratePumpOff(). +#define PARK_CONC_PUMPS TRUE ///< For park parameter to requestConcentratePumpOff(). +#define NO_PARK_CONC_PUMPS FALSE ///< For park parameter to requestConcentratePumpOff(). /// Enumeration of concentrate pumps. typedef enum ConcentratePumps { - CONCENTRATEPUMPS_CP1_ACID = 0, ///< Acid concentrate pump - CONCENTRATEPUMPS_FIRST = CONCENTRATEPUMPS_CP1_ACID, ///< First concentrate pump in list - CONCENTRATEPUMPS_CP2_BICARB, ///< Bicarbonate concentrate pump - NUM_OF_CONCENTRATE_PUMPS ///< Number of concentrate pumps + D11_PUMP = 0, ///< Acid concentrate pump + CONCENTRATEPUMPS_FIRST = D11_PUMP, ///< First concentrate pump in list + D10_PUMP, ///< Bicarbonate concentrate pump + NUM_OF_CONCENTRATE_PUMPS ///< Number of concentrate pumps } CONCENTRATE_PUMPS_T; /// Concentrate pump data struct. typedef struct { - F32 cp1CurrentSetSpeed; ///< Concentrate pump CP1 current set speed - F32 cp1MeasuredSpeed; ///< Concentrate pump CP1 measured speed - F32 cp2CurrentSetSpeed; ///< Concentrate pump CP2 current set speed - F32 cp2MeasuredSpeed; ///< Concentrate pump CP2 measured speed - U32 cp1State; ///< Concentrate pump CP1 current state - U32 cp2State; ///< Concentrate pump CP2 current state - F32 cp1PulseUS; ///< Concentrate pump CP1 pulse in microseconds - F32 cp2PulseUS; ///< Concentrate pump CP2 pulse in microseconds - F32 cp1TargetSpeed; ///< Concentrate pump CP1 target speed - F32 cp2TargetSpeed; ///< Concentrate pump CP2 target speed - BOOL cp1Parked; ///< Concentrate pump CP1 parked status - BOOL cp2Parked; ///< Concentrate pump CP2 parked status - BOOL cp1ParkFault; ///< Concentrate pump CP1 park fault status - BOOL cp2ParkFault; ///< Concentrate pump CP2 park fault status + F32 d11_PumpCurrentSetSpeed; ///< Concentrate pump D11_Pump current set speed + F32 d11_PumpMeasuredSpeed; ///< Concentrate pump D11_Pump measured speed + F32 d10_PumpCurrentSetSpeed; ///< Concentrate pump D10_Pump current set speed + F32 d10_PumpMeasuredSpeed; ///< Concentrate pump D10_Pump measured speed + U32 d11_PumpTargetRevCount; ///< Concentrate pump D11_Pump target revolution count + U32 d11_PumpMeasuredRevCount; ///< Concentrate pump D11_Pump measured revolution count + U32 d10_PumpTargetRevCount; ///< Concentrate pump D10_Pump target revolution count + U32 d10_PumpMeasuredRevCount; ///< Concentrate pump D10_Pump measured revolution count + U32 d11_PumpState; ///< Concentrate pump D11_Pump current state + U32 d10_PumpState; ///< Concentrate pump D10_Pump current state + F32 d11_PumpPulseUS; ///< Concentrate pump D11_Pump pulse in microseconds + F32 d10_PumpPulseUS; ///< Concentrate pump D10_Pump pulse in microseconds + F32 d11_PumpTargetSpeed; ///< Concentrate pump D11_Pump target speed + F32 d10_PumpTargetSpeed; ///< Concentrate pump D10_Pump target speed + BOOL d11_PumpParked; ///< Concentrate pump D11_Pump parked status + BOOL d10_PumpParked; ///< Concentrate pump D10_Pump parked status + BOOL d11_PumpParkFault; ///< Concentrate pump D11_Pump park fault status + BOOL d10_PumpParkFault; ///< Concentrate pump D10_Pump park fault status } CONCENTRATE_PUMP_DATA_T; // ********** public function prototypes ********** @@ -75,13 +79,15 @@ void requestConcentratePumpOn( CONCENTRATE_PUMPS_T pumpId ); void requestConcentratePumpOff( CONCENTRATE_PUMPS_T pumpId, BOOL park ); -void setConcentratePumpTargetSpeed( CONCENTRATE_PUMPS_T pumpId, F32 targetSpeed_ml_min ); +void setConcentratePumpTargetSpeed( CONCENTRATE_PUMPS_T pumpId, F32 targetSpeed_ml_min, F32 targetVolume_ml ); F32 getConcentratePumpTargetFlowMLPM( CONCENTRATE_PUMPS_T pumpId ); F32 getMeasuredPumpSpeedMLPM( CONCENTRATE_PUMPS_T pumpId ); F32 getPumpTargetSpeed( CONCENTRATE_PUMPS_T pumpId ); BOOL getConcPumpParkRequest( CONCENTRATE_PUMPS_T pumpId ); BOOL getConcPumpIsParked( CONCENTRATE_PUMPS_T pumpId ); BOOL getConcPumpParkIsFaulted( CONCENTRATE_PUMPS_T pumpId ); +U16 getConcPumpTargetRevolutionCount( CONCENTRATE_PUMPS_T pumpId ); +U16 getConcPumpCurrentMeasuredRevolutionCount( CONCENTRATE_PUMPS_T pumpId ); BOOL handleConcentratePumpParkRequest( void ); BOOL isConcPumpParkInProgress( CONCENTRATE_PUMPS_T pumpId ); @@ -90,6 +96,7 @@ BOOL testConcentratePumpMeasuredSpeedOverride( MESSAGE_T *message ); BOOL testConcentratePumpParkedOverride( MESSAGE_T *message ); BOOL testConcentratePumpParkCmdFaultedOverride( MESSAGE_T *message ); +BOOL testConcentratePumpTargetRevCountOverride( MESSAGE_T *message ); BOOL testConcentratePumpStartStopOverride( MESSAGE_T *message ); // Concentrate pump start/stop request BOOL testConcentratePumpParkRequestOverride( MESSAGE_T *message ); // Concentrate pump stop/park request Index: firmware/App/Controllers/DialysatePumps.c =================================================================== diff -u -rb6d20d9e5c704a9f7ebceea9bb12731dac61fc2a -red39129abdca4ec343369d83494530b23621e052 --- firmware/App/Controllers/DialysatePumps.c (.../DialysatePumps.c) (revision b6d20d9e5c704a9f7ebceea9bb12731dac61fc2a) +++ firmware/App/Controllers/DialysatePumps.c (.../DialysatePumps.c) (revision ed39129abdca4ec343369d83494530b23621e052) @@ -43,10 +43,11 @@ #define DATA_PUBLISH_COUNTER_START_COUNT 60 ///< Data publish counter start count. #define DP_CONTROL_INTERVAL ( 1000 / TASK_GENERAL_INTERVAL ) ///< Interval (ms/task time) at which the dialysate pump is controlled. +//#define DP_CONTROL_INTERVAL ( 250 / TASK_GENERAL_INTERVAL ) ///< Interval (ms/task time) at which the dialysate pump is controlled. #define DIALYSATE_PUMP_CONTROL_RUN 0x01 ///< Dialysate pump control run pump. #define DIALYSATE_PUMP_CONTROL_STOP 0x00 ///< Dialysate pump control stop pump. #define DIALYSATE_PUMP_FORWARD_DIR 1 ///< Dialysate pump forward direction. reverse direction is not allowed. -#define DIALYSATE_PUMP_SPEED_INCREMENT 5.0F ///< Speed increase when controlling dialysate pump to target step speed. +#define DIALYSATE_PUMP_SPEED_INCREMENT 10.0F ///< Speed increase when controlling dialysate pump to target step speed. #define ZERO_SPEED 0.0F ///< Zero speed/RPM value. #define DIALYSATE_PUMP_MAX_CURRENT_WHEN_OFF_A 0.1F ///< Dialysate pump maximum current when the pump is off in amps. @@ -67,11 +68,13 @@ #define DIALYSATE_PUMP_MIN_PRESSURE_PSI 0.0F ///< Minimum dialysate pump pressure in psi. #define DIALYSATE_PUMP_MAX_PRESSURE_PSI 40.0F ///< Maximum dialysate pump pressure in psi. #define DIALYSATE_PUMP_SPEED_ZERO_RPM 0 ///< Dialysate pump zero RPM speed. +#define SPEED_COUNT_ZERO 0 ///< Measured speed count zero check. +#define SPEED_CONV_FACTOR 1500000 ///< Measured speed count conversion to RPM -#define FRESH_DIALYSATE_PUMP_P_COEFFICIENT 1.0F ///< P term for fresh dialysate pump delta pressure control. -#define FRESH_DIALYSATE_PUMP_I_COEFFICIENT 0.0F ///< I term for fresh dialysate pump delta pressure control. -#define SPENT_DIALYSATE_PUMP_P_COEFFICIENT 1.0F ///< P term for spent dialysate pump delta pressure control. -#define SPENT_DIALYSATE_PUMP_I_COEFFICIENT 0.0F ///< I term for spent dialysate pump delta pressure control. +#define D12_PUMP_P_COEFFICIENT 1.0F ///< P term for fresh dialysate pump delta pressure control. +#define D12_PUMP_I_COEFFICIENT 0.0F ///< I term for fresh dialysate pump delta pressure control. +#define D48_PUMP_P_COEFFICIENT 1.0F ///< P term for spent dialysate pump delta pressure control. +#define D48_PUMP_I_COEFFICIENT 0.0F ///< I term for spent dialysate pump delta pressure control. #define MAX_ALLOWED_RPM_OUT_OF_RANGE 300 ///< Maximum allowed RPM out of range from target RPM in open loop. #define PUMP_TRANS_TO_RAMP_SPEED_THRESHOLD 20.0F ///< Speed change that alters the state to ramp during control state. @@ -102,15 +105,10 @@ U32 controlTimerCounter; ///< Timer counter to perform control on dialysate pump. DIALYSATE_PUMP_STATE_T dialysatePumpState; ///< Current state of dialysate pump controller state machine. BOOL isDialPumpOn; ///< Flag indicates dialysate pump On or Off state - OVERRIDE_F32_T pumpTargetSpeed; ///< Target dialysate pumps' speed (mL/min).forward direction only, hence positive speed. F32 prevPumpTargetSpeed; ///< Previous target dialysate pumps' speed (mL/min). F32 currentPumpSpeed; ///< Current controlled dialysate pumps' speed (mL/min). - OVERRIDE_F32_T measuredPumpSpeed; ///< Measured dialysate pump speed (mL/min). - OVERRIDE_F32_T dialysatePumpMeasuredCurrentA; ///< Measured dialysate pump current feedback. - OVERRIDE_U32_T measuredDirection; ///< Measured dialysate pump direction. U32 directionErrorCount; ///< dialysate pump direction error count from power up. U32 lastDirectionErrorCount; ///< last dialysate pump direction error count from power up. - OVERRIDE_F32_T pumpTargetPressure; ///< Target dialysate pumps' pressure (PSI). U08 control; ///< Dialysate pump control } DIALYSATE_PUMP_DATA_T; @@ -131,6 +129,11 @@ //static DD_DIALYSATE_PUMP_CAL_RECORD_T dialysatePumpCalRecord; ///< Dialysate pump calibration record. static DIALYSATE_PUMP_DATA_T dialysatePumps[ NUM_OF_DIALYSATE_PUMPS ]; ///< Array of dialysate pumps data structure. +static OVERRIDE_F32_T pumpTargetSpeed[ NUM_OF_DIALYSATE_PUMPS ]; ///< Target dialysate pumps' speed (mL/min).forward direction only, hence positive speed. +static OVERRIDE_F32_T measuredPumpSpeed[ NUM_OF_DIALYSATE_PUMPS ]; ///< Measured dialysate pump speed (mL/min). +static OVERRIDE_F32_T dialysatePumpMeasuredCurrentA[ NUM_OF_DIALYSATE_PUMPS ]; ///< Measured dialysate pump current feedback. +static OVERRIDE_U32_T measuredDirection[ NUM_OF_DIALYSATE_PUMPS ]; ///< Measured dialysate pump direction. +static OVERRIDE_F32_T pumpTargetPressure[ NUM_OF_DIALYSATE_PUMPS ]; ///< Target dialysate pumps' pressure (PSI). //TODO : Validate once HDD defines the conversion. static const F32 CURRENT_CONVERSION_COEFF = (F32)( 2.5F / ( BITS_12_FULL_SCALE - 1.0F ) ); @@ -159,66 +162,71 @@ for ( pumpId = DIALYSATE_PUMPS_FIRST; pumpId < NUM_OF_DIALYSATE_PUMPS; pumpId++ ) { - dialysatePumps[ pumpId ].controlTimerCounter = 0; - dialysatePumps[ pumpId ].dialysatePumpState = DIALYSATE_PUMP_OFF_STATE; - dialysatePumps[ pumpId ].isDialPumpOn = FALSE; - dialysatePumps[ pumpId ].measuredPumpSpeed.data = 0.0F; - dialysatePumps[ pumpId ].measuredPumpSpeed.ovInitData = 0.0F; - dialysatePumps[ pumpId ].measuredPumpSpeed.override = OVERRIDE_RESET; - dialysatePumps[ pumpId ].measuredPumpSpeed.ovData = 0.0F; - dialysatePumps[ pumpId ].pumpTargetSpeed.data = 0.0F; - dialysatePumps[ pumpId ].pumpTargetSpeed.ovInitData = 0.0F; - dialysatePumps[ pumpId ].pumpTargetSpeed.override = OVERRIDE_RESET; - dialysatePumps[ pumpId ].pumpTargetSpeed.ovData = 0.0F; - dialysatePumps[ pumpId ].measuredDirection.data = DIALYSATE_PUMP_FORWARD_DIR; - dialysatePumps[ pumpId ].measuredDirection.ovInitData = DIALYSATE_PUMP_FORWARD_DIR; - dialysatePumps[ pumpId ].measuredDirection.ovData = DIALYSATE_PUMP_FORWARD_DIR; - dialysatePumps[ pumpId ].measuredDirection.override = OVERRIDE_RESET; - dialysatePumps[ pumpId ].dialysatePumpMeasuredCurrentA.data = 0.0F; - dialysatePumps[ pumpId ].dialysatePumpMeasuredCurrentA.ovInitData = 0.0F; - dialysatePumps[ pumpId ].dialysatePumpMeasuredCurrentA.ovData = 0.0F; - dialysatePumps[ pumpId ].dialysatePumpMeasuredCurrentA.override = OVERRIDE_RESET; - dialysatePumps[ pumpId ].currentPumpSpeed = 0.0F; - dialysatePumps[ pumpId ].prevPumpTargetSpeed = 0.0F; - dialysatePumps[ pumpId ].control = DIALYSATE_PUMP_CONTROL_STOP; - dialysatePumps[ pumpId ].directionErrorCount = 0; - dialysatePumps[ pumpId ].lastDirectionErrorCount = 0; + dialysatePumps[ pumpId ].controlTimerCounter = 0; + dialysatePumps[ pumpId ].dialysatePumpState = DIALYSATE_PUMP_OFF_STATE; + dialysatePumps[ pumpId ].isDialPumpOn = FALSE; + measuredPumpSpeed[ pumpId ].data = 0.0F; + measuredPumpSpeed[ pumpId ].ovInitData = 0.0F; + measuredPumpSpeed[ pumpId ].override = OVERRIDE_RESET; + measuredPumpSpeed[ pumpId ].ovData = 0.0F; + pumpTargetSpeed[ pumpId ].data = 0.0F; + pumpTargetSpeed[ pumpId ].ovInitData = 0.0F; + pumpTargetSpeed[ pumpId ].override = OVERRIDE_RESET; + pumpTargetSpeed[ pumpId ].ovData = 0.0F; + measuredDirection[ pumpId ].data = DIALYSATE_PUMP_FORWARD_DIR; + measuredDirection[ pumpId ].ovInitData = DIALYSATE_PUMP_FORWARD_DIR; + measuredDirection[ pumpId ].ovData = DIALYSATE_PUMP_FORWARD_DIR; + measuredDirection[ pumpId ].override = OVERRIDE_RESET; + dialysatePumpMeasuredCurrentA[ pumpId ].data = 0.0F; + dialysatePumpMeasuredCurrentA[ pumpId ].ovInitData = 0.0F; + dialysatePumpMeasuredCurrentA[ pumpId ].ovData = 0.0F; + dialysatePumpMeasuredCurrentA[ pumpId ].override = OVERRIDE_RESET; + dialysatePumps[ pumpId ].currentPumpSpeed = MIN_DIALYSATE_PUMP_RPM; + dialysatePumps[ pumpId ].prevPumpTargetSpeed = 0.0F; + dialysatePumps[ pumpId ].control = DIALYSATE_PUMP_CONTROL_STOP; + dialysatePumps[ pumpId ].directionErrorCount = 0; + dialysatePumps[ pumpId ].lastDirectionErrorCount = 0; signalDialysatePumpHardStop( pumpId ); } - dialysatePumps[FRESH_DIALYSATE_PUMP].pumpTargetPressure.data = FRESH_DIALYSATE_TARGET_PRESSURE_PSI; - dialysatePumps[FRESH_DIALYSATE_PUMP].pumpTargetPressure.ovInitData = FRESH_DIALYSATE_TARGET_PRESSURE_PSI; - dialysatePumps[FRESH_DIALYSATE_PUMP].pumpTargetPressure.ovData = 0.0F; - dialysatePumps[FRESH_DIALYSATE_PUMP].pumpTargetPressure.override = OVERRIDE_RESET; + pumpTargetPressure[D12_PUMP].data = FRESH_DIALYSATE_TARGET_PRESSURE_PSI; + pumpTargetPressure[D12_PUMP].ovInitData = FRESH_DIALYSATE_TARGET_PRESSURE_PSI; + pumpTargetPressure[D12_PUMP].ovData = 0.0F; + pumpTargetPressure[D12_PUMP].override = OVERRIDE_RESET; - dialysatePumps[SPENT_DIALYSATE_PUMP].pumpTargetPressure.data = SPENT_DIALYSATE_TARGET_PRESSURE_PSI; - dialysatePumps[SPENT_DIALYSATE_PUMP].pumpTargetPressure.ovInitData = SPENT_DIALYSATE_TARGET_PRESSURE_PSI; - dialysatePumps[SPENT_DIALYSATE_PUMP].pumpTargetPressure.ovData = 0.0F; - dialysatePumps[SPENT_DIALYSATE_PUMP].pumpTargetPressure.override = OVERRIDE_RESET; + pumpTargetPressure[D48_PUMP].data = SPENT_DIALYSATE_TARGET_PRESSURE_PSI; + pumpTargetPressure[D48_PUMP].ovInitData = SPENT_DIALYSATE_TARGET_PRESSURE_PSI; + pumpTargetPressure[D48_PUMP].ovData = 0.0F; + pumpTargetPressure[D48_PUMP].override = OVERRIDE_RESET; // Initialize the fresh dialysate pump PI controller - initializePIController( PI_CONTROLLER_ID_FRESH_DIALYSATE_PUMP, DIALYSATE_PUMP_MIN_PRESSURE_PSI, FRESH_DIALYSATE_PUMP_P_COEFFICIENT, FRESH_DIALYSATE_PUMP_I_COEFFICIENT, + initializePIController( PI_CONTROLLER_ID_D12_PUMP, DIALYSATE_PUMP_MIN_PRESSURE_PSI, D12_PUMP_P_COEFFICIENT, D12_PUMP_I_COEFFICIENT, DIALYSATE_PUMP_MIN_PRESSURE_PSI, DIALYSATE_PUMP_MAX_PRESSURE_PSI ); // Initialize spent dialysate pump PI controller - initializePIController( PI_CONTROLLER_ID_SPENT_DIALYSATE_PUMP, DIALYSATE_PUMP_MIN_PRESSURE_PSI, SPENT_DIALYSATE_PUMP_P_COEFFICIENT, SPENT_DIALYSATE_PUMP_I_COEFFICIENT, + initializePIController( PI_CONTROLLER_ID_D48_PUMP, DIALYSATE_PUMP_MIN_PRESSURE_PSI, D48_PUMP_P_COEFFICIENT, D48_PUMP_I_COEFFICIENT, DIALYSATE_PUMP_MIN_PRESSURE_PSI, DIALYSATE_PUMP_MAX_PRESSURE_PSI ); + // Init the dialysate pump with valid PWM while motor is disabled. + // when enable triggers, we dont want invlid RPM set that triggers alarm in motor controller. + setFPGAD12PumpSpeed( MIN_DIALYSATE_PUMP_RPM ); + setFPGAD48PumpSpeed( MIN_DIALYSATE_PUMP_RPM ); + // Initialize the persistent alarms for fresh dialysate pump - initPersistentAlarm( ALARM_ID_DD_FRESH_DIALYSATE_PUMP_RPM_OUT_OF_RANGE, RPM_OUT_OF_RANGE_TIME_OUT, RPM_OUT_OF_RANGE_TIME_OUT ); - initPersistentAlarm( ALARM_ID_DD_FRESH_DIALYSATE_PUMP_OFF_FAULT, SAFETY_SHUTDOWN_TIMEOUT, SAFETY_SHUTDOWN_TIMEOUT ); - initPersistentAlarm( ALARM_ID_DD_FRESH_DIALYSATE_PUMP_CURRENT_OUT_OF_RANGE, DIALYSATE_PUMP_CURRENT_OUT_OF_RANGE_TIMEOUT_MS, DIALYSATE_PUMP_CURRENT_OUT_OF_RANGE_TIMEOUT_MS ); - initPersistentAlarm( ALARM_ID_DD_FRESH_DIALYSATE_PUMP_DIRECTION_INVALID, DIALYSATE_PUMP_DIR_OF_RANGE_TIMEOUT_MS, DIALYSATE_PUMP_DIR_OF_RANGE_TIMEOUT_MS ); + initPersistentAlarm( ALARM_ID_DD_D12_PUMP_RPM_OUT_OF_RANGE, RPM_OUT_OF_RANGE_TIME_OUT, RPM_OUT_OF_RANGE_TIME_OUT ); + initPersistentAlarm( ALARM_ID_DD_D12_PUMP_OFF_FAULT, SAFETY_SHUTDOWN_TIMEOUT, SAFETY_SHUTDOWN_TIMEOUT ); + initPersistentAlarm( ALARM_ID_DD_D12_PUMP_CURRENT_OUT_OF_RANGE, DIALYSATE_PUMP_CURRENT_OUT_OF_RANGE_TIMEOUT_MS, DIALYSATE_PUMP_CURRENT_OUT_OF_RANGE_TIMEOUT_MS ); + initPersistentAlarm( ALARM_ID_DD_D12_PUMP_DIRECTION_INVALID, DIALYSATE_PUMP_DIR_OF_RANGE_TIMEOUT_MS, DIALYSATE_PUMP_DIR_OF_RANGE_TIMEOUT_MS ); //Initialize the persistent alarms for spent dialysate pump - initPersistentAlarm( ALARM_ID_DD_SPENT_DIALYSATE_PUMP_RPM_OUT_OF_RANGE, RPM_OUT_OF_RANGE_TIME_OUT, RPM_OUT_OF_RANGE_TIME_OUT ); - initPersistentAlarm( ALARM_ID_DD_SPENT_DIALYSATE_PUMP_OFF_FAULT, SAFETY_SHUTDOWN_TIMEOUT, SAFETY_SHUTDOWN_TIMEOUT ); - initPersistentAlarm( ALARM_ID_DD_SPENT_DIALYSATE_PUMP_CURRENT_OUT_OF_RANGE, DIALYSATE_PUMP_CURRENT_OUT_OF_RANGE_TIMEOUT_MS, DIALYSATE_PUMP_CURRENT_OUT_OF_RANGE_TIMEOUT_MS ); - initPersistentAlarm( ALARM_ID_DD_SPENT_DIALYSATE_PUMP_DIRECTION_INVALID, DIALYSATE_PUMP_DIR_OF_RANGE_TIMEOUT_MS, DIALYSATE_PUMP_DIR_OF_RANGE_TIMEOUT_MS ); + initPersistentAlarm( ALARM_ID_DD_D48_PUMP_RPM_OUT_OF_RANGE, RPM_OUT_OF_RANGE_TIME_OUT, RPM_OUT_OF_RANGE_TIME_OUT ); + initPersistentAlarm( ALARM_ID_DD_D48_PUMP_OFF_FAULT, SAFETY_SHUTDOWN_TIMEOUT, SAFETY_SHUTDOWN_TIMEOUT ); + initPersistentAlarm( ALARM_ID_DD_D48_PUMP_CURRENT_OUT_OF_RANGE, DIALYSATE_PUMP_CURRENT_OUT_OF_RANGE_TIMEOUT_MS, DIALYSATE_PUMP_CURRENT_OUT_OF_RANGE_TIMEOUT_MS ); + initPersistentAlarm( ALARM_ID_DD_D48_PUMP_DIRECTION_INVALID, DIALYSATE_PUMP_DIR_OF_RANGE_TIMEOUT_MS, DIALYSATE_PUMP_DIR_OF_RANGE_TIMEOUT_MS ); // initialize FPGA dialysate pump hall sensor error - initTimeWindowedCount( TIME_WINDOWED_COUNT_FPGA_FRESH_DIALYSATE_PUMP_HALL_SENSOR_ERROR, MAX_FPGA_DIALYSATE_PUMP_DIRECTION_FAULT_FAILURES, MAX_FPGA_DIALYSATE_PUMP_DIRECTION_FAULT_WINDOW_MS ); - initTimeWindowedCount( TIME_WINDOWED_COUNT_FPGA_SPENT_DIALYSATE_PUMP_HALL_SENSOR_ERROR, MAX_FPGA_DIALYSATE_PUMP_DIRECTION_FAULT_FAILURES, MAX_FPGA_DIALYSATE_PUMP_DIRECTION_FAULT_WINDOW_MS ); + initTimeWindowedCount( TIME_WINDOWED_COUNT_FPGA_D12_PUMP_HALL_SENSOR_ERROR, MAX_FPGA_DIALYSATE_PUMP_DIRECTION_FAULT_FAILURES, MAX_FPGA_DIALYSATE_PUMP_DIRECTION_FAULT_WINDOW_MS ); + initTimeWindowedCount( TIME_WINDOWED_COUNT_FPGA_D48_PUMP_HALL_SENSOR_ERROR, MAX_FPGA_DIALYSATE_PUMP_DIRECTION_FAULT_FAILURES, MAX_FPGA_DIALYSATE_PUMP_DIRECTION_FAULT_WINDOW_MS ); } /*********************************************************************//** @@ -240,15 +248,15 @@ { if ( ( MIN_DIALYSATE_PUMP_RPM <= rpm ) && ( rpm <= MAX_DIALYSATE_PUMP_RPM ) ) { - dialysatePumps[ pumpId ].pumpTargetSpeed.data = rpm; + pumpTargetSpeed[ pumpId ].data = rpm; } else if ( rpm < MIN_DIALYSATE_PUMP_RPM ) { - dialysatePumps[ pumpId ].pumpTargetSpeed.data = 0.0; + pumpTargetSpeed[ pumpId ].data = 0.0; } else { - dialysatePumps[ pumpId ].pumpTargetSpeed.data = MAX_DIALYSATE_PUMP_RPM; + pumpTargetSpeed[ pumpId ].data = MAX_DIALYSATE_PUMP_RPM; } //handle target speed update when pump is running @@ -285,35 +293,35 @@ void signalDialysatePumpHardStop( DIALYSATE_PUMPS_T pumpId ) { //Update control to stop the dialysate pump - if ( FRESH_DIALYSATE_PUMP == pumpId ) + if ( D12_PUMP == pumpId ) { // dialysate pump control run enable dialysatePumps[ pumpId ].control = DIALYSATE_PUMP_CONTROL_STOP; - setFPGAFreshDialysatePumpControl( dialysatePumps[ pumpId ].control ); - setFPGAFreshDialysatePumpSpeed( DIALYSATE_PUMP_SPEED_ZERO_RPM ); + setFPGAD12PumpControl( dialysatePumps[ pumpId ].control ); + setFPGAD12PumpSpeed( MIN_DIALYSATE_PUMP_RPM ); } else { dialysatePumps[ pumpId ].control = DIALYSATE_PUMP_CONTROL_STOP; - setFPGASpentDialysatePumpControl( dialysatePumps[ pumpId ].control ); - setFPGASpentDialysatePumpSpeed( DIALYSATE_PUMP_SPEED_ZERO_RPM ); + setFPGAD48PumpControl( dialysatePumps[ pumpId ].control ); + setFPGAD48PumpSpeed( MIN_DIALYSATE_PUMP_RPM ); } // Reset all the variables to stop mode - dialysatePumps[ pumpId ].currentPumpSpeed = 0.0F; - dialysatePumps[ pumpId ].pumpTargetSpeed.data = 0.0F; + dialysatePumps[ pumpId ].currentPumpSpeed = MIN_DIALYSATE_PUMP_RPM; + pumpTargetSpeed[ pumpId ].data = 0.0F; dialysatePumps[ pumpId ].dialysatePumpState = DIALYSATE_PUMP_OFF_STATE; dialysatePumps[ pumpId ].controlTimerCounter = 0; dialysatePumps[ pumpId ].isDialPumpOn = FALSE; //Reset PI Controller - if ( FRESH_DIALYSATE_PUMP == pumpId ) + if ( D12_PUMP == pumpId ) { - resetPIController( PI_CONTROLLER_ID_FRESH_DIALYSATE_PUMP, DIALYSATE_PUMP_MIN_PRESSURE_PSI ); + resetPIController( PI_CONTROLLER_ID_D12_PUMP, DIALYSATE_PUMP_MIN_PRESSURE_PSI ); } else { - resetPIController( PI_CONTROLLER_ID_SPENT_DIALYSATE_PUMP, DIALYSATE_PUMP_MIN_PRESSURE_PSI ); + resetPIController( PI_CONTROLLER_ID_D48_PUMP, DIALYSATE_PUMP_MIN_PRESSURE_PSI ); } } @@ -324,9 +332,9 @@ * certain count with in defined time. * @details \b Inputs: directionErrorCount,lastDirectionErrorCount * @details \b Outputs: lastDirectionErrorCount - * @details \b Alarm: ALARM_ID_DD_FRESH_DIALYSATE_PUMP_DIRECTION_FPGA_FAULT when + * @details \b Alarm: ALARM_ID_DD_D12_PUMP_DIRECTION_FPGA_FAULT when * the direction error count increments for certian count with in defined time. - * @details \b Alarm: ALARM_ID_DD_SPENT_DIALYSATE_PUMP_DIRECTION_FPGA_FAULT when + * @details \b Alarm: ALARM_ID_DD_D48_PUMP_DIRECTION_FPGA_FAULT when * the direction error count increments for certian count with in defined time. * @param pumpId pump id to check the direction error count for the given dialysate * pump @@ -336,18 +344,18 @@ { if ( dialysatePumps[ pumpId ].directionErrorCount != dialysatePumps[ pumpId ].lastDirectionErrorCount ) { - if ( FRESH_DIALYSATE_PUMP == pumpId ) + if ( D12_PUMP == pumpId ) { - if ( TRUE == incTimeWindowedCount( TIME_WINDOWED_COUNT_FPGA_FRESH_DIALYSATE_PUMP_HALL_SENSOR_ERROR ) ) + if ( TRUE == incTimeWindowedCount( TIME_WINDOWED_COUNT_FPGA_D12_PUMP_HALL_SENSOR_ERROR ) ) { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_FRESH_DIALYSATE_PUMP_DIRECTION_FPGA_FAULT, MAX_FPGA_DIALYSATE_PUMP_DIRECTION_FAULT_FAILURES, dialysatePumps[ pumpId ].directionErrorCount ) + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_D12_PUMP_DIRECTION_FPGA_FAULT, MAX_FPGA_DIALYSATE_PUMP_DIRECTION_FAULT_FAILURES, dialysatePumps[ pumpId ].directionErrorCount ) } } else { - if ( TRUE == incTimeWindowedCount( TIME_WINDOWED_COUNT_FPGA_SPENT_DIALYSATE_PUMP_HALL_SENSOR_ERROR ) ) + if ( TRUE == incTimeWindowedCount( TIME_WINDOWED_COUNT_FPGA_D48_PUMP_HALL_SENSOR_ERROR ) ) { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SPENT_DIALYSATE_PUMP_DIRECTION_FPGA_FAULT, MAX_FPGA_DIALYSATE_PUMP_DIRECTION_FAULT_FAILURES, dialysatePumps[ pumpId ].directionErrorCount ) + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_D48_PUMP_DIRECTION_FPGA_FAULT, MAX_FPGA_DIALYSATE_PUMP_DIRECTION_FAULT_FAILURES, dialysatePumps[ pumpId ].directionErrorCount ) } } dialysatePumps[ pumpId ].lastDirectionErrorCount = dialysatePumps[ pumpId ].directionErrorCount; @@ -361,38 +369,48 @@ * by FPGA * @details \b Outputs: measuredPumpSpeed,dialysatePumpMeasuredCurrentA, * measuredDirection,directionErrorCount - * @detail \b Alarms: ALARM_ID_DD_FRESH_DIALYSATE_PUMP_RPM_OUT_OF_RANGE, - * ALARM_ID_DD_SPENT_DIALYSATE_PUMP_RPM_OUT_OF_RANGE when speed mismatch + * @detail \b Alarms: ALARM_ID_DD_D12_PUMP_RPM_OUT_OF_RANGE, + * ALARM_ID_DD_D48_PUMP_RPM_OUT_OF_RANGE when speed mismatch * occurs between set and measured speed. - * @detail \b Alarms: ALARM_ID_DD_FRESH_DIALYSATE_PUMP_OFF_FAULT, - * ALARM_ID_DD_SPENT_DIALYSATE_PUMP_OFF_FAULT when dialysate pump runs at + * @detail \b Alarms: ALARM_ID_DD_D12_PUMP_OFF_FAULT, + * ALARM_ID_DD_D48_PUMP_OFF_FAULT when dialysate pump runs at * certain speed when not commanded to run. - * @detail \b Alarms: ALARM_ID_DD_FRESH_DIALYSATE_PUMP_DIRECTION_INVALID, - * ALARM_ID_DD_SPENT_DIALYSATE_PUMP_DIRECTION_INVALID when dialysate pump is + * @detail \b Alarms: ALARM_ID_DD_D12_PUMP_DIRECTION_INVALID, + * ALARM_ID_DD_D48_PUMP_DIRECTION_INVALID when dialysate pump is * not running in forward direction. - * @detail \b Alarms:ALARM_ID_DD_FRESH_DIALYSATE_PUMP_CURRENT_OUT_OF_RANGE, - * ALARM_ID_DD_SPENT_DIALYSATE_PUMP_CURRENT_OUT_OF_RANGE when dialysate pump + * @detail \b Alarms:ALARM_ID_DD_D12_PUMP_CURRENT_OUT_OF_RANGE, + * ALARM_ID_DD_D48_PUMP_CURRENT_OUT_OF_RANGE when dialysate pump * is drawing more current than expected. * @return none *************************************************************************/ void execDialysatePumpMonitor( void ) { - U16 freshDialCurrent = getFPGAFreshDialysatePumpCurrentFeedback(); - U16 spentDialCurrent = getFPGAFreshDialysatePumpCurrentFeedback(); - BOOL isOffCurrentOut = FALSE; - BOOL isCurrentOutOfRange = FALSE; + U16 d12Current = getFPGAD12PumpCurrentFeedback(); + U16 d48Current = getFPGAD48PumpCurrentFeedback(); + U16 d12SpeedCnt = getFPGAD12PumpSpeed(); + U16 d48SpeedCnt = getFPGAD48PumpSpeed(); + BOOL isOffCurrentOut = FALSE; + BOOL isCurrentOutOfRange = FALSE; DIALYSATE_PUMPS_T pumpId; + // Update the paramerters - dialysatePumps[ FRESH_DIALYSATE_PUMP ].measuredPumpSpeed.data = getFPGAFreshDialysatePumpSpeed(); - dialysatePumps[ SPENT_DIALYSATE_PUMP ].measuredPumpSpeed.data = getFPGASpentDialysatePumpSpeed(); - dialysatePumps[ FRESH_DIALYSATE_PUMP ].dialysatePumpMeasuredCurrentA.data = (F32)freshDialCurrent * CURRENT_CONVERSION_COEFF; - dialysatePumps[ SPENT_DIALYSATE_PUMP ].dialysatePumpMeasuredCurrentA.data = (F32)spentDialCurrent * CURRENT_CONVERSION_COEFF; - dialysatePumps[ FRESH_DIALYSATE_PUMP ].measuredDirection.data = (U32)( ( getFPGAFreshDialysatePumpHallDirectionStatus() & DIALYSATE_PUMP_DIR_BIT_MASK ) >> SHIFT_BITS_BY_7 ); - dialysatePumps[ SPENT_DIALYSATE_PUMP ].measuredDirection.data = (U32)( ( getFPGASpentDialysatePumpHallDirectionStatus() & DIALYSATE_PUMP_DIR_BIT_MASK ) >> SHIFT_BITS_BY_7 ); - dialysatePumps[ FRESH_DIALYSATE_PUMP ].directionErrorCount = (U32)( getFPGAFreshDialysatePumpHallDirectionStatus() & DIALYSATE_PUMP_DIR_ERROR_CNT_BIT_MASK ); - dialysatePumps[ SPENT_DIALYSATE_PUMP ].directionErrorCount = (U32)( getFPGASpentDialysatePumpHallDirectionStatus() & DIALYSATE_PUMP_DIR_ERROR_CNT_BIT_MASK ); + dialysatePumpMeasuredCurrentA[ D12_PUMP ].data = (F32)d12Current * CURRENT_CONVERSION_COEFF; + dialysatePumpMeasuredCurrentA[ D48_PUMP ].data = (F32)d48Current * CURRENT_CONVERSION_COEFF; + measuredDirection[ D12_PUMP ].data = (U32)( ( getFPGAD12PumpHallDirectionStatus() & DIALYSATE_PUMP_DIR_BIT_MASK ) >> SHIFT_BITS_BY_7 ); + measuredDirection[ D48_PUMP ].data = (U32)( ( getFPGAD48PumpHallDirectionStatus() & DIALYSATE_PUMP_DIR_BIT_MASK ) >> SHIFT_BITS_BY_7 ); + dialysatePumps[ D12_PUMP ].directionErrorCount = (U32)( getFPGAD12PumpHallDirectionStatus() & DIALYSATE_PUMP_DIR_ERROR_CNT_BIT_MASK ); + dialysatePumps[ D48_PUMP ].directionErrorCount = (U32)( getFPGAD48PumpHallDirectionStatus() & DIALYSATE_PUMP_DIR_ERROR_CNT_BIT_MASK ); + if ( d12SpeedCnt > SPEED_COUNT_ZERO ) + { + measuredPumpSpeed[ D12_PUMP ].data = SPEED_CONV_FACTOR / d12SpeedCnt; + } + if ( d48SpeedCnt > SPEED_COUNT_ZERO ) + { + measuredPumpSpeed[ D48_PUMP ].data = SPEED_CONV_FACTOR / d48SpeedCnt; + } + // Monitor dialysate pumps for ( pumpId = DIALYSATE_PUMPS_FIRST; pumpId < NUM_OF_DIALYSATE_PUMPS; pumpId++ ) { @@ -405,25 +423,27 @@ isOffCurrentOut = ( getDialysatePumpMeasuredCurrentA( pumpId ) > DIALYSATE_PUMP_MAX_CURRENT_WHEN_OFF_A ? TRUE : FALSE ); isRPMTooHigh = ( getDialysatePumpMeasuredSpeed( pumpId ) > MIN_DIALYSATE_PUMP_RPM ? TRUE : FALSE ); - if ( FRESH_DIALYSATE_PUMP == pumpId ) +#if 0 + if ( D12_PUMP == pumpId ) { - checkPersistentAlarm( ALARM_ID_DD_FRESH_DIALYSATE_PUMP_RPM_OUT_OF_RANGE, FALSE, getDialysatePumpMeasuredSpeed( pumpId ), MAX_ALLOWED_RPM_OUT_OF_RANGE ); - checkPersistentAlarm( ALARM_ID_DD_FRESH_DIALYSATE_PUMP_OFF_FAULT, isRPMTooHigh, getDialysatePumpMeasuredSpeed( pumpId ), MIN_DIALYSATE_PUMP_RPM ); - checkPersistentAlarm( ALARM_ID_DD_FRESH_DIALYSATE_PUMP_DIRECTION_INVALID, FALSE, getDialysatePumpMeasuredDirection( pumpId ), DIALYSATE_PUMP_FORWARD_DIR ); + checkPersistentAlarm( ALARM_ID_DD_D12_PUMP_RPM_OUT_OF_RANGE, FALSE, getDialysatePumpMeasuredSpeed( pumpId ), MAX_ALLOWED_RPM_OUT_OF_RANGE ); + checkPersistentAlarm( ALARM_ID_DD_D12_PUMP_OFF_FAULT, isRPMTooHigh, getDialysatePumpMeasuredSpeed( pumpId ), MIN_DIALYSATE_PUMP_RPM ); + checkPersistentAlarm( ALARM_ID_DD_D12_PUMP_DIRECTION_INVALID, FALSE, getDialysatePumpMeasuredDirection( pumpId ), DIALYSATE_PUMP_FORWARD_DIR ); } else { - checkPersistentAlarm( ALARM_ID_DD_SPENT_DIALYSATE_PUMP_RPM_OUT_OF_RANGE, FALSE, getDialysatePumpMeasuredSpeed( pumpId ), MAX_ALLOWED_RPM_OUT_OF_RANGE ); - checkPersistentAlarm( ALARM_ID_DD_SPENT_DIALYSATE_PUMP_OFF_FAULT, isRPMTooHigh, getDialysatePumpMeasuredSpeed( pumpId ), MIN_DIALYSATE_PUMP_RPM ); - checkPersistentAlarm( ALARM_ID_DD_SPENT_DIALYSATE_PUMP_DIRECTION_INVALID, FALSE, getDialysatePumpMeasuredDirection( pumpId ), DIALYSATE_PUMP_FORWARD_DIR ); + checkPersistentAlarm( ALARM_ID_DD_D48_PUMP_RPM_OUT_OF_RANGE, FALSE, getDialysatePumpMeasuredSpeed( pumpId ), MAX_ALLOWED_RPM_OUT_OF_RANGE ); + checkPersistentAlarm( ALARM_ID_DD_D48_PUMP_OFF_FAULT, isRPMTooHigh, getDialysatePumpMeasuredSpeed( pumpId ), MIN_DIALYSATE_PUMP_RPM ); + checkPersistentAlarm( ALARM_ID_DD_D48_PUMP_DIRECTION_INVALID, FALSE, getDialysatePumpMeasuredDirection( pumpId ), DIALYSATE_PUMP_FORWARD_DIR ); } // If the direction off fault alarm has become active, trigger the safety shutdown - if ( ( TRUE == isAlarmActive( ALARM_ID_DD_FRESH_DIALYSATE_PUMP_OFF_FAULT ) ) || - ( TRUE == isAlarmActive( ALARM_ID_DD_FRESH_DIALYSATE_PUMP_OFF_FAULT ) ) ) + if ( ( TRUE == isAlarmActive( ALARM_ID_DD_D12_PUMP_OFF_FAULT ) ) || + ( TRUE == isAlarmActive( ALARM_ID_DD_D12_PUMP_OFF_FAULT ) ) ) { //activateSafetyShutdown(); } +#endif } break; @@ -437,19 +457,20 @@ BOOL isDirInvalid = ( ( direction != DIALYSATE_PUMP_FORWARD_DIR ) && ( rpm > DIALYSATE_PUMP_MIN_RPM_FOR_DIR_CHECK ) ? TRUE : FALSE ); isRPMOutOfRange = ( rpmDiff > MAX_ALLOWED_RPM_OUT_OF_RANGE ? TRUE : FALSE ); - - if ( FRESH_DIALYSATE_PUMP == pumpId ) +#if 0 + if ( D12_PUMP == pumpId ) { - checkPersistentAlarm( ALARM_ID_DD_FRESH_DIALYSATE_PUMP_RPM_OUT_OF_RANGE, isRPMOutOfRange, rpm, MAX_ALLOWED_RPM_OUT_OF_RANGE ); - checkPersistentAlarm( ALARM_ID_DD_FRESH_DIALYSATE_PUMP_OFF_FAULT, FALSE, getDialysatePumpMeasuredSpeed( pumpId ), MIN_DIALYSATE_PUMP_RPM ); - checkPersistentAlarm( ALARM_ID_DD_FRESH_DIALYSATE_PUMP_DIRECTION_INVALID, isDirInvalid, (F32)direction, DIALYSATE_PUMP_FORWARD_DIR ); + checkPersistentAlarm( ALARM_ID_DD_D12_PUMP_RPM_OUT_OF_RANGE, isRPMOutOfRange, rpm, MAX_ALLOWED_RPM_OUT_OF_RANGE ); + checkPersistentAlarm( ALARM_ID_DD_D12_PUMP_OFF_FAULT, FALSE, getDialysatePumpMeasuredSpeed( pumpId ), MIN_DIALYSATE_PUMP_RPM ); + checkPersistentAlarm( ALARM_ID_DD_D12_PUMP_DIRECTION_INVALID, isDirInvalid, (F32)direction, DIALYSATE_PUMP_FORWARD_DIR ); } else { - checkPersistentAlarm( ALARM_ID_DD_SPENT_DIALYSATE_PUMP_RPM_OUT_OF_RANGE, isRPMOutOfRange, rpm, MAX_ALLOWED_RPM_OUT_OF_RANGE ); - checkPersistentAlarm( ALARM_ID_DD_SPENT_DIALYSATE_PUMP_OFF_FAULT, FALSE, getDialysatePumpMeasuredSpeed( pumpId ), MIN_DIALYSATE_PUMP_RPM ); - checkPersistentAlarm( ALARM_ID_DD_SPENT_DIALYSATE_PUMP_DIRECTION_INVALID, isDirInvalid, (F32)direction, DIALYSATE_PUMP_FORWARD_DIR ); + checkPersistentAlarm( ALARM_ID_DD_D48_PUMP_RPM_OUT_OF_RANGE, isRPMOutOfRange, rpm, MAX_ALLOWED_RPM_OUT_OF_RANGE ); + checkPersistentAlarm( ALARM_ID_DD_D48_PUMP_OFF_FAULT, FALSE, getDialysatePumpMeasuredSpeed( pumpId ), MIN_DIALYSATE_PUMP_RPM ); + checkPersistentAlarm( ALARM_ID_DD_D48_PUMP_DIRECTION_INVALID, isDirInvalid, (F32)direction, DIALYSATE_PUMP_FORWARD_DIR ); } +#endif } break; @@ -464,14 +485,16 @@ // Check the persistent alarm for the maximum dialysate pump current F32 currentA = getDialysatePumpMeasuredCurrentA( pumpId ); isCurrentOutOfRange = ( currentA > DIALYSATE_PUMP_MAX_CURRENT_A ? TRUE : FALSE ) | isOffCurrentOut; - if ( FRESH_DIALYSATE_PUMP == pumpId ) +#if 0 + if ( D12_PUMP == pumpId ) { - checkPersistentAlarm( ALARM_ID_DD_FRESH_DIALYSATE_PUMP_CURRENT_OUT_OF_RANGE, isCurrentOutOfRange, currentA, DIALYSATE_PUMP_MAX_CURRENT_A ); + checkPersistentAlarm( ALARM_ID_DD_D12_PUMP_CURRENT_OUT_OF_RANGE, isCurrentOutOfRange, currentA, DIALYSATE_PUMP_MAX_CURRENT_A ); } else { - checkPersistentAlarm( ALARM_ID_DD_SPENT_DIALYSATE_PUMP_CURRENT_OUT_OF_RANGE, isCurrentOutOfRange, currentA, DIALYSATE_PUMP_MAX_CURRENT_A ); + checkPersistentAlarm( ALARM_ID_DD_D48_PUMP_CURRENT_OUT_OF_RANGE, isCurrentOutOfRange, currentA, DIALYSATE_PUMP_MAX_CURRENT_A ); } +#endif } // Publish dialysate pumps data on interval @@ -496,7 +519,7 @@ // { // get updated record //getNVRecord2Driver( GET_CAL_DIALYSATE_PUMP_RECORD, (U08*)&dialysatePumpCalRecord, sizeof( DD_DIALYSATE_PUMP_CAL_RECORD_T ), 0, - // ALARM_ID_DD_FRESH_DIALYSATE_PUMP_INVALID_CAL_RECORD ); + // ALARM_ID_DD_D12_PUMP_INVALID_CAL_RECORD ); // } for ( pumpId = DIALYSATE_PUMPS_FIRST; pumpId < NUM_OF_DIALYSATE_PUMPS; pumpId++ ) @@ -539,10 +562,10 @@ BOOL calStatus = TRUE; // TODO:initialize to false when calibration records avialble // This is only one record the number of items to check is 0 since the get NV data function does not do a for loop to check the calibration time -// calStatus |= getNVRecord2Driver( GET_CAL_FRESH_DIALYSATE_PUMP_RECORD, (U08*)&freshDialysatePumpRecord, sizeof( DD_FRESH_DIALYSATE_PUMP_RECORD_T ), 0, -// ALARM_ID_DD_FRESH_DIALYSATE_PUMP_INVALID_CAL_RECORD ); -// calStatus |= getNVRecord2Driver( GET_CAL_SPENT_DIALYSATE_PUMP_RECORD, (U08*)&spentDialysatePumpRecord, sizeof( DD_SPENT_DIALYSATE_PUMP_RECORD_T ), 0, -// ALARM_ID_DD_SPENT_DIALYSATE_PUMP_INVALID_CAL_RECORD ); +// calStatus |= getNVRecord2Driver( GET_CAL_D12_PUMP_RECORD, (U08*)&freshDialysatePumpRecord, sizeof( DD_D12_PUMP_RECORD_T ), 0, +// ALARM_ID_DD_D12_PUMP_INVALID_CAL_RECORD ); +// calStatus |= getNVRecord2Driver( GET_CAL_D48_PUMP_RECORD, (U08*)&spentDialysatePumpRecord, sizeof( DD_D48_PUMP_RECORD_T ), 0, +// ALARM_ID_DD_D48_PUMP_INVALID_CAL_RECORD ); // // calStatus |= getNVRecord2Driver( GET_CAL_DIALYSATE_PUMP_RECORD, (U08*)&dialysatePumpCalRecord, sizeof( DD_DIALYSATE_PUMP_CAL_RECORD_T ), 0, // ALARM_ID_NO_ALARM ); @@ -587,18 +610,18 @@ DIALYSATE_PUMP_STATE_T result = DIALYSATE_PUMP_OFF_STATE; F32 targetSpeed = getDialysatePumpTargetSpeed( pumpId ); - if ( targetSpeed > ZERO_SPEED ) + if ( targetSpeed >= MIN_DIALYSATE_PUMP_RPM ) { - if ( FRESH_DIALYSATE_PUMP == pumpId ) + if ( D12_PUMP == pumpId ) { // dialysate pump control run enable, forward run only. dialysatePumps[ pumpId ].control = DIALYSATE_PUMP_CONTROL_RUN; - setFPGAFreshDialysatePumpControl( dialysatePumps[ pumpId ].control ); + setFPGAD12PumpControl( dialysatePumps[ pumpId ].control ); } else { dialysatePumps[ pumpId ].control = DIALYSATE_PUMP_CONTROL_RUN; - setFPGASpentDialysatePumpControl( dialysatePumps[ pumpId ].control ); + setFPGAD48PumpControl( dialysatePumps[ pumpId ].control ); } dialysatePumps[ pumpId ].isDialPumpOn = TRUE; @@ -627,13 +650,13 @@ if ( TRUE == stepDialysatePumpToTargetSpeed( pumpId ) ) { - if ( FRESH_DIALYSATE_PUMP == pumpId ) + if ( D12_PUMP == pumpId ) { - resetPIController( PI_CONTROLLER_ID_FRESH_DIALYSATE_PUMP, DIALYSATE_PUMP_MIN_PRESSURE_PSI ); + resetPIController( PI_CONTROLLER_ID_D12_PUMP, DIALYSATE_PUMP_MIN_PRESSURE_PSI ); } else { - resetPIController( PI_CONTROLLER_ID_SPENT_DIALYSATE_PUMP, DIALYSATE_PUMP_MIN_PRESSURE_PSI ); + resetPIController( PI_CONTROLLER_ID_D48_PUMP, DIALYSATE_PUMP_MIN_PRESSURE_PSI ); } state = DIALYSATE_PUMP_CONTROL_TO_TARGET_STATE; } @@ -677,23 +700,23 @@ dialysatePumps[ pumpId ].currentPumpSpeed += speedIncrease; // If the pump's target speed is set to be 0, do not ramp down set it to zero immediately - if ( getDialysatePumpTargetSpeed( pumpId ) < ZERO_SPEED ) - { - dialysatePumps[ pumpId ].currentPumpSpeed = 0.0F; - } +// if ( getDialysatePumpTargetSpeed( pumpId ) < MIN_DIALYSATE_PUMP_RPM ) +// { +// dialysatePumps[ pumpId ].currentPumpSpeed = MIN_DIALYSATE_PUMP_RPM; +// } } - if ( dialysatePumps[ pumpId ].currentPumpSpeed > ZERO_SPEED ) + if ( dialysatePumps[ pumpId ].currentPumpSpeed >= MIN_DIALYSATE_PUMP_RPM ) { - if ( FRESH_DIALYSATE_PUMP == pumpId ) + if ( D12_PUMP == pumpId ) { // Set fresh dialyate pump speed - setFPGAFreshDialysatePumpSpeed( (U16)dialysatePumps[ pumpId ].currentPumpSpeed ); + setFPGAD12PumpSpeed( (U16)dialysatePumps[ pumpId ].currentPumpSpeed ); } else { // Set spent dialyate pump speed - setFPGASpentDialysatePumpSpeed( (U16)dialysatePumps[ pumpId ].currentPumpSpeed ); + setFPGAD48PumpSpeed( (U16)dialysatePumps[ pumpId ].currentPumpSpeed ); } } @@ -716,39 +739,61 @@ if ( ++dialysatePumps[ pumpId ].controlTimerCounter >= DP_CONTROL_INTERVAL ) { // Control based on the measured and target pressure - if ( FRESH_DIALYSATE_PUMP == pumpId ) + if ( D12_PUMP == pumpId ) { - F32 measuredPressure = getFilteredPressure( PRESSURE_SENSOR_FRESH_DIALYSATE ); + F32 measuredPressure = getFilteredPressure( D18_PRES ); F32 targetPressure = getDialysatePumpTargetPressure( pumpId ); + F32 newSpeed = 0; - F32 control = runPIController( PI_CONTROLLER_ID_FRESH_DIALYSATE_PUMP, targetPressure, measuredPressure ); + //F32 control = runPIController( PI_CONTROLLER_ID_D12_PUMP, targetPressure, measuredPressure ); // TODO : get the equivalent speed for the given control - F32 newSpeed = control * ( MAX_DIALYSATE_PUMP_RPM / DIALYSATE_PUMP_MAX_PRESSURE_PSI ); + // newSpeed = control * ( MAX_DIALYSATE_PUMP_RPM / DIALYSATE_PUMP_MAX_PRESSURE_PSI ); +#if 0 + if ( measuredPressure < targetPressure ) + { + newSpeed = dialysatePumps[ pumpId ].currentPumpSpeed + DIALYSATE_PUMP_SPEED_INCREMENT; + } + else + { + newSpeed = dialysatePumps[ pumpId ].currentPumpSpeed - DIALYSATE_PUMP_SPEED_INCREMENT; + } //Apply speed limit newSpeed = MIN( newSpeed, MAX_DIALYSATE_PUMP_RPM ); newSpeed = MAX( newSpeed, MIN_DIALYSATE_PUMP_RPM ); dialysatePumps[ pumpId ].currentPumpSpeed = newSpeed; //Set fresh dialyate pump speed - setFPGAFreshDialysatePumpSpeed( (U16)dialysatePumps[ pumpId ].currentPumpSpeed ); + setFPGAD12PumpSpeed( (U16)dialysatePumps[ pumpId ].currentPumpSpeed ); +#endif } else { - F32 measuredPressure = getFilteredPressure( PRESSURE_SENSOR_SPENT_DIALYSATE ); + F32 measuredPressure = getFilteredPressure( D51_PRES ); F32 targetPressure = getDialysatePumpTargetPressure( pumpId ); + F32 newSpeed = 0; - F32 control = runPIController( PI_CONTROLLER_ID_SPENT_DIALYSATE_PUMP, targetPressure, measuredPressure ); + //F32 control = runPIController( PI_CONTROLLER_ID_D48_PUMP, targetPressure, measuredPressure ); // TODO : get the equivalent speed for the given control - F32 newSpeed = control * ( MAX_DIALYSATE_PUMP_RPM / DIALYSATE_PUMP_MAX_PRESSURE_PSI ); + // newSpeed = control * ( MAX_DIALYSATE_PUMP_RPM / DIALYSATE_PUMP_MAX_PRESSURE_PSI ); +#if 0 + if ( measuredPressure < targetPressure ) + { + newSpeed = dialysatePumps[ pumpId ].currentPumpSpeed + DIALYSATE_PUMP_SPEED_INCREMENT; + } + else + { + newSpeed = dialysatePumps[ pumpId ].currentPumpSpeed - DIALYSATE_PUMP_SPEED_INCREMENT; + } //Apply speed limit newSpeed = MIN( newSpeed, MAX_DIALYSATE_PUMP_RPM ); newSpeed = MAX( newSpeed, MIN_DIALYSATE_PUMP_RPM ); dialysatePumps[ pumpId ].currentPumpSpeed = newSpeed; //Set spent dialyate pump speed - setFPGASpentDialysatePumpSpeed( (U16)dialysatePumps[ pumpId ].currentPumpSpeed ); + setFPGAD48PumpSpeed( (U16)dialysatePumps[ pumpId ].currentPumpSpeed ); +#endif } dialysatePumps[ pumpId ].controlTimerCounter = 0; } @@ -772,7 +817,7 @@ if ( pumpId < NUM_OF_DIALYSATE_PUMPS ) { - speed = getF32OverrideValue( &dialysatePumps[ pumpId ].pumpTargetSpeed ); + speed = getF32OverrideValue( &pumpTargetSpeed[ pumpId ] ); } else { @@ -798,7 +843,7 @@ if ( pumpId < NUM_OF_DIALYSATE_PUMPS ) { - speed = getF32OverrideValue( &dialysatePumps[ pumpId ].measuredPumpSpeed ); + speed = getF32OverrideValue( &measuredPumpSpeed[ pumpId ] ); } else { @@ -824,7 +869,7 @@ if ( pumpId < NUM_OF_DIALYSATE_PUMPS ) { - pressure = getF32OverrideValue( &dialysatePumps[ pumpId ].pumpTargetPressure ); + pressure = getF32OverrideValue( &pumpTargetPressure[ pumpId ] ); } else { @@ -849,7 +894,7 @@ if ( pumpId < NUM_OF_DIALYSATE_PUMPS ) { - current = getF32OverrideValue( &dialysatePumps[ pumpId ].dialysatePumpMeasuredCurrentA ); + current = getF32OverrideValue( &dialysatePumpMeasuredCurrentA[ pumpId ] ); } else { @@ -874,7 +919,7 @@ if ( pumpId < NUM_OF_DIALYSATE_PUMPS ) { - direction = getU32OverrideValue( &dialysatePumps[ pumpId ].measuredDirection ); + direction = getU32OverrideValue( &measuredDirection[ pumpId ] ); } else { @@ -902,26 +947,26 @@ DIALYSATE_PUMPS_PUBLISH_DATA_T dialPump; // Populate the data structure for publication - dialPump.freshDialPumpTargetRPM = getDialysatePumpTargetSpeed( FRESH_DIALYSATE_PUMP ); - dialPump.spentDialPumpTargetRPM = getDialysatePumpTargetSpeed( SPENT_DIALYSATE_PUMP ); - dialPump.freshDialPumpMeasuredSpeed = getDialysatePumpMeasuredSpeed( FRESH_DIALYSATE_PUMP ); - dialPump.spentDialPumpMeasuredSpeed = getDialysatePumpMeasuredSpeed( SPENT_DIALYSATE_PUMP ); - dialPump.freshDialPumpCurrentSpeed = dialysatePumps[ FRESH_DIALYSATE_PUMP ].currentPumpSpeed; - dialPump.spentDialPumpCurrentSpeed = dialysatePumps[ SPENT_DIALYSATE_PUMP ].currentPumpSpeed; - dialPump.freshDialPumpState = (U32)dialysatePumps[ FRESH_DIALYSATE_PUMP ].dialysatePumpState; - dialPump.spentDialPumpState = (U32)dialysatePumps[ SPENT_DIALYSATE_PUMP ].dialysatePumpState; - dialPump.freshDialPumpTargetPressure = getDialysatePumpTargetPressure( FRESH_DIALYSATE_PUMP ); - dialPump.spentDialPumpTargetPressure = getDialysatePumpTargetPressure( SPENT_DIALYSATE_PUMP ); - dialPump.freshDialPumpMeasuredPressure = getFilteredPressure( PRESSURE_SENSOR_FRESH_DIALYSATE ); - dialPump.spentDialPumpMeasuredPressure = getFilteredPressure( PRESSURE_SENSOR_SPENT_DIALYSATE ); - dialPump.freshDialPumpMeasuredCurrent = getDialysatePumpMeasuredCurrentA( FRESH_DIALYSATE_PUMP ); - dialPump.spentDialPumpMeasuredCurrent = getDialysatePumpMeasuredCurrentA( SPENT_DIALYSATE_PUMP ); - dialPump.freshDialPumpControl = (U32)dialysatePumps[ FRESH_DIALYSATE_PUMP ].control; - dialPump.spentDialPumpControl = (U32)dialysatePumps[ SPENT_DIALYSATE_PUMP ].control; - dialPump.freshDialPumpDirErrCnt = dialysatePumps[ FRESH_DIALYSATE_PUMP ].directionErrorCount; - dialPump.spentDialPumpDirErrCnt = dialysatePumps[ SPENT_DIALYSATE_PUMP ].directionErrorCount; - dialPump.freshDialPumpMeasuredDir = getDialysatePumpMeasuredDirection( FRESH_DIALYSATE_PUMP ); - dialPump.spentDialPumpMeasuredDir = getDialysatePumpMeasuredDirection( SPENT_DIALYSATE_PUMP ); + dialPump.d12PumpTargetRPM = getDialysatePumpTargetSpeed( D12_PUMP ); + dialPump.d48PumpTargetRPM = getDialysatePumpTargetSpeed( D48_PUMP ); + dialPump.d12PumpMeasuredSpeed = getDialysatePumpMeasuredSpeed( D12_PUMP ); + dialPump.d48PumpMeasuredSpeed = getDialysatePumpMeasuredSpeed( D48_PUMP ); + dialPump.d12PumpCurrentSpeed = dialysatePumps[ D12_PUMP ].currentPumpSpeed; + dialPump.d48PumpCurrentSpeed = dialysatePumps[ D48_PUMP ].currentPumpSpeed; + dialPump.d12PumpState = (U32)dialysatePumps[ D12_PUMP ].dialysatePumpState; + dialPump.d48PumpState = (U32)dialysatePumps[ D48_PUMP ].dialysatePumpState; + dialPump.d12PumpTargetPressure = getDialysatePumpTargetPressure( D12_PUMP ); + dialPump.d48PumpTargetPressure = getDialysatePumpTargetPressure( D48_PUMP ); + dialPump.d12PumpMeasuredPressure = getFilteredPressure( D18_PRES ); + dialPump.d48PumpMeasuredPressure = getFilteredPressure( D51_PRES ); + dialPump.d12PumpMeasuredCurrent = getDialysatePumpMeasuredCurrentA( D12_PUMP ); + dialPump.d48PumpMeasuredCurrent = getDialysatePumpMeasuredCurrentA( D48_PUMP ); + dialPump.d12PumpControl = (U32)dialysatePumps[ D12_PUMP ].control; + dialPump.d48PumpControl = (U32)dialysatePumps[ D48_PUMP ].control; + dialPump.d12PumpDirErrCnt = dialysatePumps[ D12_PUMP ].directionErrorCount; + dialPump.d48PumpDirErrCnt = dialysatePumps[ D48_PUMP ].directionErrorCount; + dialPump.d12PumpMeasuredDir = getDialysatePumpMeasuredDirection( D12_PUMP ); + dialPump.d48PumpMeasuredDir = getDialysatePumpMeasuredDirection( D48_PUMP ); broadcastData( MSG_ID_DIALYSATE_PUMPS_DATA, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&dialPump, sizeof( DIALYSATE_PUMPS_PUBLISH_DATA_T ) ); @@ -964,7 +1009,7 @@ *************************************************************************/ BOOL testDialysatePumpTargetSpeedOverride( MESSAGE_T *message ) { - BOOL result = f32ArrayOverride( message, &dialysatePumps[0].pumpTargetSpeed, NUM_OF_DIALYSATE_PUMPS - 1 ); + BOOL result = f32ArrayOverride( message, &pumpTargetSpeed[ 0 ], NUM_OF_DIALYSATE_PUMPS - 1 ); return result; } @@ -981,7 +1026,7 @@ *************************************************************************/ BOOL testDialysatePumpMeasuredSpeedOverride( MESSAGE_T *message ) { - BOOL result = f32ArrayOverride( message, &dialysatePumps[0].measuredPumpSpeed, NUM_OF_DIALYSATE_PUMPS - 1 ); + BOOL result = f32ArrayOverride( message, &measuredPumpSpeed[ 0 ], NUM_OF_DIALYSATE_PUMPS - 1 ); return result; } @@ -998,7 +1043,7 @@ *************************************************************************/ BOOL testDialysatePumpTargetPressureOverride( MESSAGE_T *message ) { - BOOL result = f32ArrayOverride( message, &dialysatePumps[0].pumpTargetPressure, NUM_OF_DIALYSATE_PUMPS - 1 ); + BOOL result = f32ArrayOverride( message, &pumpTargetPressure[ 0 ], NUM_OF_DIALYSATE_PUMPS - 1 ); return result; } @@ -1015,7 +1060,7 @@ *************************************************************************/ BOOL testDialysatePumpMeasuredCurrentOverride( MESSAGE_T *message ) { - BOOL result = f32ArrayOverride( message, &dialysatePumps[0].dialysatePumpMeasuredCurrentA, NUM_OF_DIALYSATE_PUMPS - 1 ); + BOOL result = f32ArrayOverride( message, &dialysatePumpMeasuredCurrentA[ 0 ], NUM_OF_DIALYSATE_PUMPS - 1 ); return result; } @@ -1032,7 +1077,7 @@ *************************************************************************/ BOOL testDialysatePumpMeasuredDirectionOverride( MESSAGE_T *message ) { - BOOL result = u32ArrayOverride( message, &dialysatePumps[0].measuredDirection, NUM_OF_DIALYSATE_PUMPS - 1, 0, DIALYSATE_PUMP_FORWARD_DIR ); + BOOL result = u32ArrayOverride( message, &measuredDirection[ 0 ], NUM_OF_DIALYSATE_PUMPS - 1, 0, DIALYSATE_PUMP_FORWARD_DIR ); return result; } Index: firmware/App/Controllers/DialysatePumps.h =================================================================== diff -u -rb6d20d9e5c704a9f7ebceea9bb12731dac61fc2a -red39129abdca4ec343369d83494530b23621e052 --- firmware/App/Controllers/DialysatePumps.h (.../DialysatePumps.h) (revision b6d20d9e5c704a9f7ebceea9bb12731dac61fc2a) +++ firmware/App/Controllers/DialysatePumps.h (.../DialysatePumps.h) (revision ed39129abdca4ec343369d83494530b23621e052) @@ -32,41 +32,41 @@ // ********** public definitions ********** -#define MIN_DIALYSATE_PUMP_RPM 300 ///< Minimum RPM target for dialysate pump (though zero is allowed if turning pump off). -#define MAX_DIALYSATE_PUMP_RPM 4500 ///< Maximum RPM target for dialysate pump. +#define MIN_DIALYSATE_PUMP_RPM 350 ///< Minimum RPM target for dialysate pump (though zero is allowed if turning pump off). +#define MAX_DIALYSATE_PUMP_RPM 2700 ///< Maximum RPM target for dialysate pump. /// Enumeration of dialysate pumps. typedef enum DialysatePumps { - FRESH_DIALYSATE_PUMP = 0, ///< Fresh dialysate pump - DIALYSATE_PUMPS_FIRST = FRESH_DIALYSATE_PUMP, ///< First dialysate pump in list - SPENT_DIALYSATE_PUMP, ///< Spent dialysate pump - NUM_OF_DIALYSATE_PUMPS ///< Number of dialysate pumps + D12_PUMP = 0, ///< Fresh dialysate pump + DIALYSATE_PUMPS_FIRST = D12_PUMP, ///< First dialysate pump in list + D48_PUMP, ///< Spent dialysate pump + NUM_OF_DIALYSATE_PUMPS ///< Number of dialysate pumps } DIALYSATE_PUMPS_T; /// Dialysate pumps data publish typedef struct { - F32 freshDialPumpTargetRPM; ///< Fresh dialysate pump speed set point. - F32 spentDialPumpTargetRPM; ///< Spent dialysate pump speed set point. - F32 freshDialPumpMeasuredSpeed; ///< Fresh dialysate pump measured speed. - F32 spentDialPumpMeasuredSpeed; ///< Spent dialysate pump measured speed. - F32 freshDialPumpCurrentSpeed; ///< Fresh dialysate pump current speed. - F32 spentDialPumpCurrentSpeed; ///< Spent dialysate pump current speed. - U32 freshDialPumpState; ///< Fresh dialysate pump state machine state. - U32 spentDialPumpState; ///< Spent state machine state. - F32 freshDialPumpTargetPressure; ///< Fresh dialysate pump target pressure. - F32 spentDialPumpTargetPressure; ///< Spent dialysate pump target pressure. - F32 freshDialPumpMeasuredPressure; ///< Fresh dialysate pump measured pressure. - F32 spentDialPumpMeasuredPressure; ///< Spent dialysate pump measured pressure. - F32 freshDialPumpMeasuredCurrent; ///< Fresh dialysate pump measured current. - F32 spentDialPumpMeasuredCurrent; ///< Spent dialysate pump measured current. - U32 freshDialPumpControl; ///< Fresh dialysate pump control to check run/stop state. - U32 spentDialPumpControl; ///< Spent dialysate pump control to check run/stop state. - U32 freshDialPumpDirErrCnt; ///< Fresh dialysate pump direction error count. - U32 spentDialPumpDirErrCnt; ///< Spent dialysate pump direction error count. - U32 freshDialPumpMeasuredDir; ///< Fresh dialysate pump direction. - U32 spentDialPumpMeasuredDir; ///< Spent dialysate pump direction. + F32 d12PumpTargetRPM; ///< Fresh dialysate pump speed set point. + F32 d48PumpTargetRPM; ///< Spent dialysate pump speed set point. + F32 d12PumpMeasuredSpeed; ///< Fresh dialysate pump measured speed. + F32 d48PumpMeasuredSpeed; ///< Spent dialysate pump measured speed. + F32 d12PumpCurrentSpeed; ///< Fresh dialysate pump current speed. + F32 d48PumpCurrentSpeed; ///< Spent dialysate pump current speed. + U32 d12PumpState; ///< Fresh dialysate pump state machine state. + U32 d48PumpState; ///< Spent state machine state. + F32 d12PumpTargetPressure; ///< Fresh dialysate pump target pressure. + F32 d48PumpTargetPressure; ///< Spent dialysate pump target pressure. + F32 d12PumpMeasuredPressure; ///< Fresh dialysate pump measured pressure. + F32 d48PumpMeasuredPressure; ///< Spent dialysate pump measured pressure. + F32 d12PumpMeasuredCurrent; ///< Fresh dialysate pump measured current. + F32 d48PumpMeasuredCurrent; ///< Spent dialysate pump measured current. + U32 d12PumpControl; ///< Fresh dialysate pump control to check run/stop state. + U32 d48PumpControl; ///< Spent dialysate pump control to check run/stop state. + U32 d12PumpDirErrCnt; ///< Fresh dialysate pump direction error count. + U32 d48PumpDirErrCnt; ///< Spent dialysate pump direction error count. + U32 d12PumpMeasuredDir; ///< Fresh dialysate pump direction. + U32 d48PumpMeasuredDir; ///< Spent dialysate pump direction. } DIALYSATE_PUMPS_PUBLISH_DATA_T; // ********** public function prototypes ********** Index: firmware/App/Controllers/Heaters.c =================================================================== diff -u -r9102c5da21a15bdaf4bb3bc38795ceb064e3c443 -red39129abdca4ec343369d83494530b23621e052 --- firmware/App/Controllers/Heaters.c (.../Heaters.c) (revision 9102c5da21a15bdaf4bb3bc38795ceb064e3c443) +++ firmware/App/Controllers/Heaters.c (.../Heaters.c) (revision ed39129abdca4ec343369d83494530b23621e052) @@ -40,32 +40,35 @@ // ********** private definitions ********** -#define HEATERS_MAX_DUTY_CYCLE 1.00F ///< Heaters max duty cycle (100%). -#define HEATERS_MIN_DUTY_CYCLE 0.00F ///< Heaters minimum duty cycle (0.00%). +#define HEATERS_MAX_DUTY_CYCLE 1.00F ///< Heaters max duty cycle (100%) or ON state +#define HEATERS_MIN_DUTY_CYCLE 0.00F ///< Heaters minimum duty cycle (0.00%) or OFF state +#define D5_HEAT_ON 1.00F ///< Primary heater ON control #define HEATERS_DISINFECT_DUTY_CYCLE 0.80F ///< Heaters disinfect cycle. #define HEATERS_DISINFECT_TRANSFER_DUTY_CYCLE 0.60F ///< Heaters disinfect transfer duty cycle. #define HEATERS_DISINFECT_TEMPERATURE_DRIFT_C 3.0F ///< Heaters disinfect temperature drift in C. #define HEATERS_ZERO_DELTA_TEMP_C 0.0F ///< Heaters zero delta temperature in C. #define HEATERS_DUTY_CYCLE_CONVERSION_FACTOR 100.0F ///< Heaters duty cycle 0: OFF, 100: 100% duty cycle. +#define D45_HEAT_GAIN 10.0F ///< Trimmer heater gain for testing. -#define PRIMARY_HEATER_P_COEFFICIENT 1.0F ///< P Term for primary heater control. -#define PRIMARY_HEATER_I_COEFFICIENT 1.0F ///< I Term for primary heater control. -#define TRIMMER_HEATER_P_COEFFICIENT 1.0F ///< P Term for trimmer heater control. -#define TRIMMER_HEATER_I_COEFFICIENT 1.0F ///< I Term for trimmer heater control. +#define D5_HEAT_P_COEFFICIENT 1.0F ///< P Term for primary heater control. +#define D5_HEAT_I_COEFFICIENT 1.0F ///< I Term for primary heater control. +#define D45_HEAT_P_COEFFICIENT 1.0F ///< P Term for trimmer heater control. +#define D45_HEAT_I_COEFFICIENT 1.0F ///< I Term for trimmer heater control. #define HEATERS_DATA_PUBLISH_INTERVAL ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) ///< Heaters data publish interval. +#define HEATER_TEMP_CONTROL_TOLERANCE 2.0F ///< Primary Heater temp tolerance for ON/Off control #define HEATER_TARGET_TEMPERATURE_MIN 10.0F ///< Minimum allowed target temperature for the heaters. #define HEATER_TARGET_TEMPERATURE_MAX 90.0F ///< Maximum allowed target temperature for the heaters. -#define PRIMARY_HEATER_ON_NO_FLUID_TIMEOUT_MS ( 10 * MS_PER_SECOND ) ///< Primary heater on with no flow time out in milliseconds. -#define TRIMMER_HEATER_ON_NO_FLUID_TIMEOUT_MS ( 12 * MS_PER_SECOND ) ///< Trimmer heater on with no flow time out in milliseconds. +#define D5_HEAT_ON_NO_FLUID_TIMEOUT_MS ( 10 * MS_PER_SECOND ) ///< Primary heater on with no flow time out in milliseconds. +#define D45_HEAT_ON_NO_FLUID_TIMEOUT_MS ( 12 * MS_PER_SECOND ) ///< Trimmer heater on with no flow time out in milliseconds. #define HEATERS_MAX_OPERATING_VOLTAGE_V 24.0F ///< Heaters max operating voltage in volts. #define HEATERS_VOLTAGE_OUT_OF_RANGE_TIMEOUT_MS ( 2 * MS_PER_SECOND ) ///< Heaters voltage out of range time out in milliseconds. #define HEATERS_MAX_VOLTAGE_OUT_OF_RANGE_TOL 0.2F ///< Heaters max voltage out of range tolerance. -#define TRIMMER_HEATER_INITIAL_CONTROL_INTERVAL_COUNT ( ( 5 * MS_PER_SECOND ) / TASK_GENERAL_INTERVAL ) ///< Trimmer heater initial control interval count. -#define TRIMMER_HEATER_CONTROL_INTERVAL_COUNT ( ( 10 * MS_PER_SECOND ) / TASK_GENERAL_INTERVAL ) ///< Trimmer heater control interval count. -#define PRIMARY_HEATER_CONTROL_INTERVAL_COUNT ( ( 1 * MS_PER_SECOND ) / TASK_GENERAL_INTERVAL ) ///< Primary heater control interval count. +#define D45_HEAT_INITIAL_CONTROL_INTERVAL_COUNT ( ( 5 * MS_PER_SECOND ) / TASK_GENERAL_INTERVAL ) ///< Trimmer heater initial control interval count. +#define D45_HEAT_CONTROL_INTERVAL_COUNT ( ( 10 * MS_PER_SECOND ) / TASK_GENERAL_INTERVAL ) ///< Trimmer heater control interval count. +#define D5_HEAT_CONTROL_INTERVAL_COUNT ( ( 1 * MS_PER_SECOND ) / TASK_GENERAL_INTERVAL ) ///< Primary heater control interval count. #define DATA_PUBLISH_COUNTER_START_COUNT 70 ///< Data publish counter start count. @@ -74,11 +77,9 @@ /// Heaters data structure typedef struct { - F32 targetTempC; ///< Heater target temperature. HEATERS_STATE_T state; ///< Heater state. BOOL startHeaterSignal; ///< Heater start indication flag. BOOL heaterOnState; ///< Heater on/off status flag. - OVERRIDE_F32_T dutyCycle; ///< Heater duty cycle. F32 targetFlowLPM; ///< Heater target flow in L/min to calculate the duty cycle. F32 nomTargetFlowLPM; ///< Heater nominal target flow in L/min. BOOL hasTargetTempChanged; ///< Heater target temperature change flag indicator. @@ -96,6 +97,8 @@ } HEATER_START_CMD_PAYLOAD_T; static HEATER_STATUS_T heatersStatus[ NUM_OF_DD_HEATERS ]; ///< Heaters status. +static OVERRIDE_F32_T targetTempC[ NUM_OF_DD_HEATERS ]; ///< Heater target temperature. +static OVERRIDE_F32_T control[ NUM_OF_DD_HEATERS ]; ///< Heater control ( Primary : On/Off, Trimmer : Dutycycle). static U32 dataPublicationTimerCounter; ///< Data publication timer counter. static OVERRIDE_U32_T heatersDataPublishInterval = { HEATERS_DATA_PUBLISH_INTERVAL, HEATERS_DATA_PUBLISH_INTERVAL, 0, 0 }; ///< Heaters data publish time interval. @@ -106,8 +109,8 @@ static HEATERS_STATE_T handleHeaterStateControlToTarget( DD_HEATERS_T heater ); static HEATERS_STATE_T handleHeaterStateControlToDisinfectTarget( DD_HEATERS_T heater ); -static void setHeaterDutyCycle( DD_HEATERS_T heater ); -static F32 getHeaterDutyCycle( DD_HEATERS_T heater ); +static void setHeaterControl( DD_HEATERS_T heater ); +static F32 getHeaterControl( DD_HEATERS_T heater ); static void publishHeatersData( void ); //static void monitorHeatersVoltage( void ); @@ -126,35 +129,39 @@ for ( heater = DD_HEATERS_FIRST; heater < NUM_OF_DD_HEATERS; heater++ ) { - heatersStatus[ heater ].targetTempC = 0.0F; + targetTempC[ heater ].data = 0.0F; + targetTempC[ heater ].ovData = 0.0F; + targetTempC[ heater ].ovInitData = 0.0F; + targetTempC[ heater ].override = OVERRIDE_RESET; heatersStatus[ heater ].state = HEATER_EXEC_STATE_OFF; heatersStatus[ heater ].startHeaterSignal = FALSE; heatersStatus[ heater ].heaterOnState = FALSE; - heatersStatus[ heater ].dutyCycle.data = HEATERS_MIN_DUTY_CYCLE; - heatersStatus[ heater ].dutyCycle.ovData = HEATERS_MIN_DUTY_CYCLE; - heatersStatus[ heater ].dutyCycle.ovInitData = HEATERS_MIN_DUTY_CYCLE; - heatersStatus[ heater ].dutyCycle.override = OVERRIDE_RESET; + control[ heater ].data = HEATERS_MIN_DUTY_CYCLE; + control[ heater ].ovData = HEATERS_MIN_DUTY_CYCLE; + control[ heater ].ovInitData = HEATERS_MIN_DUTY_CYCLE; + control[ heater ].override = OVERRIDE_RESET; heatersStatus[ heater ].targetFlowLPM = 0.0F; heatersStatus[ heater ].nomTargetFlowLPM = 0.0F; heatersStatus[ heater ].hasTargetTempChanged = FALSE; heatersStatus[ heater ].controlIntervalCounter = 0; heatersStatus[ heater ].isThisFirstControl = TRUE; heatersStatus[ heater ].prevDiaTargetFlowLPM = 0.0F; + setHeaterControl( heater ); } // Initialize the primary controller PI controller - initializePIController( PI_CONTROLLER_ID_PRIMARY_HEATER, HEATERS_MIN_DUTY_CYCLE, PRIMARY_HEATER_P_COEFFICIENT, PRIMARY_HEATER_I_COEFFICIENT, + initializePIController( PI_CONTROLLER_ID_D5_HEAT, HEATERS_MIN_DUTY_CYCLE, D5_HEAT_P_COEFFICIENT, D5_HEAT_I_COEFFICIENT, HEATERS_MIN_DUTY_CYCLE, HEATERS_MAX_DUTY_CYCLE ); // Initialize the trimmer heater PI controller - initializePIController( PI_CONTROLLER_ID_TRIMMER_HEATER, HEATERS_MIN_DUTY_CYCLE, TRIMMER_HEATER_P_COEFFICIENT, TRIMMER_HEATER_I_COEFFICIENT, + initializePIController( PI_CONTROLLER_ID_D45_HEAT, HEATERS_MIN_DUTY_CYCLE, D45_HEAT_P_COEFFICIENT, D45_HEAT_I_COEFFICIENT, HEATERS_MIN_DUTY_CYCLE, HEATERS_MAX_DUTY_CYCLE ); // Initialize the persistent alarms - //initPersistentAlarm( ALARM_ID_DD_PRIMARY_HEATER_VOLTAGE_OUT_OF_RANGE, 0, HEATERS_VOLTAGE_OUT_OF_RANGE_TIMEOUT_MS ); - //initPersistentAlarm( ALARM_ID_DD_TRIMMER_HEATER_VOLTAGE_OUT_OF_RANGE, 0, HEATERS_VOLTAGE_OUT_OF_RANGE_TIMEOUT_MS ); - initPersistentAlarm( ALARM_ID_DD_FLUID_TOO_LOW_WHILE_PRIMARY_HEATER_IS_ON, 0, PRIMARY_HEATER_ON_NO_FLUID_TIMEOUT_MS ); - initPersistentAlarm( ALARM_ID_DD_FLUID_TOO_LOW_WHILE_TRIMMER_HEATER_IS_ON, 0, TRIMMER_HEATER_ON_NO_FLUID_TIMEOUT_MS ); + //initPersistentAlarm( ALARM_ID_DD_D5_HEAT_VOLTAGE_OUT_OF_RANGE, 0, HEATERS_VOLTAGE_OUT_OF_RANGE_TIMEOUT_MS ); + //initPersistentAlarm( ALARM_ID_DD_D45_HEAT_VOLTAGE_OUT_OF_RANGE, 0, HEATERS_VOLTAGE_OUT_OF_RANGE_TIMEOUT_MS ); + initPersistentAlarm( ALARM_ID_DD_FLUID_TOO_LOW_WHILE_D5_HEAT_IS_ON, 0, D5_HEAT_ON_NO_FLUID_TIMEOUT_MS ); + initPersistentAlarm( ALARM_ID_DD_FLUID_TOO_LOW_WHILE_D45_HEAT_IS_ON, 0, D45_HEAT_ON_NO_FLUID_TIMEOUT_MS ); } /*********************************************************************//** @@ -182,7 +189,7 @@ // Check if the requested temperature is within the allowed range if ( ( targetTemperature >= HEATER_TARGET_TEMPERATURE_MIN ) && ( targetTemperature <= HEATER_TARGET_TEMPERATURE_MAX ) ) { - heatersStatus[ heater ].targetTempC = targetTemperature; + targetTempC[ heater ].data = targetTemperature; heatersStatus[ heater ].hasTargetTempChanged = TRUE; result = TRUE; } @@ -200,13 +207,15 @@ * The getHeaterTargetTemperature function returns the given heater target * temperature. * @details \b Inputs: none - * @details \b Outputs: heaterStatus + * @details \b Outputs: targetTempC * @param heater: heater ID to get heater target temperature. * @return the given heater target temperature *************************************************************************/ F32 getHeaterTargetTemperature( DD_HEATERS_T heater ) { - return heatersStatus[ heater ].targetTempC; + F32 targetTemp = getF32OverrideValue( &targetTempC[ heater ] ); + + return targetTemp; } /*********************************************************************//** @@ -230,26 +239,21 @@ * @details \b Outputs: startHeaterSignal * @details \b Alarms: ALARM_ID_DD_SOFTWARE_FAULT when invalid heater ID passed * @param heater: heater ID to set the heater start signal. - * @return status TRUE when heater start flag set otherwise, FALSE + * @return None *************************************************************************/ -BOOL startHeater( DD_HEATERS_T heater ) +void startHeater( DD_HEATERS_T heater ) { - BOOL status = FALSE; - if( heater < NUM_OF_DD_HEATERS ) { if ( HEATER_EXEC_STATE_OFF == heatersStatus[ heater ].state ) { heatersStatus[ heater ].startHeaterSignal = TRUE; - status = TRUE; } } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_HEATERS_INVALID_HEATER_ID_SELECTED, heater ) } - - return status; } /*********************************************************************//** @@ -268,11 +272,11 @@ { heatersStatus[ heater ].startHeaterSignal = FALSE; heatersStatus[ heater ].heaterOnState = FALSE; - heatersStatus[ heater ].dutyCycle.data = HEATERS_MIN_DUTY_CYCLE; + control[ heater ].data = HEATERS_MIN_DUTY_CYCLE; heatersStatus[ heater ].state = HEATER_EXEC_STATE_OFF; // update duty cycle - setHeaterDutyCycle( heater ); + setHeaterControl( heater ); } else { @@ -295,13 +299,6 @@ for ( heater = DD_HEATERS_FIRST; heater < NUM_OF_DD_HEATERS; heater++ ) { - // Check if the heater is requested to be off - if ( FALSE == heatersStatus[ heater ].heaterOnState ) - { - // stop the heater - stopHeater( heater ); - } - switch( heatersStatus[ heater ].state ) { case HEATER_EXEC_STATE_OFF: @@ -326,6 +323,12 @@ SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_HEATERS_INVALID_EXEC_STATE, heater ); break; } + // Check if the heater is requested to be off + if ( FALSE == heatersStatus[ heater ].heaterOnState ) + { + // stop the heater + stopHeater( heater ); + } } } @@ -354,14 +357,14 @@ switch ( heater ) { - case DD_PRIMARY_HEATER: - alarm = ALARM_ID_DD_FLUID_TOO_LOW_WHILE_PRIMARY_HEATER_IS_ON; - isLevelLow = ( ( getLevelStatus( FLOATER_1 ) != 0 )? FALSE : TRUE ); + case D5_HEAT: + alarm = ALARM_ID_DD_FLUID_TOO_LOW_WHILE_D5_HEAT_IS_ON; + isLevelLow = ( ( getLevelStatus( D6_LEVL ) != 0 )? FALSE : TRUE ); break; - case DD_TRIMMER_HEATER: - alarm = ALARM_ID_DD_FLUID_TOO_LOW_WHILE_TRIMMER_HEATER_IS_ON; - isLevelLow = ( ( getLevelStatus( SPENT_DIALYSATE_LEVEL ) != 0 )? FALSE : TRUE ); + case D45_HEAT: + alarm = ALARM_ID_DD_FLUID_TOO_LOW_WHILE_D45_HEAT_IS_ON; + isLevelLow = ( ( getLevelStatus( D46_LEVL ) != 0 )? FALSE : TRUE ); break; default: @@ -373,8 +376,14 @@ } else { - checkPersistentAlarm( ALARM_ID_DD_FLUID_TOO_LOW_WHILE_PRIMARY_HEATER_IS_ON, FALSE, 0.0F, 0.0F ); - checkPersistentAlarm( ALARM_ID_DD_FLUID_TOO_LOW_WHILE_TRIMMER_HEATER_IS_ON, FALSE, 0.0F, 0.0F ); + if ( D5_HEAT == heater ) + { + checkPersistentAlarm( ALARM_ID_DD_FLUID_TOO_LOW_WHILE_D5_HEAT_IS_ON, FALSE, 0.0F, 0.0F ); + } + else + { + checkPersistentAlarm( ALARM_ID_DD_FLUID_TOO_LOW_WHILE_D45_HEAT_IS_ON, FALSE, 0.0F, 0.0F ); + } } } @@ -422,23 +431,41 @@ static HEATERS_STATE_T handleHeaterStateRampToTarget( DD_HEATERS_T heater ) { HEATERS_STATE_T state = HEATER_EXEC_STATE_RAMP_TO_TARGET; - F32 dutyCycle = 0.0F; + F32 ctrl = 0.0F; DD_OP_MODE_T opMode = getCurrentOperationMode(); + F32 targetTemperature = getHeaterTargetTemperature( heater ); - if ( DD_MODE_HEAT != opMode ) + if ( D5_HEAT == heater ) { - dutyCycle = ( ( heatersStatus[ heater ].targetTempC / HEATER_TARGET_TEMPERATURE_MAX ) * HEATERS_DUTY_CYCLE_CONVERSION_FACTOR ) + FLOAT_TO_INT_ROUNDUP_OFFSET; - state = HEATER_EXEC_STATE_CONTROL_TO_TARGET; + if ( DD_MODE_HEAT != opMode ) + { + control[ heater ].data = D5_HEAT_ON; + state = HEATER_EXEC_STATE_CONTROL_TO_TARGET; + } + else + { + // TODO : Calculate required duty cycle + state = HEATER_EXEC_STATE_CONTROL_TO_DISINFECT_TARGET; + } } else { - // TODO : Calculate required duty cycle - state = HEATER_EXEC_STATE_CONTROL_TO_DISINFECT_TARGET; + if ( DD_MODE_HEAT != opMode ) + { + ctrl = ( ( targetTemperature / HEATER_TARGET_TEMPERATURE_MAX ) * HEATERS_DUTY_CYCLE_CONVERSION_FACTOR ) + FLOAT_TO_INT_ROUNDUP_OFFSET; + state = HEATER_EXEC_STATE_CONTROL_TO_TARGET; + } + else + { + // TODO : Calculate required duty cycle + state = HEATER_EXEC_STATE_CONTROL_TO_DISINFECT_TARGET; + } + + // Update the duty cycle + control[ heater ].data = ctrl; } - // Update the duty cycle - heatersStatus[ heater ].dutyCycle.data = dutyCycle; - setHeaterDutyCycle( heater ); + setHeaterControl( heater ); return state; } @@ -456,22 +483,43 @@ static HEATERS_STATE_T handleHeaterStateControlToTarget( DD_HEATERS_T heater ) { HEATERS_STATE_T state = HEATER_EXEC_STATE_CONTROL_TO_TARGET; - F32 targetTemperature = heatersStatus[ heater ].targetTempC; + F32 targetTemperature = getHeaterTargetTemperature( heater ); F32 measuredTemperature = 0.0F; - F32 dutyCycle = 0.0F; + F32 ctrl = 0.0F; - if( ++heatersStatus[ heater ].controlIntervalCounter > PRIMARY_HEATER_CONTROL_INTERVAL_COUNT ) + if( ++heatersStatus[ heater ].controlIntervalCounter > D5_HEAT_CONTROL_INTERVAL_COUNT ) { switch ( heater ) { - case DD_PRIMARY_HEATER: - measuredTemperature = getTemperatureValue( (U32)TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER ); - dutyCycle = runPIController( PI_CONTROLLER_ID_PRIMARY_HEATER, targetTemperature, measuredTemperature ); + case D5_HEAT: + measuredTemperature = getTemperatureValue( (U32)D4_TEMP ); + if ( measuredTemperature >= targetTemperature ) + { + // Turn off heater + control[ heater ].data = HEATERS_MIN_DUTY_CYCLE; + } + else + { + // Turn On heater + control[ heater ].data = D5_HEAT_ON; + } + + //control = runPIController( PI_CONTROLLER_ID_D5_HEAT, targetTemperature, measuredTemperature ); break; - case DD_TRIMMER_HEATER: - measuredTemperature = getTemperatureValue( (U32)TEMPSENSORS_TRIMMER_HEATER ); - dutyCycle = runPIController( PI_CONTROLLER_ID_TRIMMER_HEATER, targetTemperature, measuredTemperature ); + case D45_HEAT: + measuredTemperature = getTemperatureValue( (U32)D50_TEMP ); + //control = runPIController( PI_CONTROLLER_ID_D45_HEAT, targetTemperature, measuredTemperature ); + if ( targetTemperature > 0.0F ) + { + ctrl = HEATERS_MAX_DUTY_CYCLE - ( measuredTemperature / targetTemperature ); + ctrl = ( ctrl < 0.0F ? HEATERS_MIN_DUTY_CYCLE: ctrl * D45_HEAT_GAIN ); + //Apply dutycycle limit + ctrl = MIN( ctrl, HEATERS_MAX_DUTY_CYCLE ); + ctrl = MAX( ctrl, HEATERS_MIN_DUTY_CYCLE ); + } + + control[ heater ].data = ( ctrl * HEATERS_DUTY_CYCLE_CONVERSION_FACTOR ) + FLOAT_TO_INT_ROUNDUP_OFFSET; break; default: @@ -480,10 +528,9 @@ } heatersStatus[ heater ].hasTargetTempChanged = FALSE; - heatersStatus[ heater ].dutyCycle.data = ( dutyCycle * HEATERS_DUTY_CYCLE_CONVERSION_FACTOR ) + FLOAT_TO_INT_ROUNDUP_OFFSET; heatersStatus[ heater ].controlIntervalCounter = 0; - setHeaterDutyCycle( heater ); + setHeaterControl( heater ); } return state; @@ -505,37 +552,38 @@ //TODO : update dutycycle for the heat disinfect state - setHeaterDutyCycle( DD_TRIMMER_HEATER ); - setHeaterDutyCycle( DD_PRIMARY_HEATER ); + setHeaterControl( D45_HEAT ); + setHeaterControl( D5_HEAT ); return state; } /*********************************************************************//** * @brief - * The setHeaterDutyCycle function sets the duty cycle of a heater. - * @details \b Inputs: dutyCycle + * The setHeaterControl function sets the duty cycle of a heater. + * @details \b Inputs: control * @details \b Outputs: FPGA heater control * @details \b Alarms: ALARM_ID_DD_SOFTWARE_FAULT when invalid heater ID * is selected. * @param heater: The heater Id that its duty cycle is set * @return none *************************************************************************/ -static void setHeaterDutyCycle( DD_HEATERS_T heater ) +static void setHeaterControl( DD_HEATERS_T heater ) { if ( heater < NUM_OF_DD_HEATERS ) { - F32 duty; + F32 control; - duty = getHeaterDutyCycle( heater ); + control = getHeaterControl( heater ); - if ( DD_PRIMARY_HEATER == heater ) + if ( D5_HEAT == heater ) { - setFPGAPrimaryHeaterPWMControl( (U08)duty ); + BOOL heaterCntrl = (BOOL)control; + setFPGACPrimaryHeaterOnOffControl( heaterCntrl ); } else { - setFPGATrimmerHeaterPWMControl( (U08)duty ); + setFPGATrimmerHeaterPWMControl( (U08)control ); } } else @@ -546,15 +594,15 @@ /*********************************************************************//** * @brief - * The getHeaterDutyCycle function returns the heater's duty cycle. + * The getHeaterControl function returns the heater's duty cycle. * @details \b Inputs: heaterStatus * @details \b Outputs: none * @param heater: The heater Id to get the duty cycle. * @return PWM duty cycle for the given heater *************************************************************************/ -static F32 getHeaterDutyCycle( DD_HEATERS_T heater ) +static F32 getHeaterControl( DD_HEATERS_T heater ) { - F32 duty = getF32OverrideValue( &heatersStatus[ heater ].dutyCycle ); + F32 duty = getF32OverrideValue( &control[ heater ] ); return duty; } @@ -564,9 +612,9 @@ * The monitorHeatersVoltage function monitors the heaters' voltages * @details \b Inputs: Voltage range * @details \b Outputs: none - * @details \b Alarms: ALARM_ID_DD_MAIN_PRIMARY_HEATER_VOLTAGE_OUT_OF_RANGE when + * @details \b Alarms: ALARM_ID_DD_MAIN_D5_HEAT_VOLTAGE_OUT_OF_RANGE when * primary heater voltage found out of range. - * @details \b Alarms: ALARM_ID_DD_TRIMMER_HEATER_VOLTAGE_OUT_OF_RANGE when + * @details \b Alarms: ALARM_ID_D45_HEAT_VOLTAGE_OUT_OF_RANGE when * trimmer heater voltage found out of range. * @return none *************************************************************************/ @@ -576,8 +624,8 @@ // F32 trimmerVoltage = getMonitoredLineLevel( MONITORED_LINE_24V_GND_TRIM_HTR_V ); // // // Voltage to PWM is reverse. If PWM = 0 -> V = 24V -// F32 mainPriDC = getHeaterDutyCycle( DD_PRIMARY_HEATER ); -// F32 trimmerDC = getHeaterDutyCycle( DD_TRIMMER_HEATER ); +// F32 mainPriDC = getHeaterControl( D5_HEAT ); +// F32 trimmerDC = getHeaterControl( D45_HEAT ); // // // The expected voltage is the inverse of the duty cycle // F32 mainPriExpectedVoltage = HEATERS_MAX_OPERATING_VOLTAGE_V * ( 1.0F - mainPriDC ); @@ -587,15 +635,15 @@ // BOOL isTrimmerOut = FALSE; // // // If the system is DVT, check the FPGA persistent alarm of the main primary heater's voltage ADC -// checkFPGAPersistentAlarms( FPGA_PERS_ERROR_MAIN_PRIMARY_HEATER_VOLTAGE_ADC, getFPGAHeaterGateADCReadCount() ); +// checkFPGAPersistentAlarms( FPGA_PERS_ERROR_MAIN_D5_HEAT_VOLTAGE_ADC, getFPGAHeaterGateADCReadCount() ); // // isMainPriOut = ( fabs( mainPriExpectedVoltage - mainPriVoltage ) > HEATERS_VOLTAGE_TOLERANCE_V ? TRUE : FALSE ); // isTrimmerOut = ( fabs( trimmerExpectedVoltage - trimmerVoltage ) > HEATERS_VOLTAGE_TOLERANCE_V ? TRUE : FALSE ); // // if ( getCurrentOperationMode() != DD_MODE_INIT ) // { -// checkPersistentAlarm( ALARM_ID_DD_MAIN_PRIMARY_HEATER_VOLTAGE_OUT_OF_RANGE, isMainPriOut, mainPriDC, HEATERS_VOLTAGE_TOLERANCE_V ); -// checkPersistentAlarm( ALARM_ID_DD_TRIMMER_HEATER_VOLTAGE_OUT_OF_RANGE, isTrimmerOut, trimmerDC, HEATERS_VOLTAGE_TOLERANCE_V ); +// checkPersistentAlarm( ALARM_ID_DD_MAIN_D5_HEAT_VOLTAGE_OUT_OF_RANGE, isMainPriOut, mainPriDC, HEATERS_VOLTAGE_TOLERANCE_V ); +// checkPersistentAlarm( ALARM_ID_D45_HEAT_VOLTAGE_OUT_OF_RANGE, isTrimmerOut, trimmerDC, HEATERS_VOLTAGE_TOLERANCE_V ); // } //} @@ -615,14 +663,14 @@ { HEATERS_DATA_T data; - data.mainPrimayHeaterDC = getHeaterDutyCycle( DD_PRIMARY_HEATER ) * FRACTION_TO_PERCENT_FACTOR; - data.trimmerHeaterDC = getHeaterDutyCycle( DD_TRIMMER_HEATER ) * FRACTION_TO_PERCENT_FACTOR; - data.primaryTargetTemp = heatersStatus[ DD_PRIMARY_HEATER ].targetTempC; - data.trimmerTargetTemp = heatersStatus[ DD_TRIMMER_HEATER ].targetTempC; - data.primaryHeaterState = heatersStatus[ DD_PRIMARY_HEATER ].state; - data.trimmerHeaterState = heatersStatus[ DD_TRIMMER_HEATER ].state; - data.primaryControlCounter = heatersStatus[ DD_PRIMARY_HEATER ].controlIntervalCounter; - data.trimmerControlCounter = heatersStatus[ DD_TRIMMER_HEATER ].controlIntervalCounter; + data.d5_HeaterDC = getHeaterControl( D5_HEAT ); + data.d45_HeaterDC = getHeaterControl( D45_HEAT ); + data.d5_HeaterTargetTemp = getHeaterTargetTemperature( D5_HEAT ); + data.d45_HeaterTargetTemp = getHeaterTargetTemperature( D45_HEAT ); + data.d5_HeaterState = heatersStatus[ D5_HEAT ].state; + data.d45_HeaterState = heatersStatus[ D45_HEAT ].state; + data.d5_HeaterControlCounter = heatersStatus[ D5_HEAT ].controlIntervalCounter; + data.d45_HeaterControlCounter = heatersStatus[ D45_HEAT ].controlIntervalCounter; dataPublicationTimerCounter = 0; @@ -665,13 +713,30 @@ *************************************************************************/ BOOL testHeaterDutyCycleOverride( MESSAGE_T *message ) { - BOOL result = f32ArrayOverride( message, &heatersStatus[0].dutyCycle, NUM_OF_DD_HEATERS - 1 ); + BOOL result = f32ArrayOverride( message, &control[ 0 ], NUM_OF_DD_HEATERS - 1 ); return result; } /*********************************************************************//** * @brief + * The testHeaterTargetTemperatureOverride function overrides the specified heater's + * target temperature. + * @details \b Inputs: targetTempC + * @details \b Outputs: targetTempC + * @param message Override message from Dialin which includes an ID of + * the heater to override and the target temperature of the heater. + * @return TRUE if the override was successful otherwise FALSE + *************************************************************************/ +BOOL testHeaterTargetTemperatureOverride( MESSAGE_T *message ) +{ + BOOL result = f32ArrayOverride( message, &targetTempC[ 0 ], NUM_OF_DD_HEATERS - 1 ); + + return result; +} + +/*********************************************************************//** + * @brief * The testHeaterStartStopOverride function starts/stops a given heater * at mentioned temperature. * @details \b Inputs: tester logged in Index: firmware/App/Controllers/Heaters.h =================================================================== diff -u -rb6d20d9e5c704a9f7ebceea9bb12731dac61fc2a -red39129abdca4ec343369d83494530b23621e052 --- firmware/App/Controllers/Heaters.h (.../Heaters.h) (revision b6d20d9e5c704a9f7ebceea9bb12731dac61fc2a) +++ firmware/App/Controllers/Heaters.h (.../Heaters.h) (revision ed39129abdca4ec343369d83494530b23621e052) @@ -37,30 +37,30 @@ /// Name of DD heaters typedef enum Heaters { - DD_PRIMARY_HEATER = 0, ///< DD primary heater - DD_HEATERS_FIRST = DD_PRIMARY_HEATER, ///< First heater - DD_TRIMMER_HEATER, ///< DD trimmer heater + D5_HEAT = 0, ///< DD primary heater + DD_HEATERS_FIRST = D5_HEAT, ///< First heater + D45_HEAT, ///< DD trimmer heater NUM_OF_DD_HEATERS, ///< Number of the heaters } DD_HEATERS_T; /// Heaters data structure. typedef struct { - F32 mainPrimayHeaterDC; ///< Main primary heater DC - F32 trimmerHeaterDC; ///< Trimmer heater DC - F32 primaryTargetTemp; ///< Primary heater target temperature - F32 trimmerTargetTemp; ///< Trimmer heater target temperature - U32 primaryHeaterState; ///< Primary heater state - U32 trimmerHeaterState; ///< Trimmer heater state - U32 primaryControlCounter; ///< Primary heater control interval count - U32 trimmerControlCounter; ///< Trimmer heater control interval count + F32 d5_HeaterDC; ///< Main primary heater Duty Cycle + F32 d45_HeaterDC; ///< Trimmer heater Duty Cycle + F32 d5_HeaterTargetTemp; ///< Primary heater target temperature + F32 d45_HeaterTargetTemp; ///< Trimmer heater target temperature + U32 d5_HeaterState; ///< Primary heater state + U32 d45_HeaterState; ///< Trimmer heater state + U32 d5_HeaterControlCounter; ///< Primary heater control interval count + U32 d45_HeaterControlCounter; ///< Trimmer heater control interval count } HEATERS_DATA_T; // ********** Public function prototypes ********** void initHeaters( void ); BOOL setHeaterTargetTemperature( DD_HEATERS_T heater, F32 targetTemperature ); -BOOL startHeater( DD_HEATERS_T heater ); +void startHeater( DD_HEATERS_T heater ); F32 getHeaterTargetTemperature( DD_HEATERS_T heater ); BOOL isHeaterOn( DD_HEATERS_T heater ); void stopHeater( DD_HEATERS_T heater ); @@ -69,6 +69,7 @@ BOOL testHeatersDataPublishIntervalOverride( MESSAGE_T *message ); BOOL testHeaterDutyCycleOverride( MESSAGE_T *message ); +BOOL testHeaterTargetTemperatureOverride( MESSAGE_T *message ); BOOL testHeaterStartStopOverride( MESSAGE_T *message ); /**@}*/ Index: firmware/App/Controllers/Valves.c =================================================================== diff -u -r9102c5da21a15bdaf4bb3bc38795ceb064e3c443 -red39129abdca4ec343369d83494530b23621e052 --- firmware/App/Controllers/Valves.c (.../Valves.c) (revision 9102c5da21a15bdaf4bb3bc38795ceb064e3c443) +++ firmware/App/Controllers/Valves.c (.../Valves.c) (revision ed39129abdca4ec343369d83494530b23621e052) @@ -18,26 +18,26 @@ #include // For memcpy #include "FpgaDD.h" -#include "MessageSupport.h" -#include "Messaging.h" +#include "MessageSupport.h" +#include "Messaging.h" #include "TaskPriority.h" #include "Timers.h" #include "Valves.h" - -/** - * @addtogroup Valves - * @{ - */ - + +/** + * @addtogroup Valves + * @{ + */ + // ********** private definitions ********** #define DEENERGIZED 0 ///< 0 for de-energized valve. #define ENERGIZED 1 ///< 1 for energized valve. -#define ALL_VALVES_DEENERGIZED 0x0000 ///< 0 in U16 bit field for all valves. - -#define MAX_VALVE_STATE_MISMATCH_TIMER_COUNT (100 / TASK_PRIORITY_INTERVAL ) ///< Maximum time commanded valves state can fail to match read back valve states in a row. - -#define VALVES_STATE_PUB_INTERVAL ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) ///< Interval ( ms / task time) at which valves states are published on CAN bus. +#define ALL_VALVES_DEENERGIZED 0x0000 ///< 0 in U16 bit field for all valves. + +#define MAX_VALVE_STATE_MISMATCH_TIMER_COUNT (100 / TASK_PRIORITY_INTERVAL ) ///< Maximum time commanded valves state can fail to match read back valve states in a row. + +#define VALVES_STATE_PUB_INTERVAL ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) ///< Interval ( ms / task time) at which valves states are published on CAN bus. #define DATA_PUBLISH_COUNTER_START_COUNT 50 ///< Data publish counter start count. /// Payload record structure for valve open/close request @@ -46,40 +46,40 @@ U32 valveID; ///< ValveID ( valid range 0 to 28 ) U32 valveState; ///< Valve state ( Open : 0, closed :1) } VALVE_CMD_PAYLOAD_T; - -// ********** private data ********** - -static U32 valvesStatesPublicationTimerCounter; ///< Timer counter used to schedule valve state publication to CAN bus. + +// ********** private data ********** + +static U32 valvesStatesPublicationTimerCounter; ///< Timer counter used to schedule valve state publication to CAN bus. static U16 commandedValvesStates; ///< Initialize commanded valves states bit field. static U08 commandedBCValveStates; ///< Initialize balancing chamber commanded valves states bit field. -static U08 commandedUFValveStates; ///< Initialize ultra filtration commanded valves states bit field. +static U08 commandedUFValveStates; ///< Initialize ultra filtration commanded valves states bit field. static U32 valveStateMismatchTimerCounter; ///< Initialize valve state mismatch timer. static U32 pendingValveStateChanges[ NUM_OF_VALVES ]; ///< Delayed (pending) valve state changes. -static U32 pendingValveStateChangeCountDowns[ NUM_OF_VALVES ]; ///< Delayed (pending) valve state change count down timers (in task intervals). +static U32 pendingValveStateChangeCountDowns[ NUM_OF_VALVES ]; ///< Delayed (pending) valve state change count down timers (in task intervals). static OVERRIDE_U32_T valveStates[ NUM_OF_VALVES ]; ///< Currently commanded valves states. -static OVERRIDE_U32_T valveSensedStates[ NUM_OF_VALVES ]; ///< Valve sensed states override. -static OVERRIDE_U32_T valvesStatesPublishInterval = { VALVES_STATE_PUB_INTERVAL, VALVES_STATE_PUB_INTERVAL, 0, 0 }; ///< Interval (in ms/task interval) at which to publish valves state to CAN bus. +static OVERRIDE_U32_T valveSensedStates[ NUM_OF_VALVES ]; ///< Valve sensed states override. +static OVERRIDE_U32_T valvesStatesPublishInterval = { VALVES_STATE_PUB_INTERVAL, VALVES_STATE_PUB_INTERVAL, 0, 0 }; ///< Interval (in ms/task interval) at which to publish valves state to CAN bus. -// ********** private function prototypes ********** +// ********** private function prototypes ********** static void publishValvesStates( void ); static void readCommandedValveStates( void ); static BOOL checkValveStateName( VALVES_T valveID, VALVE_STATE_NAMES_T valveStateName ); static U32 convertValveStateNameToValveState( VALVE_STATE_NAMES_T valveStateName ); static U32 getValveState( U32 valveID ); - -/*********************************************************************//** - * @brief - * The initValves function initializes the Valves unit. - * @details \b Inputs: none + +/*********************************************************************//** + * @brief + * The initValves function initializes the Valves unit. + * @details \b Inputs: none * @details \b Outputs: valveStates, pendingValveStateChanges, valveSensedStates, * pendingValveStateChangeCountDowns, valveStateMismatchCounter, - * commandedValvesStates - * @return none - *************************************************************************/ -void initValves( void ) -{ + * commandedValvesStates + * @return none + *************************************************************************/ +void initValves( void ) +{ U32 i; // initialize commanded valve states @@ -102,50 +102,50 @@ commandedBCValveStates = ALL_VALVES_DEENERGIZED; commandedUFValveStates = ALL_VALVES_DEENERGIZED; valveStateMismatchTimerCounter = 0; - valvesStatesPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; // reset valves states publication timer + valvesStatesPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; // reset valves states publication timer readCommandedValveStates(); - // initially set all valves to de-energized state via FPGA + // initially set all valves to de-energized state via FPGA setFPGAValveStates( commandedValvesStates ); setFPGABCValveStates( commandedBCValveStates ); - setFPGAUFValveStates( commandedUFValveStates ); -} - -/*********************************************************************//** - * @brief - * The execValves function executes the valves driver. + setFPGAUFValveStates( commandedUFValveStates ); +} + +/*********************************************************************//** + * @brief + * The execValves function executes the valves driver. * @details \b Inputs: valvesStates, valveStateMismatchCounter * pendingValveStateChangeCountDowns, commandedValvesStates, - * commandedBCValveStates , commandedUFValveStates + * commandedBCValveStates , commandedUFValveStates * @details \b Outputs: valvesStates, valveStateMismatchCounter * pendingValveStateChanges, valve controls * @details \b Alarm: ALARM_ID_DD_VALVE_CONTROL_FAILURE when FPGA read back - * valve state mismatches with the commanded valve state after defined time (100ms). - * @return none - *************************************************************************/ -void execValves( void ) + * valve state mismatches with the commanded valve state after defined time (100ms). + * @return none + *************************************************************************/ +void execValves( void ) { U32 i; - // get valves states from FPGA + // get valves states from FPGA U16 readValvesStates = getFPGAValveStates(); U08 readValveBCStates = getFPGAValveBCStates(); U08 readValveUFStates = getFPGAValveUFStates(); - // Verify read back FPGA valve states match last commanded valve states + // Verify read back FPGA valve states match last commanded valve states if ( ( readValvesStates != commandedValvesStates ) || ( readValveBCStates != commandedBCValveStates ) || - ( readValveUFStates != commandedUFValveStates ) ) - { - valveStateMismatchTimerCounter++; // increment valve state mismatch counter by 1 - if ( valveStateMismatchTimerCounter > MAX_VALVE_STATE_MISMATCH_TIMER_COUNT ) - { - activateAlarmNoData( ALARM_ID_DD_VALVE_CONTROL_FAILURE ); - } - } - else - { - valveStateMismatchTimerCounter = 0; + ( readValveUFStates != commandedUFValveStates ) ) + { + valveStateMismatchTimerCounter++; // increment valve state mismatch counter by 1 + if ( valveStateMismatchTimerCounter > MAX_VALVE_STATE_MISMATCH_TIMER_COUNT ) + { + activateAlarmNoData( ALARM_ID_DD_VALVE_CONTROL_FAILURE ); + } } + else + { + valveStateMismatchTimerCounter = 0; + } // Handle pending delayed valve state changes for ( i = 0; i < NUM_OF_VALVES; i++ ) @@ -159,17 +159,17 @@ pendingValveStateChanges[ i ] = DEENERGIZED; } } - } - - // Set valves states (via FPGA) to currently commanded states - readCommandedValveStates(); + } + + // Set valves states (via FPGA) to currently commanded states + readCommandedValveStates(); setFPGAValveStates( commandedValvesStates ); setFPGABCValveStates( commandedBCValveStates ); setFPGAUFValveStates( commandedUFValveStates ); - // Publish valve states on interval - publishValvesStates(); -} + // Publish valve states on interval + publishValvesStates(); +} /*********************************************************************//** * @brief @@ -207,45 +207,48 @@ commandedUFValveStates |= ( getValveState( i ) == ENERGIZED ? 0x01 << ( i - FIRST_UF_VALVE ) : 0 ); } } - -/*********************************************************************//** - * @brief - * The checkValveStateName function checks the validity of requested valve - * state name for given valve. - * @details \b Inputs: none + +/*********************************************************************//** + * @brief + * The checkValveStateName function checks the validity of requested valve + * state name for given valve. + * @details \b Inputs: none * @details \b Outputs: none - * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when invalid valve ID passed. - * @param valveID ID of valve to check a valve state name for - * @param valveStateName valve state name to check for given valve ID - * @return TRUE if given valveStateName is appropriate for given valve ID, FALSE if not. - *************************************************************************/ -static BOOL checkValveStateName( VALVES_T valveID, VALVE_STATE_NAMES_T valveStateName ) -{ - BOOL result = FALSE; // initialize result flag to FALSE - - switch ( valveStateName ) - { + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when invalid valve ID passed. + * @param valveID ID of valve to check a valve state name for + * @param valveStateName valve state name to check for given valve ID + * @return TRUE if given valveStateName is appropriate for given valve ID, FALSE if not. + *************************************************************************/ +static BOOL checkValveStateName( VALVES_T valveID, VALVE_STATE_NAMES_T valveStateName ) +{ + BOOL result = FALSE; // initialize result flag to FALSE + + switch ( valveStateName ) + { case VALVE_STATE_OPEN: - case VALVE_STATE_CLOSED: - if ( ( VDR == valveID ) || ( VTD == valveID ) || ( VHB == valveID ) || ( VRP == valveID ) || ( VHO == valveID ) || - ( VDB1 == valveID ) || ( VP1 == valveID ) || ( VPT == valveID ) || ( VDB2 == valveID ) || ( VDI == valveID ) || - ( VDO == valveID ) || ( VP2 == valveID ) || ( VHI == valveID ) || ( VWI == valveID ) || ( BCV1 == valveID ) || - ( BCV2 == valveID ) || ( BCV3 == valveID ) || ( BCV4 == valveID ) || ( BCV5 == valveID ) || ( BCV6 == valveID ) || - ( BCV7 == valveID ) || ( BCV8 == valveID ) || ( UFI1 == valveID ) || ( UFO1 == valveID ) || ( UFI2 == valveID ) || - ( UFO2 == valveID ) ) - { - result = TRUE; + case VALVE_STATE_CLOSED: + if ( ( D53_VALV == valveID ) || ( D52_VALV == valveID ) || ( D8_VALV == valveID ) || ( D54_VALV == valveID ) || ( D14_VALV == valveID ) || + ( D65_VALV == valveID ) || ( D64_VALV == valveID ) || ( D31_VALV == valveID ) || ( D34_VALV == valveID ) || ( D35_VALV == valveID ) || + ( D40_VALV == valveID ) || ( D47_VALV == valveID ) || ( D3_VALV == valveID ) || ( M4_VALV == valveID ) || ( D23_VALV == valveID ) || +#ifdef __PUMPTEST__ + ( UF1 == valveID ) || ( UF2 == valveID ) || +#endif + ( D19_VALV == valveID ) || ( D25_VALV == valveID ) || ( D21_VALV == valveID ) || ( D24_VALV == valveID ) || ( D20_VALV == valveID ) || + ( D26_VALV == valveID ) || ( D22_VALV == valveID ) || ( D69_VALV == valveID ) || ( D70_VALV == valveID ) || ( D71_VALV == valveID ) || + ( D72_VALV == valveID ) ) + { + result = TRUE; } break; - - default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_STATE_NAME, valveStateName ) - break; - } - - return result; -} + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_STATE_NAME, valveStateName ) + break; + } + + return result; +} + /*********************************************************************//** * @brief * The convertValveStateNameToValveState function converts valve state \n @@ -276,7 +279,7 @@ } return vState; -} +} /*********************************************************************//** * @brief @@ -349,38 +352,38 @@ return result; } - -/*********************************************************************//** - * @brief - * The getValveStateName function gets the current valve state enum for given valve. - * @details \b Inputs: valveStates[] + +/*********************************************************************//** + * @brief + * The getValveStateName function gets the current valve state enum for given valve. + * @details \b Inputs: valveStates[] * @details \b Outputs: none - * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when invalid valve ID passed. - * @param valveID ID of valve to get state for - * @return the current valve state for given valve in enum - *************************************************************************/ -VALVE_STATE_NAMES_T getValveStateName( VALVES_T valveID ) + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when invalid valve ID passed. + * @param valveID ID of valve to get state for + * @return the current valve state for given valve in enum + *************************************************************************/ +VALVE_STATE_NAMES_T getValveStateName( VALVES_T valveID ) { // Initialized per CppCheck. VALVE_STATE_NAMES_T name = NUM_OF_VALVE_STATES; - - if ( valveID < NUM_OF_VALVES ) + + if ( valveID < NUM_OF_VALVES ) { - U32 valveState = getU32OverrideValue( &valveStates[ valveID ] ); + U32 valveState = getU32OverrideValue( &valveSensedStates[ valveID ] ); - if ( OVERRIDE_KEY == valveSensedStates[ valveID ].override ) - { - valveState = valveSensedStates[ valveID ].ovData; - } +// if ( OVERRIDE_KEY == valveSensedStates[ valveID ].override ) +// { +// valveState = valveSensedStates[ valveID ].ovData; +// } name = ( DEENERGIZED == valveState ? VALVE_STATE_CLOSED : VALVE_STATE_OPEN ); - } - else - { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_ID, valveID ) - } - - return name; + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_ID, valveID ) + } + + return name; } /*********************************************************************//** @@ -445,19 +448,19 @@ setValveState( valve, VALVE_STATE_CLOSED ); } } - -/*********************************************************************//** - * @brief - * The publishValvesStates function publishes DD valves states at the set interval. - * @details \b Inputs: valvesStatesPublicationTimerCounter + +/*********************************************************************//** + * @brief + * The publishValvesStates function publishes DD valves states at the set interval. + * @details \b Inputs: valvesStatesPublicationTimerCounter * @details \b Outputs: valvesStatesPublicationTimerCounter - * @details \b Messages: MSG_ID_DD_VALVES_STATES_DATA to publish FPGA read valve states. - * @return none - *************************************************************************/ -static void publishValvesStates( void ) -{ - // publish valve state on interval - if ( ++valvesStatesPublicationTimerCounter >= getU32OverrideValue( &valvesStatesPublishInterval ) ) + * @details \b Messages: MSG_ID_DD_VALVES_STATES_DATA to publish FPGA read valve states. + * @return none + *************************************************************************/ +static void publishValvesStates( void ) +{ + // publish valve state on interval + if ( ++valvesStatesPublicationTimerCounter >= getU32OverrideValue( &valvesStatesPublishInterval ) ) { DD_VALVES_DATA_T data; U32 i; @@ -469,35 +472,35 @@ for ( i = 0; i < NUM_OF_VALVES; i++ ) { data.valvesSensedState[ i ] = (U08)getValveStateName( (VALVES_T)i ); - } + } broadcastData( MSG_ID_DD_VALVES_STATES_DATA, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&data, sizeof( DD_VALVES_DATA_T ) ); - - valvesStatesPublicationTimerCounter = 0; - } + + valvesStatesPublicationTimerCounter = 0; + } } - -/************************************************************************* - * TEST SUPPORT FUNCTIONS - *************************************************************************/ +/************************************************************************* + * TEST SUPPORT FUNCTIONS + *************************************************************************/ -/*********************************************************************//** - * @brief - * The testValvesStatesPublishIntervalOverride function overrides the - * valves states publish interval. - * @details \b Inputs: none - * @details \b Outputs: valvesStatesPublishInterval + +/*********************************************************************//** + * @brief + * The testValvesStatesPublishIntervalOverride function overrides the + * valves states publish interval. + * @details \b Inputs: none + * @details \b Outputs: valvesStatesPublishInterval * @param message Override message from Dialin which includes the value - * that override valves states publish interval with (in ms) - * @return TRUE if override successful, FALSE if not - *************************************************************************/ -BOOL testValvesStatesPublishIntervalOverride( MESSAGE_T *message ) -{ - BOOL result = u32BroadcastIntervalOverride( message, &valvesStatesPublishInterval, TASK_PRIORITY_INTERVAL ); - - return result; + * that override valves states publish interval with (in ms) + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testValvesStatesPublishIntervalOverride( MESSAGE_T *message ) +{ + BOOL result = u32BroadcastIntervalOverride( message, &valvesStatesPublishInterval, TASK_PRIORITY_INTERVAL ); + + return result; } /*********************************************************************//** @@ -515,10 +518,39 @@ BOOL result = u32ArrayOverride( message, &valveStates[0], NUM_OF_VALVES - 1, 0, NUM_OF_VALVE_STATES - 1 ); return result; -} +} /*********************************************************************//** * @brief + * The testBCValveStatesOverride function overrides the state of all + * balancing chamber valves with a given bits (corresponding to BC valve + * enumeration order). + * @details \b Inputs: none + * @details \b Outputs: valveStates[] + * @param message Override message from Dialin which includes the states + * to override the balancing chamber valves to. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testBCValveStatesOverride( MESSAGE_T *message ) +{ + DD_BC_VALVE_OVERRIDE_PAYLOAD_T payload; + VALVES_T valve; + BOOL result = FALSE; + + memcpy( (U08*)(&payload), message, sizeof( DD_BC_VALVE_OVERRIDE_PAYLOAD_T ) ); + for ( valve = FIRST_BC_VALVE; valve <= LAST_BC_VALVE; valve++ ) + { + U32 mask = 0x1 << (valve - FIRST_BC_VALVE); + VALVE_STATE_NAMES_T pos = ( ( ( payload.valveStatesBits & mask ) != 0 ) ? VALVE_STATE_OPEN : VALVE_STATE_CLOSED ); + + result = setValveState( valve, pos ); + } + + return result; +} + +/*********************************************************************//** + * @brief * The testValveSensedStateOverride function overrides the value of the * specified sensed state with a given value. * @details \b Inputs: none @@ -569,5 +601,5 @@ return result; } - -/**@}*/ + +/**@}*/ Index: firmware/App/Controllers/Valves.h =================================================================== diff -u -r9102c5da21a15bdaf4bb3bc38795ceb064e3c443 -red39129abdca4ec343369d83494530b23621e052 --- firmware/App/Controllers/Valves.h (.../Valves.h) (revision 9102c5da21a15bdaf4bb3bc38795ceb064e3c443) +++ firmware/App/Controllers/Valves.h (.../Valves.h) (revision ed39129abdca4ec343369d83494530b23621e052) @@ -14,59 +14,65 @@ * @date (original) 14-Aug-2024 * ***************************************************************************/ - -#ifndef __VALVES_DD_H__ -#define __VALVES_DD_H__ - + +#ifndef __VALVES_DD_H__ +#define __VALVES_DD_H__ + #include "DDCommon.h" - -/** - * @defgroup Valves Valves + +/** + * @defgroup Valves Valves * @brief Valves driver unit. Controls all hydraulics valves, balancing chamber and - * ultrafiltration valves through FPGA Interface. - * - * @addtogroup Valves - * @{ + * ultrafiltration valves through FPGA Interface. + * + * @addtogroup Valves + * @{ */ - -/// Enumeration of valves. -typedef enum Valves -{ + +/// Enumeration of valves. +typedef enum Valves +{ FIRST_HYD_VALVE = 0, ///< Start of Hydraulics valve group - VDR = FIRST_HYD_VALVE, ///< Valve Drain (D53) - VTD, ///< Valve Thermal Disinfect (D52) - VHB, ///< Valve Hydraulics Bypass (D8) - VRP, ///< Valve Rinse Port (D54) - VHO, ///< Valve Hydraulics Outlet (D14) - VDB1, ///< Valve DryBcarb Inlet (D65) - VP1, ///< Valve Purge 1 (D64) - VPT, ///< Valve Pressure Test (D31) - VDB2, ///< Valve Dialyzer Bypass (D34) - VDI, ///< Valve Dialyzer Inlet (D35) - VDO, ///< Valve Dialyzer Outlet (D40) - VP2, ///< Valve Dialysate Out Purge 2 (D47) - VHI, ///< Valve Hydraulics Inlet (D3) - VWI, ///< Valve Water Inlet (M4) - LAST_HYD_VALVE = VWI, ///< End of Hydraulics valve of group + D14_VALV = FIRST_HYD_VALVE, ///< Valve Hydraulics Outlet (D14) + D52_VALV, ///< Valve Thermal Disinfect (D52) + D8_VALV, ///< Valve Hydraulics Bypass (D8) + D54_VALV, ///< Valve Rinse Port (D54) + D53_VALV, ///< Valve Drain (D53) + D34_VALV, ///< Valve Dialyzer Bypass (D34) + D64_VALV, ///< Valve Purge 1 (D64) + D31_VALV, ///< Valve Pressure Test (D31) + D65_VALV, ///< Valve DryBcarb Inlet (D65) + D35_VALV, ///< Valve Dialyzer Inlet (D35) + D40_VALV, ///< Valve Dialyzer Outlet (D40) + D47_VALV, ///< Valve Dialysate Out Purge 2 (D47) + D3_VALV, ///< Valve Hydraulics Inlet (D3) + M4_VALV, ///< Valve Water Inlet (M4) +#ifdef __PUMPTEST__ + UF1, ///< UF1 valve + UF2, ///< UF2 valve + LAST_HYD_VALVE = UF2, ///< End of Hydraulics valve of group +#else + LAST_HYD_VALVE = M4_VALV, ///< End of Hydraulics valve of group RSRVD_SPACE1, ///< This space has been reserved RSRVD_SPACE2, ///< This space has been reserved +#endif FIRST_BC_VALVE, ///< Start of Balancing Chamber valve group - BCV1 = FIRST_BC_VALVE, ///< Balancing chamber Valve 1 (D23) - BCV2, ///< Balancing chamber Valve 2 (D19) - BCV3, ///< Balancing chamber Valve 3 (D25) - BCV4, ///< Balancing chamber Valve 4 (D21) - BCV5, ///< Balancing chamber Valve 5 (D24) - BCV6, ///< Balancing chamber Valve 6 (D20) - BCV7, ///< Balancing chamber Valve 7 (D26) - BCV8, ///< Balancing chamber Valve 8 (D22) - LAST_BC_VALVE = BCV8, ///< End of Balancing Chamber valve group + D23_VALV = FIRST_BC_VALVE, ///< Balancing chamber Valve 1 (D23) + D19_VALV, ///< Balancing chamber Valve 2 (D19) + D25_VALV, ///< Balancing chamber Valve 3 (D25) + D26_VALV, ///< Balancing chamber Valve 7 (D26) + D24_VALV, ///< Balancing chamber Valve 5 (D24) + D20_VALV, ///< Balancing chamber Valve 6 (D20) + D21_VALV, ///< Balancing chamber Valve 4 (D21) + D22_VALV, ///< Balancing chamber Valve 8 (D22) + LAST_BC_VALVE = D22_VALV, ///< End of Balancing Chamber valve group FIRST_UF_VALVE, ///< Start of Ultrafiltration valve group - UFI1 = FIRST_UF_VALVE, ///< Ultrafiltration Valve 1 Inlet (D69) - UFI2, ///< Ultrafiltration Valve 2 Inlet (D71) - UFO1, ///< Ultrafiltration Valve 1 Outlet (D70) - UFO2, ///< Ultrafiltration Valve 2 Outlet (D72) - LAST_UF_VALVE = UFO2, ///< End of Ultrafiltration valve group - NUM_OF_VALVES ///< Number of valves + D69_VALV = FIRST_UF_VALVE, ///< Ultrafiltration Valve 1 Inlet (D69) + D71_VALV, ///< Ultrafiltration Valve 2 Inlet (D71) + D70_VALV, ///< Ultrafiltration Valve 1 Outlet (D70) + D72_VALV, ///< Ultrafiltration Valve 2 Outlet (D72) + LAST_UF_VALVE = D72_VALV, ///< End of Ultrafiltration valve group + NUM_OF_VALVES ///< Number of valves } VALVES_T; /// Enumeration of available valve state names per valve type (from SA and DD SRS documents). @@ -86,24 +92,32 @@ U08 valvesUFStatus; ///< Ultrafiltration valves status. U08 valvesSensedState[ NUM_OF_VALVES ]; ///< DD valves sensed states. } DD_VALVES_DATA_T; -#pragma pack(pop) - -// ********** public function prototypes ********** - -void initValves( void ); -void execValves( void ); +/// Balancing chamber valve states override structure +typedef struct +{ + U32 valveStatesBits; ///< Bits indicating whether balancing chamber valve states should be open(1) or closed(0). +} DD_BC_VALVE_OVERRIDE_PAYLOAD_T; +#pragma pack(pop) + +// ********** public function prototypes ********** + +void initValves( void ); +void execValves( void ); + BOOL setValveState( VALVES_T valve, VALVE_STATE_NAMES_T valveState ); BOOL setValveStateDelayed( VALVES_T valve, VALVE_STATE_NAMES_T valveState, U32 delayMs ); VALVE_STATE_NAMES_T getValveStateName( VALVES_T valveID ); void setHydValvesStatetoClosedState( void ); void setUFValvesStatetoClosedState( void ); - + BOOL testValvesStatesPublishIntervalOverride( MESSAGE_T *message ); BOOL testValveStateOverride( MESSAGE_T *message ); +BOOL testBCValveStatesOverride( MESSAGE_T *message ); BOOL testValveSensedStateOverride( MESSAGE_T *message ); BOOL testValveOpenCloseStateOverride( MESSAGE_T *message ); - -/**@}*/ - -#endif + + +/**@}*/ + +#endif Index: firmware/App/Drivers/ConductivitySensors.c =================================================================== diff -u -re7fe0454b5b2d39009dc784dc8c156856df8bc86 -red39129abdca4ec343369d83494530b23621e052 --- firmware/App/Drivers/ConductivitySensors.c (.../ConductivitySensors.c) (revision e7fe0454b5b2d39009dc784dc8c156856df8bc86) +++ firmware/App/Drivers/ConductivitySensors.c (.../ConductivitySensors.c) (revision ed39129abdca4ec343369d83494530b23621e052) @@ -139,10 +139,10 @@ } // Initialize the conductivity sensor FPGA alarms - initFPGAPersistentAlarm( FPGA_PERS_ERROR_CD1_COND_SENSOR, ALARM_ID_DD_CD1_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); - initFPGAPersistentAlarm( FPGA_PERS_ERROR_CD2_COND_SENSOR, ALARM_ID_DD_CD2_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); - initFPGAPersistentAlarm( FPGA_PERS_ERROR_CD3_COND_SENSOR, ALARM_ID_DD_CD3_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); - initFPGAPersistentAlarm( FPGA_PERS_ERROR_CD4_COND_SENSOR, ALARM_ID_DD_CD4_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); + initFPGAPersistentAlarm( FPGA_PERS_ERROR_D17_COND_SENSOR, ALARM_ID_DD_D17_COND_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); + initFPGAPersistentAlarm( FPGA_PERS_ERROR_D27_COND_SENSOR, ALARM_ID_DD_D27_COND_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); + initFPGAPersistentAlarm( FPGA_PERS_ERROR_D29_COND_SENSOR, ALARM_ID_DD_D29_COND_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); + initFPGAPersistentAlarm( FPGA_PERS_ERROR_D43_COND_SENSOR, ALARM_ID_DD_D43_COND_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); } /*********************************************************************//** @@ -161,27 +161,27 @@ void readConductivitySensors( void ) { // Read raw conductivity - currentConductivityReadings[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (F32)getFPGACD1(); - currentConductivityReadings[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (F32)getFPGACD2(); - currentConductivityReadings[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (F32)getFPGACD3(); - currentConductivityReadings[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (F32)getFPGACD4(); + currentConductivityReadings[ D17_COND ].data = (F32)getFPGAD17Cond(); + currentConductivityReadings[ D27_COND ].data = (F32)getFPGAD27Cond(); + currentConductivityReadings[ D29_COND ].data = (F32)getFPGAD29Cond(); + currentConductivityReadings[ D43_COND ].data = (F32)getFPGAD43Cond(); // Read temperature associated to conductivity sensor - currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (F32)getFPGACD1Temp(); - currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (F32)getFPGACD2Temp(); - currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (F32)getFPGACD3Temp(); - currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (F32)getFPGACD4Temp(); + currentTemperatureReadings[ D17_COND ].data = (F32)getFPGAD17CondTemp(); + currentTemperatureReadings[ D27_COND ].data = (F32)getFPGAD27CondTemp(); + currentTemperatureReadings[ D29_COND ].data = (F32)getFPGAD29CondTemp(); + currentTemperatureReadings[ D43_COND ].data = (F32)getFPGAD43CondTemp(); // Update read and error counters for each conductivity sensor - lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (U32)getFPGACD1ReadCount(); - lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (U32)getFPGACD2ReadCount(); - lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (U32)getFPGACD3ReadCount(); - lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (U32)getFPGACD4ReadCount(); + lastConductivityReadCounter[ D17_COND ].data = (U32)getFPGAD17CondReadCount(); + lastConductivityReadCounter[ D27_COND ].data = (U32)getFPGAD27CondReadCount(); + lastConductivityReadCounter[ D29_COND ].data = (U32)getFPGAD29CondReadCount(); + lastConductivityReadCounter[ D43_COND ].data = (U32)getFPGAD43CondReadCount(); - lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (U32)getFPGACD1ErrorCount(); - lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (U32)getFPGACD2ErrorCount(); - lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (U32)getFPGACD3ErrorCount(); - lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (U32)getFPGACD4ErrorCount(); + lastConductivityErrorCounter[ D17_COND ].data = (U32)getFPGAD17CondErrorCount(); + lastConductivityErrorCounter[ D27_COND ].data = (U32)getFPGAD27CondErrorCount(); + lastConductivityErrorCounter[ D29_COND ].data = (U32)getFPGAD29CondErrorCount(); + lastConductivityErrorCounter[ D43_COND ].data = (U32)getFPGAD43CondErrorCount(); // Monitor conductivity sensor health checkConductivitySensors(); @@ -191,29 +191,29 @@ * @brief * The checkConductivitySensors function checks the read and error counters for * each conductivity sensor. - * @details \b Alarm: ALARM_ID_DD_CD1_SENSOR_FPGA_FAULT if the - * CD1 conductivity sensor is not able to be read. - * @details \b Alarm: ALARM_ID_DD_CD2_SENSOR_FPGA_FAULT if the - * CD2 conductivity sensor is not able to be read. - * @details \b Alarm: ALARM_ID_DD_CD3_SENSOR_FPGA_FAULT if the - * CD3 conductivity sensor is not able to be read. - * @details \b Alarm: ALARM_ID_DD_CD4_SENSOR_FPGA_FAULT if the - * CD4 conductivity sensor is not able to be read. + * @details \b Alarm: ALARM_ID_DD_D17_COND_SENSOR_FPGA_FAULT if the + * D17 conductivity sensor is not able to be read. + * @details \b Alarm: ALARM_ID_DD_D27_COND_SENSOR_FPGA_FAULT if the + * D27 conductivity sensor is not able to be read. + * @details \b Alarm: ALARM_ID_DD_D29_COND_SENSOR_FPGA_FAULT if the + * D29 conductivity sensor is not able to be read. + * @details \b Alarm: ALARM_ID_DD_D43_COND_SENSOR_FPGA_FAULT if the + * D43 conductivity sensor is not able to be read. * @details \b Inputs: lastConductivityReadCounter, lastConductivityErrorCounter * @details \b Outputs: none * @return none *************************************************************************/ static void checkConductivitySensors( void ) { - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_CD1_COND_SENSOR, getConductivitySensorReadCount(CONDUCTIVITYSENSORS_CD1_SENSOR) ); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_CD2_COND_SENSOR, getConductivitySensorReadCount(CONDUCTIVITYSENSORS_CD2_SENSOR) ); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_CD3_COND_SENSOR, getConductivitySensorReadCount(CONDUCTIVITYSENSORS_CD3_SENSOR) ); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_CD4_COND_SENSOR, getConductivitySensorReadCount(CONDUCTIVITYSENSORS_CD4_SENSOR) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D17_COND_SENSOR, getConductivitySensorReadCount(D17_COND) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D27_COND_SENSOR, getConductivitySensorReadCount(D27_COND) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D29_COND_SENSOR, getConductivitySensorReadCount(D29_COND) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D43_COND_SENSOR, getConductivitySensorReadCount(D43_COND) ); - checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_CD1_COND_SENSOR, getConductivitySensorErrorCount( CONDUCTIVITYSENSORS_CD1_SENSOR ) ); - checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_CD2_COND_SENSOR, getConductivitySensorErrorCount( CONDUCTIVITYSENSORS_CD2_SENSOR ) ); - checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_CD3_COND_SENSOR, getConductivitySensorErrorCount( CONDUCTIVITYSENSORS_CD3_SENSOR ) ); - checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_CD4_COND_SENSOR, getConductivitySensorErrorCount( CONDUCTIVITYSENSORS_CD4_SENSOR ) ); + checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_D17_COND_SENSOR, getConductivitySensorErrorCount( D17_COND ) ); + checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_D27_COND_SENSOR, getConductivitySensorErrorCount( D27_COND ) ); + checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_D27_COND_SENSOR, getConductivitySensorErrorCount( D29_COND ) ); + checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_D43_COND_SENSOR, getConductivitySensorErrorCount( D43_COND ) ); } /*********************************************************************//** @@ -468,52 +468,52 @@ *************************************************************************/ void handleConductivitySensorsReset( void ) { - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].resetRequested ) + if ( TRUE == conductivitySensorControl[ D17_COND ].resetRequested ) { - // CD1 reset - setFPGACD1Reset(); - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].resetRequested = FALSE; + // D17 Cond sensor reset + setFPGAD17CondReset(); + conductivitySensorControl[ D17_COND ].resetRequested = FALSE; } else { - // clear CD1 reset - clearFPGACD1Reset(); + // clear D17 reset + clearFPGAD17CondReset(); } - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].resetRequested ) + if ( TRUE == conductivitySensorControl[ D27_COND ].resetRequested ) { - // CD2 reset - setFPGACD2Reset(); - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].resetRequested = FALSE; + // D27 reset + setFPGAD27CondReset(); + conductivitySensorControl[ D27_COND ].resetRequested = FALSE; } else { - // clear CD2 reset - clearFPGACD2Reset(); + // clear D27 reset + clearFPGAD27CondReset(); } - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].resetRequested ) + if ( TRUE == conductivitySensorControl[ D29_COND ].resetRequested ) { - // CD3 reset - setFPGACD3Reset(); - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].resetRequested = FALSE; + // D29 reset + setFPGAD29CondReset(); + conductivitySensorControl[ D29_COND ].resetRequested = FALSE; } else { - // clear CD3 reset - clearFPGACD3Reset(); + // clear D29 reset + clearFPGAD29CondReset(); } - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].resetRequested ) + if ( TRUE == conductivitySensorControl[ D43_COND ].resetRequested ) { - // CD4 reset - setFPGACD4Reset(); - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].resetRequested = FALSE; + // D43 reset + setFPGAD43CondReset(); + conductivitySensorControl[ D43_COND ].resetRequested = FALSE; } else { - // clear CD4 reset - clearFPGACD4Reset(); + // clear D43 reset + clearFPGAD43CondReset(); } } @@ -530,52 +530,52 @@ *************************************************************************/ void handleConductivitySensorsInitProcedure( void ) { - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].initEnable ) + if ( TRUE == conductivitySensorControl[ D17_COND ].initEnable ) { - // CD1 initialization - setFPGACD1InitEnable(); - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].initEnable = FALSE; + // D17 initialization + setFPGAD17CondInitEnable(); + conductivitySensorControl[ D17_COND ].initEnable = FALSE; } else { - // clear CD1 Init command - clearFPGACD1InitEnable(); + // clear D17 Init command + clearFPGAD17CondInitEnable(); } - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].initEnable ) + if ( TRUE == conductivitySensorControl[ D27_COND ].initEnable ) { - // CD2 initialization - setFPGACD2InitEnable(); - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].initEnable = FALSE; + // D27 initialization + setFPGAD27CondInitEnable(); + conductivitySensorControl[ D27_COND ].initEnable = FALSE; } else { - // clear CD2 Init command - clearFPGACD2InitEnable(); + // clear D27 Init command + clearFPGAD27CondInitEnable(); } - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].initEnable ) + if ( TRUE == conductivitySensorControl[ D29_COND ].initEnable ) { - // CD3 initialization - setFPGACD3InitEnable(); - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].initEnable = FALSE; + // D29 initialization + setFPGAD29CondInitEnable(); + conductivitySensorControl[ D29_COND ].initEnable = FALSE; } else { - // clear CD3 Init command - clearFPGACD3InitEnable(); + // clear D29 Init command + clearFPGAD29CondInitEnable(); } - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].initEnable ) + if ( TRUE == conductivitySensorControl[ D43_COND ].initEnable ) { - // CD4 initialization - setFPGACD4InitEnable(); - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].initEnable = FALSE; + // D43 initialization + setFPGAD43CondInitEnable(); + conductivitySensorControl[ D43_COND ].initEnable = FALSE; } else { - // clear CD4 Init command - clearFPGACD4InitEnable(); + // clear D43 Init command + clearFPGAD43CondInitEnable(); } } @@ -593,7 +593,7 @@ { CONDUCTIVITY_SENSORS_T sensor; - for ( sensor = CONDUCTIVITYSENSORS_CD1_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) + for ( sensor = FIRST_COND_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) { // write state machine switch ( conductivitySensorControl[sensor].writeExecState ) @@ -626,51 +626,51 @@ { CONDUCTIVITY_WRITE_STATE_T state = CONDUCTIVITY_WRITE_INITIATE; - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeEnable && - FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeInProgress ) + if ( TRUE == conductivitySensorControl[ D17_COND ].writeEnable && + FALSE == conductivitySensorControl[ D17_COND ].writeInProgress ) { - // CD1 write request - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeComplete = FALSE; - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeInProgress = TRUE; - setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeAddress ); - setFPGACD12Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeData ); - setFPGACD1WriteEnable(); + // D17 write request + conductivitySensorControl[ D17_COND ].writeComplete = FALSE; + conductivitySensorControl[ D17_COND ].writeInProgress = TRUE; + setFPGACD12Address( conductivitySensorControl[ D17_COND ].writeAddress ); + setFPGACD12Data( conductivitySensorControl[ D17_COND ].writeData ); + setFPGAD17CondWriteEnable(); state = CONDUCTIVITY_WRITE_COMPLETE; } - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeEnable && - FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeInProgress ) + if ( TRUE == conductivitySensorControl[ D27_COND ].writeEnable && + FALSE == conductivitySensorControl[ D27_COND ].writeInProgress ) { - // CD2 write request - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeComplete = FALSE; - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeInProgress = TRUE; - setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeAddress ); - setFPGACD12Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeData ); - setFPGACD2WriteEnable(); + // D27 write request + conductivitySensorControl[ D27_COND ].writeComplete = FALSE; + conductivitySensorControl[ D27_COND ].writeInProgress = TRUE; + setFPGACD12Address( conductivitySensorControl[ D27_COND ].writeAddress ); + setFPGACD12Data( conductivitySensorControl[ D27_COND ].writeData ); + setFPGAD27CondWriteEnable(); state = CONDUCTIVITY_WRITE_COMPLETE; } - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeEnable && - FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeInProgress ) + if ( TRUE == conductivitySensorControl[ D29_COND ].writeEnable && + FALSE == conductivitySensorControl[ D29_COND ].writeInProgress ) { - // CD3 write request - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeComplete = FALSE; - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeInProgress = TRUE; - setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeAddress ); - setFPGACD34Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeData ); - setFPGACD3WriteEnable(); + // D29 write request + conductivitySensorControl[ D29_COND ].writeComplete = FALSE; + conductivitySensorControl[ D29_COND ].writeInProgress = TRUE; + setFPGACD34Address( conductivitySensorControl[ D29_COND ].writeAddress ); + setFPGACD34Data( conductivitySensorControl[ D29_COND ].writeData ); + setFPGAD29CondWriteEnable(); state = CONDUCTIVITY_WRITE_COMPLETE; } - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeEnable && - FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeInProgress ) + if ( TRUE == conductivitySensorControl[ D43_COND ].writeEnable && + FALSE == conductivitySensorControl[ D43_COND ].writeInProgress ) { - // CD4 write request - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeComplete = FALSE; - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeInProgress = TRUE; - setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeAddress ); - setFPGACD34Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeData ); - setFPGACD4WriteEnable(); + // D43 write request + conductivitySensorControl[ D43_COND ].writeComplete = FALSE; + conductivitySensorControl[ D43_COND ].writeInProgress = TRUE; + setFPGACD34Address( conductivitySensorControl[ D43_COND ].writeAddress ); + setFPGACD34Data( conductivitySensorControl[ D43_COND ].writeData ); + setFPGAD43CondWriteEnable(); state = CONDUCTIVITY_WRITE_COMPLETE; } @@ -689,35 +689,35 @@ { CONDUCTIVITY_WRITE_STATE_T state = CONDUCTIVITY_WRITE_COMPLETE; - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeInProgress ) + if ( TRUE == conductivitySensorControl[ D17_COND ].writeInProgress ) { - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeComplete = TRUE; - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeEnable = FALSE; - clearFPGACD1WriteEnable(); + conductivitySensorControl[ D17_COND ].writeComplete = TRUE; + conductivitySensorControl[ D17_COND ].writeEnable = FALSE; + clearFPGAD17CondWriteEnable(); state = CONDUCTIVITY_WRITE_INITIATE; } - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeInProgress ) + if ( TRUE == conductivitySensorControl[ D27_COND ].writeInProgress ) { - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeComplete = TRUE; - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeEnable = FALSE; - clearFPGACD2WriteEnable(); + conductivitySensorControl[ D27_COND ].writeComplete = TRUE; + conductivitySensorControl[ D27_COND ].writeEnable = FALSE; + clearFPGAD27CondWriteEnable(); state = CONDUCTIVITY_WRITE_INITIATE; } - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeInProgress ) + if ( TRUE == conductivitySensorControl[ D29_COND ].writeInProgress ) { - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeComplete = TRUE; - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeEnable = FALSE; - clearFPGACD3WriteEnable(); + conductivitySensorControl[ D29_COND ].writeComplete = TRUE; + conductivitySensorControl[ D29_COND ].writeEnable = FALSE; + clearFPGAD29CondWriteEnable(); state = CONDUCTIVITY_WRITE_INITIATE; } - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeInProgress ) + if ( TRUE == conductivitySensorControl[ D43_COND ].writeInProgress ) { - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeComplete = TRUE; - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeEnable = FALSE; - clearFPGACD4WriteEnable(); + conductivitySensorControl[ D43_COND ].writeComplete = TRUE; + conductivitySensorControl[ D43_COND ].writeEnable = FALSE; + clearFPGAD43CondWriteEnable(); state = CONDUCTIVITY_WRITE_INITIATE; } @@ -738,7 +738,7 @@ { CONDUCTIVITY_SENSORS_T sensor; - for ( sensor = CONDUCTIVITYSENSORS_CD1_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) + for ( sensor = FIRST_COND_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) { // Read state machine switch ( conductivitySensorControl[sensor].readExecState ) @@ -771,47 +771,47 @@ { CONDUCTIVITY_READ_STATE_T state = CONDUCTIVITY_READ_INITIATE; - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readEnable && - FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readInProgress ) + if ( TRUE == conductivitySensorControl[ D17_COND ].readEnable && + FALSE == conductivitySensorControl[ D17_COND ].readInProgress ) { - // CD1 read request - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readComplete = FALSE; - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readInProgress = TRUE; - setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readAddress ); - setFPGACD1ReadEnable(); + // D17 read request + conductivitySensorControl[ D17_COND ].readComplete = FALSE; + conductivitySensorControl[ D17_COND ].readInProgress = TRUE; + setFPGACD12Address( conductivitySensorControl[ D17_COND ].readAddress ); + setFPGAD17CondReadEnable(); state = CONDUCTIVITY_READ_COMPLETE; } - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readEnable && - FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readInProgress ) + if ( TRUE == conductivitySensorControl[ D27_COND ].readEnable && + FALSE == conductivitySensorControl[ D27_COND ].readInProgress ) { - // CD2 read request - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readComplete = FALSE; - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readInProgress = TRUE; - setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readAddress ); - setFPGACD2ReadEnable(); + // D27 read request + conductivitySensorControl[ D27_COND ].readComplete = FALSE; + conductivitySensorControl[ D27_COND ].readInProgress = TRUE; + setFPGACD12Address( conductivitySensorControl[ D27_COND ].readAddress ); + setFPGAD27CondReadEnable(); state = CONDUCTIVITY_READ_COMPLETE; } - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readEnable && - FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readInProgress ) + if ( TRUE == conductivitySensorControl[ D29_COND ].readEnable && + FALSE == conductivitySensorControl[ D29_COND ].readInProgress ) { - // CD3 read request - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readComplete = FALSE; - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readInProgress = TRUE; - setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readAddress ); - setFPGACD3ReadEnable(); + // D29 read request + conductivitySensorControl[ D29_COND ].readComplete = FALSE; + conductivitySensorControl[ D29_COND ].readInProgress = TRUE; + setFPGACD34Address( conductivitySensorControl[ D29_COND ].readAddress ); + setFPGAD29CondReadEnable(); state = CONDUCTIVITY_READ_COMPLETE; } - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readEnable && - FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readInProgress ) + if ( TRUE == conductivitySensorControl[ D43_COND ].readEnable && + FALSE == conductivitySensorControl[ D43_COND ].readInProgress ) { - // CD4 read request - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readComplete = FALSE; - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readInProgress = TRUE; - setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readAddress ); - setFPGACD4ReadEnable(); + // D43 read request + conductivitySensorControl[ D43_COND ].readComplete = FALSE; + conductivitySensorControl[ D43_COND ].readInProgress = TRUE; + setFPGACD34Address( conductivitySensorControl[ D43_COND ].readAddress ); + setFPGAD43CondReadEnable(); state = CONDUCTIVITY_READ_COMPLETE; } @@ -830,39 +830,39 @@ { CONDUCTIVITY_READ_STATE_T state = CONDUCTIVITY_READ_COMPLETE; - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readInProgress ) + if ( TRUE == conductivitySensorControl[ D17_COND ].readInProgress ) { - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readData = getFPGACD1Data(); - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readComplete = TRUE; - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readEnable = FALSE; - clearFPGACD1ReadEnable(); + conductivitySensorControl[ D17_COND ].readData = getFPGAD17CondData(); + conductivitySensorControl[ D17_COND ].readComplete = TRUE; + conductivitySensorControl[ D17_COND ].readEnable = FALSE; + clearFPGAD17CondReadEnable(); state = CONDUCTIVITY_READ_INITIATE; } - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readInProgress ) + if ( TRUE == conductivitySensorControl[ D27_COND ].readInProgress ) { - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readData = getFPGACD2Data(); - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readComplete = TRUE; - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readEnable = FALSE; - clearFPGACD2ReadEnable(); + conductivitySensorControl[ D27_COND ].readData = getFPGAD27CondData(); + conductivitySensorControl[ D27_COND ].readComplete = TRUE; + conductivitySensorControl[ D27_COND ].readEnable = FALSE; + clearFPGAD27CondReadEnable(); state = CONDUCTIVITY_READ_INITIATE; } - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readInProgress ) + if ( TRUE == conductivitySensorControl[ D29_COND ].readInProgress ) { - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readData = getFPGACD3Data(); - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readComplete = TRUE; - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readEnable = FALSE; - clearFPGACD3ReadEnable(); + conductivitySensorControl[ D29_COND ].readData = getFPGAD29CondData(); + conductivitySensorControl[ D29_COND ].readComplete = TRUE; + conductivitySensorControl[ D29_COND ].readEnable = FALSE; + clearFPGAD29CondReadEnable(); state = CONDUCTIVITY_READ_INITIATE; } - if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readInProgress ) + if ( TRUE == conductivitySensorControl[ D43_COND ].readInProgress ) { - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readData = getFPGACD4Data(); - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readComplete = TRUE; - conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readEnable = FALSE; - clearFPGACD4ReadEnable(); + conductivitySensorControl[ D43_COND ].readData = getFPGAD43CondData(); + conductivitySensorControl[ D43_COND ].readComplete = TRUE; + conductivitySensorControl[ D43_COND ].readEnable = FALSE; + clearFPGAD43CondReadEnable(); state = CONDUCTIVITY_READ_INITIATE; } Index: firmware/App/Drivers/ConductivitySensors.h =================================================================== diff -u -rb6d20d9e5c704a9f7ebceea9bb12731dac61fc2a -red39129abdca4ec343369d83494530b23621e052 --- firmware/App/Drivers/ConductivitySensors.h (.../ConductivitySensors.h) (revision b6d20d9e5c704a9f7ebceea9bb12731dac61fc2a) +++ firmware/App/Drivers/ConductivitySensors.h (.../ConductivitySensors.h) (revision ed39129abdca4ec343369d83494530b23621e052) @@ -40,11 +40,12 @@ /// Enumeration of conductivity sensors. typedef enum ConductivitySensors { - CONDUCTIVITYSENSORS_CD1_SENSOR = 0, ///< Bicarb only conductivity sensor - CONDUCTIVITYSENSORS_CD2_SENSOR, ///< Acid and Bicarb mix conductivity sensor - 1 - CONDUCTIVITYSENSORS_CD3_SENSOR, ///< Acid and Bicarb mix conductivity sensor - 2 - CONDUCTIVITYSENSORS_CD4_SENSOR, ///< Spent dialysate conductivity sensor - NUM_OF_CONDUCTIVITY_SENSORS ///< Number of conductivity sensors + FIRST_COND_SENSOR = 0, ///< First conductivity sensor + D17_COND = FIRST_COND_SENSOR, ///< Bicarb only conductivity sensor + D27_COND, ///< Acid and Bicarb mix conductivity sensor - 1 + D29_COND, ///< Acid and Bicarb mix conductivity sensor - 2 + D43_COND, ///< Spent dialysate conductivity sensor + NUM_OF_CONDUCTIVITY_SENSORS ///< Number of conductivity sensors } CONDUCTIVITY_SENSORS_T; // ********** public function prototypes ********** Index: firmware/App/Drivers/InternalADC.c =================================================================== diff -u -r9102c5da21a15bdaf4bb3bc38795ceb064e3c443 -red39129abdca4ec343369d83494530b23621e052 --- firmware/App/Drivers/InternalADC.c (.../InternalADC.c) (revision 9102c5da21a15bdaf4bb3bc38795ceb064e3c443) +++ firmware/App/Drivers/InternalADC.c (.../InternalADC.c) (revision ed39129abdca4ec343369d83494530b23621e052) @@ -14,25 +14,25 @@ * @date (original) 13-Aug-2024 * ***************************************************************************/ - -#include "adc.h" - -#include "InternalADC.h" - -/** - * @addtogroup InternalADC - * @{ - */ - -// ********** private definitions ********** - -#define MAX_ADC_CHANNELS 24 ///< DD internal ADC supports up to 24 channels. -#define SIZE_OF_ROLLING_AVG 16 ///< Number of DD internal ADC samples in rolling average calculations for each channel. -#define ROLLING_AVG_SHIFT_DIVIDER 4 ///< Rolling average shift divider for DD internal ADC readings. - -/// ADC channel number to ADC channel ID (enumeration) look-up table. -const INT_ADC_CHANNEL_T adcChannelNum2ChannelId[ MAX_ADC_CHANNELS ] = -{ + +#include "adc.h" + +#include "InternalADC.h" + +/** + * @addtogroup InternalADC + * @{ + */ + +// ********** private definitions ********** + +#define MAX_ADC_CHANNELS 24 ///< DD internal ADC supports up to 24 channels. +#define SIZE_OF_ROLLING_AVG 16 ///< Number of DD internal ADC samples in rolling average calculations for each channel. +#define ROLLING_AVG_SHIFT_DIVIDER 4 ///< Rolling average shift divider for DD internal ADC readings. + +/// ADC channel number to ADC channel ID (enumeration) look-up table. +const INT_ADC_CHANNEL_T adcChannelNum2ChannelId[ MAX_ADC_CHANNELS ] = +{ INT_ADC_NOT_USED, // 0 INT_ADC_NOT_USED, // 1 - TD specific INT_ADC_3_3V_SENSOR_ADC_REF, // 2 @@ -56,10 +56,10 @@ INT_ADC_NOT_USED, // 20 INT_ADC_NOT_USED, // 21 INT_ADC_24V_ACTUATORS, // 22 - INT_ADC_NOT_USED // 23 -}; + INT_ADC_NOT_USED // 23 +}; -/// ADC channel read to units look-up table. +/// ADC channel read to units look-up table. const F32 ADC_CHANNEL_READ_TO_UNITS[ NUM_OF_INT_ADC_CHANNELS ] = { 0.0, // - INT_ADC_NOT_USED @@ -73,136 +73,136 @@ 0.001465, // V - INT_ADC_5V_LOGIC 0.007106, // V - INT_ADC_24V_ACTUATORS 0.007106, // V - INT_ADC_BACKUP_V -// 0.000000, // V - INT_ADC_DUMMY + 0.000000, // V - INT_ADC_DUMMY }; -// ********** private data ********** - -static adcData_t adcRawReadings[ NUM_OF_INT_ADC_CHANNELS ]; ///< Buffer holds latest adc channel readings. -static U32 adcRawReadingsCount = 0; ///< Readings count for raw readings buffer. - -static U16 adcReadings[ NUM_OF_INT_ADC_CHANNELS ][ SIZE_OF_ROLLING_AVG ]; ///< Buffer holds samples for each channel for a rolling average. -static U32 adcReadingsIdx[ NUM_OF_INT_ADC_CHANNELS ]; ///< Index for next reading in each rolling average buffer. -static U32 adcReadingsTotals[ NUM_OF_INT_ADC_CHANNELS ]; ///< Rolling sum for each ADC channel - used to calc average. -static U32 adcReadingsAvgs[ NUM_OF_INT_ADC_CHANNELS ]; ///< Rolling average for each ADC channel. - -/*********************************************************************//** - * @brief - * The initInternalADC function initializes the InternalADC unit. - * @details \b Inputs: none - * @details \b Outputs: InternalADC unit is initialized. - * @return none - *************************************************************************/ -void initInternalADC( void ) -{ - U32 c,r; - - // zero all adc values and stats - adcRawReadingsCount = 0; - for ( c = 0; c < NUM_OF_INT_ADC_CHANNELS; c++ ) - { - adcRawReadings[ c ].id = 0; - adcRawReadings[ c ].value = 0; - adcReadingsIdx[ c ] = 0; - adcReadingsTotals[ c ] = 0; - adcReadingsAvgs[ c ] = 0; - for ( r = 0; r < SIZE_OF_ROLLING_AVG; r++ ) - { - adcReadings[ c ][ r ] = 0; - } - } - - // enable interrupt when all channels converted - adcEnableNotification( adcREG1, adcGROUP1 ); -} - -/*********************************************************************//** - * @brief - * The adcNotification function handles an ADC conversion complete interrupt. - * All channel readings in the FIFO are retrieved. - * @details \b Inputs: ADC FIFO - * @details \b Outputs: adcRawReadingsCount, adcRawReadings[] - * @param adc pointer to the ADC1 controller - * @param group ADC channel group ID - * @return none - *************************************************************************/ -void adcNotification( adcBASE_t *adc, uint32 group ) -{ - if ( adcGROUP1 == group ) - { - adcRawReadingsCount = adcGetData( adcREG1, adcGROUP1, adcRawReadings ); - } -} - -/*********************************************************************//** - * @brief - * The execInternalADC function processes the last set of raw ADC channel - * readings and kicks off the next conversion of ADC channels. - * @details \b Inputs: adcRawReadingsCount, adcRawReadings[] +// ********** private data ********** + +static adcData_t adcRawReadings[ NUM_OF_INT_ADC_CHANNELS ]; ///< Buffer holds latest adc channel readings. +static U32 adcRawReadingsCount = 0; ///< Readings count for raw readings buffer. + +static U16 adcReadings[ NUM_OF_INT_ADC_CHANNELS ][ SIZE_OF_ROLLING_AVG ]; ///< Buffer holds samples for each channel for a rolling average. +static U32 adcReadingsIdx[ NUM_OF_INT_ADC_CHANNELS ]; ///< Index for next reading in each rolling average buffer. +static U32 adcReadingsTotals[ NUM_OF_INT_ADC_CHANNELS ]; ///< Rolling sum for each ADC channel - used to calc average. +static U32 adcReadingsAvgs[ NUM_OF_INT_ADC_CHANNELS ]; ///< Rolling average for each ADC channel. + +/*********************************************************************//** + * @brief + * The initInternalADC function initializes the InternalADC unit. + * @details \b Inputs: none + * @details \b Outputs: InternalADC unit is initialized. + * @return none + *************************************************************************/ +void initInternalADC( void ) +{ + U32 c,r; + + // zero all adc values and stats + adcRawReadingsCount = 0; + for ( c = 0; c < NUM_OF_INT_ADC_CHANNELS; c++ ) + { + adcRawReadings[ c ].id = 0; + adcRawReadings[ c ].value = 0; + adcReadingsIdx[ c ] = 0; + adcReadingsTotals[ c ] = 0; + adcReadingsAvgs[ c ] = 0; + for ( r = 0; r < SIZE_OF_ROLLING_AVG; r++ ) + { + adcReadings[ c ][ r ] = 0; + } + } + + // enable interrupt when all channels converted + adcEnableNotification( adcREG1, adcGROUP1 ); +} + +/*********************************************************************//** + * @brief + * The adcNotification function handles an ADC conversion complete interrupt. + * All channel readings in the FIFO are retrieved. + * @details \b Inputs: ADC FIFO + * @details \b Outputs: adcRawReadingsCount, adcRawReadings[] + * @param adc pointer to the ADC1 controller + * @param group ADC channel group ID + * @return none + *************************************************************************/ +void adcNotification( adcBASE_t *adc, uint32 group ) +{ + if ( adcGROUP1 == group ) + { + adcRawReadingsCount = adcGetData( adcREG1, adcGROUP1, adcRawReadings ); + } +} + +/*********************************************************************//** + * @brief + * The execInternalADC function processes the last set of raw ADC channel + * readings and kicks off the next conversion of ADC channels. + * @details \b Inputs: adcRawReadingsCount, adcRawReadings[] * @details \b Outputs: adcReadings[][], adcReadingsIdx[], adcReadingsTotals[], adcReadingsAvgs[] * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when invalid ADC channel number - * processed. - * @return none - *************************************************************************/ -void execInternalADC( void ) -{ - U32 i; - - if ( adcRawReadingsCount < NUM_OF_INT_ADC_CHANNELS ) - { - // process readings from last conversion - for ( i = 0; i < adcRawReadingsCount; i++ ) + * processed. + * @return none + *************************************************************************/ +void execInternalADC( void ) +{ + U32 i; + + if ( adcRawReadingsCount < NUM_OF_INT_ADC_CHANNELS ) + { + // process readings from last conversion + for ( i = 0; i < adcRawReadingsCount; i++ ) { if ( adcRawReadings[ i ].id < NUM_OF_INT_ADC_CHANNELS ) - { - U32 ch = adcChannelNum2ChannelId[ adcRawReadings[ i ].id ]; - - adcReadingsTotals[ ch ] -= adcReadings[ ch ][ adcReadingsIdx[ ch ] ]; - adcReadings[ ch ][ adcReadingsIdx[ ch ] ] = adcRawReadings[i].value; - adcReadingsTotals[ ch ] += adcRawReadings[ i ].value; - adcReadingsAvgs[ ch ] = adcReadingsTotals[ ch ] >> ROLLING_AVG_SHIFT_DIVIDER; + { + U32 ch = adcChannelNum2ChannelId[ adcRawReadings[ i ].id ]; + + adcReadingsTotals[ ch ] -= adcReadings[ ch ][ adcReadingsIdx[ ch ] ]; + adcReadings[ ch ][ adcReadingsIdx[ ch ] ] = adcRawReadings[i].value; + adcReadingsTotals[ ch ] += adcRawReadings[ i ].value; + adcReadingsAvgs[ ch ] = adcReadingsTotals[ ch ] >> ROLLING_AVG_SHIFT_DIVIDER; adcReadingsIdx[ ch ] = INC_WRAP( adcReadingsIdx[ ch ], 0, SIZE_OF_ROLLING_AVG - 1 ); } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_INT_ADC_CHANNEL_NUMBER, adcRawReadings[ i ].id ) - } - } - } - else - { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INT_ADC_DATA_OVERRUN, adcRawReadingsCount ) - } - - // start an adc channel group conversion - adcStartConversion( adcREG1, adcGROUP1 ); -} - -/*********************************************************************//** - * @brief - * The getIntADCReading function gets the latest average reading for a given channel. - * @details \b Inputs: adcReadingsAvgs[] + } + } + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INT_ADC_DATA_OVERRUN, adcRawReadingsCount ) + } + + // start an adc channel group conversion + adcStartConversion( adcREG1, adcGROUP1 ); +} + +/*********************************************************************//** + * @brief + * The getIntADCReading function gets the latest average reading for a given channel. + * @details \b Inputs: adcReadingsAvgs[] * @details \b Outputs: none - * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when invalid ADC channel requested. - * @param channel adc channel to retrieve a reading for - * @return average reading for the given channel - *************************************************************************/ -U16 getIntADCReading( INT_ADC_CHANNEL_T channel ) -{ - U16 result = 0; - - if ( channel < NUM_OF_INT_ADC_CHANNELS ) - { - result = adcReadingsAvgs[ channel ]; - } - else - { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INT_ADC_INVALID_CHANNEL_REQUESTED, channel ) - } - - return result; -} - + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when invalid ADC channel requested. + * @param channel adc channel to retrieve a reading for + * @return average reading for the given channel + *************************************************************************/ +U16 getIntADCReading( INT_ADC_CHANNEL_T channel ) +{ + U16 result = 0; + + if ( channel < NUM_OF_INT_ADC_CHANNELS ) + { + result = adcReadingsAvgs[ channel ]; + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INT_ADC_INVALID_CHANNEL_REQUESTED, channel ) + } + + return result; +} + /*********************************************************************//** * @brief * The getIntADCVoltageConverted function gets the latest average voltage @@ -229,4 +229,4 @@ return result; } -/**@}*/ +/**@}*/ Index: firmware/App/Drivers/InternalADC.h =================================================================== diff -u -re7fe0454b5b2d39009dc784dc8c156856df8bc86 -red39129abdca4ec343369d83494530b23621e052 --- firmware/App/Drivers/InternalADC.h (.../InternalADC.h) (revision e7fe0454b5b2d39009dc784dc8c156856df8bc86) +++ firmware/App/Drivers/InternalADC.h (.../InternalADC.h) (revision ed39129abdca4ec343369d83494530b23621e052) @@ -14,31 +14,31 @@ * @date (original) 13-Aug-2024 * ***************************************************************************/ - -#ifndef __INT_ADC_H__ -#define __INT_ADC_H__ - -#include "DDCommon.h" - -/** - * @defgroup InternalADC InternalADC + +#ifndef __INT_ADC_H__ +#define __INT_ADC_H__ + +#include "DDCommon.h" + +/** + * @defgroup InternalADC InternalADC * @brief DD internal ADC unit. This unit converts all analog channel (DD * different voltage rails, pressure, temperature) into digital value for further - * processing ( monitoring and controls). - * - * @addtogroup InternalADC - * @{ - */ - -// ********** public definitions ********** + * processing ( monitoring and controls). + * + * @addtogroup InternalADC + * @{ + */ +// ********** public definitions ********** + #define INT_ADC_BITS_PER_CHANNEL 12 ///< DD internal ADC bits per channel. #define INT_ADC_FULL_SCALE_BITS 4095 ///< DD internal ADC full scale range. #define INT_ADC_REF_V 3.0F ///< DD internal ADC reference voltage. - -/// Enumeration of DD internal ADC channels. -typedef enum Int_ADC_Channels -{ + +/// Enumeration of DD internal ADC channels. +typedef enum Int_ADC_Channels +{ INT_ADC_NOT_USED = 0, ///< Not used INT_ADC_3_3V_SENSOR_ADC_REF, ///< Internal ADC channel for 3.3V sensor volatge INT_ADC_24V_ACTUATORS_REG, ///< Internal ADC channel for 24V regen (diode drop) to actuators @@ -50,17 +50,17 @@ INT_ADC_5V_LOGIC, ///< Internal ADC channel for 5V to logic INT_ADC_24V_ACTUATORS, ///< Internal ADC channel for 24V to actuators INT_ADC_BACKUP_V, ///< Internal ADC channel for VBackup - //INT_ADC_DUMMY, ///< Internal ADC channel - not used, needed to get even number of channels - NUM_OF_INT_ADC_CHANNELS ///< Number of used internal ADC channels. -} INT_ADC_CHANNEL_T; - -// ********** public function prototypes ********** - -void initInternalADC( void ); -void execInternalADC( void ); -U16 getIntADCReading( INT_ADC_CHANNEL_T channel ); + INT_ADC_DUMMY, ///< Internal ADC channel - not used, needed to get even number of channels + NUM_OF_INT_ADC_CHANNELS ///< Number of used internal ADC channels. +} INT_ADC_CHANNEL_T; + +// ********** public function prototypes ********** + +void initInternalADC( void ); +void execInternalADC( void ); +U16 getIntADCReading( INT_ADC_CHANNEL_T channel ); F32 getIntADCVoltageConverted( INT_ADC_CHANNEL_T channel ); -/**@}*/ - -#endif +/**@}*/ + +#endif Index: firmware/App/Drivers/PressureSensor.c =================================================================== diff -u -r48c75a394c56b82886760e9a136b638edecf7572 -red39129abdca4ec343369d83494530b23621e052 --- firmware/App/Drivers/PressureSensor.c (.../PressureSensor.c) (revision 48c75a394c56b82886760e9a136b638edecf7572) +++ firmware/App/Drivers/PressureSensor.c (.../PressureSensor.c) (revision ed39129abdca4ec343369d83494530b23621e052) @@ -15,21 +15,26 @@ * ***************************************************************************/ -#include "AlarmMgmtDD.h" -#include "FpgaDD.h" +#include "AlarmMgmtDD.h" +#include "FpgaDD.h" #include "Messaging.h" #include "PersistentAlarm.h" #include "PressureSensor.h" #include "TemperatureSensors.h" - -/** - * @addtogroup PressureSensor - * @{ - */ - -// ********** private definitions ********** +/** + * @addtogroup PressureSensor + * @{ + */ + +// ********** private definitions ********** + #define PRES_SENSORS_COUNT_ERROR_TIMEOUT_MS ( 2 * MS_PER_SECOND ) ///< Pressure sensors read and error count timeout in milliseconds. +#define HIGH_PRES_MAX_PSI 145.038F ///< Convert pressure to PSI for 10 bar pressure sensor +#define LOW_PRES_MAX_PSI 50.7632F ///< Convert pressure to PSI for 3.5 bar pressure sensor +#define PRES_MIN_PSI 0.0F ///< Minimum value for PSI conversion + + #define ONE_BAR_TO_MILLI_BAR 1000 ///< 1 bar to milli-bar conversion. #define COUNTS_TO_MILLI_BAR 100 ///< Counts to milli-bar conversion. #define BAR_TO_MMHG ( 750.062F ) ///< Conversion factor for converting bar to mmHg. @@ -43,9 +48,9 @@ U16 pressureSensitivityTempCoeff; ///< Barometric sensor pressure sensitivity temperature coefficient. U16 pressureOffsetTempCoeff; ///< Barometric sensor pressure offset temperature coefficient. } BARO_SENSOR_CONSTS_T; - -// ********** private data ********** - + +// ********** private data ********** + static OVERRIDE_F32_T currentPressureReadings[ NUM_OF_PRESSURE_SENSORS ]; ///< Current pressure sensor pressure readings (overrideable). static OVERRIDE_F32_T currentPresTempReadings[ NUM_OF_PRESSURE_SENSORS ]; ///< Current pressure sensor temperature readings (overrideable). static OVERRIDE_U32_T lastPressureReadCounter[ NUM_OF_PRESSURE_SENSORS ]; ///< Last pressure sensor read count (Overrideable). @@ -58,9 +63,9 @@ static const U32 TWO_TO_POWER_OF_16 = ( 1 << 16 ); ///< 2^16. static const U32 TWO_TO_POWER_OF_17 = ( 1 << 17 ); ///< 2^17. static const U32 TWO_TO_POWER_OF_21 = ( 1 << 21 ); ///< 2^21. - -// ********** private function prototypes ********** - + +// ********** private function prototypes ********** + static void checkPressureSensors( void ); static F32 convertBaroPressureReading2mmHg( U32 rawPressure ); static F32 calculateBaroPressure( U32 pressure ); @@ -139,40 +144,40 @@ void readPressureSensors( void ) { // Update and convert raw pressures to mmHg - currentPressureReadings[ PRESSURE_SENSOR_WATER_INLET_INPUT ].data = convertPressureReading2mmHg( getFPGAPRiRawPressure() ); - currentPressureReadings[ PRESSURE_SENSOR_WATER_INLET_OUTPUT ].data = convertPressureReading2mmHg( getFPGAPRoRawPressure() ); - currentPressureReadings[ PRESSURE_SENSOR_HYDRAULICS_OUTLET ].data = convertPressureReading2mmHg( getFPGAPnRawPressure() ); - currentPressureReadings[ PRESSURE_SENSOR_BIBAG ].data = convertPressureReading2mmHg( getFPGAPCbRawPressure() ); - currentPressureReadings[ PRESSURE_SENSOR_SPENT_DIALYSATE ].data = convertPressureReading2mmHg( getFPGAPDsRawPressure() ); - currentPressureReadings[ PRESSURE_SENSOR_FRESH_DIALYSATE ].data = convertPressureReading2mmHg( getFPGAPDfRawPressure() ); - currentPressureReadings[ PRESSURE_SENSOR_TRANSMEMBRANE ].data = convertPressureReading2mmHg( getFPGAPtmRawPressure() ); - currentPressureReadings[ PRESSURE_SENSOR_BAROMETRIC ].data = convertBaroPressureReading2mmHg( getFPGABaroPressure() ); + currentPressureReadings[ M1_PRES ].data = convertPressureReading( getFPGAM1PresRawPressure(), PRES_MIN_PSI, HIGH_PRES_MAX_PSI ); + currentPressureReadings[ M3_PRES ].data = convertPressureReading( getFPGAM3PresRawPressure(),PRES_MIN_PSI, HIGH_PRES_MAX_PSI ); + currentPressureReadings[ D9_PRES ].data = convertPressureReading( getFPGAD9PresRawPressure(),PRES_MIN_PSI, HIGH_PRES_MAX_PSI ); + currentPressureReadings[ D66_PRES ].data = convertPressureReading( getFPGAD66PresRawPressure(), PRES_MIN_PSI, LOW_PRES_MAX_PSI ); + currentPressureReadings[ D51_PRES ].data = convertPressureReading( getFPGAD51PresRawPressure(), PRES_MIN_PSI, LOW_PRES_MAX_PSI ); + currentPressureReadings[ D18_PRES ].data = convertPressureReading( getFPGAD18PresRawPressure(), PRES_MIN_PSI, LOW_PRES_MAX_PSI ); + currentPressureReadings[ D41_PRES ].data = convertPressureReading( getFPGAD41PresRawPressure(), PRES_MIN_PSI, LOW_PRES_MAX_PSI ); + currentPressureReadings[ BARO_PRES ].data = convertBaroPressureReading2mmHg( getFPGABaroPressure() ); // Update and convert raw pressure sensor temperatures to deg C - currentPresTempReadings[ PRESSURE_SENSOR_WATER_INLET_INPUT ].data = convertPressureTempReading2DegC( getFPGAPRiRawTemperature() ); - currentPresTempReadings[ PRESSURE_SENSOR_WATER_INLET_OUTPUT ].data = convertPressureTempReading2DegC( getFPGAPRoRawTemperature() ); - currentPresTempReadings[ PRESSURE_SENSOR_HYDRAULICS_OUTLET ].data = convertPressureTempReading2DegC( getFPGAPnRawTemperature() ); - currentPresTempReadings[ PRESSURE_SENSOR_BIBAG ].data = convertPressureTempReading2DegC( getFPGAPCbRawTemperature() ); - currentPresTempReadings[ PRESSURE_SENSOR_SPENT_DIALYSATE ].data = convertPressureTempReading2DegC( getFPGAPDsRawTemperature() ); - currentPresTempReadings[ PRESSURE_SENSOR_FRESH_DIALYSATE ].data = convertPressureTempReading2DegC( getFPGAPDfRawTemperature() ); - currentPresTempReadings[ PRESSURE_SENSOR_TRANSMEMBRANE ].data = convertPressureTempReading2DegC( getFPGAPtmRawTemperature() ); + currentPresTempReadings[ M1_PRES ].data = convertPressureTempReading2DegC( getFPGAM1PresRawTemperature() ); + currentPresTempReadings[ M3_PRES ].data = convertPressureTempReading2DegC( getFPGAM3PresRawTemperature() ); + currentPresTempReadings[ D9_PRES ].data = convertPressureTempReading2DegC( getFPGAD9PresRawTemperature() ); + currentPresTempReadings[ D66_PRES ].data = convertPressureTempReading2DegC( getFPGAD66PresRawTemperature() ); + currentPresTempReadings[ D51_PRES ].data = convertPressureTempReading2DegC( getFPGAD51PresRawTemperature() ); + currentPresTempReadings[ D18_PRES ].data = convertPressureTempReading2DegC( getFPGAD18PresRawTemperature() ); + currentPresTempReadings[ D41_PRES ].data = convertPressureTempReading2DegC( getFPGAD41PresRawTemperature() ); // Update read and error counters for each pressure sensor - lastPressureReadCounter[ PRESSURE_SENSOR_WATER_INLET_INPUT ].data = (U32)getFPGAPRiReadCount(); - lastPressureReadCounter[ PRESSURE_SENSOR_WATER_INLET_OUTPUT ].data = (U32)getFPGAPRoReadCount(); - lastPressureReadCounter[ PRESSURE_SENSOR_HYDRAULICS_OUTLET ].data = (U32)getFPGAPnReadCount(); - lastPressureReadCounter[ PRESSURE_SENSOR_BIBAG ].data = (U32)getFPGAPCbReadCount(); - lastPressureReadCounter[ PRESSURE_SENSOR_SPENT_DIALYSATE ].data = (U32)getFPGAPDsReadCount(); - lastPressureReadCounter[ PRESSURE_SENSOR_FRESH_DIALYSATE ].data = (U32)getFPGAPDfReadCount(); - lastPressureReadCounter[ PRESSURE_SENSOR_TRANSMEMBRANE ].data = (U32)getFPGAPtmReadCount(); + lastPressureReadCounter[ M1_PRES ].data = (U32)getFPGAM1PresReadCount(); + lastPressureReadCounter[ M3_PRES ].data = (U32)getFPGAM3PresReadCount(); + lastPressureReadCounter[ D9_PRES ].data = (U32)getFPGAD9PresReadCount(); + lastPressureReadCounter[ D66_PRES ].data = (U32)getFPGAD66PresReadCount(); + lastPressureReadCounter[ D51_PRES ].data = (U32)getFPGAD51PresReadCount(); + lastPressureReadCounter[ D18_PRES ].data = (U32)getFPGAD18PresReadCount(); + lastPressureReadCounter[ D41_PRES ].data = (U32)getFPGAD41PresReadCount(); - lastPressureErrorCounter[ PRESSURE_SENSOR_WATER_INLET_INPUT ].data = (U32)getFPGAPRiErrorCount(); - lastPressureErrorCounter[ PRESSURE_SENSOR_WATER_INLET_OUTPUT ].data = (U32)getFPGAPRoErrorCount(); - lastPressureErrorCounter[ PRESSURE_SENSOR_HYDRAULICS_OUTLET ].data = (U32)getFPGAPnErrorCount(); - lastPressureErrorCounter[ PRESSURE_SENSOR_BIBAG ].data = (U32)getFPGAPCbErrorCount(); - lastPressureErrorCounter[ PRESSURE_SENSOR_SPENT_DIALYSATE ].data = (U32)getFPGAPDsErrorCount(); - lastPressureErrorCounter[ PRESSURE_SENSOR_FRESH_DIALYSATE ].data = (U32)getFPGAPDfErrorCount(); - lastPressureErrorCounter[ PRESSURE_SENSOR_TRANSMEMBRANE ].data = (U32)getFPGAPtmErrorCount(); + lastPressureErrorCounter[ M1_PRES ].data = (U32)getFPGAM1PresErrorCount(); + lastPressureErrorCounter[ M3_PRES ].data = (U32)getFPGAM3PresErrorCount(); + lastPressureErrorCounter[ D9_PRES ].data = (U32)getFPGAD9PresErrorCount(); + lastPressureErrorCounter[ D66_PRES ].data = (U32)getFPGAD66PresErrorCount(); + lastPressureErrorCounter[ D51_PRES ].data = (U32)getFPGAD51PresErrorCount(); + lastPressureErrorCounter[ D18_PRES ].data = (U32)getFPGAD18PresErrorCount(); + lastPressureErrorCounter[ D41_PRES ].data = (U32)getFPGAD41PresErrorCount(); // Monitor pressure sensor health checkPressureSensors(); @@ -244,21 +249,21 @@ *************************************************************************/ static void checkPressureSensors( void ) { - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_WATER_INLET_INPUT_PRESSURE, getPressureSensorReadCount( PRESSURE_SENSOR_WATER_INLET_INPUT ) ); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_WATER_INLET_OUTPUT_PRESSURE, getPressureSensorReadCount( PRESSURE_SENSOR_WATER_INLET_OUTPUT ) ); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_HYDRAULICS_OUTLET_PRESSURE, getPressureSensorReadCount( PRESSURE_SENSOR_HYDRAULICS_OUTLET ) ); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_BIBAG_PRESSURE, getPressureSensorReadCount( PRESSURE_SENSOR_BIBAG ) ); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_SPENT_DIALYSATE_PRESSURE, getPressureSensorReadCount( PRESSURE_SENSOR_SPENT_DIALYSATE ) ); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_FRESH_DIALYSATE_PRESSURE, getPressureSensorReadCount( PRESSURE_SENSOR_FRESH_DIALYSATE ) ); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_TRANSMEMBRANE_PRESSURE, getPressureSensorReadCount( PRESSURE_SENSOR_TRANSMEMBRANE ) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_WATER_INLET_INPUT_PRESSURE, getPressureSensorReadCount( M1_PRES ) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_WATER_INLET_OUTPUT_PRESSURE, getPressureSensorReadCount( M3_PRES ) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_HYDRAULICS_OUTLET_PRESSURE, getPressureSensorReadCount( D9_PRES ) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_BIBAG_PRESSURE, getPressureSensorReadCount( D66_PRES ) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_SPENT_DIALYSATE_PRESSURE, getPressureSensorReadCount( D51_PRES ) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_FRESH_DIALYSATE_PRESSURE, getPressureSensorReadCount( D18_PRES ) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_TRANSMEMBRANE_PRESSURE, getPressureSensorReadCount( D41_PRES ) ); - checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_WATER_INLET_INPUT_PRESSURE, getPressureSensorErrorCount( PRESSURE_SENSOR_WATER_INLET_INPUT ) ); - checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_WATER_INLET_OUTPUT_PRESSURE, getPressureSensorErrorCount( PRESSURE_SENSOR_WATER_INLET_OUTPUT ) ); - checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_HYDRAULICS_OUTLET_PRESSURE, getPressureSensorErrorCount( PRESSURE_SENSOR_HYDRAULICS_OUTLET ) ); - checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_BIBAG_PRESSURE, getPressureSensorErrorCount( PRESSURE_SENSOR_BIBAG ) ); - checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_SPENT_DIALYSATE_PRESSURE, getPressureSensorErrorCount( PRESSURE_SENSOR_SPENT_DIALYSATE ) ); - checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_FRESH_DIALYSATE_PRESSURE, getPressureSensorErrorCount( PRESSURE_SENSOR_FRESH_DIALYSATE ) ); - checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_TRANSMEMBRANE_PRESSURE, getPressureSensorErrorCount( PRESSURE_SENSOR_TRANSMEMBRANE ) ); + checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_WATER_INLET_INPUT_PRESSURE, getPressureSensorErrorCount( M1_PRES ) ); + checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_WATER_INLET_OUTPUT_PRESSURE, getPressureSensorErrorCount( M3_PRES ) ); + checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_HYDRAULICS_OUTLET_PRESSURE, getPressureSensorErrorCount( D9_PRES ) ); + checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_BIBAG_PRESSURE, getPressureSensorErrorCount( D66_PRES ) ); + checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_SPENT_DIALYSATE_PRESSURE, getPressureSensorErrorCount( D51_PRES ) ); + checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_FRESH_DIALYSATE_PRESSURE, getPressureSensorErrorCount( D18_PRES ) ); + checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_TRANSMEMBRANE_PRESSURE, getPressureSensorErrorCount( D41_PRES ) ); } /*********************************************************************//** @@ -381,12 +386,12 @@ return result; } - -/************************************************************************* - * TEST SUPPORT FUNCTIONS - *************************************************************************/ +/************************************************************************* + * TEST SUPPORT FUNCTIONS + *************************************************************************/ + /*********************************************************************//** * @brief * The testPressureSensorReadingsOverride function overrides the value of the @@ -403,7 +408,7 @@ return result; } - + /*********************************************************************//** * @brief * The testPressureSensorTemperatureReadingsOverride function overrides the value of the @@ -454,5 +459,5 @@ return result; } - -/**@}*/ + +/**@}*/ Index: firmware/App/Drivers/PressureSensor.h =================================================================== diff -u -r48c75a394c56b82886760e9a136b638edecf7572 -red39129abdca4ec343369d83494530b23621e052 --- firmware/App/Drivers/PressureSensor.h (.../PressureSensor.h) (revision 48c75a394c56b82886760e9a136b638edecf7572) +++ firmware/App/Drivers/PressureSensor.h (.../PressureSensor.h) (revision ed39129abdca4ec343369d83494530b23621e052) @@ -14,42 +14,42 @@ * @date (original) 04-Sep-2024 * ***************************************************************************/ - -#ifndef __PRESSURE_SENSOR_H__ -#define __PRESSURE_SENSOR_H__ - + +#ifndef __PRESSURE_SENSOR_H__ +#define __PRESSURE_SENSOR_H__ + #include "DDCommon.h" -#include "PressureCommon.h" - -/** - * @defgroup PressureSensor PressureSensor - * @brief Pressure sensors driver module. Reads the various DD pressure - * sensors raw pressure and temperature value. - * - * @addtogroup PressureSensor - * @{ - */ - +#include "PressureCommon.h" + +/** + * @defgroup PressureSensor PressureSensor + * @brief Pressure sensors driver module. Reads the various DD pressure + * sensors raw pressure and temperature value. + * + * @addtogroup PressureSensor + * @{ + */ + // ********** public definitions ********** - -/// Enumeration of pressure sensors monitored by this module. -typedef enum PressureSensors -{ - PRESSURE_SENSOR_WATER_INLET_INPUT = 0, ///< Water Inlet pressure before regulator (PRi) - PRESSURE_SENSOR_FIRST = PRESSURE_SENSOR_WATER_INLET_INPUT, ///< First pressure to scan - PRESSURE_SENSOR_WATER_INLET_OUTPUT, ///< Water Inlet pressure after regulator (PRo) - PRESSURE_SENSOR_HYDRAULICS_OUTLET, ///< Hydraulics outlet pressure (PHo/Pn) - PRESSURE_SENSOR_BIBAG, ///< Dry Bicarb pressure (PDB/PCb) - PRESSURE_SENSOR_SPENT_DIALYSATE, ///< Spent Dialysate pressure (PDs) - PRESSURE_SENSOR_FRESH_DIALYSATE, ///< Fresh Dialysate pressure (PDf) - PRESSURE_SENSOR_TRANSMEMBRANE, ///< Transmembrane pressure (Ptm) - PRESSURE_SENSOR_BAROMETRIC, ///< barometric pressure sensor - NUM_OF_PRESSURE_SENSORS ///< Number of pressure sensors -} PRESSURE_SENSORS_T; - -// ********** public function prototypes ********** - -void initPressureSensor( void ); + +/// Enumeration of pressure sensors monitored by this module. +typedef enum PressureSensors +{ + M1_PRES = 0, ///< Water Inlet pressure before regulator (PRi) + PRESSURE_SENSOR_FIRST = M1_PRES, ///< First pressure to scan + M3_PRES, ///< Water Inlet pressure after regulator (PRo) + D9_PRES, ///< Hydraulics outlet pressure (PHo/Pn) + D66_PRES, ///< Dry Bicarb pressure (PDB/PCb) + D51_PRES, ///< Spent Dialysate pressure (PDs) + D18_PRES, ///< Fresh Dialysate pressure (PDf) + D41_PRES, ///< Transmembrane pressure (Ptm) + BARO_PRES, ///< barometric pressure sensor + NUM_OF_PRESSURE_SENSORS ///< Number of pressure sensors +} PRESSURE_SENSORS_T; + +// ********** public function prototypes ********** + +void initPressureSensor( void ); void readPressureSensors( void ); F32 getPressure( PRESSURE_SENSORS_T sensor ); F32 getPressureSensorTemperature( PRESSURE_SENSORS_T sensor ); @@ -59,8 +59,8 @@ BOOL testPressureSensorReadingsOverride( MESSAGE_T *message ); BOOL testPressureSensorTemperatureReadingsOverride( MESSAGE_T *message ); BOOL testPressureSensorReadCounterOverride( MESSAGE_T *message ); -BOOL testPressureSensorErrorCounterOverride( MESSAGE_T *message ); - -/**@}*/ - -#endif +BOOL testPressureSensorErrorCounterOverride( MESSAGE_T *message ); + +/**@}*/ + +#endif Index: firmware/App/Drivers/TemperatureSensors.c =================================================================== diff -u -re7fe0454b5b2d39009dc784dc8c156856df8bc86 -red39129abdca4ec343369d83494530b23621e052 --- firmware/App/Drivers/TemperatureSensors.c (.../TemperatureSensors.c) (revision e7fe0454b5b2d39009dc784dc8c156856df8bc86) +++ firmware/App/Drivers/TemperatureSensors.c (.../TemperatureSensors.c) (revision ed39129abdca4ec343369d83494530b23621e052) @@ -34,11 +34,16 @@ // ********** private definitions ********** +#define USE_PT_100 1 ///< flag to check PT100 use in calculations + #define PRIMARY_HEATER_TEMP_SENSORS_GAIN 8U ///< Primary heater temperature sensors gain. #define PRIMARY_HEATER_TEMP_SENSORS_REF_RESISTANCE 20000 ///< Primary heater temperature sensors reference resistance. #define PRIMARY_HEATER_TEMP_SENSORS_0_DEGREE_RESISTANCE 1000U ///< Primary heater temperature sensors zero degree resistance. -#define PRIMARY_HEATER_TEMP_SENSORS_V3_REF_RESISTANCE 19600 ///< Primary heater temperature sensors V3 reference resistance. +#define PT100_TEMP_SENSORS_GAIN 8U ///< PT100 temperature sensors gain. +#define PT100_TEMP_SENSORS_REF_RESISTANCE 4700 ///< PT100 temperature sensors reference resistance. +#define PT100_TEMP_SENSORS_0_DEGREE_RESISTANCE 100U ///< PT100 temperature sensors zero degree resistance. + #define TEMP_SENSORS_ADC_BITS 24U ///< External temperature sensors ADC bits. #define MAX_NUM_OF_RAW_ADC_SAMPLES 4U ///< Number of ADC reads for moving average calculations. #define SHIFT_BITS_BY_2 2U ///< Shift bits by 2 to create a 4 for averaging 4 samples. @@ -77,7 +82,6 @@ S32 rawADCReads[ MAX_NUM_OF_RAW_ADC_SAMPLES ]; ///< Raw ADC reads array S32 adcNextIndex; ///< Next ADC read index S32 adcRunningSum; ///< ADC running sum - OVERRIDE_F32_T temperatureValue; ///< Temperature values with override F32 maxAllowedTemp; ///< Maximum allowed temperature of the sensor S32 baroTempSnsrDiff; ///< Barometric sensor temperature difference } TEMP_SENSOR_T; @@ -108,6 +112,7 @@ // ********** private data ********** static TEMP_SENSOR_T tempSensors [ NUM_OF_TEMPERATURE_SENSORS ]; ///< Temperature sensors' data structure. +static OVERRIDE_F32_T temperatureValue[ NUM_OF_TEMPERATURE_SENSORS ]; ///< Temperature values with override static OVERRIDE_U32_T lastTemperatureReadCounter; ///< Temperature sensors read count from FPGA. static OVERRIDE_U32_T lastBaroTempReadCounter; ///< Barometric sensor read count from FPGA. static BARO_SENSOR_CONSTS_T baroConvConsts; ///< Barometric sensor conversion constants. @@ -149,32 +154,56 @@ memset( &baroConvConsts, 0x0, sizeof( BARO_SENSOR_CONSTS_T ) ); // Initialize TH1 (primary heater), TH2(outlet Heat Exchanger), TAUX ( Inlet Heat exchanger), - // TH3 ( Trim Heater) constants. For now, assume same gain across all sensors. - tempSensors[ TEMPSENSORS_INLET_HEAT_EXCHANGER ].gain = PRIMARY_HEATER_TEMP_SENSORS_GAIN; - tempSensors[ TEMPSENSORS_INLET_HEAT_EXCHANGER ].refResistance = PRIMARY_HEATER_TEMP_SENSORS_REF_RESISTANCE; - tempSensors[ TEMPSENSORS_INLET_HEAT_EXCHANGER ].zeroDegreeResistance = PRIMARY_HEATER_TEMP_SENSORS_0_DEGREE_RESISTANCE; - tempSensors[ TEMPSENSORS_INLET_HEAT_EXCHANGER ].maxAllowedTemp = TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; + // TH3 ( Trim Heater) constants. + // Based on the PT100/PT1000,define the constants for all temperature sensors +#ifdef USE_PT_100 + tempSensors[ D1_TEMP ].gain = PT100_TEMP_SENSORS_GAIN; + tempSensors[ D1_TEMP ].refResistance = PT100_TEMP_SENSORS_REF_RESISTANCE; + tempSensors[ D1_TEMP ].zeroDegreeResistance = PT100_TEMP_SENSORS_0_DEGREE_RESISTANCE; + tempSensors[ D1_TEMP ].maxAllowedTemp = TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; - tempSensors[ TEMPSENSORS_OUTLET_HEAT_EXCHANGER ].gain = PRIMARY_HEATER_TEMP_SENSORS_GAIN; - tempSensors[ TEMPSENSORS_OUTLET_HEAT_EXCHANGER ].refResistance = PRIMARY_HEATER_TEMP_SENSORS_REF_RESISTANCE; - tempSensors[ TEMPSENSORS_OUTLET_HEAT_EXCHANGER ].zeroDegreeResistance = PRIMARY_HEATER_TEMP_SENSORS_0_DEGREE_RESISTANCE; - tempSensors[ TEMPSENSORS_OUTLET_HEAT_EXCHANGER ].maxAllowedTemp = TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; + tempSensors[ X6_TEMP ].gain = PT100_TEMP_SENSORS_GAIN; + tempSensors[ X6_TEMP ].refResistance = PT100_TEMP_SENSORS_REF_RESISTANCE; + tempSensors[ X6_TEMP ].zeroDegreeResistance = PT100_TEMP_SENSORS_0_DEGREE_RESISTANCE; + tempSensors[ X6_TEMP ].maxAllowedTemp = TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; - tempSensors[ TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER ].gain = PRIMARY_HEATER_TEMP_SENSORS_GAIN; - tempSensors[ TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER ].refResistance = PRIMARY_HEATER_TEMP_SENSORS_REF_RESISTANCE; - tempSensors[ TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER ].zeroDegreeResistance = PRIMARY_HEATER_TEMP_SENSORS_0_DEGREE_RESISTANCE; - tempSensors[ TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER ].maxAllowedTemp = HEATERS_INTERNAL_TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; + tempSensors[ D4_TEMP ].gain = PT100_TEMP_SENSORS_GAIN; + tempSensors[ D4_TEMP ].refResistance = PT100_TEMP_SENSORS_REF_RESISTANCE; + tempSensors[ D4_TEMP ].zeroDegreeResistance = PT100_TEMP_SENSORS_0_DEGREE_RESISTANCE; + tempSensors[ D4_TEMP ].maxAllowedTemp = HEATERS_INTERNAL_TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; - tempSensors[ TEMPSENSORS_TRIMMER_HEATER ].gain = PRIMARY_HEATER_TEMP_SENSORS_GAIN; - tempSensors[ TEMPSENSORS_TRIMMER_HEATER ].refResistance = PRIMARY_HEATER_TEMP_SENSORS_REF_RESISTANCE; - tempSensors[ TEMPSENSORS_TRIMMER_HEATER ].zeroDegreeResistance = PRIMARY_HEATER_TEMP_SENSORS_0_DEGREE_RESISTANCE; - tempSensors[ TEMPSENSORS_TRIMMER_HEATER ].maxAllowedTemp = TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; + tempSensors[ D50_TEMP ].gain = PT100_TEMP_SENSORS_GAIN; + tempSensors[ D50_TEMP ].refResistance = PT100_TEMP_SENSORS_REF_RESISTANCE; + tempSensors[ D50_TEMP ].zeroDegreeResistance = PT100_TEMP_SENSORS_0_DEGREE_RESISTANCE; + tempSensors[ D50_TEMP ].maxAllowedTemp = TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; +#else + tempSensors[ D1_TEMP ].gain = PRIMARY_HEATER_TEMP_SENSORS_GAIN; + tempSensors[ D1_TEMP ].refResistance = PRIMARY_HEATER_TEMP_SENSORS_REF_RESISTANCE; + tempSensors[ D1_TEMP ].zeroDegreeResistance = PRIMARY_HEATER_TEMP_SENSORS_0_DEGREE_RESISTANCE; + tempSensors[ D1_TEMP ].maxAllowedTemp = TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; + tempSensors[ X6_TEMP ].gain = PRIMARY_HEATER_TEMP_SENSORS_GAIN; + tempSensors[ X6_TEMP ].refResistance = PRIMARY_HEATER_TEMP_SENSORS_REF_RESISTANCE; + tempSensors[ X6_TEMP ].zeroDegreeResistance = PRIMARY_HEATER_TEMP_SENSORS_0_DEGREE_RESISTANCE; + tempSensors[ X6_TEMP ].maxAllowedTemp = TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; + + tempSensors[ D4_TEMP ].gain = PRIMARY_HEATER_TEMP_SENSORS_GAIN; + tempSensors[ D4_TEMP ].refResistance = PRIMARY_HEATER_TEMP_SENSORS_REF_RESISTANCE; + tempSensors[ D4_TEMP ].zeroDegreeResistance = PRIMARY_HEATER_TEMP_SENSORS_0_DEGREE_RESISTANCE; + tempSensors[ D4_TEMP ].maxAllowedTemp = HEATERS_INTERNAL_TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; + + tempSensors[ D50_TEMP ].gain = PRIMARY_HEATER_TEMP_SENSORS_GAIN; + tempSensors[ D50_TEMP ].refResistance = PRIMARY_HEATER_TEMP_SENSORS_REF_RESISTANCE; + tempSensors[ D50_TEMP ].zeroDegreeResistance = PRIMARY_HEATER_TEMP_SENSORS_0_DEGREE_RESISTANCE; + tempSensors[ D50_TEMP ].maxAllowedTemp = TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; +#endif + + // Board temperature sensors conversion coefficient - tempSensors[ TEMPSENSORS_BOARD_TEMPERATURE ].conversionCoeff = conversionCoeff; - tempSensors[ TEMPSENSORS_BOARD_TEMPERATURE ].maxAllowedTemp = NON_FLUID_PATH_TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; + tempSensors[ BRD_TEMP ].conversionCoeff = conversionCoeff; + tempSensors[ BRD_TEMP ].maxAllowedTemp = NON_FLUID_PATH_TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; - tempSensors[ TEMPSENSORS_BAROMETRIC_TEMP_SENSOR ].maxAllowedTemp = NON_FLUID_PATH_TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; + tempSensors[ BARO_TEMP ].maxAllowedTemp = NON_FLUID_PATH_TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; // Persistent alarm for the temperature sensors range check initPersistentAlarm( ALARM_ID_DD_TEMPERATURE_SENSOR_OUT_OF_RANGE, TEMP_SENSORS_OUT_OF_RANGE_TIME_OUT_MS, TEMP_SENSORS_OUT_OF_RANGE_TIME_OUT_MS ); @@ -201,7 +230,7 @@ if ( sensorIndex < NUM_OF_TEMPERATURE_SENSORS ) { - temperature = getF32OverrideValue( &tempSensors[ sensorIndex ].temperatureValue ); + temperature = getF32OverrideValue( &temperatureValue[ sensorIndex ] ); } else { @@ -222,7 +251,7 @@ *************************************************************************/ S32 getBaroSensorTemperatureDiff( void ) { - return tempSensors[ TEMPSENSORS_BAROMETRIC_TEMP_SENSOR ].baroTempSnsrDiff; + return tempSensors[ BARO_TEMP ].baroTempSnsrDiff; } /*********************************************************************//** @@ -252,10 +281,10 @@ lastTemperatureReadCounter.data = (U32)getFPGARTDReadCount(); //Read temperature sensors - processTempSnsrsADCRead( TEMPSENSORS_INLET_HEAT_EXCHANGER, getFPGAInletHeatExchangerTemp() ); - processTempSnsrsADCRead( TEMPSENSORS_OUTLET_HEAT_EXCHANGER, getFPGAOutletHeatExchangerTemp() ); - processTempSnsrsADCRead( TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER, getFPGAHydraulicsPrimaryHeaterTemp() ); - processTempSnsrsADCRead( TEMPSENSORS_TRIMMER_HEATER, getFPGATrimmerHeaterTemp() ); + processTempSnsrsADCRead( D1_TEMP, getFPGAD1Temp() ); + processTempSnsrsADCRead( X6_TEMP, getFPGAX6Temp() ); + processTempSnsrsADCRead( D4_TEMP, getFPGAD4Temp() ); + processTempSnsrsADCRead( D50_TEMP, getFPGAD50Temp() ); //TODO: Read Board temperture //processTempSnsrsADCRead( TEMPSENSORS_INTERNAL_COND_TEMP_SENSOR, getFPGACondSnsrInternalTemp() ); @@ -270,7 +299,7 @@ baroConvConsts.temperatureCoeff = getFPGABaroTempCoeffOfTemperature(); lastBaroTempReadCounter.data = (U32)getFPGABaroReadCount(); - processTempSnsrsADCRead( TEMPSENSORS_BAROMETRIC_TEMP_SENSOR, getFPGABaroTemperature() ); + processTempSnsrsADCRead( BARO_TEMP, getFPGABaroTemperature() ); } } @@ -413,19 +442,19 @@ // Different sensors have different ADC to temperature conversion methods switch( sensorIndex ) { - case TEMPSENSORS_INLET_HEAT_EXCHANGER: - case TEMPSENSORS_OUTLET_HEAT_EXCHANGER: - case TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER: - case TEMPSENSORS_TRIMMER_HEATER: + case D1_TEMP: + case X6_TEMP: + case D4_TEMP: + case D50_TEMP: temperature = getADC2TempConversion( avgADCReads, (U32)tempSensors [ sensorIndex ].gain, (U32)tempSensors [ sensorIndex ].refResistance, (U32)tempSensors [ sensorIndex ].zeroDegreeResistance, tempSensors [ sensorIndex ].conversionCoeff ); break; - case TEMPSENSORS_BOARD_TEMPERATURE: + case BRD_TEMP: //TODO : Need details on calculations. break; - case TEMPSENSORS_BAROMETRIC_TEMP_SENSOR: + case BARO_TEMP: { S32 baroTempSensorsDiff = (S32)avgADCReads - ( baroConvConsts.refTemperature * TWO_TO_POWER_OF_8 ); S64 differenceTimesCoefficient = (S64)baroTempSensorsDiff * (S64)baroConvConsts.temperatureCoeff; @@ -446,7 +475,7 @@ getCalibrationAppliedTemperatureValue( sensorIndex, &temperature ); // Update the temperature - tempSensors[ sensorIndex ].temperatureValue.data = temperature; + temperatureValue[ sensorIndex ].data = temperature; } @@ -553,23 +582,23 @@ switch( sesnorIndex ) { - case TEMPSENSORS_INLET_HEAT_EXCHANGER: + case D1_TEMP: //calId = CAL_DATA_INLET_HEAT_EXCHANGER_TEMP; break; - case TEMPSENSORS_OUTLET_HEAT_EXCHANGER: + case X6_TEMP: //calId = CAL_DATA_OUTLET_HEAT_EXCHANGER_TEMP; break; - case TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER: + case D4_TEMP: //calId = CAL_DATA_HYD_PRIMARY_HEATER_TEMP; break; - case TEMPSENSORS_TRIMMER_HEATER: + case D50_TEMP: //calId = CAL_DATA_TRIM_HEATER_TEMP; break; - case TEMPSENSORS_BAROMETRIC_TEMP_SENSOR: + case BARO_TEMP: //calId = CAL_DATA_BARMOTERIC_TEMP; break; @@ -607,7 +636,7 @@ *************************************************************************/ BOOL testMeasuredTemperatureOverride( MESSAGE_T *message ) { - BOOL result = f32ArrayOverride( message, &tempSensors[0].temperatureValue, NUM_OF_TEMPERATURE_SENSORS - 1 ); + BOOL result = f32ArrayOverride( message, &temperatureValue[0], NUM_OF_TEMPERATURE_SENSORS - 1 ); return result; } Index: firmware/App/Drivers/TemperatureSensors.h =================================================================== diff -u -re7fe0454b5b2d39009dc784dc8c156856df8bc86 -red39129abdca4ec343369d83494530b23621e052 --- firmware/App/Drivers/TemperatureSensors.h (.../TemperatureSensors.h) (revision e7fe0454b5b2d39009dc784dc8c156856df8bc86) +++ firmware/App/Drivers/TemperatureSensors.h (.../TemperatureSensors.h) (revision ed39129abdca4ec343369d83494530b23621e052) @@ -35,14 +35,14 @@ /// Enumeration of temperature sensors. typedef enum SENSORS_NAME { - TEMPSENSORS_INLET_HEAT_EXCHANGER = 0, ///< First temp sensor to scan - TEMPSENSORS_FIRST = TEMPSENSORS_INLET_HEAT_EXCHANGER, ///< Heat exchanger Inlet temperature sensor - TEMPSENSORS_OUTLET_HEAT_EXCHANGER, ///< Heat exchanger Outlet temperature sensor - TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER, ///< Hydraulics primary heater temperature sensor - TEMPSENSORS_TRIMMER_HEATER, ///< Trimmer heater temperature sensor - TEMPSENSORS_BAROMETRIC_TEMP_SENSOR, ///< Barometric temperature sensor - TEMPSENSORS_BOARD_TEMPERATURE, ///< DD board temperature sensor ( thermistor ) - NUM_OF_TEMPERATURE_SENSORS ///< Number of temperature sensors + D1_TEMP = 0, ///< First temp sensor to scan + TEMPSENSORS_FIRST = D1_TEMP, ///< Heat exchanger Inlet temperature sensor + X6_TEMP, ///< Heat exchanger Outlet temperature sensor + D4_TEMP, ///< Hydraulics primary heater temperature sensor + D50_TEMP, ///< Trimmer heater temperature sensor + BARO_TEMP, ///< Barometric temperature sensor + BRD_TEMP, ///< DD board temperature sensor ( thermistor ) + NUM_OF_TEMPERATURE_SENSORS ///< Number of temperature sensors } TEMPERATURE_SENSORS_T; // ********** public function prototypes **********