Index: firmware/App/Controllers/DialysatePumps.c =================================================================== diff -u -rb6d20d9e5c704a9f7ebceea9bb12731dac61fc2a -r5126b79e4970ffe2ed9db4cccea18a1216c78570 --- firmware/App/Controllers/DialysatePumps.c (.../DialysatePumps.c) (revision b6d20d9e5c704a9f7ebceea9bb12731dac61fc2a) +++ firmware/App/Controllers/DialysatePumps.c (.../DialysatePumps.c) (revision 5126b79e4970ffe2ed9db4cccea18a1216c78570) @@ -17,6 +17,7 @@ #include +#include "BalancingChamber.h" #include "DialysatePumps.h" #include "FpgaDD.h" #include "MessageSupport.h" @@ -38,15 +39,13 @@ */ // ********** private definitions ********** - #define DIALYSATE_PUMP_DATA_PUB_INTERVAL ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) ///< Interval (ms/task time) at which the dialysate pump data is published on the CAN bus. #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 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_RAMP_SPEED_INCREMENT 10.0F ///< Speed increase when controlling dialysate pump ramp 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. @@ -60,18 +59,20 @@ #define MAX_FPGA_DIALYSATE_PUMP_DIRECTION_FAULT_WINDOW_MS ( 1 * SEC_PER_MIN * MS_PER_SECOND ) ///< FPGA dialysate pump direction fault window #define MAX_FPGA_DIALYSATE_PUMP_DIRECTION_FAULT_FAILURES 10 ///< FPGA dialysate pump direction fault failures per MAX_FPGA_DIALYSATE_PUMP_DIRECTION_FAULT_WINDOW_MS -#define FRESH_DIALYSATE_TARGET_PRESSURE_PSI (-12.0F) ///< Fresh dialysate pump recommended pressure(Pn/PHo) in psi. -#define FRESH_DIALYSATE_MAX_PRESSURE_PSI (-15.0F) ///< Fresh dialysate pump maximum allowed (Pn/PHo) pressure in psi. -#define SPENT_DIALYSATE_TARGET_PRESSURE_PSI 25.0F ///< Spent dialysate pump recommended pressure(PDs) in psi. +#define FRESH_DIALYSATE_TARGET_PRESSURE_PSI 25.0F ///< Fresh dialysate pump recommended pressure(D18) in psi. +#define FRESH_DIALYSATE_MAX_PRESSURE_PSI 26.0F ///< Fresh dialysate pump maximum allowed (D18) pressure in psi. +#define SPENT_DIALYSATE_TARGET_PRESSURE_PSI 29.0F ///< Spent dialysate pump recommended pressure(PDs) in psi. #define SPENT_DIALYSATE_MAX_PRESSURE_PSI 30.0F ///< Spent dialysate pump maximum allowed (PDs) pressure in psi. -#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 FRESH_DIAL_OPEN_LOOP_SPEED_RPM 2000.0F ///< fresh dialysate pump open loop speed to meet target pressure. +#define SPENT_DIAL_OPEN_LOOP_SPEED_RPM 2500.0F ///< spent dialysate pump open loop speed to meet target pressure. #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 20.0F ///< P term for fresh dialysate pump delta pressure control. +#define D12_PUMP_I_COEFFICIENT 60.0F ///< I term for fresh dialysate pump delta pressure control. +#define D48_PUMP_P_COEFFICIENT 20.0F ///< P term for spent dialysate pump delta pressure control. +#define D48_PUMP_I_COEFFICIENT 60.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 +103,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,8 +127,18 @@ //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). +static BOOL dialPumpsReadyToControl; ///< Flag use to indicate the minimum control interval is met for pump control -//TODO : Validate once HDD defines the conversion. +//For testing +#ifdef __PITEST__ +static F32 pIControlSignal[ NUM_OF_CONTROLLER_SIGNAL ]; +#endif + static const F32 CURRENT_CONVERSION_COEFF = (F32)( 2.5F / ( BITS_12_FULL_SCALE - 1.0F ) ); // ********** private function prototypes ********** @@ -148,77 +154,94 @@ * @brief * The initDialysatePump function initializes the DialysatePumps unit. * @details \b Inputs: none - * @details \b Outputs: Dialysate unit variables initialized. + * @details \b Outputs: Dialysate pump unit variables initialized. * @return none *************************************************************************/ void initDialysatePump( void ) { DIALYSATE_PUMPS_T pumpId; +#ifdef __PITEST__ + U32 i; +#endif + dialysatePumpDataPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; 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; + dialPumpsReadyToControl = FALSE; 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, - DIALYSATE_PUMP_MIN_PRESSURE_PSI, DIALYSATE_PUMP_MAX_PRESSURE_PSI ); + initializePIController( PI_CONTROLLER_ID_D12_PUMP, FRESH_DIAL_OPEN_LOOP_SPEED_RPM, D12_PUMP_P_COEFFICIENT, D12_PUMP_I_COEFFICIENT, + MIN_DIALYSATE_PUMP_RPM, MAX_DIALYSATE_PUMP_RPM ); // 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, - DIALYSATE_PUMP_MIN_PRESSURE_PSI, DIALYSATE_PUMP_MAX_PRESSURE_PSI ); + initializePIController( PI_CONTROLLER_ID_D48_PUMP, SPENT_DIAL_OPEN_LOOP_SPEED_RPM, D48_PUMP_P_COEFFICIENT, D48_PUMP_I_COEFFICIENT, + MIN_DIALYSATE_PUMP_RPM, MAX_DIALYSATE_PUMP_RPM ); + // 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 ); + +#ifdef __PITEST__ + for ( i = 0; i < NUM_OF_CONTROLLER_SIGNAL; i++ ) + { + pIControlSignal[ i ] = 0.0F; + } +#endif + // 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 +263,16 @@ { 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; + // Lets assign minimum speed to make sure, driver is not getting into fault mode + pumpTargetSpeed[ pumpId ].data = MIN_DIALYSATE_PUMP_RPM; } 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 +309,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, FRESH_DIAL_OPEN_LOOP_SPEED_RPM ); } else { - resetPIController( PI_CONTROLLER_ID_SPENT_DIALYSATE_PUMP, DIALYSATE_PUMP_MIN_PRESSURE_PSI ); + resetPIController( PI_CONTROLLER_ID_D48_PUMP, SPENT_DIAL_OPEN_LOOP_SPEED_RPM ); } } @@ -324,9 +348,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 +360,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 +385,47 @@ * 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++ ) { @@ -404,26 +437,28 @@ 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 ) + //TODO : Enable the code later for alarm testing +#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 +472,21 @@ 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 ) + //TODO : Enable the code later for alarm testing +#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 +501,17 @@ // 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 ) + //TODO : Enable the code later for alarm testing +#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 +536,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++ ) @@ -515,13 +555,10 @@ dialysatePumps[ pumpId ].dialysatePumpState = handleDialysatePumpControlToTargetState( pumpId ); break; -#ifndef _VECTORCAST_ - // The switch case is in a for loop so the default case cannot be covered in VectorCAST default: SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_DIALYSATE_PUMP_EXEC_INVALID_STATE, pumpId ) dialysatePumps[ pumpId ].dialysatePumpState = DIALYSATE_PUMP_OFF_STATE; break; -#endif } } } @@ -539,10 +576,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 +624,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 +664,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, FRESH_DIAL_OPEN_LOOP_SPEED_RPM ); } else { - resetPIController( PI_CONTROLLER_ID_SPENT_DIALYSATE_PUMP, DIALYSATE_PUMP_MIN_PRESSURE_PSI ); + resetPIController( PI_CONTROLLER_ID_D48_PUMP, SPENT_DIAL_OPEN_LOOP_SPEED_RPM ); } state = DIALYSATE_PUMP_CONTROL_TO_TARGET_STATE; } @@ -658,9 +695,9 @@ if ( currentToTargetDiff > ZERO_SPEED ) { - if ( currentToTargetDiff > DIALYSATE_PUMP_SPEED_INCREMENT ) + if ( currentToTargetDiff > DIALYSATE_PUMP_RAMP_SPEED_INCREMENT ) { - speedIncrease = DIALYSATE_PUMP_SPEED_INCREMENT; + speedIncrease = DIALYSATE_PUMP_RAMP_SPEED_INCREMENT; } else { @@ -677,23 +714,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 ); } } @@ -712,45 +749,56 @@ { DIALYSATE_PUMP_STATE_T state = DIALYSATE_PUMP_CONTROL_TO_TARGET_STATE; - // control at set interval - if ( ++dialysatePumps[ pumpId ].controlTimerCounter >= DP_CONTROL_INTERVAL ) + // control at set minimum interval or interval is expired and balance chamber fill is complete + if ( ( ++dialysatePumps[ pumpId ].controlTimerCounter >= DP_CONTROL_INTERVAL ) || + ( TRUE == dialPumpsReadyToControl ) ) { - // Control based on the measured and target pressure - if ( FRESH_DIALYSATE_PUMP == pumpId ) + dialysatePumps[ pumpId ].controlTimerCounter = 0; + dialPumpsReadyToControl = TRUE; + + // Control happen only when balancing chamber fill is complete. + if ( FALSE == getBalancingChamberFillinProgressStatus() ) { - F32 measuredPressure = getFilteredPressure( PRESSURE_SENSOR_FRESH_DIALYSATE ); - F32 targetPressure = getDialysatePumpTargetPressure( pumpId ); + dialPumpsReadyToControl = FALSE; - F32 control = runPIController( PI_CONTROLLER_ID_FRESH_DIALYSATE_PUMP, targetPressure, measuredPressure ); - // TODO : get the equivalent speed for the given control - F32 newSpeed = control * ( MAX_DIALYSATE_PUMP_RPM / DIALYSATE_PUMP_MAX_PRESSURE_PSI ); + // Control based on the measured and target pressure + if ( D12_PUMP == pumpId ) + { + F32 measuredPressure = getFilteredPressure( D18_PRES ); + F32 targetPressure = getDialysatePumpTargetPressure( pumpId ); - //Apply speed limit - newSpeed = MIN( newSpeed, MAX_DIALYSATE_PUMP_RPM ); - newSpeed = MAX( newSpeed, MIN_DIALYSATE_PUMP_RPM ); + F32 control = runPIController( PI_CONTROLLER_ID_D12_PUMP, targetPressure, measuredPressure ); +#ifdef __PITEST__ + U32 i; - dialysatePumps[ pumpId ].currentPumpSpeed = newSpeed; - //Set fresh dialyate pump speed - setFPGAFreshDialysatePumpSpeed( (U16)dialysatePumps[ pumpId ].currentPumpSpeed ); - } - else - { - F32 measuredPressure = getFilteredPressure( PRESSURE_SENSOR_SPENT_DIALYSATE ); - F32 targetPressure = getDialysatePumpTargetPressure( pumpId ); + for ( i = 0; i < NUM_OF_CONTROLLER_SIGNAL; i++ ) + { + pIControlSignal[ i ] = getPIControllerSignals( PI_CONTROLLER_ID_D12_PUMP, (PI_CONTROLLER_SIGNALS_ID)i ); + } +#endif + dialysatePumps[ pumpId ].currentPumpSpeed = control; + //Set fresh dialyate pump speed + setFPGAD12PumpSpeed( (U16)dialysatePumps[ pumpId ].currentPumpSpeed ); + } + else + { + F32 measuredPressure = getFilteredPressure( D51_PRES ); + F32 targetPressure = getDialysatePumpTargetPressure( pumpId ); - F32 control = runPIController( PI_CONTROLLER_ID_SPENT_DIALYSATE_PUMP, targetPressure, measuredPressure ); - // TODO : get the equivalent speed for the given control - F32 newSpeed = control * ( MAX_DIALYSATE_PUMP_RPM / DIALYSATE_PUMP_MAX_PRESSURE_PSI ); + F32 control = runPIController( PI_CONTROLLER_ID_D48_PUMP, targetPressure, measuredPressure ); +#ifdef __PITEST__ + U32 i; - //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 ); + for ( i = 0; i < NUM_OF_CONTROLLER_SIGNAL; i++ ) + { + pIControlSignal[ i ] = getPIControllerSignals( PI_CONTROLLER_ID_D48_PUMP, (PI_CONTROLLER_SIGNALS_ID)i ); + } +#endif + dialysatePumps[ pumpId ].currentPumpSpeed = control; + //Set spent dialyate pump speed + setFPGAD48PumpSpeed( (U16)dialysatePumps[ pumpId ].currentPumpSpeed ); + } } - dialysatePumps[ pumpId ].controlTimerCounter = 0; } return state; @@ -772,7 +820,7 @@ if ( pumpId < NUM_OF_DIALYSATE_PUMPS ) { - speed = getF32OverrideValue( &dialysatePumps[ pumpId ].pumpTargetSpeed ); + speed = getF32OverrideValue( &pumpTargetSpeed[ pumpId ] ); } else { @@ -798,7 +846,7 @@ if ( pumpId < NUM_OF_DIALYSATE_PUMPS ) { - speed = getF32OverrideValue( &dialysatePumps[ pumpId ].measuredPumpSpeed ); + speed = getF32OverrideValue( &measuredPumpSpeed[ pumpId ] ); } else { @@ -824,7 +872,7 @@ if ( pumpId < NUM_OF_DIALYSATE_PUMPS ) { - pressure = getF32OverrideValue( &dialysatePumps[ pumpId ].pumpTargetPressure ); + pressure = getF32OverrideValue( &pumpTargetPressure[ pumpId ] ); } else { @@ -849,7 +897,7 @@ if ( pumpId < NUM_OF_DIALYSATE_PUMPS ) { - current = getF32OverrideValue( &dialysatePumps[ pumpId ].dialysatePumpMeasuredCurrentA ); + current = getF32OverrideValue( &dialysatePumpMeasuredCurrentA[ pumpId ] ); } else { @@ -874,7 +922,7 @@ if ( pumpId < NUM_OF_DIALYSATE_PUMPS ) { - direction = getU32OverrideValue( &dialysatePumps[ pumpId ].measuredDirection ); + direction = getU32OverrideValue( &measuredDirection[ pumpId ] ); } else { @@ -902,26 +950,40 @@ 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 ); +#ifndef __PITEST__ + dialPump.d12PumpTargetRPM = getDialysatePumpTargetSpeed( D12_PUMP ); + dialPump.d48PumpTargetRPM = getDialysatePumpTargetSpeed( D48_PUMP ); +#else + dialPump.d12PumpTargetRPM = pIControlSignal[ 0 ]; + dialPump.d48PumpTargetRPM = pIControlSignal[ 1 ]; +#endif + 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; +#ifndef __PITEST__ + 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 ); +#else + dialPump.d12PumpTargetPressure = pIControlSignal[ 2 ]; + dialPump.d48PumpTargetPressure = pIControlSignal[ 3 ]; + dialPump.d12PumpMeasuredPressure = pIControlSignal[ 4 ]; + dialPump.d48PumpMeasuredPressure = pIControlSignal[ 5 ]; + dialPump.d12PumpMeasuredCurrent = pIControlSignal[ 6 ]; + dialPump.d48PumpMeasuredCurrent = pIControlSignal[ 7 ]; +#endif + 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 +1026,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 +1043,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 +1060,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 +1077,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 +1094,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; } @@ -1051,7 +1113,7 @@ { BOOL result = FALSE; - // Verify tester has logged in with TD + // Verify tester has logged in with DD if ( TRUE == isTestingActivated() ) { // Verify payload length is valid