Index: firmware/App/Controllers/Pressures.c =================================================================== diff -u -r138efd92a8645e0d2fe422409ef5a33dd2929a25 -r68fc03b5a22f14190146fc9069f022c109682b63 --- firmware/App/Controllers/Pressures.c (.../Pressures.c) (revision 138efd92a8645e0d2fe422409ef5a33dd2929a25) +++ firmware/App/Controllers/Pressures.c (.../Pressures.c) (revision 68fc03b5a22f14190146fc9069f022c109682b63) @@ -5,12 +5,12 @@ * THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN * WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. * - * @file BloodFlow.c + * @file Pressures.c * - * @date 15-Jan-2020 + * @date 05-Apr-2020 * @author S. Nash * - * @brief Monitor for pressure and occlusion sensors. + * @brief Monitor for DG pressure sensors. * **************************************************************************/ @@ -19,188 +19,111 @@ #include "FPGA.h" #include "OperationModes.h" #include "SystemCommMessages.h" -#include "TaskGeneral.h" +#include "TaskPriority.h" #include "Timers.h" /** - * @addtogroup PressureOcclusion + * @addtogroup DGPressures * @{ */ // ********** private definitions ********** /// Default publication interval for pressure and occlusion data. -#define PRES_OCCL_DATA_PUB_INTERVAL ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) ///< interval (ms/task time) at which the pressure/occlusion data is published on the CAN bus. +#define PRESSURES_DATA_PUB_INTERVAL ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) ///< interval (ms/task time) at which the pressures data is published on the CAN bus. -/// Defined states for the pressure and occlusion monitor state machine. +/// Defined states for the pressures monitor state machine. typedef enum PresOccl_States { PRESSURE_INIT_STATE = 0, ///< Initialization state. PRESSURE_CONTINUOUS_READ_STATE, ///< Continuous read sensors state. - NUM_OF_PRESSURE_STATES ///< Number of pressure/occlusion monitor states. + NUM_OF_PRESSURE_STATES ///< Number of pressure monitor states. } PRESSURE_STATE_T; -/// Defined states for the pressure and occlusion self test state machine. -typedef enum PresOccl_Self_Test_States +/// Defined states for the pressures self test state machine. +typedef enum Pressures_Self_Test_States { PRESSURE_SELF_TEST_STATE_START = 0, ///< Self test start state. PRESSURE_TEST_STATE_IN_PROGRESS, ///< Self test in progress state. PRESSURE_TEST_STATE_COMPLETE, ///< Self test completed state. - NUM_OF_PRESSURE_SELF_TEST_STATES ///< Number of pressure/occlusion self test states. + NUM_OF_PRESSURE_SELF_TEST_STATES ///< Number of pressure self test states. } PRESSURE_SELF_TEST_STATE_T; // ********** private data ********** -static PRESSURE_STATE_T presOcclState = PRESSURE_INIT_STATE; ///< current state of pressure monitor state machine. -static U32 presOcclDataPublicationTimerCounter = 0; ///< used to schedule pressure data publication to CAN bus. +static PRESSURE_STATE_T pressuresState = PRESSURE_INIT_STATE; ///< current state of pressure monitor state machine. +static U32 pressuresDataPublicationTimerCounter = 0; ///< used to schedule pressure data publication to CAN bus. -DATA_DECL( U32, PresOcclDataPub, presOcclDataPublishInterval, PRES_OCCL_DATA_PUB_INTERVAL, PRES_OCCL_DATA_PUB_INTERVAL ); ///< interval (in ms) at which to publish pressure/occlusion data to CAN bus. -DATA_DECL( F32, ArterialPressure, arterialPressure, 0, 0 ); ///< measured arterial pressure. -DATA_DECL( F32, VenousPressure, venousPressure, 0.0, 0.0 ); ///< measured venous pressure. -DATA_DECL( F32, BloodPumpOcclusion, bloodPumpOcclusion, 0.0, 0.0 ); ///< measured blood pump occlusion pressure. -DATA_DECL( F32, DialInPumpOcclusion, dialInPumpOcclusion, 0.0, 0.0 ); ///< measured dialysate inlet pump occlusion pressure. -DATA_DECL( F32, DialOutPumpOcclusion, dialOutPumpOcclusion, 0.0, 0.0 ); ///< measured dialysate outlet pump occlusion pressure. +static OVERRIDE_U32_T pressuresDataPublishInterval = { PRESSURES_DATA_PUB_INTERVAL, PRESSURES_DATA_PUB_INTERVAL, 0, 0 }; ///< interval (in ms) at which to publish pressures data to CAN bus. +static OVERRIDE_F32_T pressures[ NUM_OF_PRESSURE_SENSORS ]; ///< Measured weight from load cells. -static PRESSURE_SELF_TEST_STATE_T presOcclSelfTestState = PRESSURE_SELF_TEST_STATE_START; ///< current pressure self test state. -static U32 bloodPumpSelfTestTimerCount = 0; ///< timer counter for pressure self test. +static PRESSURE_SELF_TEST_STATE_T pressuresSelfTestState = PRESSURE_SELF_TEST_STATE_START; ///< current pressure self test state. +static U32 pressuresSelfTestTimerCount = 0; ///< timer counter for pressure self test. -static F32 arterialPressureLowLimitmmHG = 0.0; ///< lower alarm limit for arterial pressure. -static F32 arterialPressureHighLimitmmHG = 0.0; ///< upper alarm limit for arterial pressure. -static F32 venousPressureLowLimitmmHG = 0.0; ///< lower alarm limit for venous pressure. -static F32 venousPressureHighLimitmmHG = 0.0; ///< upper alarm limit for venous pressure. -// TODO - set thresholds for occlusions -static F32 bloodPumpOcclusionPressureThresholdmmHG = 50.0; ///< pressure threshold for blood pump occlusion. -static F32 dialInPumpOcclusionPressureThresholdmmHG = 50.0; ///< pressure threshold for dialysate inlet pump occlusion. -static F32 dialOutPumpOcclusionPressureThresholdmmHG = 50.0; ///< pressure threshold for dialysate outlet pump occlusion. - // ********** private function prototypes ********** -static PRESSURE_STATE_T handlePresOcclInitState( void ); -static PRESSURE_STATE_T handlePresOcclContReadState( void ); -static void checkOcclusions( void ); -static void publishPresOcclData( void ); -static DATA_GET_PROTOTYPE( U32, getPublishPresOcclDataInterval ); +static PRESSURE_STATE_T handlePressuresInitState( void ); +static PRESSURE_STATE_T handlePressuresContReadState( void ); +static void checkPressures( void ); +static void publishPressuresData( void ); +static DATA_GET_PROTOTYPE( U32, getPublishPressuresDataInterval ); /**@}*/ /*********************************************************************//** * @brief - * The initPresOccl function initializes the initPresOccl module. + * The initPressures function initializes the Pressures module. * @details * Inputs : none - * Outputs : initPresOccl module initialized. + * Outputs : Pressures module initialized. * @return none *************************************************************************/ -void initPresOccl( void ) +void initPressures( void ) { // TODO - anything to initialize? } /*********************************************************************//** * @brief - * The setPressureLimits function sets the lower and upper alarm limits \n - * for a given pressure sensor. + * The execPressures function executes the pressure monitor. * @details - * Inputs : none - * Outputs : pressure limits - * @param sensor : pressure sensor we are setting limits for - * @param low : lower alarm limit (mmHg) - * @param high : upper alarm limit (mmHg) + * Inputs : pressuresState + * Outputs : pressuresState * @return none *************************************************************************/ -void setPressureLimits( PRESSURE_SENSORS_T sensor, F32 low, F32 high ) +void execPressures( void ) { - switch ( sensor ) // TODO - will low/high limits be range checked by caller or should we do it here? what are valid ranges? - { - case PRESSURE_SENSOR_ARTERIAL: - arterialPressureLowLimitmmHG = low; - arterialPressureHighLimitmmHG = high; - break; - - case PRESSURE_SENSOR_VENOUS: - venousPressureLowLimitmmHG = low; - venousPressureHighLimitmmHG = high; - break; - - default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_SOFTWARE_FAULT, 0, sensor ) // TODO - replace 1st param with s/w fault enum - break; - } -} - -/*********************************************************************//** - * @brief - * The setOcclusionThreshold function sets the occlusion pressure threshold \n - * for a given occlusion sensor. - * @details - * Inputs : none - * Outputs : pressure threshold - * @param sensor : occlusion sensor we are setting threshold for - * @param threshold : pressure threshold above which indicates an occlusion (mmHg) - * @return none - *************************************************************************/ -void setOcclusionThreshold( OCCLUSION_SENSORS_T sensor, F32 threshold ) -{ - switch ( sensor ) // TODO - will threshold be range checked by caller or should we do it here? what is valid range? - { - case OCCLUSION_SENSOR_BLOOD_PUMP: - bloodPumpOcclusionPressureThresholdmmHG = threshold; - break; - - case OCCLUSION_SENSOR_DIAL_IN_PUMP: - dialInPumpOcclusionPressureThresholdmmHG = threshold; - break; - - case OCCLUSION_SENSOR_DIAL_OUT_PUMP: - dialOutPumpOcclusionPressureThresholdmmHG = threshold; - break; - - default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_SOFTWARE_FAULT, 0, sensor ) // TODO - replace 1st param with s/w fault enum - break; - } -} - -/*********************************************************************//** - * @brief - * The execPresOccl function executes the pressure and occlusion monitor. - * @details - * Inputs : presOcclState - * Outputs : presOcclState - * @return none - *************************************************************************/ -void execPresOccl( void ) -{ // state machine - switch ( presOcclState ) + switch ( pressuresState ) { case PRESSURE_INIT_STATE: - presOcclState = handlePresOcclInitState(); + pressuresState = handlePressuresInitState(); break; case PRESSURE_CONTINUOUS_READ_STATE: - presOcclState = handlePresOcclContReadState(); + pressuresState = handlePressuresContReadState(); break; default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_SOFTWARE_FAULT, 0, presOcclState ) // TODO - replace 1st param with s/w fault enum + pressuresState = PRESSURE_INIT_STATE; + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_SOFTWARE_FAULT, 0, pressuresState ) // TODO - replace 1st param with s/w fault enum break; } // publish pressure/occlusion data on interval - publishPresOcclData(); + publishPressuresData(); } /*********************************************************************//** * @brief - * The handlePresOcclInitState function handles the pres/occl initialize state \n - * of the pressure/occlusion monitor state machine. + * The handlePressuresInitState function handles the pressures initialize state \n + * of the pressures monitor state machine. * @details * Inputs : TBD * Outputs : TBD * @return next state *************************************************************************/ -static PRESSURE_STATE_T handlePresOcclInitState( void ) +static PRESSURE_STATE_T handlePressuresInitState( void ) { PRESSURE_STATE_T result = PRESSURE_CONTINUOUS_READ_STATE; @@ -209,34 +132,32 @@ /*********************************************************************//** * @brief - * The handlePresOcclContReadState function handles the continuous read state \n - * of the pressure/occlusion monitor state machine. + * The handlePressuresContReadState function handles the continuous read state \n + * of the pressures monitor state machine. * @details * Inputs : TBD * Outputs : pressure sensor values updated * @return next state *************************************************************************/ -static PRESSURE_STATE_T handlePresOcclContReadState( void ) +static PRESSURE_STATE_T handlePressuresContReadState( void ) { PRESSURE_STATE_T result = PRESSURE_CONTINUOUS_READ_STATE; - U16 artPres = getFPGAArterialPressure(); - U16 venPres = getFPGAVenousPressure(); - U16 bldOccl = getFPGABloodPumpOcclusion(); - U16 dliOccl = getFPGADialInPumpOcclusion(); - U16 dloOccl = getFPGADialOutPumpOcclusion(); + U16 roIn = getFPGAROPumpInletPressure(); + U16 roOut = getFPGAROPumpOutletPressure(); + U16 drainIn = getFPGADrainPumpInletPressure(); + U16 drainOut = getFPGADrainPumpOutletPressure(); // TODO - convert ADC counts to mmHg for each sensor - arterialPressure.data = (F32)artPres; - venousPressure.data = (F32)venPres; - bloodPumpOcclusion.data = (F32)bldOccl; - dialInPumpOcclusion.data = (F32)dliOccl; - dialOutPumpOcclusion.data = (F32)dloOccl; + pressures[ PRESSURE_SENSOR_RO_PUMP_INLET ].data = (F32)roIn; + pressures[ PRESSURE_SENSOR_RO_PUMP_OUTLET ].data = (F32)roOut; + pressures[ PRESSURE_SENSOR_DRAIN_PUMP_INLET ].data = (F32)drainIn; + pressures[ PRESSURE_SENSOR_DRAIN_PUMP_OUTLET ].data = (F32)drainOut; // TODO - any filtering required??? - // check for occlusions - checkOcclusions(); + // check for pressure ranges + checkPressures(); // TODO - any other checks @@ -245,47 +166,37 @@ /*********************************************************************//** * @brief - * The checkPressureLimits function gets the pressure/occlusion data \n - * publication interval. + * The checkPressures function checks the pressure sensors are in range. * @details - * Inputs : occlusion pressures for the pumps - * Outputs : + * Inputs : pressures[] + * Outputs : none * @return none *************************************************************************/ -static void checkOcclusions( void ) +static void checkPressures( void ) { - F32 bpOccl = getMeasuredBloodPumpOcclusion(); - F32 diOccl = getMeasuredDialInPumpOcclusion(); - F32 doOccl = getMeasuredDialOutPumpOcclusion(); - - if ( bpOccl > bloodPumpOcclusionPressureThresholdmmHG ) - { - SET_ALARM_WITH_1_F32_DATA( ALARM_ID_OCCLUSION_BLOOD_PUMP, bpOccl ) - // TODO - stop blood pump immediately, ... - } - if ( diOccl > dialInPumpOcclusionPressureThresholdmmHG ) - { - SET_ALARM_WITH_1_F32_DATA( ALARM_ID_OCCLUSION_DIAL_IN_PUMP, diOccl ) - // TODO - stop dialysate inlet pump immediately, ... - } - if ( doOccl > dialOutPumpOcclusionPressureThresholdmmHG ) - { - SET_ALARM_WITH_1_F32_DATA( ALARM_ID_OCCLUSION_DIAL_OUT_PUMP, doOccl ) - // TODO - stop dialysate outlet pump immediately, ... - } } /*********************************************************************//** * @brief * The getPublishPresOcclDataInterval function gets the pressure/occlusion data \n * publication interval. * @details - * Inputs : presOcclDataPublishInterval + * Inputs : pressuresDataPublishInterval * Outputs : none - * @return the current pressure/occlusion data publication interval (in ms). + * @return the current pressures data publication interval (in task intervals). *************************************************************************/ -DATA_GET( U32, getPublishPresOcclDataInterval, presOcclDataPublishInterval ) +U32 getPublishPressuresDataInterval( void ) +{ + U32 result = pressuresDataPublishInterval.data; + if ( OVERRIDE_KEY == pressuresDataPublishInterval.override ) + { + result = pressuresDataPublishInterval.ovData; + } + + return result; +} + /*********************************************************************//** * @brief * The getMeasuredArterialPressure function gets the current arterial pressure. @@ -294,86 +205,62 @@ * Outputs : none * @return the current arterial pressure (in mmHg). *************************************************************************/ -DATA_GET( F32, getMeasuredArterialPressure, arterialPressure ) +F32 getMeasuredDGPressure( U32 pressureID ) +{ + F32 result = 0.0; -/*********************************************************************//** - * @brief - * The getMeasuredVenousPressure function gets the measured venous pressure. - * @details - * Inputs : venousPressure - * Outputs : none - * @return the current venous pressure (in mmHg). - *************************************************************************/ -DATA_GET( F32, getMeasuredVenousPressure, venousPressure ) + if ( pressureID <= NUM_OF_PRESSURE_SENSORS ) + { + if ( OVERRIDE_KEY == pressures[ pressureID ].override ) + { + result = pressures[ pressureID ].ovData; + } + else + { + result = pressures[ pressureID ].data; + } + } + else + { + activateAlarmNoData( ALARM_ID_SOFTWARE_FAULT ); + } + return result; +} /*********************************************************************//** * @brief - * The getMeasuredBloodPumpOcclusion function gets the measured blood pump \n - * occlusion pressure. - * @details - * Inputs : bloodPumpOcclusion - * Outputs : none - * @return the current blood pump occlusion pressure (in mmHg). - *************************************************************************/ -DATA_GET( F32, getMeasuredBloodPumpOcclusion, bloodPumpOcclusion ) - -/*********************************************************************//** - * @brief - * The getMeasuredDialInPumpOcclusion function gets the measured dialysate \n - * inlet pump occlusion pressure. - * @details - * Inputs : dialInPumpOcclusion - * Outputs : none - * @return the current dialysis inlet pump occlusion pressure (in mmHg). - *************************************************************************/ -DATA_GET( F32, getMeasuredDialInPumpOcclusion, dialInPumpOcclusion ) - -/*********************************************************************//** - * @brief - * The getMeasuredDialOutPumpOcclusion function gets the measured dialysate \n - * outlet pump occlusion pressure. - * @details - * Inputs : dialOutPumpOcclusion - * Outputs : none - * @return the current dialysis outlet pump occlusion pressure (in mmHg). - *************************************************************************/ -DATA_GET( F32, getMeasuredDialOutPumpOcclusion, dialOutPumpOcclusion ) - -/*********************************************************************//** - * @brief - * The publishPresOcclData function publishes pressure/occlusion data at the \n + * The publishPressuresData function publishes DG pressures data at the \n * set interval. * @details - * Inputs : TBD - * Outputs : Pressure/occlusion data are published to CAN bus. + * Inputs : pressuresDataPublicationTimerCounter + * Outputs : DG Pressures data are published to CAN bus. * @return none *************************************************************************/ -static void publishPresOcclData( void ) +static void publishPressuresData( void ) { // publish pressure/occlusion data on interval - if ( ++presOcclDataPublicationTimerCounter >= getPublishPresOcclDataInterval() ) + if ( ++pressuresDataPublicationTimerCounter >= getPublishPressuresDataInterval() ) { - F32 artPres = getMeasuredArterialPressure(); - F32 venPres = getMeasuredVenousPressure(); - F32 bpOccl = getMeasuredBloodPumpOcclusion(); - F32 diOccl = getMeasuredDialInPumpOcclusion(); - F32 doOccl = getMeasuredDialOutPumpOcclusion(); + F32 roIn = getMeasuredDGPressure( PRESSURE_SENSOR_RO_PUMP_INLET ); + F32 roOut = getMeasuredDGPressure( PRESSURE_SENSOR_RO_PUMP_OUTLET ); + F32 drainIn = getMeasuredDGPressure( PRESSURE_SENSOR_DRAIN_PUMP_INLET ); + F32 drainOut = getMeasuredDGPressure( PRESSURE_SENSOR_DRAIN_PUMP_OUTLET ); - broadcastPresOcclData( artPres, venPres, bpOccl, diOccl, doOccl ); - presOcclDataPublicationTimerCounter = 0; + broadcastPressuresData( roIn, roOut, drainIn, drainOut ); + pressuresDataPublicationTimerCounter = 0; } } /*********************************************************************//** * @brief - * The execPresOcclTest function executes the state machine for the \n - * PresOccl self test. + * The execPressuresTest function executes the state machine for the \n + * Pressures self test. * @details * Inputs : none * Outputs : none - * @return the current state of the PresOccl self test. + * @return the current state of the Pressures self test. *************************************************************************/ -SELF_TEST_STATUS_T execPresOcclTest( void ) +SELF_TEST_STATUS_T execPressuresTest( void ) { SELF_TEST_STATUS_T result = SELF_TEST_STATUS_FAILED; @@ -392,121 +279,104 @@ /*********************************************************************//** * @brief - * The testSetPresOcclDataPublishIntervalOverride function overrides the \n + * The testSetPressuresDataPublishIntervalOverride function overrides the \n * pressure and occlusion data publish interval. * @details * Inputs : none - * Outputs : presOcclDataPublishInterval + * Outputs : pressuresDataPublishInterval * @param value : override pressure and occlusion data publish interval with (in ms) * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testSetPresOcclDataPublishIntervalOverride( U32 value ) +BOOL testSetPressuresDataPublishIntervalOverride( U32 value ) { BOOL result = FALSE; if ( TRUE == isTestingActivated() ) { - U32 intvl = value / TASK_GENERAL_INTERVAL; + U32 intvl = value / TASK_PRIORITY_INTERVAL; result = TRUE; - presOcclDataPublishInterval.ovData = intvl; - presOcclDataPublishInterval.override = OVERRIDE_KEY; + pressuresDataPublishInterval.ovData = intvl; + pressuresDataPublishInterval.override = OVERRIDE_KEY; } return result; } /*********************************************************************//** * @brief - * The testResetPresOcclDataPublishIntervalOverride function resets the override \n + * The testResetPressuresDataPublishIntervalOverride function resets the override \n * of the pressure and occlusion data publish interval. * @details * Inputs : none - * Outputs : presOcclDataPublishInterval + * Outputs : pressuresDataPublishInterval * @return TRUE if override reset successful, FALSE if not *************************************************************************/ -BOOL testResetPresOcclDataPublishIntervalOverride( void ) +BOOL testResetPressuresDataPublishIntervalOverride( void ) { BOOL result = FALSE; if ( TRUE == isTestingActivated() ) { result = TRUE; - presOcclDataPublishInterval.override = OVERRIDE_RESET; - presOcclDataPublishInterval.ovData = presOcclDataPublishInterval.ovInitData; + pressuresDataPublishInterval.override = OVERRIDE_RESET; + pressuresDataPublishInterval.ovData = pressuresDataPublishInterval.ovInitData; } return result; } -/*********************************************************************//** +/************************************************************************* * @brief - * The testSetArterialPressureOverride function overrides the measured arterial \n - * pressure. - * The testResetArterialPressureOverride function resets the override of the \n - * arterial pressure. - * @details + * The testSetDGPressureSensorOverride function overrides the value of the \n + * specified pressure sensor with a given value. * Inputs : none - * Outputs : arterialPressure - * @param value : override arterial pressure (in mmHg) + * Outputs : pressures[] + * @param sensor : ID of pressure sensor to override for + * @param value : override value for the given pressure sensor ID * @return TRUE if override successful, FALSE if not *************************************************************************/ -DATA_OVERRIDE_FUNC( F32, testSetArterialPressureOverride, testResetArterialPressureOverride, arterialPressure ) +BOOL testSetDGPressureSensorOverride( U32 sensor, F32 value ) +{ + BOOL result = FALSE; -/*********************************************************************//** - * @brief - * The testSetVenousPressureOverride function overrides the measured venous \n - * pressure. - * The testResetVenousPressureOverride function resets the override of the \n - * venous pressure. - * @details - * Inputs : none - * Outputs : venousPressure - * @param value : override measured vensous pressure with (in mmHg) - * @return TRUE if override successful, FALSE if not - *************************************************************************/ -DATA_OVERRIDE_FUNC( F32, testSetVenousPressureOverride, testResetVenousPressureOverride, venousPressure ) + if ( sensor < NUM_OF_PRESSURE_SENSORS ) + { + if ( TRUE == isTestingActivated() ) + { + result = TRUE; + pressures[ sensor ].ovData = value; + pressures[ sensor ].override = OVERRIDE_KEY; + } + } -/*********************************************************************//** - * @brief - * The testSetBloodPumpOcclusionOverride function overrides the measured \n - * blood pump occlusion pressure. \n - * The testResetBloodPumpOcclusionOverride function resets the override of the \n - * measured blood pump occlusion pressure. - * @details - * Inputs : none - * Outputs : bloodPumpOcclusion - * @param value : override measured blood pump occlusion pressure with (in mmHg) - * @return TRUE if override successful, FALSE if not - *************************************************************************/ -DATA_OVERRIDE_FUNC( F32, testSetBloodPumpOcclusionOverride, testResetBloodPumpOcclusionOverride, bloodPumpOcclusion ) + return result; +} -/*********************************************************************//** +/************************************************************************* * @brief - * The testSetDialInPumpOcclusionOverride function overrides the measured \n - * dialysate inlet pump occlusion pressure. \n - * The testResetDialInPumpOcclusionOverride function resets the override of the \n - * measured dialysate inlet pump occlusion pressure. + * The testResetDGPressureSensorOverride function resets the override of the \n + * specified DG pressure sensor. * @details * Inputs : none - * Outputs : dialInPumpOcclusion - * @param value : override measured dialysate inlet pump occlusion pressure (in mmHg) + * Outputs : pressures[] + * @param value : ID of sensor to reset override pressure for * @return TRUE if override successful, FALSE if not *************************************************************************/ -DATA_OVERRIDE_FUNC( F32, testSetDialInPumpOcclusionOverride, testResetDialInPumpOcclusionOverride, dialInPumpOcclusion ) +BOOL testResetDGPressureSensorOverride( U32 sensor ) +{ + BOOL result = FALSE; -/*********************************************************************//** - * @brief - * The testSetDialOutPumpOcclusionOverride function overrides the measured \n - * dialysate outlet pump occlusion pressure. \n - * The testResetDialOutPumpOcclusionOverride function resets the override of the \n - * measured dialysate outlet pump occlusion pressure. - * @details - * Inputs : none - * Outputs : dialOutPumpOcclusion - * @param value : override measured dialysate outlet pump occlusion pressure (in mmHg) - * @return TRUE if override successful, FALSE if not - *************************************************************************/ -DATA_OVERRIDE_FUNC( F32, testSetDialOutPumpOcclusionOverride, testResetDialOutPumpOcclusionOverride, dialOutPumpOcclusion ) + if ( sensor < NUM_OF_PRESSURE_SENSORS ) + { + if ( TRUE == isTestingActivated() ) + { + result = TRUE; + pressures[ sensor ].override = OVERRIDE_RESET; + pressures[ sensor ].ovData = pressures[ sensor ].ovInitData; + } + } + return result; +}