Index: firmware/App/Controllers/ConcentratePumps.c =================================================================== diff -u -ra9f55b2dd2aad22db9676faf661b81866b47affa -rc4a199308f24cb8f6c805928b433903d95b59c6d --- firmware/App/Controllers/ConcentratePumps.c (.../ConcentratePumps.c) (revision a9f55b2dd2aad22db9676faf661b81866b47affa) +++ firmware/App/Controllers/ConcentratePumps.c (.../ConcentratePumps.c) (revision c4a199308f24cb8f6c805928b433903d95b59c6d) @@ -107,18 +107,11 @@ U32 controlTimerCounter; ///< Timer counter to perform control on concentrate pump. CONCENTRATE_PUMP_STATE_T execState; ///< Concentrate pump execute current state. BOOL hasTurnOnPumpsBeenRequested; ///< Flag indicates a request to turn concentrate pumps on. - OVERRIDE_U32_T hasParkBeenRequested; ///< Flag indicates a request to park the pump. - OVERRIDE_F32_T pumpTargetSpeed; ///< Target concentrate pumps' speed (mL/min). - OVERRIDE_U32_T pumpTargetRevCnt; ///< Target concentrate pump revolution count - OVERRIDE_U32_T pumpMesauredRevCnt; ///< Current measured concentrate pump revolution count F32 currentPumpSpeed; ///< Current controlled concentrate pumps' speed (mL/min). - OVERRIDE_F32_T measuredPumpSpeed; ///< Measured concentrate pump speed (mL/min). U16 togglePeriodCount; ///< Converted pump speed (mL/min) to toggle period counts (0.5 uS increment counts per step). U08 direction; ///< Concentrate pump motor direction. U08 controlSet; ///< Concentrate pump control set. (Used in DVT) F32 pulseWidthUS; ///< Concentrate pump pulse width in microseconds. - OVERRIDE_U32_T parked; ///< Concentrate pump is currently parked (T/F). - OVERRIDE_U32_T parkFaulted; ///< Concentrate pump park command has faulted (T/F). BOOL isConcPumpParkInProgress; ///< Concentrate pump park progress boolean flag (T/F). } CONCENTRATE_PUMP_T; @@ -141,6 +134,14 @@ static OVERRIDE_U32_T concentratePumpDataPublishInterval = { CONCENTRATE_PUMP_DATA_PUBLISH_INTERVAL, CONCENTRATE_PUMP_DATA_PUBLISH_INTERVAL, 0, 0 }; static CONCENTRATE_PUMP_T concentratePumps[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Array of concentrate pumps' data structure. +static OVERRIDE_U32_T hasParkBeenRequested[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Flag indicates a request to park the pump. +static OVERRIDE_F32_T pumpTargetSpeed[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Target concentrate pumps' speed (mL/min). +static OVERRIDE_U32_T pumpTargetRevCnt[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Target concentrate pump revolution count +static OVERRIDE_U32_T pumpMesauredRevCnt[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Current measured concentrate pump revolution count +static OVERRIDE_F32_T measuredPumpSpeed[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Measured concentrate pump speed (mL/min). +static OVERRIDE_U32_T parked[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Concentrate pump is currently parked (T/F). +static OVERRIDE_U32_T parkFaulted[ NUM_OF_CONCENTRATE_PUMPS ]; ///< Concentrate pump park command has faulted (T/F). + //static DD_ACID_CONCENTRATES_RECORD_T acidConcentrateCalRecord; ///< Acid concentrate calibration record. //static DD_BICARB_CONCENTRATES_RECORD_T bicarbConcentrateCalRecord; ///< Bicarb concentrate calibration record. //static DD_CONC_PUMPS_CAL_RECORD_T concentratePumpsCalRecord; ///< Concentrate pumps calibration record. @@ -176,35 +177,35 @@ { concentratePumps[ pumpId ].controlTimerCounter = 0; concentratePumps[ pumpId ].execState = CONCENTRATE_PUMP_OFF_STATE; - concentratePumps[ pumpId ].measuredPumpSpeed.data = 0.0F; - concentratePumps[ pumpId ].measuredPumpSpeed.ovInitData = 0.0F; - concentratePumps[ pumpId ].measuredPumpSpeed.ovData = 0.0F; - concentratePumps[ pumpId ].measuredPumpSpeed.override = OVERRIDE_RESET; + measuredPumpSpeed[ pumpId ].data = 0.0F; + measuredPumpSpeed[ pumpId ].ovInitData = 0.0F; + measuredPumpSpeed[ pumpId ].ovData = 0.0F; + measuredPumpSpeed[ pumpId ].override = OVERRIDE_RESET; concentratePumps[ pumpId ].hasTurnOnPumpsBeenRequested = FALSE; - concentratePumps[ pumpId ].hasParkBeenRequested.data = FALSE; - concentratePumps[ pumpId ].hasParkBeenRequested.ovInitData = FALSE; - concentratePumps[ pumpId ].hasParkBeenRequested.ovData = FALSE; - concentratePumps[ pumpId ].hasParkBeenRequested.override = OVERRIDE_RESET; - concentratePumps[ pumpId ].parked.data = FALSE; - concentratePumps[ pumpId ].parked.ovInitData = FALSE; - concentratePumps[ pumpId ].parked.ovData = FALSE; - concentratePumps[ pumpId ].parked.override = OVERRIDE_RESET; - concentratePumps[ pumpId ].parkFaulted.data = FALSE; - concentratePumps[ pumpId ].parkFaulted.ovInitData = FALSE; - concentratePumps[ pumpId ].parkFaulted.ovData = FALSE; - concentratePumps[ pumpId ].parkFaulted.override = OVERRIDE_RESET; - concentratePumps[ pumpId ].pumpTargetSpeed.data = 0.0F; - concentratePumps[ pumpId ].pumpTargetSpeed.ovInitData = 0.0F; - concentratePumps[ pumpId ].pumpTargetSpeed.ovData = 0.0F; - concentratePumps[ pumpId ].pumpTargetSpeed.override = OVERRIDE_RESET; - concentratePumps[ pumpId ].pumpTargetRevCnt.data = 0; - concentratePumps[ pumpId ].pumpTargetRevCnt.ovInitData = 0; - concentratePumps[ pumpId ].pumpTargetRevCnt.ovData = 0; - concentratePumps[ pumpId ].pumpTargetRevCnt.override = OVERRIDE_RESET; - concentratePumps[ pumpId ].pumpMesauredRevCnt.data = 0; - concentratePumps[ pumpId ].pumpMesauredRevCnt.ovInitData = 0; - concentratePumps[ pumpId ].pumpMesauredRevCnt.ovData = 0; - concentratePumps[ pumpId ].pumpMesauredRevCnt.override = OVERRIDE_RESET; + hasParkBeenRequested[ pumpId ].data = FALSE; + hasParkBeenRequested[ pumpId ].ovInitData = FALSE; + hasParkBeenRequested[ pumpId ].ovData = FALSE; + hasParkBeenRequested[ pumpId ].override = OVERRIDE_RESET; + parked[ pumpId ].data = FALSE; + parked[ pumpId ].ovInitData = FALSE; + parked[ pumpId ].ovData = FALSE; + parked[ pumpId ].override = OVERRIDE_RESET; + parkFaulted[ pumpId ].data = FALSE; + parkFaulted[ pumpId ].ovInitData = FALSE; + parkFaulted[ pumpId ].ovData = FALSE; + parkFaulted[ pumpId ].override = OVERRIDE_RESET; + pumpTargetSpeed[ pumpId ].data = 0.0F; + pumpTargetSpeed[ pumpId ].ovInitData = 0.0F; + pumpTargetSpeed[ pumpId ].ovData = 0.0F; + pumpTargetSpeed[ pumpId ].override = OVERRIDE_RESET; + pumpTargetRevCnt[ pumpId ].data = 0; + pumpTargetRevCnt[ pumpId ].ovInitData = 0; + pumpTargetRevCnt[ pumpId ].ovData = 0; + pumpTargetRevCnt[ pumpId ].override = OVERRIDE_RESET; + pumpMesauredRevCnt[ pumpId ].data = 0; + pumpMesauredRevCnt[ pumpId ].ovInitData = 0; + pumpMesauredRevCnt[ pumpId ].ovData = 0; + pumpMesauredRevCnt[ pumpId ].override = OVERRIDE_RESET; concentratePumps[ pumpId ].direction = CONCENTRATE_PUMP_FORWARD_DIR; concentratePumps[ pumpId ].controlSet = CONCENTRATE_PUMP_CONTROL_FORWARD; concentratePumps[ pumpId ].isConcPumpParkInProgress = FALSE; @@ -244,13 +245,13 @@ // Calculate pump speed for each defined pump calcMeasuredPumpsSpeed(); - concentratePumps[ CONCENTRATEPUMPS_CP1_ACID ].parked.data = (U32)getFPGAAcidPumpIsParked(); - concentratePumps[ CONCENTRATEPUMPS_CP2_BICARB ].parked.data = (U32)getFPGABicarbPumpIsParked(); - concentratePumps[ CONCENTRATEPUMPS_CP1_ACID ].parkFaulted.data = (U32)getFPGAAcidPumpParkFault(); - concentratePumps[ CONCENTRATEPUMPS_CP2_BICARB ].parkFaulted.data = (U32)getFPGABicarbPumpParkFault(); + parked[ CONCENTRATEPUMPS_CP1_ACID ].data = (U32)getFPGAAcidPumpIsParked(); + parked[ CONCENTRATEPUMPS_CP2_BICARB ].data = (U32)getFPGABicarbPumpIsParked(); + parkFaulted[ CONCENTRATEPUMPS_CP1_ACID ].data = (U32)getFPGAAcidPumpParkFault(); + parkFaulted[ CONCENTRATEPUMPS_CP2_BICARB ].data = (U32)getFPGABicarbPumpParkFault(); - concentratePumps[ CONCENTRATEPUMPS_CP1_ACID ].pumpMesauredRevCnt.data = (U32)getFPGACPARevolutionCountStatus(); - concentratePumps[ CONCENTRATEPUMPS_CP2_BICARB ].pumpMesauredRevCnt.data = (U32)getFPGACPBRevolutionCountStatus(); + pumpMesauredRevCnt[ CONCENTRATEPUMPS_CP1_ACID ].data = (U32)getFPGACPARevolutionCountStatus(); + pumpMesauredRevCnt[ CONCENTRATEPUMPS_CP2_BICARB ].data = (U32)getFPGACPBRevolutionCountStatus(); if ( ( TRUE == getConcPumpIsParked( CONCENTRATEPUMPS_CP1_ACID ) ) || ( TRUE == getConcPumpParkIsFaulted( CONCENTRATEPUMPS_CP1_ACID ) ) ) { @@ -459,7 +460,7 @@ if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) { concentratePumps[ pumpId ].hasTurnOnPumpsBeenRequested = FALSE; - concentratePumps[ pumpId ].hasParkBeenRequested.data = park; + hasParkBeenRequested[ pumpId ].data = park; } else { @@ -497,7 +498,7 @@ //Update target revolution count if ( targetVolume_ml > 0.0 ) { - concentratePumps[ pumpId ].pumpTargetRevCnt.data = (U32)( targetVolume_ml * CONCENTRATE_PUMP_VOLUME_TO_REVOLUTION ); + pumpTargetRevCnt[ pumpId ].data = (U32)( targetVolume_ml * CONCENTRATE_PUMP_VOLUME_TO_REVOLUTION ); if ( CONCENTRATEPUMPS_CP1_ACID == pumpId ) { setFPGACPARevolutionCount( getConcPumpTargetRevolutionCount( pumpId ) ); @@ -515,15 +516,15 @@ */ if ( ( CONCENTRATE_PUMP_MIN_SPEED <= targetSpeed_ml_min ) && ( targetSpeed_ml_min <= CONCENTRATE_PUMP_MAX_SPEED ) ) { - concentratePumps[ pumpId ].pumpTargetSpeed.data = targetSpeed_ml_min; + pumpTargetSpeed[ pumpId ].data = targetSpeed_ml_min; } else if ( targetSpeed_ml_min < CONCENTRATE_PUMP_MIN_SPEED ) { - concentratePumps[ pumpId ].pumpTargetSpeed.data = 0.0; + pumpTargetSpeed[ pumpId ].data = 0.0; } else { - concentratePumps[ pumpId ].pumpTargetSpeed.data = CONCENTRATE_PUMP_MAX_SPEED; + pumpTargetSpeed[ pumpId ].data = CONCENTRATE_PUMP_MAX_SPEED; } } else @@ -574,7 +575,7 @@ if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) { - speed = getF32OverrideValue( &concentratePumps[ pumpId ].pumpTargetSpeed ); + speed = getF32OverrideValue( &pumpTargetSpeed[ pumpId ] ); } else { @@ -603,7 +604,7 @@ if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) { - speed = getF32OverrideValue( &concentratePumps[ pumpId ].measuredPumpSpeed ); + speed = getF32OverrideValue( &measuredPumpSpeed[ pumpId ] ); speed = ( CONCENTRATE_PUMP_REVERSE_DIR == concentratePumps[ pumpId ].direction ? speed * -1.0F : speed ); } else @@ -631,7 +632,7 @@ if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) { - result = (BOOL)getU32OverrideValue( &concentratePumps[ pumpId ].hasParkBeenRequested ); + result = (BOOL)getU32OverrideValue( &hasParkBeenRequested[ pumpId ] ); } else { @@ -657,7 +658,7 @@ if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) { - result = (U16)getU32OverrideValue( &concentratePumps[ pumpId ].pumpTargetRevCnt ); + result = (U16)getU32OverrideValue( &pumpTargetRevCnt[ pumpId ] ); } else { @@ -683,7 +684,7 @@ if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) { - result = (U16)getU32OverrideValue( &concentratePumps[ pumpId ].pumpMesauredRevCnt ); + result = (U16)getU32OverrideValue( &pumpMesauredRevCnt[ pumpId ] ); } else { @@ -709,7 +710,7 @@ if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) { - result = (BOOL)getU32OverrideValue( &concentratePumps[ pumpId ].parked ); + result = (BOOL)getU32OverrideValue( &parked[ pumpId ] ); } else { @@ -735,7 +736,7 @@ if ( pumpId < NUM_OF_CONCENTRATE_PUMPS ) { - result = (BOOL)getU32OverrideValue( &concentratePumps[ pumpId ].parkFaulted ); + result = (BOOL)getU32OverrideValue( &parkFaulted[ pumpId ] ); } else { @@ -758,11 +759,11 @@ { BOOL parkPump = getConcPumpParkRequest( pumpId ); - concentratePumps[ pumpId ].hasParkBeenRequested.data = FALSE; // reset park request for next time + hasParkBeenRequested[ pumpId ].data = FALSE; // reset park request for next time concentratePumps[ pumpId ].hasTurnOnPumpsBeenRequested = FALSE; // Just to make sure pump is in Off state. concentratePumps[ pumpId ].currentPumpSpeed = 0.0F; // set target rate to zero - concentratePumps[ pumpId ].pumpTargetSpeed.data = 0.0F; - concentratePumps[ pumpId ].pumpTargetRevCnt.data = 0; + pumpTargetSpeed[ pumpId ].data = 0.0F; + pumpTargetRevCnt[ pumpId ].data = 0; // Disable the motor when stopping, to take next revolution count // Send zero rate command to stop the pump @@ -1022,11 +1023,11 @@ // Determine measured speed for the pump if ( CONCENTRATE_PUMP_ZERO_FLOW_RATE == pulseWidthCount ) { - concentratePumps[ pumpId ].measuredPumpSpeed.data = 0.0F; + measuredPumpSpeed[ pumpId ].data = 0.0F; } else if ( FALSE == isPumpPulseWidthOut ) { - concentratePumps[ pumpId ].measuredPumpSpeed.data = ( US_PER_SECOND / pulseWidthInMicroSeconds ) * CONCENTRATE_PUMP_VOLUME_PER_PULSE * SEC_PER_MIN; + measuredPumpSpeed[ pumpId ].data = ( US_PER_SECOND / pulseWidthInMicroSeconds ) * CONCENTRATE_PUMP_VOLUME_PER_PULSE * SEC_PER_MIN; } // If pulse width is out of range capture pump out of range, pumpId and pulse width @@ -1200,7 +1201,7 @@ *************************************************************************/ BOOL testConcentratePumpTargetSpeedOverride( MESSAGE_T *message ) { - BOOL result = f32ArrayOverride( message, &concentratePumps[0].pumpTargetSpeed, NUM_OF_CONCENTRATE_PUMPS - 1 ); + BOOL result = f32ArrayOverride( message, &pumpTargetSpeed[ 0 ], NUM_OF_CONCENTRATE_PUMPS - 1 ); return result; } @@ -1217,7 +1218,7 @@ *************************************************************************/ BOOL testConcentratePumpMeasuredSpeedOverride( MESSAGE_T *message ) { - BOOL result = f32ArrayOverride( message, &concentratePumps[0].measuredPumpSpeed, NUM_OF_CONCENTRATE_PUMPS - 1 ); + BOOL result = f32ArrayOverride( message, &measuredPumpSpeed[ 0 ], NUM_OF_CONCENTRATE_PUMPS - 1 ); return result; } @@ -1234,7 +1235,7 @@ *************************************************************************/ BOOL testConcentratePumpParkedOverride( MESSAGE_T *message ) { - BOOL result = u32ArrayOverride( message, &concentratePumps[0].parked, NUM_OF_CONCENTRATE_PUMPS - 1, FALSE, TRUE ); + BOOL result = u32ArrayOverride( message, &parked[ 0 ], NUM_OF_CONCENTRATE_PUMPS - 1, FALSE, TRUE ); return result; } @@ -1251,7 +1252,7 @@ *************************************************************************/ BOOL testConcentratePumpTargetRevCountOverride( MESSAGE_T *message ) { - BOOL result = u32ArrayOverride( message, &concentratePumps[0].pumpTargetRevCnt, NUM_OF_CONCENTRATE_PUMPS - 1, 0, 65535 ); + BOOL result = u32ArrayOverride( message, &pumpTargetRevCnt[ 0 ], NUM_OF_CONCENTRATE_PUMPS - 1, 0, 65535 ); return result; } @@ -1268,7 +1269,7 @@ *************************************************************************/ BOOL testConcentratePumpParkCmdFaultedOverride( MESSAGE_T *message ) { - BOOL result = u32ArrayOverride( message, &concentratePumps[0].parkFaulted, NUM_OF_CONCENTRATE_PUMPS - 1, FALSE, TRUE ); + BOOL result = u32ArrayOverride( message, &parkFaulted[ 0 ], NUM_OF_CONCENTRATE_PUMPS - 1, FALSE, TRUE ); return result; } @@ -1350,10 +1351,10 @@ { U32 value = override.state.u32; - concentratePumps[ pumpId ].hasParkBeenRequested.ovData = value; - concentratePumps[ pumpId ].hasParkBeenRequested.override = OVERRIDE_KEY; + hasParkBeenRequested[ pumpId ].ovData = value; + hasParkBeenRequested[ pumpId ].override = OVERRIDE_KEY; - if ( TRUE == concentratePumps[ pumpId ].hasParkBeenRequested.ovData ) + if ( TRUE == hasParkBeenRequested[ pumpId ].ovData ) { // If pump is running, stop it w/ park option if ( TRUE == concentratePumps[ pumpId ].hasTurnOnPumpsBeenRequested ) @@ -1369,8 +1370,8 @@ } else { - concentratePumps[ pumpId ].hasParkBeenRequested.override = OVERRIDE_RESET; - concentratePumps[ pumpId ].hasParkBeenRequested.ovData = concentratePumps[ pumpId ].hasParkBeenRequested.ovInitData; + hasParkBeenRequested[ pumpId ].override = OVERRIDE_RESET; + hasParkBeenRequested[ pumpId ].ovData = hasParkBeenRequested[ pumpId ].ovInitData; } result = TRUE; Index: firmware/App/Controllers/DialysatePumps.c =================================================================== diff -u -r25e940840c5a54bd98fcadf582d3a1587b55a59d -rc4a199308f24cb8f6c805928b433903d95b59c6d --- firmware/App/Controllers/DialysatePumps.c (.../DialysatePumps.c) (revision 25e940840c5a54bd98fcadf582d3a1587b55a59d) +++ firmware/App/Controllers/DialysatePumps.c (.../DialysatePumps.c) (revision c4a199308f24cb8f6c805928b433903d95b59c6d) @@ -105,15 +105,10 @@ U32 controlTimerCounter; ///< Timer counter to perform control on dialysate pump. DIALYSATE_PUMP_STATE_T dialysatePumpState; ///< Current state of dialysate pump controller state machine. BOOL isDialPumpOn; ///< Flag indicates dialysate pump On or Off state - OVERRIDE_F32_T pumpTargetSpeed; ///< Target dialysate pumps' speed (mL/min).forward direction only, hence positive speed. F32 prevPumpTargetSpeed; ///< Previous target dialysate pumps' speed (mL/min). F32 currentPumpSpeed; ///< Current controlled dialysate pumps' speed (mL/min). - OVERRIDE_F32_T measuredPumpSpeed; ///< Measured dialysate pump speed (mL/min). - OVERRIDE_F32_T dialysatePumpMeasuredCurrentA; ///< Measured dialysate pump current feedback. - OVERRIDE_U32_T measuredDirection; ///< Measured dialysate pump direction. U32 directionErrorCount; ///< dialysate pump direction error count from power up. U32 lastDirectionErrorCount; ///< last dialysate pump direction error count from power up. - OVERRIDE_F32_T pumpTargetPressure; ///< Target dialysate pumps' pressure (PSI). U08 control; ///< Dialysate pump control } DIALYSATE_PUMP_DATA_T; @@ -134,6 +129,11 @@ //static DD_DIALYSATE_PUMP_CAL_RECORD_T dialysatePumpCalRecord; ///< Dialysate pump calibration record. static DIALYSATE_PUMP_DATA_T dialysatePumps[ NUM_OF_DIALYSATE_PUMPS ]; ///< Array of dialysate pumps data structure. +static OVERRIDE_F32_T pumpTargetSpeed[ NUM_OF_DIALYSATE_PUMPS ]; ///< Target dialysate pumps' speed (mL/min).forward direction only, hence positive speed. +static OVERRIDE_F32_T measuredPumpSpeed[ NUM_OF_DIALYSATE_PUMPS ]; ///< Measured dialysate pump speed (mL/min). +static OVERRIDE_F32_T dialysatePumpMeasuredCurrentA[ NUM_OF_DIALYSATE_PUMPS ]; ///< Measured dialysate pump current feedback. +static OVERRIDE_U32_T measuredDirection[ NUM_OF_DIALYSATE_PUMPS ]; ///< Measured dialysate pump direction. +static OVERRIDE_F32_T pumpTargetPressure[ NUM_OF_DIALYSATE_PUMPS ]; ///< Target dialysate pumps' pressure (PSI). //TODO : Validate once HDD defines the conversion. static const F32 CURRENT_CONVERSION_COEFF = (F32)( 2.5F / ( BITS_12_FULL_SCALE - 1.0F ) ); @@ -162,42 +162,42 @@ for ( pumpId = DIALYSATE_PUMPS_FIRST; pumpId < NUM_OF_DIALYSATE_PUMPS; pumpId++ ) { - dialysatePumps[ pumpId ].controlTimerCounter = 0; - dialysatePumps[ pumpId ].dialysatePumpState = DIALYSATE_PUMP_OFF_STATE; - dialysatePumps[ pumpId ].isDialPumpOn = FALSE; - dialysatePumps[ pumpId ].measuredPumpSpeed.data = 0.0F; - dialysatePumps[ pumpId ].measuredPumpSpeed.ovInitData = 0.0F; - dialysatePumps[ pumpId ].measuredPumpSpeed.override = OVERRIDE_RESET; - dialysatePumps[ pumpId ].measuredPumpSpeed.ovData = 0.0F; - dialysatePumps[ pumpId ].pumpTargetSpeed.data = 0.0F; - dialysatePumps[ pumpId ].pumpTargetSpeed.ovInitData = 0.0F; - dialysatePumps[ pumpId ].pumpTargetSpeed.override = OVERRIDE_RESET; - dialysatePumps[ pumpId ].pumpTargetSpeed.ovData = 0.0F; - dialysatePumps[ pumpId ].measuredDirection.data = DIALYSATE_PUMP_FORWARD_DIR; - dialysatePumps[ pumpId ].measuredDirection.ovInitData = DIALYSATE_PUMP_FORWARD_DIR; - dialysatePumps[ pumpId ].measuredDirection.ovData = DIALYSATE_PUMP_FORWARD_DIR; - dialysatePumps[ pumpId ].measuredDirection.override = OVERRIDE_RESET; - dialysatePumps[ pumpId ].dialysatePumpMeasuredCurrentA.data = 0.0F; - dialysatePumps[ pumpId ].dialysatePumpMeasuredCurrentA.ovInitData = 0.0F; - dialysatePumps[ pumpId ].dialysatePumpMeasuredCurrentA.ovData = 0.0F; - dialysatePumps[ pumpId ].dialysatePumpMeasuredCurrentA.override = OVERRIDE_RESET; - dialysatePumps[ pumpId ].currentPumpSpeed = MIN_DIALYSATE_PUMP_RPM; - dialysatePumps[ pumpId ].prevPumpTargetSpeed = 0.0F; - dialysatePumps[ pumpId ].control = DIALYSATE_PUMP_CONTROL_STOP; - dialysatePumps[ pumpId ].directionErrorCount = 0; - dialysatePumps[ pumpId ].lastDirectionErrorCount = 0; + dialysatePumps[ pumpId ].controlTimerCounter = 0; + dialysatePumps[ pumpId ].dialysatePumpState = DIALYSATE_PUMP_OFF_STATE; + dialysatePumps[ pumpId ].isDialPumpOn = FALSE; + measuredPumpSpeed[ pumpId ].data = 0.0F; + measuredPumpSpeed[ pumpId ].ovInitData = 0.0F; + measuredPumpSpeed[ pumpId ].override = OVERRIDE_RESET; + measuredPumpSpeed[ pumpId ].ovData = 0.0F; + pumpTargetSpeed[ pumpId ].data = 0.0F; + pumpTargetSpeed[ pumpId ].ovInitData = 0.0F; + pumpTargetSpeed[ pumpId ].override = OVERRIDE_RESET; + pumpTargetSpeed[ pumpId ].ovData = 0.0F; + measuredDirection[ pumpId ].data = DIALYSATE_PUMP_FORWARD_DIR; + measuredDirection[ pumpId ].ovInitData = DIALYSATE_PUMP_FORWARD_DIR; + measuredDirection[ pumpId ].ovData = DIALYSATE_PUMP_FORWARD_DIR; + measuredDirection[ pumpId ].override = OVERRIDE_RESET; + dialysatePumpMeasuredCurrentA[ pumpId ].data = 0.0F; + dialysatePumpMeasuredCurrentA[ pumpId ].ovInitData = 0.0F; + dialysatePumpMeasuredCurrentA[ pumpId ].ovData = 0.0F; + dialysatePumpMeasuredCurrentA[ pumpId ].override = OVERRIDE_RESET; + dialysatePumps[ pumpId ].currentPumpSpeed = MIN_DIALYSATE_PUMP_RPM; + dialysatePumps[ pumpId ].prevPumpTargetSpeed = 0.0F; + dialysatePumps[ pumpId ].control = DIALYSATE_PUMP_CONTROL_STOP; + dialysatePumps[ pumpId ].directionErrorCount = 0; + dialysatePumps[ pumpId ].lastDirectionErrorCount = 0; signalDialysatePumpHardStop( pumpId ); } - dialysatePumps[FRESH_DIALYSATE_PUMP].pumpTargetPressure.data = FRESH_DIALYSATE_TARGET_PRESSURE_PSI; - dialysatePumps[FRESH_DIALYSATE_PUMP].pumpTargetPressure.ovInitData = FRESH_DIALYSATE_TARGET_PRESSURE_PSI; - dialysatePumps[FRESH_DIALYSATE_PUMP].pumpTargetPressure.ovData = 0.0F; - dialysatePumps[FRESH_DIALYSATE_PUMP].pumpTargetPressure.override = OVERRIDE_RESET; + pumpTargetPressure[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; - dialysatePumps[SPENT_DIALYSATE_PUMP].pumpTargetPressure.data = SPENT_DIALYSATE_TARGET_PRESSURE_PSI; - dialysatePumps[SPENT_DIALYSATE_PUMP].pumpTargetPressure.ovInitData = SPENT_DIALYSATE_TARGET_PRESSURE_PSI; - dialysatePumps[SPENT_DIALYSATE_PUMP].pumpTargetPressure.ovData = 0.0F; - dialysatePumps[SPENT_DIALYSATE_PUMP].pumpTargetPressure.override = OVERRIDE_RESET; + pumpTargetPressure[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; // 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, @@ -248,15 +248,15 @@ { if ( ( MIN_DIALYSATE_PUMP_RPM <= rpm ) && ( rpm <= MAX_DIALYSATE_PUMP_RPM ) ) { - dialysatePumps[ pumpId ].pumpTargetSpeed.data = rpm; + pumpTargetSpeed[ pumpId ].data = rpm; } else if ( rpm < MIN_DIALYSATE_PUMP_RPM ) { - dialysatePumps[ pumpId ].pumpTargetSpeed.data = 0.0; + pumpTargetSpeed[ pumpId ].data = 0.0; } else { - dialysatePumps[ pumpId ].pumpTargetSpeed.data = MAX_DIALYSATE_PUMP_RPM; + pumpTargetSpeed[ pumpId ].data = MAX_DIALYSATE_PUMP_RPM; } //handle target speed update when pump is running @@ -309,7 +309,7 @@ // Reset all the variables to stop mode dialysatePumps[ pumpId ].currentPumpSpeed = MIN_DIALYSATE_PUMP_RPM; - dialysatePumps[ pumpId ].pumpTargetSpeed.data = 0.0F; + pumpTargetSpeed[ pumpId ].data = 0.0F; dialysatePumps[ pumpId ].dialysatePumpState = DIALYSATE_PUMP_OFF_STATE; dialysatePumps[ pumpId ].controlTimerCounter = 0; dialysatePumps[ pumpId ].isDialPumpOn = FALSE; @@ -395,20 +395,20 @@ // Update the paramerters - dialysatePumps[ FRESH_DIALYSATE_PUMP ].dialysatePumpMeasuredCurrentA.data = (F32)freshDialCurrent * CURRENT_CONVERSION_COEFF; - dialysatePumps[ SPENT_DIALYSATE_PUMP ].dialysatePumpMeasuredCurrentA.data = (F32)spentDialCurrent * CURRENT_CONVERSION_COEFF; - dialysatePumps[ FRESH_DIALYSATE_PUMP ].measuredDirection.data = (U32)( ( getFPGAFreshDialysatePumpHallDirectionStatus() & DIALYSATE_PUMP_DIR_BIT_MASK ) >> SHIFT_BITS_BY_7 ); - dialysatePumps[ SPENT_DIALYSATE_PUMP ].measuredDirection.data = (U32)( ( getFPGASpentDialysatePumpHallDirectionStatus() & DIALYSATE_PUMP_DIR_BIT_MASK ) >> SHIFT_BITS_BY_7 ); - dialysatePumps[ FRESH_DIALYSATE_PUMP ].directionErrorCount = (U32)( getFPGAFreshDialysatePumpHallDirectionStatus() & DIALYSATE_PUMP_DIR_ERROR_CNT_BIT_MASK ); - dialysatePumps[ SPENT_DIALYSATE_PUMP ].directionErrorCount = (U32)( getFPGASpentDialysatePumpHallDirectionStatus() & DIALYSATE_PUMP_DIR_ERROR_CNT_BIT_MASK ); + dialysatePumpMeasuredCurrentA[ 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 ); if ( freshDialSpeedCnt > SPEED_COUNT_ZERO ) { - dialysatePumps[ FRESH_DIALYSATE_PUMP ].measuredPumpSpeed.data = SPEED_CONV_FACTOR / freshDialSpeedCnt; + measuredPumpSpeed[ FRESH_DIALYSATE_PUMP ].data = SPEED_CONV_FACTOR / freshDialSpeedCnt; } if ( spentDialSpeedCnt > SPEED_COUNT_ZERO ) { - dialysatePumps[ SPENT_DIALYSATE_PUMP ].measuredPumpSpeed.data = SPEED_CONV_FACTOR / spentDialSpeedCnt; + measuredPumpSpeed[ SPENT_DIALYSATE_PUMP ].data = SPEED_CONV_FACTOR / spentDialSpeedCnt; } // Monitor dialysate pumps @@ -817,7 +817,7 @@ if ( pumpId < NUM_OF_DIALYSATE_PUMPS ) { - speed = getF32OverrideValue( &dialysatePumps[ pumpId ].pumpTargetSpeed ); + speed = getF32OverrideValue( &pumpTargetSpeed[ pumpId ] ); } else { @@ -843,7 +843,7 @@ if ( pumpId < NUM_OF_DIALYSATE_PUMPS ) { - speed = getF32OverrideValue( &dialysatePumps[ pumpId ].measuredPumpSpeed ); + speed = getF32OverrideValue( &measuredPumpSpeed[ pumpId ] ); } else { @@ -869,7 +869,7 @@ if ( pumpId < NUM_OF_DIALYSATE_PUMPS ) { - pressure = getF32OverrideValue( &dialysatePumps[ pumpId ].pumpTargetPressure ); + pressure = getF32OverrideValue( &pumpTargetPressure[ pumpId ] ); } else { @@ -894,7 +894,7 @@ if ( pumpId < NUM_OF_DIALYSATE_PUMPS ) { - current = getF32OverrideValue( &dialysatePumps[ pumpId ].dialysatePumpMeasuredCurrentA ); + current = getF32OverrideValue( &dialysatePumpMeasuredCurrentA[ pumpId ] ); } else { @@ -919,7 +919,7 @@ if ( pumpId < NUM_OF_DIALYSATE_PUMPS ) { - direction = getU32OverrideValue( &dialysatePumps[ pumpId ].measuredDirection ); + direction = getU32OverrideValue( &measuredDirection[ pumpId ] ); } else { @@ -1009,7 +1009,7 @@ *************************************************************************/ BOOL testDialysatePumpTargetSpeedOverride( MESSAGE_T *message ) { - BOOL result = f32ArrayOverride( message, &dialysatePumps[0].pumpTargetSpeed, NUM_OF_DIALYSATE_PUMPS - 1 ); + BOOL result = f32ArrayOverride( message, &pumpTargetSpeed[ 0 ], NUM_OF_DIALYSATE_PUMPS - 1 ); return result; } @@ -1026,7 +1026,7 @@ *************************************************************************/ BOOL testDialysatePumpMeasuredSpeedOverride( MESSAGE_T *message ) { - BOOL result = f32ArrayOverride( message, &dialysatePumps[0].measuredPumpSpeed, NUM_OF_DIALYSATE_PUMPS - 1 ); + BOOL result = f32ArrayOverride( message, &measuredPumpSpeed[ 0 ], NUM_OF_DIALYSATE_PUMPS - 1 ); return result; } @@ -1043,7 +1043,7 @@ *************************************************************************/ BOOL testDialysatePumpTargetPressureOverride( MESSAGE_T *message ) { - BOOL result = f32ArrayOverride( message, &dialysatePumps[0].pumpTargetPressure, NUM_OF_DIALYSATE_PUMPS - 1 ); + BOOL result = f32ArrayOverride( message, &pumpTargetPressure[ 0 ], NUM_OF_DIALYSATE_PUMPS - 1 ); return result; } @@ -1060,7 +1060,7 @@ *************************************************************************/ BOOL testDialysatePumpMeasuredCurrentOverride( MESSAGE_T *message ) { - BOOL result = f32ArrayOverride( message, &dialysatePumps[0].dialysatePumpMeasuredCurrentA, NUM_OF_DIALYSATE_PUMPS - 1 ); + BOOL result = f32ArrayOverride( message, &dialysatePumpMeasuredCurrentA[ 0 ], NUM_OF_DIALYSATE_PUMPS - 1 ); return result; } @@ -1077,7 +1077,7 @@ *************************************************************************/ BOOL testDialysatePumpMeasuredDirectionOverride( MESSAGE_T *message ) { - BOOL result = u32ArrayOverride( message, &dialysatePumps[0].measuredDirection, NUM_OF_DIALYSATE_PUMPS - 1, 0, DIALYSATE_PUMP_FORWARD_DIR ); + BOOL result = u32ArrayOverride( message, &measuredDirection[ 0 ], NUM_OF_DIALYSATE_PUMPS - 1, 0, DIALYSATE_PUMP_FORWARD_DIR ); return result; }