Index: firmware/App/Controllers/DialysatePumps.c =================================================================== diff -u -rbf55b31e342873e3d6047b09749628f5fe275d8d -ra3a396aa37fb562327f05e54990f06538c7617ed --- firmware/App/Controllers/DialysatePumps.c (.../DialysatePumps.c) (revision bf55b31e342873e3d6047b09749628f5fe275d8d) +++ firmware/App/Controllers/DialysatePumps.c (.../DialysatePumps.c) (revision a3a396aa37fb562327f05e54990f06538c7617ed) @@ -71,10 +71,10 @@ #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. @@ -189,44 +189,44 @@ signalDialysatePumpHardStop( pumpId ); } - pumpTargetPressure[FRESH_DIALYSATE_PUMP].data = FRESH_DIALYSATE_TARGET_PRESSURE_PSI; - pumpTargetPressure[FRESH_DIALYSATE_PUMP].ovInitData = FRESH_DIALYSATE_TARGET_PRESSURE_PSI; - pumpTargetPressure[FRESH_DIALYSATE_PUMP].ovData = 0.0F; - pumpTargetPressure[FRESH_DIALYSATE_PUMP].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; - pumpTargetPressure[SPENT_DIALYSATE_PUMP].data = SPENT_DIALYSATE_TARGET_PRESSURE_PSI; - pumpTargetPressure[SPENT_DIALYSATE_PUMP].ovInitData = SPENT_DIALYSATE_TARGET_PRESSURE_PSI; - pumpTargetPressure[SPENT_DIALYSATE_PUMP].ovData = 0.0F; - pumpTargetPressure[SPENT_DIALYSATE_PUMP].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. - setFPGAFreshDialysatePumpSpeed( MIN_DIALYSATE_PUMP_RPM ); - setFPGASpentDialysatePumpSpeed( MIN_DIALYSATE_PUMP_RPM ); + 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 ); } /*********************************************************************//** @@ -293,18 +293,18 @@ 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( MIN_DIALYSATE_PUMP_RPM ); + setFPGAD12PumpControl( dialysatePumps[ pumpId ].control ); + setFPGAD12PumpSpeed( MIN_DIALYSATE_PUMP_RPM ); } else { dialysatePumps[ pumpId ].control = DIALYSATE_PUMP_CONTROL_STOP; - setFPGASpentDialysatePumpControl( dialysatePumps[ pumpId ].control ); - setFPGASpentDialysatePumpSpeed( MIN_DIALYSATE_PUMP_RPM ); + setFPGAD48PumpControl( dialysatePumps[ pumpId ].control ); + setFPGAD48PumpSpeed( MIN_DIALYSATE_PUMP_RPM ); } // Reset all the variables to stop mode @@ -315,13 +315,13 @@ 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 ); } } @@ -332,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 @@ -344,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; @@ -369,46 +369,46 @@ * 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 = getFPGASpentDialysatePumpCurrentFeedback(); - U16 freshDialSpeedCnt = getFPGAFreshDialysatePumpSpeed(); - U16 spentDialSpeedCnt = getFPGASpentDialysatePumpSpeed(); - 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 - dialysatePumpMeasuredCurrentA[ FRESH_DIALYSATE_PUMP ].data = (F32)freshDialCurrent * CURRENT_CONVERSION_COEFF; - dialysatePumpMeasuredCurrentA[ SPENT_DIALYSATE_PUMP ].data = (F32)spentDialCurrent * CURRENT_CONVERSION_COEFF; - measuredDirection[ FRESH_DIALYSATE_PUMP ].data = (U32)( ( getFPGAFreshDialysatePumpHallDirectionStatus() & DIALYSATE_PUMP_DIR_BIT_MASK ) >> SHIFT_BITS_BY_7 ); - measuredDirection[ SPENT_DIALYSATE_PUMP ].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 ( freshDialSpeedCnt > SPEED_COUNT_ZERO ) + if ( d12SpeedCnt > SPEED_COUNT_ZERO ) { - measuredPumpSpeed[ FRESH_DIALYSATE_PUMP ].data = SPEED_CONV_FACTOR / freshDialSpeedCnt; + measuredPumpSpeed[ D12_PUMP ].data = SPEED_CONV_FACTOR / d12SpeedCnt; } - if ( spentDialSpeedCnt > SPEED_COUNT_ZERO ) + if ( d48SpeedCnt > SPEED_COUNT_ZERO ) { - measuredPumpSpeed[ SPENT_DIALYSATE_PUMP ].data = SPEED_CONV_FACTOR / spentDialSpeedCnt; + measuredPumpSpeed[ D48_PUMP ].data = SPEED_CONV_FACTOR / d48SpeedCnt; } // Monitor dialysate pumps @@ -424,22 +424,22 @@ isRPMTooHigh = ( getDialysatePumpMeasuredSpeed( pumpId ) > MIN_DIALYSATE_PUMP_RPM ? TRUE : FALSE ); #if 0 - if ( FRESH_DIALYSATE_PUMP == pumpId ) + 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(); } @@ -458,17 +458,17 @@ isRPMOutOfRange = ( rpmDiff > MAX_ALLOWED_RPM_OUT_OF_RANGE ? TRUE : FALSE ); #if 0 - if ( FRESH_DIALYSATE_PUMP == pumpId ) + 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 } @@ -486,13 +486,13 @@ F32 currentA = getDialysatePumpMeasuredCurrentA( pumpId ); isCurrentOutOfRange = ( currentA > DIALYSATE_PUMP_MAX_CURRENT_A ? TRUE : FALSE ) | isOffCurrentOut; #if 0 - if ( FRESH_DIALYSATE_PUMP == pumpId ) + 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 } @@ -519,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++ ) @@ -562,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 ); @@ -612,16 +612,16 @@ 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; @@ -650,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; } @@ -708,15 +708,15 @@ 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 ); } } @@ -739,13 +739,13 @@ 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 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 // newSpeed = control * ( MAX_DIALYSATE_PUMP_RPM / DIALYSATE_PUMP_MAX_PRESSURE_PSI ); #if 0 @@ -764,7 +764,7 @@ dialysatePumps[ pumpId ].currentPumpSpeed = newSpeed; //Set fresh dialyate pump speed - setFPGAFreshDialysatePumpSpeed( (U16)dialysatePumps[ pumpId ].currentPumpSpeed ); + setFPGAD12PumpSpeed( (U16)dialysatePumps[ pumpId ].currentPumpSpeed ); #endif } else @@ -773,7 +773,7 @@ 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 // newSpeed = control * ( MAX_DIALYSATE_PUMP_RPM / DIALYSATE_PUMP_MAX_PRESSURE_PSI ); #if 0 @@ -792,7 +792,7 @@ dialysatePumps[ pumpId ].currentPumpSpeed = newSpeed; //Set spent dialyate pump speed - setFPGASpentDialysatePumpSpeed( (U16)dialysatePumps[ pumpId ].currentPumpSpeed ); + setFPGAD48PumpSpeed( (U16)dialysatePumps[ pumpId ].currentPumpSpeed ); #endif } dialysatePumps[ pumpId ].controlTimerCounter = 0; @@ -947,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( PRESSURE_SENSOR_FRESH_DIALYSATE ); + dialPump.d48PumpMeasuredPressure = getFilteredPressure( PRESSURE_SENSOR_SPENT_DIALYSATE ); + 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 ) );