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 ) ); Index: firmware/App/Controllers/DialysatePumps.h =================================================================== diff -u -rd54f4bbfdb5b751ccc661735d4586f6a2dad5d02 -ra3a396aa37fb562327f05e54990f06538c7617ed --- firmware/App/Controllers/DialysatePumps.h (.../DialysatePumps.h) (revision d54f4bbfdb5b751ccc661735d4586f6a2dad5d02) +++ firmware/App/Controllers/DialysatePumps.h (.../DialysatePumps.h) (revision a3a396aa37fb562327f05e54990f06538c7617ed) @@ -38,35 +38,35 @@ /// 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 -r77f16abd083c385b3ed9cb0c41a60dff7295022c -ra3a396aa37fb562327f05e54990f06538c7617ed --- firmware/App/Controllers/Heaters.c (.../Heaters.c) (revision 77f16abd083c385b3ed9cb0c41a60dff7295022c) +++ firmware/App/Controllers/Heaters.c (.../Heaters.c) (revision a3a396aa37fb562327f05e54990f06538c7617ed) @@ -42,33 +42,33 @@ #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 PRIMARY_HEATER_ON 1.00F ///< Primary heater ON control +#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 TRIMMER_HEATER_GAIN 10.0F ///< Trimmer heater gain for testing. +#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. @@ -150,18 +150,18 @@ } // 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 ); } /*********************************************************************//** @@ -357,13 +357,13 @@ switch ( heater ) { - case DD_PRIMARY_HEATER: - alarm = ALARM_ID_DD_FLUID_TOO_LOW_WHILE_PRIMARY_HEATER_IS_ON; + case D5_HEAT: + alarm = ALARM_ID_DD_FLUID_TOO_LOW_WHILE_D5_HEAT_IS_ON; isLevelLow = ( ( getLevelStatus( FLOATER_LEVEL ) != 0 )? FALSE : TRUE ); break; - case DD_TRIMMER_HEATER: - alarm = ALARM_ID_DD_FLUID_TOO_LOW_WHILE_TRIMMER_HEATER_IS_ON; + case D45_HEAT: + alarm = ALARM_ID_DD_FLUID_TOO_LOW_WHILE_D45_HEAT_IS_ON; isLevelLow = ( ( getLevelStatus( SPENT_DIALYSATE_LEVEL ) != 0 )? FALSE : TRUE ); break; @@ -376,13 +376,13 @@ } else { - if ( DD_PRIMARY_HEATER == heater ) + if ( D5_HEAT == heater ) { - 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_D5_HEAT_IS_ON, FALSE, 0.0F, 0.0F ); } else { - checkPersistentAlarm( ALARM_ID_DD_FLUID_TOO_LOW_WHILE_TRIMMER_HEATER_IS_ON, FALSE, 0.0F, 0.0F ); + checkPersistentAlarm( ALARM_ID_DD_FLUID_TOO_LOW_WHILE_D45_HEAT_IS_ON, FALSE, 0.0F, 0.0F ); } } } @@ -435,11 +435,11 @@ DD_OP_MODE_T opMode = getCurrentOperationMode(); F32 targetTemperature = getHeaterTargetTemperature( heater ); - if ( DD_PRIMARY_HEATER == heater ) + if ( D5_HEAT == heater ) { if ( DD_MODE_HEAT != opMode ) { - control[ heater ].data = PRIMARY_HEATER_ON; + control[ heater ].data = D5_HEAT_ON; state = HEATER_EXEC_STATE_CONTROL_TO_TARGET; } else @@ -487,11 +487,11 @@ F32 measuredTemperature = 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: + case D5_HEAT: measuredTemperature = getTemperatureValue( (U32)TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER ); if ( measuredTemperature >= targetTemperature ) { @@ -501,19 +501,19 @@ else { // Turn On heater - control[ heater ].data = PRIMARY_HEATER_ON; + control[ heater ].data = D5_HEAT_ON; } - //control = runPIController( PI_CONTROLLER_ID_PRIMARY_HEATER, targetTemperature, measuredTemperature ); + //control = runPIController( PI_CONTROLLER_ID_D5_HEAT, targetTemperature, measuredTemperature ); break; - case DD_TRIMMER_HEATER: + case D45_HEAT: measuredTemperature = getTemperatureValue( (U32)TEMPSENSORS_TRIMMER_HEATER ); - //control = runPIController( PI_CONTROLLER_ID_TRIMMER_HEATER, targetTemperature, measuredTemperature ); + //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 * TRIMMER_HEATER_GAIN ); + 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 ); @@ -552,8 +552,8 @@ //TODO : update dutycycle for the heat disinfect state - setHeaterControl( DD_TRIMMER_HEATER ); - setHeaterControl( DD_PRIMARY_HEATER ); + setHeaterControl( D45_HEAT ); + setHeaterControl( D5_HEAT ); return state; } @@ -576,7 +576,7 @@ control = getHeaterControl( heater ); - if ( DD_PRIMARY_HEATER == heater ) + if ( D5_HEAT == heater ) { BOOL heaterCntrl = (BOOL)control; setFPGACPrimaryHeaterOnOffControl( heaterCntrl ); @@ -612,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 *************************************************************************/ @@ -624,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 = getHeaterControl( DD_PRIMARY_HEATER ); -// F32 trimmerDC = getHeaterControl( 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 ); @@ -635,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 ); // } //} @@ -663,14 +663,14 @@ { HEATERS_DATA_T data; - data.mainPrimayHeaterDC = getHeaterControl( DD_PRIMARY_HEATER ); - data.trimmerHeaterDC = getHeaterControl( DD_TRIMMER_HEATER ); - data.primaryTargetTemp = getHeaterTargetTemperature( DD_PRIMARY_HEATER ); - data.trimmerTargetTemp = getHeaterTargetTemperature( DD_TRIMMER_HEATER ); - 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; Index: firmware/App/Controllers/Heaters.h =================================================================== diff -u -r8116b493a8085f28f85e5a9e8ead7e18d0dc77a8 -ra3a396aa37fb562327f05e54990f06538c7617ed --- firmware/App/Controllers/Heaters.h (.../Heaters.h) (revision 8116b493a8085f28f85e5a9e8ead7e18d0dc77a8) +++ firmware/App/Controllers/Heaters.h (.../Heaters.h) (revision a3a396aa37fb562327f05e54990f06538c7617ed) @@ -37,23 +37,23 @@ /// 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 ********** Index: firmware/App/Modes/ModeFault.c =================================================================== diff -u -rf49295a21525d5d1b88ec52eb4fcac72e7a526b7 -ra3a396aa37fb562327f05e54990f06538c7617ed --- firmware/App/Modes/ModeFault.c (.../ModeFault.c) (revision f49295a21525d5d1b88ec52eb4fcac72e7a526b7) +++ firmware/App/Modes/ModeFault.c (.../ModeFault.c) (revision a3a396aa37fb562327f05e54990f06538c7617ed) @@ -174,10 +174,10 @@ requestConcentratePumpOff( D11_PUMP, parkPumps ); requestConcentratePumpOff( D10_PUMP, parkPumps ); - signalDialysatePumpHardStop( FRESH_DIALYSATE_PUMP ); - signalDialysatePumpHardStop( SPENT_DIALYSATE_PUMP ); - stopHeater( DD_PRIMARY_HEATER ); - stopHeater( DD_TRIMMER_HEATER ); + signalDialysatePumpHardStop( D12_PUMP ); + signalDialysatePumpHardStop( D48_PUMP ); + stopHeater( D5_HEAT ); + stopHeater( D45_HEAT ); } /*********************************************************************//** Index: firmware/App/Modes/ModeGenDialysate.c =================================================================== diff -u -rf49295a21525d5d1b88ec52eb4fcac72e7a526b7 -ra3a396aa37fb562327f05e54990f06538c7617ed --- firmware/App/Modes/ModeGenDialysate.c (.../ModeGenDialysate.c) (revision f49295a21525d5d1b88ec52eb4fcac72e7a526b7) +++ firmware/App/Modes/ModeGenDialysate.c (.../ModeGenDialysate.c) (revision a3a396aa37fb562327f05e54990f06538c7617ed) @@ -182,8 +182,8 @@ targetHydChamberFluidTemp.data = getTDTargetDialysateTemperature(); // Turn on the primary heater - setHeaterTargetTemperature( DD_PRIMARY_HEATER, getGenDilaysateTargetTemperature() ); - startHeater( DD_PRIMARY_HEATER ); + setHeaterTargetTemperature( D5_HEAT, getGenDilaysateTargetTemperature() ); + startHeater( D5_HEAT ); lastDialTargetTemperatureSet = getGenDilaysateTargetTemperature(); break; @@ -193,7 +193,7 @@ // Start timer for hyd chamber negative pressure check state hydChamberPressureCheckStartTimeMS = getMSTimerCount(); // Start D12/DGP pump - setDialysatePumpTargetRPM( FRESH_DIALYSATE_PUMP, FRESH_DIAL_PUMP_INITIAL_RPM ); + setDialysatePumpTargetRPM( D12_PUMP, FRESH_DIAL_PUMP_INITIAL_RPM ); break; case DD_GEND_FRESH_DIALYSATE_PRESSURE_CHECK_STATE: @@ -228,7 +228,7 @@ setValveState( VDB2, VALVE_STATE_OPEN ); // Start D48/SDP pump - setDialysatePumpTargetRPM( SPENT_DIALYSATE_PUMP, SPENT_DIAL_PUMP_INITIAL_RPM ); + setDialysatePumpTargetRPM( D48_PUMP, SPENT_DIAL_PUMP_INITIAL_RPM ); break; case DD_GEND_PRODUCE_DIALYSATE_STATE: @@ -250,13 +250,13 @@ case DD_GEND_DIALYSATE_DELIVERY_PAUSE: // stop the motor during pause conditions - signalDialysatePumpHardStop( FRESH_DIALYSATE_PUMP ); - signalDialysatePumpHardStop( SPENT_DIALYSATE_PUMP ); + signalDialysatePumpHardStop( D12_PUMP ); + signalDialysatePumpHardStop( D48_PUMP ); requestConcentratePumpOff( D11_PUMP, FALSE ); requestConcentratePumpOff( D10_PUMP, FALSE ); - stopHeater( DD_PRIMARY_HEATER ); - stopHeater( DD_TRIMMER_HEATER ); + stopHeater( D5_HEAT ); + stopHeater( D45_HEAT ); //close the DD - water inlet and drain valves? break; @@ -370,7 +370,7 @@ if ( lastDialTargetTemperatureSet != targetTemperature ) { // Update the target temperature for heater control - setHeaterTargetTemperature( DD_PRIMARY_HEATER, targetTemperature ); + setHeaterTargetTemperature( D5_HEAT, targetTemperature ); lastDialTargetTemperatureSet = targetTemperature; } Index: firmware/App/Services/FpgaDD.c =================================================================== diff -u -rf49295a21525d5d1b88ec52eb4fcac72e7a526b7 -ra3a396aa37fb562327f05e54990f06538c7617ed --- firmware/App/Services/FpgaDD.c (.../FpgaDD.c) (revision f49295a21525d5d1b88ec52eb4fcac72e7a526b7) +++ firmware/App/Services/FpgaDD.c (.../FpgaDD.c) (revision a3a396aa37fb562327f05e54990f06538c7617ed) @@ -89,8 +89,8 @@ #define FPGA_READ_V3_START_BYTE_NUM 256 ///< FPGA V3 read sensors start byte number. #define FPGA_READ_V3_END_BYTE_NUM 430 ///< FPGA V3 read sensors end byte number. -#define FPGA_DGP_PUMP_ERROR_BIT 0x01 ///< Fresh dialysate pump error bit mask. -#define FPGA_SDP_PUMP_ERROR_BIT 0x02 ///< Spent dialysate pump error bit mask. +#define FPGA_D12_PUMP_ERROR_BIT 0x01 ///< Fresh dialysate pump error bit mask. +#define FPGA_D48_PUMP_ERROR_BIT 0x02 ///< Spent dialysate pump error bit mask. #define FPGA_FLOATER_LEVEL_BIT 0x03 ///< Floater level bit mask. @@ -224,18 +224,18 @@ U32 fpgaBaroPressure; ///< Reg 406. Barometric sensor pressure value U32 fpgaBaroTemperature; ///< Reg 410. Barometric sensor temperature sensor - U16 fpgaDGPMeasuredSpeed; ///< Reg 414. Fresh dialysate pump measured speed - U16 fpgaSDPMeasuredSpeed; ///< Reg 416. Spent dialysate pump measured speed + U16 fpgaD12MeasuredSpeed; ///< Reg 414. Fresh dialysate pump measured speed + U16 fpgaD48MeasuredSpeed; ///< Reg 416. Spent dialysate pump measured speed U08 fpgaBaroErrorCount; ///< Reg 418. Barometric sensor Error count - U08 fpgaDGPSDPPumpStatus; ///< Reg 419. Dialysate pumps Error status - U16 fpgaDGPCurrentFeedback; ///< Reg 420. Fresh dialysate pump current feedback - U16 fpgaSDPCurrentFeedback; ///< Reg 422. Spent dialysate pump current feedback - U08 fpgaDGPHallStatus; ///< Reg 424. Fresh dialysate pump hall sensor direction status - U08 fpgaSDPHallStatus; ///< Reg 425. Spent dialysate pump hall sensor direction status + U08 fpgaD12D48PumpStatus; ///< Reg 419. Dialysate pumps Error status + U16 fpgaD12CurrentFeedback; ///< Reg 420. Fresh dialysate pump current feedback + U16 fpgaD48CurrentFeedback; ///< Reg 422. Spent dialysate pump current feedback + U08 fpgaD12HallStatus; ///< Reg 424. Fresh dialysate pump hall sensor direction status + U08 fpgaD48HallStatus; ///< Reg 425. Spent dialysate pump hall sensor direction status U08 fpgaFloater1Status; ///< Reg 426. Floater 1 level sensor status U08 fpgaFloater2Status; ///< Reg 427. Floater 2 level sensor status - U16 fpgaD11_PumpStepCountStatus; ///< Reg 428. Acid concentrate pump revolution down count status - U16 fpgaD10_PumpStepCountStatus; ///< Reg 430. Bicarb concentrate pump revolution down count status + U16 fpgaD11PumpStepCountStatus; ///< Reg 428. Acid concentrate pump revolution down count status + U16 fpgaD10PumpStepCountStatus; ///< Reg 430. Bicarb concentrate pump revolution down count status } DD_FPGA_SENSORS_T; typedef struct @@ -302,20 +302,20 @@ U16 fpgaRemoteUpdate_Write; ///< Reg 110.Register for Remote update used by SW. - U16 fpgaDGPSpeed; ///< Reg 112. DGP Speed/RPM Control - U08 fpgaDGPControl; ///< Reg 114. DGP Control - U08 fpgaSDPControl; ///< Reg 115. SDP Control - U16 fpgaSDPSpeed; ///< Reg 116. SDP Speed/RPM Control - U16 fpgaD11_PumpSpeed; ///< Reg 118. Acid Concentrate Pump Speed/RPM Control - U08 fpgaD11_PumpControl; ///< Reg 120. Acid Concentrate Pump Control - U08 fpgaD10_PumpControl; ///< Reg 121. BiCarb Concentrate Pump Control - U16 fpgaD10_PumpSpeed; ///< Reg 122. BiCarb Concentrate Pump Speed/RPM Control + U16 fpgaD12PumpSpeed; ///< Reg 112. D48 Speed/RPM Control + U08 fpgaD12PumpControl; ///< Reg 114. DGP Control + U08 fpgaD48PumpControl; ///< Reg 115. SDP Control + U16 fpgaD48PumpSpeed; ///< Reg 116. SDP Speed/RPM Control + U16 fpgaD11PumpSpeed; ///< Reg 118. Acid Concentrate Pump Speed/RPM Control + U08 fpgaD11PumpControl; ///< Reg 120. Acid Concentrate Pump Control + U08 fpgaD10PumpControl; ///< Reg 121. BiCarb Concentrate Pump Control + U16 fpgaD10PumpSpeed; ///< Reg 122. BiCarb Concentrate Pump Speed/RPM Control U08 fpgaBloodLeakSensorTest; ///< Reg 124. Blood leak sensor test U08 fpgaBloodLeakUARTControl; ///< Reg 125. Blood leak sensor UART control U08 fpgaBloodLeakFIFOTx; ///< Reg 126. Blood leak sensor FIFO transmit control - U08 fpgaPrimaryHeaterPWMControl; ///< Reg 127. Primary heater PWM control - U08 fpgaTrimmerHeaterPWMControl; ///< Reg 128. Trimmer heater PWM control + U08 fpgaD5HeaterPWMControl; ///< Reg 127. Primary heater PWM control + U08 fpgaD45HeaterPWMControl; ///< Reg 128. Trimmer heater PWM control U08 fpgaNotUsed; ///< Reg 129. Not used U16 fpgaVBCPWMLow; ///< Reg 130. VBC PWM low ( Balancing chamber valves) @@ -324,8 +324,8 @@ U16 fpgaVUFPWMLow; ///< Reg 136. VUF PWM low ( Ultra filteration valves ) U16 fpgaVUFPWMPeriod; ///< Reg 138. VUF PWM period U16 fpgaVUFPWMPullin; ///< Reg 140. VUF PWM pull in - U16 fpgaD11_PumpRevCount; ///< Reg 142. Acid Concentrate pump revolution count - U16 fpgaD10_PumpRevCount; ///< Reg 144. Bicarb Concentrate pump revolution count + U16 fpgaD11PumpRevCount; ///< Reg 142. Acid Concentrate pump revolution count + U16 fpgaD10PumpRevCount; ///< Reg 144. Bicarb Concentrate pump revolution count U08 fpgaADCControl; ///< Reg 146. FPGA internal ADC Control register for debugging U08 fpgaGPIOControl; ///< Reg 147. FPGA GPIO control interface } FPGA_ACTUATORS_T; @@ -524,35 +524,35 @@ /*********************************************************************//** * @brief - * The setFPGASpentDialysatePumpSpeed function sets the speed for the + * The setFPGAD48PumpSpeed function sets the speed for the * spent dialysate pump (SDP). * @details \b Inputs: none - * @details \b Outputs: fpgaActuatorSetPoints.fpgaSDPSpeed + * @details \b Outputs: fpgaActuatorSetPoints.fpgaD48PumpSpeed * @param speed The spent dialysate pump speed * @return none *************************************************************************/ -void setFPGASpentDialysatePumpSpeed( U16 speed ) +void setFPGAD48PumpSpeed( U16 speed ) { - fpgaActuatorSetPoints.fpgaSDPSpeed = speed; + fpgaActuatorSetPoints.fpgaD48PumpSpeed = speed; } /*********************************************************************//** * @brief - * The setFPGAFreshDialysatePumpSpeed function sets the speed for the + * The setFPGAD12PumpSpeed function sets the speed for the * fresh dialysate pump (DGP). * @details \b Inputs: none - * @details \b Outputs: fpgaActuatorSetPoints.fpgaDGPSpeed + * @details \b Outputs: fpgaActuatorSetPoints.fpgaD12PumpSpeed * @param speed The fresh dialysate pump speed * @return none *************************************************************************/ -void setFPGAFreshDialysatePumpSpeed( U16 speed ) +void setFPGAD12PumpSpeed( U16 speed ) { - fpgaActuatorSetPoints.fpgaDGPSpeed = speed; + fpgaActuatorSetPoints.fpgaD12PumpSpeed = speed; } /*********************************************************************//** * @brief - * The setFPGASpentDialysatePumpControl function sets the controls for + * The setFPGAD48PumpControl function sets the controls for * dialysate out pump (SDP). * bit 7: TBD * bit 6: TBD @@ -562,18 +562,18 @@ * bit 1-2: TBD * bit 0: Run (1), stop (0) * @details \b Inputs: none - * @details \b Outputs: fpgaActuatorSetPoints.fpgaSDPControl + * @details \b Outputs: fpgaActuatorSetPoints.fpgaD48PumpControl * @param control The dialysate out pump controls * @return none *************************************************************************/ -void setFPGASpentDialysatePumpControl( U08 control ) +void setFPGAD48PumpControl( U08 control ) { - fpgaActuatorSetPoints.fpgaSDPControl = control; + fpgaActuatorSetPoints.fpgaD48PumpControl = control; } /*********************************************************************//** * @brief - * The setFPGAFreshDialysatePumpControl function sets the controls for + * The setFPGAD12PumpControl function sets the controls for * dialysate In pump (DGP). * bit 7: TBD * bit 6: TBD @@ -583,41 +583,41 @@ * bit 1-2: TBD * bit 0: Run (1), stop (0) * @details \b Inputs: none - * @details \b Outputs: fpgaActuatorSetPoints.fpgaDGPControl + * @details \b Outputs: fpgaActuatorSetPoints.fpgaD12PumpControl * @param control The dialysate In pump controls * @return none *************************************************************************/ -void setFPGAFreshDialysatePumpControl( U08 control ) +void setFPGAD12PumpControl( U08 control ) { - fpgaActuatorSetPoints.fpgaDGPControl = control; + fpgaActuatorSetPoints.fpgaD12PumpControl = control; } /*********************************************************************//** * @brief * The setFPGAD11PumpSetStepSpeed function sets the step speed period for * concentrate pump D11_Pump. * @details \b Inputs: none - * @details \b Outputs: fpgaActuatorSetPoints.fpgaD11_PumpSpeed + * @details \b Outputs: fpgaActuatorSetPoints.fpgaD11PumpSpeed * @param stepSpeed The concentrate pump step speed period * @return none *************************************************************************/ void setFPGAD11PumpSetStepSpeed( U16 stepSpeed ) { - fpgaActuatorSetPoints.fpgaD11_PumpSpeed = stepSpeed; + fpgaActuatorSetPoints.fpgaD11PumpSpeed = stepSpeed; } /*********************************************************************//** * @brief * The setFPGAD10PumpSetStepSpeed function sets the step speed period for * concentrate pump D10_Pump. * @details \b Inputs: none - * @details \b Outputs: fpgaActuatorSetPoints.fpgaD10_PumpSpeed + * @details \b Outputs: fpgaActuatorSetPoints.fpgaD10PumpSpeed * @param stepSpeed The concentrate pump step speed period * @return none *************************************************************************/ void setFPGAD10PumpSetStepSpeed( U16 stepSpeed ) { - fpgaActuatorSetPoints.fpgaD10_PumpSpeed = stepSpeed; + fpgaActuatorSetPoints.fpgaD10PumpSpeed = stepSpeed; } /*********************************************************************//** @@ -631,14 +631,14 @@ * bit 3: Direction (1=Fwd, 0=Rev) * bit 0-2: Microstepping resolution * @details \b Inputs: none - * @details \b Outputs: fpgaActuatorSetPoints.fpgaD11_PumpControl + * @details \b Outputs: fpgaActuatorSetPoints.fpgaD11PumpControl * @param control Concentrate pump control set * @return none *************************************************************************/ void setFPGAD11PumpControl( U08 control ) { - fpgaActuatorSetPoints.fpgaD11_PumpControl &= FPGA_CONC_PUMP_PARK_COMMAND; // preserve msb (park command bit) - fpgaActuatorSetPoints.fpgaD11_PumpControl |= control; + fpgaActuatorSetPoints.fpgaD11PumpControl &= FPGA_CONC_PUMP_PARK_COMMAND; // preserve msb (park command bit) + fpgaActuatorSetPoints.fpgaD11PumpControl |= control; } /*********************************************************************//** @@ -652,14 +652,14 @@ * bit 3: Direction (1=Fwd, 0=Rev) * bit 0-2: Microstepping resolution * @details \b Inputs: none - * @details \b Outputs: fpgaActuatorSetPoints.fpgaD10_PumpControl + * @details \b Outputs: fpgaActuatorSetPoints.fpgaD10PumpControl * @param control Concentrate pump control set * @return none *************************************************************************/ void setFPGAD10PumpControl( U08 control ) { - fpgaActuatorSetPoints.fpgaD10_PumpControl &= FPGA_CONC_PUMP_PARK_COMMAND; // preserve msb (park command bit) - fpgaActuatorSetPoints.fpgaD10_PumpControl |= control; + fpgaActuatorSetPoints.fpgaD10PumpControl &= FPGA_CONC_PUMP_PARK_COMMAND; // preserve msb (park command bit) + fpgaActuatorSetPoints.fpgaD10PumpControl |= control; } /*********************************************************************//** @@ -669,13 +669,13 @@ * bit 7: Park command bit * bit 0-6: Other pump control bits (set in different function) * @details \b Inputs: none - * @details \b Outputs: fpgaActuatorSetPoints.fpgaD11_PumpControl + * @details \b Outputs: fpgaActuatorSetPoints.fpgaD11PumpControl * @param Park command bit set * @return none *************************************************************************/ void setFPGAD11PumpParkCmd( void ) { - fpgaActuatorSetPoints.fpgaD11_PumpControl |= FPGA_CONC_PUMP_PARK_COMMAND; // this bit must be cleared after next transmit to prevent continuous park commands + fpgaActuatorSetPoints.fpgaD11PumpControl |= FPGA_CONC_PUMP_PARK_COMMAND; // this bit must be cleared after next transmit to prevent continuous park commands } /*********************************************************************//** @@ -685,13 +685,13 @@ * bit 7: Park command bit * bit 0-6: Other pump control bits (set in different function) * @details \b Inputs: none - * @details \b Outputs: fpgaActuatorSetPoints.fpgaD10_PumpControl + * @details \b Outputs: fpgaActuatorSetPoints.fpgaD10PumpControl * @param Park command bit set * @return none *************************************************************************/ void setFPGAD10PumpParkCmd( void ) { - fpgaActuatorSetPoints.fpgaD10_PumpControl |= FPGA_CONC_PUMP_PARK_COMMAND; // this bit must be cleared after next transmit to prevent continuous park commands + fpgaActuatorSetPoints.fpgaD10PumpControl |= FPGA_CONC_PUMP_PARK_COMMAND; // this bit must be cleared after next transmit to prevent continuous park commands } /*********************************************************************//** @@ -1271,55 +1271,55 @@ * The setFPGAPrimaryHeaterPWMControl function sets the primary heater * PWM input. * @details \b Inputs: none - * @details \b Outputs: fpgaPrimaryHeaterPWMControl + * @details \b Outputs: fpgaD5HeaterPWMControl * @param control the PWM dutycycle to control the heater * @return none *************************************************************************/ void setFPGAPrimaryHeaterPWMControl( U08 control ) { - fpgaActuatorSetPoints.fpgaPrimaryHeaterPWMControl = control; + fpgaActuatorSetPoints.fpgaD5HeaterPWMControl = control; } /*********************************************************************//** * @brief * The setFPGATrimmerHeaterPWMControl function sets the trimmer heater * PWM input. * @details \b Inputs: none - * @details \b Outputs: fpgaTrimmerHeaterPWMControl + * @details \b Outputs: fpgaD45HeaterPWMControl * @param control the PWM dutycycle to control the heater * @return none *************************************************************************/ void setFPGATrimmerHeaterPWMControl( U08 control ) { - fpgaActuatorSetPoints.fpgaTrimmerHeaterPWMControl = control; + fpgaActuatorSetPoints.fpgaD45HeaterPWMControl = control; } /*********************************************************************//** * @brief * The setFPGAD11PumpRevolutionCount function sets the Acid concentrate * pump revolution count. * @details \b Inputs: none - * @details \b Outputs: fpgaD11_PumpRevCount + * @details \b Outputs: fpgaD11PumpRevCount * @param count the number of revolution to be rotated for the pump. * @return none *************************************************************************/ void setFPGAD11PumpRevolutionCount( U16 count ) { - fpgaActuatorSetPoints.fpgaD11_PumpRevCount = count; + fpgaActuatorSetPoints.fpgaD11PumpRevCount = count; } /*********************************************************************//** * @brief * The setFPGAD10PumpRevolutionCount function sets the Bicarb concentrate * pump revolution count. * @details \b Inputs: none - * @details \b Outputs: fpgaD10_PumpRevCount + * @details \b Outputs: fpgaD10PumpRevCount * @param count the number of revolution to be rotated for the pump. * @return none *************************************************************************/ void setFPGAD10PumpRevolutionCount( U16 count ) { - fpgaActuatorSetPoints.fpgaD10_PumpRevCount = count; + fpgaActuatorSetPoints.fpgaD10PumpRevCount = count; } /*********************************************************************//** @@ -1360,7 +1360,7 @@ /*********************************************************************//** * @brief - * The getFPGASpentDialysatePumpControl function gets the status of the + * The getFPGAD48PumpControl function gets the status of the * dialysate out pump control status bits. * bit 7: TBD * bit 6: TBD @@ -1370,17 +1370,17 @@ * bit 1-2: TBD * bit 0: Run (1), stop (0) * @details \b Inputs: none - * @details \b Outputs: fpgaActuatorSetPoints.fpgaSDPControl + * @details \b Outputs: fpgaActuatorSetPoints.fpgaD48PumpControl * @return Dialysate Out pump control status bit *************************************************************************/ -U08 getFPGASpentDialysatePumpControl( void ) +U08 getFPGAD48PumpControl( void ) { - return fpgaActuatorSetPoints.fpgaSDPControl; + return fpgaActuatorSetPoints.fpgaD48PumpControl; } /*********************************************************************//** * @brief - * The getFPGAFreshDialysatePumpControl function gets the status of the + * The getFPGAD12PumpControl function gets the status of the * dialysate Inlet pump control status bits. * bit 7: TBD * bit 6: TBD @@ -1390,128 +1390,128 @@ * bit 1-2: TBD * bit 0: Run (1), stop (0) * @details \b Inputs: none - * @details \b Outputs: fpgaActuatorSetPoints.fpgaDGPControl + * @details \b Outputs: fpgaActuatorSetPoints.fpgaD12PumpControl * @return Dialysate Inlet pump control status bit *************************************************************************/ -U08 getFPGAFreshDialysatePumpControl( void ) +U08 getFPGAD12PumpControl( void ) { - return fpgaActuatorSetPoints.fpgaDGPControl; + return fpgaActuatorSetPoints.fpgaD12PumpControl; } /*********************************************************************//** * @brief - * The getFPGASpentDialysatePumpSpeed function gets the spent dialysate + * The getFPGAD48PumpSpeed function gets the spent dialysate * pump speed. * @details \b Inputs: none - * @details \b Outputs: fpgaSensorReadings.fpgaSDPMeasuredSpeed + * @details \b Outputs: fpgaSensorReadings.fpgaD48MeasuredSpeed * @return Spent dialysate pump measured speed. *************************************************************************/ -U16 getFPGASpentDialysatePumpSpeed( void ) +U16 getFPGAD48PumpSpeed( void ) { - return fpgaSensorReadings.fpgaSDPMeasuredSpeed; + return fpgaSensorReadings.fpgaD48MeasuredSpeed; } /*********************************************************************//** * @brief - * The getFPGAFreshDialysatePumpSpeed function gets the fresh dialysate + * The getFPGAD12PumpSpeed function gets the fresh dialysate * pump speed. * @details \b Inputs: none - * @details \b Outputs: fpgaSensorReadings.fpgaDGPMeasuredSpeed + * @details \b Outputs: fpgaSensorReadings.fpgaD12MeasuredSpeed * @return fresh dialysate pump measured speed. *************************************************************************/ -U16 getFPGAFreshDialysatePumpSpeed( void ) +U16 getFPGAD12PumpSpeed( void ) { - return fpgaSensorReadings.fpgaDGPMeasuredSpeed; + return fpgaSensorReadings.fpgaD12MeasuredSpeed; } /*********************************************************************//** * @brief - * The getFPGAFreshDialysatePumpErrorStatus function gets the fresh dialysate + * The getFPGAD12PumpErrorStatus function gets the fresh dialysate * pump error status. * bit 7-2: TBD * bit 1 : spent dialysate pump error (1), no error(0) * bit 0 : fresh dialysate pump error (1), no error(0) * @details \b Inputs: none - * @details \b Outputs: fpgaSensorReadings.fpgaDGPSDPPumpStatus + * @details \b Outputs: fpgaSensorReadings.fpgaD12D48PumpStatus * @return fresh dialysate pump error status. *************************************************************************/ -BOOL getFPGAFreshDialysatePumpErrorStatus( void ) +BOOL getFPGAD12PumpErrorStatus( void ) { - U08 mask = fpgaSensorReadings.fpgaDGPSDPPumpStatus & FPGA_DGP_PUMP_ERROR_BIT; + U08 mask = fpgaSensorReadings.fpgaD12D48PumpStatus & FPGA_D12_PUMP_ERROR_BIT; BOOL result = ( mask > 0 ? TRUE : FALSE ); return result; } /*********************************************************************//** * @brief - * The getFPGASpentDialysatePumpErrorStatus function gets the spent dialysate + * The getFPGAD48PumpErrorStatus function gets the spent dialysate * pump error status. * bit 7-2: TBD * bit 1 : spent dialysate pump error (1), no error(0) * bit 0 : fresh dialysate pump error (1), no error(0) * @details \b Inputs: none - * @details \b Outputs: fpgaSensorReadings.fpgaDGPSDPPumpStatus + * @details \b Outputs: fpgaSensorReadings.fpgaD12D48PumpStatus * @return spent dialysate pump error status. *************************************************************************/ -BOOL getFPGASpentDialysatePumpErrorStatus( void ) +BOOL getFPGAD48PumpErrorStatus( void ) { - U08 mask = fpgaSensorReadings.fpgaDGPSDPPumpStatus & FPGA_SDP_PUMP_ERROR_BIT; + U08 mask = fpgaSensorReadings.fpgaD12D48PumpStatus & FPGA_D48_PUMP_ERROR_BIT; BOOL result = ( mask > 0 ? TRUE : FALSE ); return result; } /*********************************************************************//** * @brief - * The getFPGAFreshDialysatePumpCurrentFeedback function gets the fresh dialysate + * The getFPGAD12PumpCurrentFeedback function gets the fresh dialysate * pump current consumption. * @details \b Inputs: none - * @details \b Outputs: fpgaSensorReadings.fpgaDGPCurrentFeedback + * @details \b Outputs: fpgaSensorReadings.fpgaD12CurrentFeedback * @return fresh dialysate pump measured current. *************************************************************************/ -U16 getFPGAFreshDialysatePumpCurrentFeedback( void ) +U16 getFPGAD12PumpCurrentFeedback( void ) { - return fpgaSensorReadings.fpgaDGPCurrentFeedback; + return fpgaSensorReadings.fpgaD12CurrentFeedback; } /*********************************************************************//** * @brief - * The getFPGASpentDialysatePumpCurrentFeedback function gets the spent dialysate + * The getFPGAD48PumpCurrentFeedback function gets the spent dialysate * pump current consumption. * @details \b Inputs: none - * @details \b Outputs: fpgaSensorReadings.fpgaSDPCurrentFeedback + * @details \b Outputs: fpgaSensorReadings.fpgaD48CurrentFeedback * @return spent dialysate pump measured current. *************************************************************************/ -U16 getFPGASpentDialysatePumpCurrentFeedback( void ) +U16 getFPGAD48PumpCurrentFeedback( void ) { - return fpgaSensorReadings.fpgaSDPCurrentFeedback; + return fpgaSensorReadings.fpgaD48CurrentFeedback; } /*********************************************************************//** * @brief - * The getFPGAFreshDialysatePumpHallDirectionStatus function gets the fresh dialysate + * The getFPGAD12PumpHallDirectionStatus function gets the fresh dialysate * pump hall sensor based direction error status. * @details \b Inputs: none - * @details \b Outputs: fpgaSensorReadings.fpgaDGPHallStatus + * @details \b Outputs: fpgaSensorReadings.fpgaD12HallStatus * @return fresh dialysate pump hall sensor based direction status. *************************************************************************/ -U08 getFPGAFreshDialysatePumpHallDirectionStatus( void ) +U08 getFPGAD12PumpHallDirectionStatus( void ) { - return fpgaSensorReadings.fpgaDGPHallStatus; + return fpgaSensorReadings.fpgaD12HallStatus; } /*********************************************************************//** * @brief - * The getFPGASpentDialysatePumpHallDirectionStatus function gets the spent dialysate + * The getFPGAD48PumpHallDirectionStatus function gets the spent dialysate * pump hall sensor based direction error status. * @details \b Inputs: none - * @details \b Outputs: fpgaSensorReadings.fpgaSDPHallStatus + * @details \b Outputs: fpgaSensorReadings.fpgaD48HallStatus * @return spent dialysate pump hall sensor based direction status. *************************************************************************/ -U08 getFPGASpentDialysatePumpHallDirectionStatus( void ) +U08 getFPGAD48PumpHallDirectionStatus( void ) { - return fpgaSensorReadings.fpgaSDPHallStatus; + return fpgaSensorReadings.fpgaD48HallStatus; } /*********************************************************************//** @@ -1525,12 +1525,12 @@ * bit 3: Direction (1=Fwd, 0=Rev) * bit 0-2: Microstepping resolution * @details \b Inputs: none - * @details \b Outputs: fpgaActuatorSetPoints.fpgaD11_PumpControl + * @details \b Outputs: fpgaActuatorSetPoints.fpgaD11PumpControl * @return Acid pump control status bit *************************************************************************/ U08 getFPGAD11PumpControlStatus( void ) { - return fpgaActuatorSetPoints.fpgaD11_PumpControl; + return fpgaActuatorSetPoints.fpgaD11PumpControl; } /*********************************************************************//** @@ -1544,12 +1544,12 @@ * bit 3: Direction (1=Fwd, 0=Rev) * bit 0-2: Microstepping resolution * @details \b Inputs: none - * @details \b Outputs: fpgaActuatorSetPoints.fpgaD10_PumpControl + * @details \b Outputs: fpgaActuatorSetPoints.fpgaD10PumpControl * @return Bicarb pump control status bit *************************************************************************/ U08 getFPGAD10PumpControlStatus( void ) { - return fpgaActuatorSetPoints.fpgaD10_PumpControl; + return fpgaActuatorSetPoints.fpgaD10PumpControl; } /*********************************************************************//** @@ -2614,26 +2614,26 @@ * @brief * The getFPGAD11PumpRevolutionCountStatus function gets the current revolution of * acid concentrate pump (down counter). - * @details \b Inputs: fpgaD11_PumpStepCountStatus + * @details \b Inputs: fpgaD11PumpStepCountStatus * @details \b Outputs: none * @return the current revolution of the acid concentrate pump *************************************************************************/ U16 getFPGAD11PumpRevolutionCountStatus( void ) { - return fpgaSensorReadings.fpgaD11_PumpStepCountStatus; + return fpgaSensorReadings.fpgaD11PumpStepCountStatus; } /*********************************************************************//** * @brief * The getFPGAD10PumpRevolutionCountStatus function gets the current revolution of * bicarb concentrate pump (down counter). - * @details \b Inputs: fpgaD10_PumpStepCountStatus + * @details \b Inputs: fpgaD10PumpStepCountStatus * @details \b Outputs: none * @return the current revolution of the bicarb concentrate pump *************************************************************************/ U16 getFPGAD10PumpRevolutionCountStatus( void ) { - return fpgaSensorReadings.fpgaD10_PumpStepCountStatus; + return fpgaSensorReadings.fpgaD10PumpStepCountStatus; } /*********************************************************************//** Index: firmware/App/Services/FpgaDD.h =================================================================== diff -u -rf49295a21525d5d1b88ec52eb4fcac72e7a526b7 -ra3a396aa37fb562327f05e54990f06538c7617ed --- firmware/App/Services/FpgaDD.h (.../FpgaDD.h) (revision f49295a21525d5d1b88ec52eb4fcac72e7a526b7) +++ firmware/App/Services/FpgaDD.h (.../FpgaDD.h) (revision a3a396aa37fb562327f05e54990f06538c7617ed) @@ -141,21 +141,21 @@ U16 getFPGAD11PumpRevolutionCountStatus( void ); U16 getFPGAD10PumpRevolutionCountStatus( void ); -void setFPGASpentDialysatePumpSpeed( U16 speed ); -void setFPGAFreshDialysatePumpSpeed( U16 speed ); -void setFPGASpentDialysatePumpControl( U08 control ); -void setFPGAFreshDialysatePumpControl( U08 control ); +void setFPGAD48PumpSpeed( U16 speed ); +void setFPGAD12PumpSpeed( U16 speed ); +void setFPGAD48PumpControl( U08 control ); +void setFPGAD12PumpControl( U08 control ); -U08 getFPGASpentDialysatePumpControl( void ); -U08 getFPGAFreshDialysatePumpControl( void ); -U16 getFPGASpentDialysatePumpSpeed( void ); -U16 getFPGAFreshDialysatePumpSpeed( void ); -BOOL getFPGAFreshDialysatePumpErrorStatus( void ); -BOOL getFPGASpentDialysatePumpErrorStatus( void ); -U16 getFPGAFreshDialysatePumpCurrentFeedback( void ); -U16 getFPGASpentDialysatePumpCurrentFeedback( void ); -U08 getFPGAFreshDialysatePumpHallDirectionStatus( void ); -U08 getFPGASpentDialysatePumpHallDirectionStatus( void ); +U08 getFPGAD48PumpControl( void ); +U08 getFPGAD12PumpControl( void ); +U16 getFPGAD48PumpSpeed( void ); +U16 getFPGAD12PumpSpeed( void ); +BOOL getFPGAD12PumpErrorStatus( void ); +BOOL getFPGAD48PumpErrorStatus( void ); +U16 getFPGAD12PumpCurrentFeedback( void ); +U16 getFPGAD48PumpCurrentFeedback( void ); +U08 getFPGAD12PumpHallDirectionStatus( void ); +U08 getFPGAD48PumpHallDirectionStatus( void ); //Pressure sensor U08 getFPGAPnReadCount( void );