Index: firmware/App/Services/TxParams.c =================================================================== diff -u -r6f02ff4686ec9dfc60247e9ed3fc9c5cc7771543 -r30e46b4f07697652455fa861bcaa18f3d60ae11f --- firmware/App/Services/TxParams.c (.../TxParams.c) (revision 6f02ff4686ec9dfc60247e9ed3fc9c5cc7771543) +++ firmware/App/Services/TxParams.c (.../TxParams.c) (revision 30e46b4f07697652455fa861bcaa18f3d60ae11f) @@ -47,6 +47,8 @@ #define SYRINGE_PUMP_PRIME_VOLUME_ML 0.353F ///< Target syringe prime volume (in mL). TODO- move these to syringe pump controller when implemented #define SYRINGE_PUMP_FILL_VOLUME_OFFSET_ML 0.8F ///< Advised fill volume offset due to HW variance. +#define TX_PARAM_VALUE_NA 0 ///< Value for the not applicable treatment parameters +#define MAX_ACID_CONC_TYPES 10 ///< Number of acid concentrate conversion factors /// Record for range and default of treatment parameters. typedef struct @@ -105,28 +107,48 @@ static const TREATMENT_PARAMS_PROPERTIES_T TREAT_PARAMS_PROPERTIES[ NUM_OF_TREATMENT_PARAMS ] = { // type min max default + { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=2}, {.uInt=0} }, // TREATMENT_PARAM_TREATMENT_MODALITY + { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=2}, {.uInt=0} }, // TREATMENT_PARAM_HDF_DILUTION { CRITICAL_DATA_TYPE_U32, {.uInt=50}, {.uInt=500}, {.uInt=50} }, // TREATMENT_PARAM_BLOOD_FLOW { CRITICAL_DATA_TYPE_U32, {.uInt=50}, {.uInt=600}, {.uInt=50} }, // TREATMENT_PARAM_DIALYSATE_FLOW { CRITICAL_DATA_TYPE_U32, {.uInt=60}, {.uInt=480}, {.uInt=60} }, // TREATMENT_PARAM_TREATMENT_DURATION - { CRITICAL_DATA_TYPE_U32, {.uInt=100}, {.uInt=300}, {.uInt=100} }, // TREATMENT_PARAM_SALINE_BOLUS_VOLUME - { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=480}, {.uInt=0} }, // TREATMENT_PARAM_HEPARIN_STOP_TIME + { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=480}, {.uInt=0} }, // TREATMENT_PARAM_HEPARIN_DELIVERY_DURATION { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=0}, {.uInt=0} }, // TREATMENT_PARAM_HEPARIN_TYPE - { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=2}, {.uInt=0} }, // TREATMENT_PARAM_ACID_CONCENTRATE - { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=0}, {.uInt=0} }, // TREATMENT_PARAM_BICARB_CONCENTRATE + { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=5}, {.uInt=0} }, // TREATMENT_PARAM_DRY_BICARB_CART_SIZE + { CRITICAL_DATA_TYPE_U32, {.uInt=130}, {.uInt=155}, {.uInt=137} }, // TREATMENT_PARAM_SODIUM + { CRITICAL_DATA_TYPE_U32, {.uInt=20}, {.uInt=40}, {.uInt=33} }, // TREATMENT_PARAM_BICARBONATE { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=6}, {.uInt=0} }, // TREATMENT_PARAM_DIALYZER_TYPE + { CRITICAL_DATA_TYPE_U32, {.uInt=100}, {.uInt=300}, {.uInt=100} }, // TREATMENT_PARAM_FLUID_BOLUS_VOLUME { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=60}, {.uInt=0} }, // TREATMENT_PARAM_BP_MEAS_INTERVAL - { CRITICAL_DATA_TYPE_U32, {.uInt=100}, {.uInt=300}, {.uInt=200} }, // TREATMENT_PARAM_RINSEBACK_FLOW_RATE - { CRITICAL_DATA_TYPE_U32, {.uInt=200}, {.uInt=400}, {.uInt=300} }, // TREATMENT_PARAM_RINSEBACK_VOLUME - { CRITICAL_DATA_TYPE_S32, {.sInt=120}, {.sInt=200}, {.sInt=120} }, // TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW - { CRITICAL_DATA_TYPE_S32, {.sInt=100}, {.sInt=200}, {.sInt=100} }, // TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW - { CRITICAL_DATA_TYPE_S32, {.sInt=20}, {.sInt=35}, {.sInt=20} }, // TREATMENT_PARAM_VEN_PRES_LIMIT_ASYMMETRIC - { CRITICAL_DATA_TYPE_S32, {.sInt=40}, {.sInt=100}, {.sInt=40} }, // TREATMENT_PARAM_TMP_PRES_LIMIT_WINDOW - { CRITICAL_DATA_TYPE_F32, {.sFlt=35.0}, {.sFlt=38.0}, {.sFlt=37.0} }, // TREATMENT_PARAM_DIALYSATE_TEMPERATURE - { CRITICAL_DATA_TYPE_F32, {.sFlt=0.0}, {.sFlt=1.0}, {.sFlt=0.0} }, // TREATMENT_PARAM_HEPARIN_DISPENSE_RATE + { CRITICAL_DATA_TYPE_U32, {.uInt=300}, {.uInt=1000}, {.uInt=300} }, // TREATMENT_PARAM_PRIME_DISCARD_VOLUME + { CRITICAL_DATA_TYPE_U32, {.uInt=300}, {.uInt=500}, {.uInt=300} }, // TREATMENT_PARAM_PRIME_RINSEBACK_VOLUME + { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=3}, {.uInt=0} }, // TREATMENT_PARAM_HEPATITIS_B + { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=2}, {.uInt=0} }, // TREATMENT_PARAM_ACID_CONCENTRATE + { CRITICAL_DATA_TYPE_F32, {.sFlt=0.0}, {.sFlt=30.0}, {.sFlt=1.0} }, // TREATMENT_PARAM_SUBST_FLUID_VOLUME { CRITICAL_DATA_TYPE_F32, {.sFlt=0.0}, {.sFlt=2.0}, {.sFlt=0.0} }, // TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME + { CRITICAL_DATA_TYPE_F32, {.sFlt=0.0}, {.sFlt=3.0}, {.sFlt=0.0} }, // TREATMENT_PARAM_HEPARIN_DELIVERY_RATE + { CRITICAL_DATA_TYPE_F32, {.sFlt=35.0}, {.sFlt=38.0}, {.sFlt=37.0} }, // TREATMENT_PARAM_DIALYSATE_TEMPERATURE + { CRITICAL_DATA_TYPE_F32, {.sFlt=0.10}, {.sFlt=0.20}, {.sFlt=0.20} }, // TREATMENT_PARAM_ACID_CONCENTRATE_CONV_FACTOR // TODO + { CRITICAL_DATA_TYPE_F32, {.sFlt=50.0}, {.sFlt=900.0},{.sFlt=50.0} }, // TREATMENT_PARAM_PRE_WEIGHT + { CRITICAL_DATA_TYPE_F32, {.sFlt=50.0}, {.sFlt=900.0},{.sFlt=50.0} }, // TREATMENT_PARAM_EST_TARGET_WEIGHT { CRITICAL_DATA_TYPE_F32, {.sFlt=0.0}, {.sFlt=8.0}, {.sFlt=0.0} }, // TREATMENT_PARAM_UF_VOLUME }; +static const TREATMENT_PARAMS_PROPERTIES_T SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ NUM_OF_SYS_CONFIG_TREATMENT_PARAMS ] = +{ // type min max default + + { CRITICAL_DATA_TYPE_U32, {.uInt=120}, {.uInt=200}, {.uInt=120} }, // TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW + { CRITICAL_DATA_TYPE_U32, {.uInt=100}, {.uInt=200}, {.uInt=100} }, // TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW + { CRITICAL_DATA_TYPE_U32, {.uInt=20}, {.uInt=35}, {.uInt=20} }, // TREATMENT_PARAM_VEN_PRES_LIMIT_ASYMMETRIC + { CRITICAL_DATA_TYPE_U32, {.uInt=40}, {.uInt=100}, {.uInt=40} }, // TREATMENT_PARAM_TMP_PRES_LIMIT_WINDOW + { CRITICAL_DATA_TYPE_U32, {.uInt=100}, {.uInt=500}, {.uInt=200} }, // TREATMENT_PARAM_RINSEBACK_FLOW_RATE + { CRITICAL_DATA_TYPE_U32, {.uInt=70}, {.uInt=140}, {.uInt=90} }, // TREATMENT_PARAM_SYSTOLIC_BP_LOW_ALARM_LIMIT + { CRITICAL_DATA_TYPE_U32, {.uInt=100}, {.uInt=260}, {.uInt=200} }, // TREATMENT_PARAM_SYSTOLIC_BP_HIGH_ALARM_LIMIT + { CRITICAL_DATA_TYPE_U32, {.uInt=40}, {.uInt=140}, {.uInt=40} }, // TREATMENT_PARAM_HEART_RATE_LOW_ALARM_LIMIT + { CRITICAL_DATA_TYPE_U32, {.uInt=80}, {.uInt=180}, {.uInt=120} }, // TREATMENT_PARAM_HEART_RATE_HIGH_ALARM_LIMIT + { CRITICAL_DATA_TYPE_U32, {.uInt=1}, {.uInt=5}, {.uInt=1} }, // TREATMENT_PARAM_PRES_ALARM_PERSISTENCE +}; + /// Dialyzer volumes (blood and dialysate) table in mL for each type of dialyzer. const DIALYZER_VOLUME_DATA_T dialyzerVolumeTable[ NUM_OF_DIALYZER_TYPES ] = { { 82, 170 }, // DIALYZER_TYPE_BBRAUN_PRO_13H @@ -137,9 +159,22 @@ { 113, 348 }, // DIALYZER_TYPE_FRESENIUS_OPTIFLUX_F200NRE { 142, 304 } }; // DIALYZER_TYPE_FRESENIUS_OPTIFLUX_F250NRE +/// Acid concentration conversion factors for each acid type +const F32 ACID_CONVERSION_FACTOR[ MAX_ACID_CONC_TYPES ] = { 0.1119255F, + 0.1131362F, + 0.1143568F, + 0.0F, + 0.0F, + 0.0F, + 0.0F, + 0.0F, + 0.0F, + 0.0F }; ///< Acid conversion factors. + // Current treatment parameter values -static CRITICAL_DATA_T treatmentParameters[ NUM_OF_TREATMENT_PARAMS ]; ///< Treatment parameters. -static CRITICAL_DATAS_T stagedParams[ NUM_OF_TREATMENT_PARAMS ]; ///< Temporary staged treatment parameters for validation and awaiting user confirmation. +static CRITICAL_DATA_T treatmentParameters[ NUM_OF_TREATMENT_PARAMS ]; ///< Treatment parameters. +static CRITICAL_DATAS_T stagedParams[ NUM_OF_TREATMENT_PARAMS ]; ///< Temporary staged treatment parameters for validation and awaiting user confirmation. +static CRITICAL_DATA_T sysConfigTreatmentParameters[ NUM_OF_SYS_CONFIG_TREATMENT_PARAMS ]; ///< System configured treatment parameters. // Original treatment parameter values (for those that can be changed during treatment) static ADJ_TREATMENT_PARAMS_T origTreatmentParams; ///< Originally set (before treatment) treatment parameters. @@ -150,8 +185,11 @@ // ********** private function prototypes ********** static void resetAllTreatmentParameters( void ); +static BOOL isTreatmentParamNotApplicable( TREATMENT_PARAM_T param ); +static BOOL isNotApplicableTreatmentParamZero( TREATMENT_PARAM_T param ); static BOOL checkTreatmentParamsInRange( U32 *reasons ); static BOOL checkTreatmentParamsDependencies( U32 *reasons ); +static BOOL checkUFDependencies( U32 *reasons ); static void extractTreatmentParamsFromPayload( TREATMENT_PARAMS_DATA_PAYLOAD_T payload ); //static void checkPressureParamsRange( TREATMENT_PARAMS_DATA_PAYLOAD_T* txParams ); static void sendTreatmentParamsResponse( BOOL rejected, U32 *reasons ); @@ -169,6 +207,7 @@ static void resetAllTreatmentParameters( void ) { TREATMENT_PARAM_T param; + SYS_CONFIG_TREATMENT_PARAM_T sysConfigTxParam; for ( param = TREATMENT_PARAM_FIRST_UINT; param < NUM_OF_TREATMENT_PARAMS; param++ ) { @@ -182,6 +221,18 @@ stagedParams[ param ].uInt = 0; } + for ( sysConfigTxParam = TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW; sysConfigTxParam < NUM_OF_TREATMENT_PARAMS; sysConfigTxParam++ ) + { + // Set type, range, and default value for each treatment parameter + sysConfigTreatmentParameters[ sysConfigTxParam ].typ = SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ sysConfigTxParam ].dataType; + sysConfigTreatmentParameters[ sysConfigTxParam ].minimum = SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ sysConfigTxParam ].min; + sysConfigTreatmentParameters[ sysConfigTxParam ].maximum = SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ sysConfigTxParam ].max; + sysConfigTreatmentParameters[ sysConfigTxParam ].defValue = SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ sysConfigTxParam ].def; + resetCriticalData( &sysConfigTreatmentParameters[ sysConfigTxParam ] ); + // Set staged parameter values to zero +// stagedParams[ param ].uInt = 0; + } + // Zero original parameter values origTreatmentParams.bloodFlowRate_mL_min = 0; origTreatmentParams.dialysateFlowRate_mL_min = 0; @@ -233,44 +284,6 @@ /*********************************************************************//** * @brief - * The setTreatmentParameterS32 function sets a given signed integer treatment - * parameter to a given value. - * @details \b Alarm: ALARM_ID_TD_SOFTWARE_FAULT if given param is invalid - * @details \b Inputs: treatmentParameters[] - * @details \b Outputs: treatmentParameters[] - * @param param ID of treatment parameter to set signed integer value for - * @param value signed integer value to assign to given treatment parameter - * @return TRUE if set was successful, FALSE if not - *************************************************************************/ -BOOL setTreatmentParameterS32( TREATMENT_PARAM_T param, S32 value ) -{ - CRITICAL_DATAS_T unsignedIntData; - BOOL result = FALSE; - - unsignedIntData.sInt = value; - result = isTreatmentParamInRange( param, unsignedIntData ); - - // Validate parameter - if ( ( param >= TREATMENT_PARAM_FIRST_INT ) && ( param <= TREATMENT_PARAM_LAST_INT ) ) - { - if ( TRUE == result ) - { - CRITICAL_DATAS_T data = treatmentParameters[ param ].data; - - data.sInt = value; - result = setCriticalData( &treatmentParameters[ param ], data ); - } - } - else - { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_TREATMENT_PARAMS_INVALID_SET_S32_PARAM, (U32)param ) - } - - return result; -} - -/*********************************************************************//** - * @brief * The setTreatmentParameterF32 sets a given floating point treatment parameter * to a given value. * @details \b Alarm: ALARM_ID_TD_SOFTWARE_FAULT if given param is invalid @@ -338,74 +351,75 @@ /*********************************************************************//** * @brief - * The getTreatmentParameterS32 function gets the value of a given signed - * integer treatment parameter. + * The getTreatmentParameterF32 function gets the value of a given floating point + * treatment parameter. * @details \b Alarm: ALARM_ID_TD_SOFTWARE_FAULT if given param is invalid * @details \b Inputs: treatmentParameters[] * @details \b Outputs: none - * @param param ID of treatment parameter to get signed integer value for - * @return value of given signed integer treatment parameter + * @param param ID of treatment parameter to get floating point value for + * @return value of given floating point treatment parameter *************************************************************************/ -S32 getTreatmentParameterS32( TREATMENT_PARAM_T param ) +F32 getTreatmentParameterF32( TREATMENT_PARAM_T param ) { - S32 result = 1; + F32 result = 1.0; // Validate parameter - if ( ( param >= TREATMENT_PARAM_FIRST_INT ) && ( param <= TREATMENT_PARAM_LAST_INT ) ) + if ( ( param >= TREATMENT_PARAM_FIRST_F32 ) && ( param < NUM_OF_TREATMENT_PARAMS ) ) { CRITICAL_DATAS_T data = getCriticalData( &treatmentParameters[ param ] ); - result = data.sInt; + result = data.sFlt; } else { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_TREATMENT_PARAMS_INVALID_GET_S32_PARAM, (U32)param ) + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_TREATMENT_PARAMS_INVALID_GET_F32_PARAM, (U32)param ) } return result; } /*********************************************************************//** * @brief - * The getTreatmentParameterF32 function gets the value of a given floating point - * treatment parameter. + * The getSysConfigTreatmentParameterU32 function gets the value of a + * given unsigned integer system configured treatment parameter. * @details \b Alarm: ALARM_ID_TD_SOFTWARE_FAULT if given param is invalid - * @details \b Inputs: treatmentParameters[] + * @details \b Inputs: sysConfigTreatmentParameters[] * @details \b Outputs: none - * @param param ID of treatment parameter to get floating point value for - * @return value of given floating point treatment parameter + * @param param ID of system configured treatment parameter to get + * unsigned integer value for + * @return value of given unsigned integer treatment parameter *************************************************************************/ -F32 getTreatmentParameterF32( TREATMENT_PARAM_T param ) +U32 getSysConfigTreatmentParameterU32( SYS_CONFIG_TREATMENT_PARAM_T param ) { - F32 result = 1.0; + U32 result = 1; // Validate parameter - if ( ( param >= TREATMENT_PARAM_FIRST_F32 ) && ( param < NUM_OF_TREATMENT_PARAMS ) ) + if ( param <= NUM_OF_SYS_CONFIG_TREATMENT_PARAMS ) { - CRITICAL_DATAS_T data = getCriticalData( &treatmentParameters[ param ] ); + CRITICAL_DATAS_T data = getCriticalData( &sysConfigTreatmentParameters[ param ] ); - result = data.sFlt; + result = data.uInt; } else { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_TREATMENT_PARAMS_INVALID_GET_F32_PARAM, (U32)param ) + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_TREATMENT_PARAMS_INVALID_GET_U32_PARAM, (U32)param ) // TODO change ID } return result; } /*********************************************************************//** * @brief - * The getTreatmentParameterS32DefaultValue function gets the defaultvalue - * of a given signed integer treatment parameter. - * @details \b Inputs: TREAT_PARAMS_PROPERTIES[] + * The getSysConfigTreatmentParameterU32DefaultValue function gets the defaultvalue + * of a given unsigned integer system configured treatment parameter. + * @details \b Inputs: SYS_CONFIG_TREAT_PARAMS_PROPERTIES[] * @details \b Outputs: none * @param param ID of treatment parameter to get signed integer default value for - * @return default value of given signed integer treatment parameter + * @return default value of given unsigned integer treatment parameter *************************************************************************/ -S32 getTreatmentParameterS32DefaultValue( TREATMENT_PARAM_T param ) +U32 getSysConfigTreatmentParameterU32DefaultValue( SYS_CONFIG_TREATMENT_PARAM_T param ) { - return TREAT_PARAMS_PROPERTIES[ param ].def.sInt; + return SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].def.uInt; } /*********************************************************************//** @@ -423,7 +437,7 @@ BOOL validateAndSetTreatmentParameters( MESSAGE_T *message ) { BOOL paramsAreInvalid = TRUE; - BOOL paramsAreInRange, paramsAreConsistent; + BOOL paramsAreInRange, paramsAreConsistent, isUFValid; BOOL result = FALSE; TREATMENT_PARAMS_DATA_PAYLOAD_T params; U32 rejReasons[ NUM_OF_TREATMENT_PARAMS ]; @@ -438,7 +452,7 @@ // Check the received arterial and venous pressure values from the UI to be checked and capped against the min and max // values in the institutional record - // checkPressureParamsRange( ¶ms ); // TODO + // checkPressureParamsRange( ¶ms ); // TODO do as pre-check when user click create tx // Extract treatment parameters from given payload to staging array so we can more easily work with them extractTreatmentParamsFromPayload( params ); @@ -449,17 +463,23 @@ // Validate dependencies paramsAreConsistent = checkTreatmentParamsDependencies( &rejReasons[0] ); + //Validate UF dependencies + isUFValid = checkUFDependencies( &rejReasons[0] ); + // Determine overall validity of received treatment parameters - if ( ( TRUE == paramsAreInRange ) && ( TRUE == paramsAreConsistent ) ) + if ( ( TRUE == paramsAreInRange ) && ( TRUE == paramsAreConsistent ) && ( TRUE == isUFValid ) ) { paramsAreInvalid = FALSE; - validTreatParamsReceived = TRUE; + validTreatParamsReceived = TRUE; // direct confirmation, no validation state exists now + treatParamsConfirmed = TRUE; + // Send latest and final treatment parameters to UI + sendMessage( MSG_ID_TD_VALIDATED_TREATMENT_PARAMS, COMM_BUFFER_OUT_CAN_TD_2_UI, (U08*)(&stagedParams), sizeof( TREATMENT_PARAMS_DATA_PAYLOAD_T ) ); } // Respond to set treatment parameters request message sendTreatmentParamsResponse( paramsAreInvalid, &rejReasons[0] ); // Send initial adjustable ranges to UI so UF volume range will be known when UF volume prompted for later - if ( TRUE == validTreatParamsReceived ) + if ( TRUE == treatParamsConfirmed ) { U32 setTxDuration = stagedParams[ TREATMENT_PARAM_TREATMENT_DURATION ].uInt; TREATMENT_PARAM_RANGE_BROADCAST_PAYLOAD_T payload; @@ -481,6 +501,92 @@ /*********************************************************************//** * @brief + * The isTreatmentParamNotApplicable function checks whether received + * treatment parameters not applicable for a set treatment modality. + * @details \b Inputs: stagedParams + * @details \b Outputs: none + * @return TRUE if treatment parameters is not applicable, FALSE if not + *************************************************************************/ +static BOOL isTreatmentParamNotApplicable( TREATMENT_PARAM_T param ) +{ + BOOL result = TRUE; + TREATMENT_TYPE_T txType = (TREATMENT_TYPE_T)stagedParams[ TREATMENT_PARAM_TREATMENT_MODALITY ].uInt; + + switch ( txType ) + { + case TREATMENT_MODALITY_HDF: + result = FALSE; + break; + + case TREATMENT_MODALITY_HD: + result = ( ( ( param == TREATMENT_PARAM_HDF_DILUTION ) || ( param == TREATMENT_PARAM_SUBST_FLUID_VOLUME ) ) ? TRUE : FALSE ); + break; + + // TODO uncomment in phase 3 when ISO UF feature is required +// case TREATMENT_MODALITY_ISOLATED_UF: +// switch ( param ) +// { +// // Treatment parameters that are not applicable for isolated UF +// case TREATMENT_PARAM_HDF_DILUTION: +// case TREATMENT_PARAM_SUBST_FLUID_VOLUME: +// case TREATMENT_PARAM_DIALYSATE_FLOW: +// case TREATMENT_PARAM_DIALYSATE_TEMPERATURE: +// case TREATMENT_PARAM_ACID_CONCENTRATE: +// case TREATMENT_PARAM_ACID_CONCENTRATE_CONV_FACTOR: +// case TREATMENT_PARAM_SODIUM: +// case TREATMENT_PARAM_BICARBONATE: +// case TREATMENT_PARAM_DRY_BICARB_CART_SIZE: +// result = TRUE; +// break; +// +// // Treatment parameters applicable for isolated UF +// default: +// result = FALSE; +// break; +// } +// break; + + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_TREATMENT_MODALITY, (U32)txType ) + break; + } + + return result; +} + +/*********************************************************************//** + * @brief + * The isNotApplicableTreatmentParamZero function checks whether received + * treatment parameters is set to zero or not. + * @details \b Inputs: stagedParams + * @details \b Outputs: none + * @return TRUE if treatment parameters is set to zero, FALSE if not + *************************************************************************/ +static BOOL isNotApplicableTreatmentParamZero( TREATMENT_PARAM_T param ) +{ + BOOL result = TRUE; + + if ( param <= TREATMENT_PARAM_LAST_UINT ) + { + if ( stagedParams[ param ].uInt != TX_PARAM_VALUE_NA ) + { + result = FALSE; + } + } + // check for float type params + else + { + if ( stagedParams[ param ].sFlt != (F32)NEARLY_ZERO ) + { + result = FALSE; + } + } + + return result; +} + +/*********************************************************************//** + * @brief * The checkTreatmentParamsInRange function checks whether received * treatment parameters are in range. * @details \b Inputs: stagedParams[] @@ -493,45 +599,61 @@ BOOL result = TRUE; TREATMENT_PARAM_T param; - // Range check treatment parameters up to (but not including) UF volume - for ( param = TREATMENT_PARAM_FIRST_UINT; param < TREATMENT_PARAM_UF_VOLUME; param++ ) + reasons[ TREATMENT_PARAM_TREATMENT_MODALITY ] = REQUEST_REJECT_REASON_NONE; +// if ( FALSE == isTreatmentParamInRange( TREATMENT_PARAM_TREATMENT_MODALITY, stagedParams[ TREATMENT_PARAM_TREATMENT_MODALITY ] ) ) // TODO - restore when institutional settings implemented + if ( ( stagedParams[ TREATMENT_PARAM_TREATMENT_MODALITY ].uInt < TREAT_PARAMS_PROPERTIES[ TREATMENT_PARAM_TREATMENT_MODALITY ].min.uInt ) || + ( stagedParams[ TREATMENT_PARAM_TREATMENT_MODALITY ].uInt > TREAT_PARAMS_PROPERTIES[ TREATMENT_PARAM_TREATMENT_MODALITY ].max.uInt ) ) { - reasons[ param ] = REQUEST_REJECT_REASON_NONE; - -#if 0 -// if ( FALSE == isTreatmentParamInRange( param, stagedParams[ param ] ) ) // TODO - restore when institutional settings implemented (and remove range checks below) -// { -// reasons[ param ] = REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE; -// result = FALSE; -// } -#else - if ( param <= TREATMENT_PARAM_LAST_UINT ) + reasons[ TREATMENT_PARAM_TREATMENT_MODALITY ] = REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE; + result = FALSE; + } + else + { + // Range check treatment parameters excluding treatment modality and up to (but not including) UF volume + for ( param = TREATMENT_PARAM_HDF_DILUTION; param < TREATMENT_PARAM_UF_VOLUME; param++ ) { - if ( ( stagedParams[ param ].uInt < TREAT_PARAMS_PROPERTIES[ param ].min.uInt ) || - ( stagedParams[ param ].uInt > TREAT_PARAMS_PROPERTIES[ param ].max.uInt ) ) + reasons[ param ] = REQUEST_REJECT_REASON_NONE; + + // Check if not applicable parameter is not set + if ( TRUE == isTreatmentParamNotApplicable( param ) ) { - reasons[ param ] = REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE; - result = FALSE; + // reject if the not applicable parameter is set to non-zero + if ( FALSE == isNotApplicableTreatmentParamZero( param ) ) + { + reasons[ param ] = REQUEST_REJECT_REASON_PARAM_NOT_APPLICABLE; + result = FALSE; + } } - } - else if ( param <= TREATMENT_PARAM_LAST_INT ) - { - if ( ( stagedParams[ param ].sInt < TREAT_PARAMS_PROPERTIES[ param ].min.sInt ) || - ( stagedParams[ param ].sInt > TREAT_PARAMS_PROPERTIES[ param ].max.sInt ) ) + // do a range check for the applicable parameter + else { - reasons[ param ] = REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE; - result = FALSE; +#if 0 +// if ( FALSE == isTreatmentParamInRange( param, stagedParams[ param ] ) ) // TODO - restore when institutional settings implemented (and remove range checks below) +// { +// reasons[ param ] = REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE; +// result = FALSE; +// } +#else + if ( param <= TREATMENT_PARAM_LAST_UINT ) + { + if ( ( stagedParams[ param ].uInt < TREAT_PARAMS_PROPERTIES[ param ].min.uInt ) || + ( stagedParams[ param ].uInt > TREAT_PARAMS_PROPERTIES[ param ].max.uInt ) ) + { + reasons[ param ] = REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE; + result = FALSE; + } + } + else + { + if ( ( stagedParams[ param ].sFlt < TREAT_PARAMS_PROPERTIES[ param ].min.sFlt ) || + ( stagedParams[ param ].sFlt > TREAT_PARAMS_PROPERTIES[ param ].max.sFlt ) ) + { + reasons[ param ] = REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE; + result = FALSE; + } + } } } - else - { - if ( ( stagedParams[ param ].sFlt < TREAT_PARAMS_PROPERTIES[ param ].min.sFlt ) || - ( stagedParams[ param ].sFlt > TREAT_PARAMS_PROPERTIES[ param ].max.sFlt ) ) - { - reasons[ param ] = REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE; - result = FALSE; - } - } } #endif @@ -551,103 +673,201 @@ { BOOL result = TRUE; U32 txDur = stagedParams[ TREATMENT_PARAM_TREATMENT_DURATION ].uInt; - U32 hepST = stagedParams[ TREATMENT_PARAM_HEPARIN_STOP_TIME ].uInt; - F32 hepDR = stagedParams[ TREATMENT_PARAM_HEPARIN_DISPENSE_RATE ].sFlt; + U32 hepST = stagedParams[ TREATMENT_PARAM_HEPARIN_DELIVERY_DURATION ].uInt; + F32 hepDR = stagedParams[ TREATMENT_PARAM_HEPARIN_DELIVERY_RATE ].sFlt; F32 hepBV = stagedParams[ TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME ].sFlt; F32 txVol = hepBV + ( hepDR * ( hepST / (F32)SEC_PER_MIN ) ) + SYRINGE_PUMP_PRIME_VOLUME_ML + SYRINGE_PUMP_FILL_VOLUME_OFFSET_ML; + // Variable to validate acid conversion factor consistency + U32 acidType = stagedParams[ TREATMENT_PARAM_ACID_CONCENTRATE ].uInt; + F32 acidConvFactor = stagedParams[ TREATMENT_PARAM_ACID_CONCENTRATE_CONV_FACTOR ].sFlt; + // Verify Heparin stop time is only set if Heparin dispense rate is set if ( ( hepST > 0 ) && ( hepDR < NEARLY_ZERO ) ) { - reasons[ TREATMENT_PARAM_HEPARIN_STOP_TIME ] = REQUEST_REJECT_REASON_HEPARIN_STOP_TIME_WITH_NO_DISPENSE; + reasons[ TREATMENT_PARAM_HEPARIN_DELIVERY_DURATION ] = REQUEST_REJECT_REASON_HEPARIN_STOP_TIME_WITH_NO_DISPENSE; result = FALSE; } // Verify Heparin stop time does not exceed Tx duration else if ( hepST > txDur ) { - reasons[ TREATMENT_PARAM_HEPARIN_STOP_TIME ] = REQUEST_REJECT_REASON_HEPARIN_STOP_TIME_EXCEEDS_DURATION; + reasons[ TREATMENT_PARAM_HEPARIN_DELIVERY_DURATION ] = REQUEST_REJECT_REASON_HEPARIN_STOP_TIME_EXCEEDS_DURATION; result = FALSE; } // Verify Heparin stop time does not exceed max 10 mL Heparin volume else if ( txVol > MAX_HEPARIN_VOLUME_ML ) { - reasons[ TREATMENT_PARAM_HEPARIN_STOP_TIME ] = REQUEST_REJECT_REASON_HEPARIN_VOLUME_EXCEEDS_10_ML; + reasons[ TREATMENT_PARAM_HEPARIN_DELIVERY_DURATION ] = REQUEST_REJECT_REASON_HEPARIN_VOLUME_EXCEEDS_10_ML; result = FALSE; } + // Verify Acid conversion factor from UI is consistent with FW + if ( acidConvFactor != ACID_CONVERSION_FACTOR[ acidType ] ) + { + reasons[ TREATMENT_PARAM_ACID_CONCENTRATE_CONV_FACTOR ] = REQUEST_REJECT_REASON_ACID_CONV_FACTOR_MISMATCH; + result = FALSE; + } return result; } /*********************************************************************//** * @brief - * The validateAndSetUFVolume function validates received ultrafiltration + * The checkUFDependencies function validates set ultrafiltration * volume treatment parameter. - * @details \b Message \b Sent: MSG_ID_TD_RESP_ULTRAFILTRATION_VOLUME_TO_VALIDATE * @details \b Inputs: none * @details \b Outputs: none - * @param message set message from UI which includes the user set ultrafiltration - * volume (in mL). - * @return TRUE if received UF volume parameter is valid, FALSE if not + * @return TRUE if ultrafiltration dependencies are ok, FALSE if not *************************************************************************/ -BOOL validateAndSetUFVolume( MESSAGE_T *message ) +static BOOL checkUFDependencies( U32 *reasons ) { - BOOL accepted = FALSE; - REQUEST_REJECT_REASON_CODE_T rejReason = REQUEST_REJECT_REASON_NONE; + BOOL result = FALSE; + BOOL updateUF = FALSE; + BOOL validWeights = TRUE; F32 uFVolumeMl; F32 uFVolumeL; + F32 preWeight; + F32 targetWeight; + F32 derivedUFVolumeL; - // Verify message payload length is valid - if ( sizeof( F32 ) == message->hdr.payloadLen ) + preWeight = stagedParams[ TREATMENT_PARAM_PRE_WEIGHT ].sFlt; + targetWeight = stagedParams[ TREATMENT_PARAM_EST_TARGET_WEIGHT ].sFlt; + uFVolumeL = stagedParams[ TREATMENT_PARAM_UF_VOLUME ].sFlt; + + // TODO add check to calculate UF volume from weights. near zero check for weight is done in range check. + if ( preWeight > NEARLY_ZERO && targetWeight > NEARLY_ZERO && preWeight >= targetWeight) { - UF_VOLUME_VAL_RESP_DATA_PAYLOAD_T respPayload; + // Weights are valid - Calculate UF volume + derivedUFVolumeL = preWeight - targetWeight; + if ( uFVolumeL <= NEARLY_ZERO && derivedUFVolumeL > NEARLY_ZERO ) + { + // Update UF volume with calculated UF volume + stagedParams[ TREATMENT_PARAM_UF_VOLUME ].sFlt = derivedUFVolumeL; + uFVolumeL = derivedUFVolumeL; + } + // case where UF volume is non-zero and provided weights + else + { + reasons[ TREATMENT_PARAM_PRE_WEIGHT ] = REQUEST_REJECT_REASON_INVALID_PATIENT_WEIGHTS; + reasons[ TREATMENT_PARAM_EST_TARGET_WEIGHT ] = REQUEST_REJECT_REASON_INVALID_PATIENT_WEIGHTS; + result = FALSE; + validWeights = FALSE; + } + } + // if weights are invalid + else + { + reasons[ TREATMENT_PARAM_PRE_WEIGHT ] = REQUEST_REJECT_REASON_INVALID_PATIENT_WEIGHTS; + reasons[ TREATMENT_PARAM_EST_TARGET_WEIGHT ] = REQUEST_REJECT_REASON_INVALID_PATIENT_WEIGHTS; + result = FALSE; + validWeights = FALSE; + } - memcpy( &uFVolumeMl, message->payload, sizeof( F32 ) ); - uFVolumeL = uFVolumeMl / (F32)ML_PER_LITER; + // Validate given UF volume + updateUF = setTreatmentParameterF32( TREATMENT_PARAM_UF_VOLUME, uFVolumeL ); + uFVolumeMl = uFVolumeL * (F32)ML_PER_LITER; - // Validate given UF volume - accepted = setTreatmentParameterF32( TREATMENT_PARAM_UF_VOLUME, uFVolumeL ); + if ( ( TRUE == updateUF ) && ( TRUE == validWeights ) ) + { + U32 treatmentDuration = getTreatmentParameterU32( TREATMENT_PARAM_TREATMENT_DURATION ); - if ( TRUE == accepted ) + // store the user set ultrafiltration volume in pre-treatment parameters setup, if it is validated, otherwise keep the initial 0.0 + origTreatmentParams.uFVolume_L = uFVolumeL; + + if ( treatmentDuration > 0 ) { - U32 treatmentDuration = getTreatmentParameterU32( TREATMENT_PARAM_TREATMENT_DURATION ); + F32 uFRate = uFVolumeMl / (F32)treatmentDuration; - // store the user set ultrafiltration volume in pre-treatment parameters setup, if it is validated, otherwise keep the initial 0.0 - origTreatmentParams.uFVolume_L = uFVolumeL; - - if ( treatmentDuration > 0 ) + if ( ( uFRate > MAX_UF_RATE_ML_MIN ) || ( uFRate < MIN_UF_RATE_ML_MIN ) ) { - F32 uFRate = uFVolumeMl / (F32)treatmentDuration; - - if ( ( uFRate > MAX_UF_RATE_ML_MIN ) || ( uFRate < MIN_UF_RATE_ML_MIN ) ) - { - accepted = FALSE; - rejReason = REQUEST_REJECT_REASON_UF_RATE_OUT_OF_RANGE; - } + result = FALSE; + reasons[ TREATMENT_PARAM_UF_VOLUME ] = REQUEST_REJECT_REASON_UF_RATE_OUT_OF_RANGE; } - else - { - accepted = FALSE; - rejReason = REQUEST_REJECT_REASON_TREATMENT_TIME_LESS_THAN_MINIMUM; - } } else { - rejReason = REQUEST_REJECT_REASON_UF_VOLUME_OUT_OF_RANGE; + result = FALSE; + reasons[ TREATMENT_PARAM_UF_VOLUME ] = REQUEST_REJECT_REASON_TREATMENT_TIME_LESS_THAN_MINIMUM; } - - // Respond to set UF volume request message - uFVolumeL = getTreatmentParameterF32( TREATMENT_PARAM_UF_VOLUME ); - uFVolumeMl = uFVolumeL * (F32)ML_PER_LITER; - respPayload.accepted = accepted; - respPayload.rejReason = rejReason; - respPayload.ufVolumeMl = uFVolumeMl; - sendMessage( MSG_ID_TD_RESP_ULTRAFILTRATION_VOLUME_TO_VALIDATE, COMM_BUFFER_OUT_CAN_TD_2_UI, (U08*)(&respPayload), sizeof( UF_VOLUME_VAL_RESP_DATA_PAYLOAD_T ) ); - // setUserSetUFVolumeStatus( accepted ); // TODO - tell pre-tx whether UF volume has been set and accepted } + else + { + reasons[ TREATMENT_PARAM_UF_VOLUME ] = REQUEST_REJECT_REASON_UF_VOLUME_OUT_OF_RANGE; + } - return accepted; + return result; } +// +///*********************************************************************//** +// * @brief +// * The validateAndSetUFVolume function validates received ultrafiltration +// * volume treatment parameter. +// * @details \b Message \b Sent: MSG_ID_TD_RESP_ULTRAFILTRATION_VOLUME_TO_VALIDATE +// * @details \b Inputs: none +// * @details \b Outputs: none +// * @param message set message from UI which includes the user set ultrafiltration +// * volume (in mL). +// * @return TRUE if received UF volume parameter is valid, FALSE if not +// *************************************************************************/ +//BOOL validateAndSetUFVolume( MESSAGE_T *message ) // TODO remove? or use it for UF validation for changes during treatment? +//{ +// BOOL accepted = FALSE; +// REQUEST_REJECT_REASON_CODE_T rejReason = REQUEST_REJECT_REASON_NONE; +// F32 uFVolumeMl; +// F32 uFVolumeL; +// +// // Verify message payload length is valid +// if ( sizeof( F32 ) == message->hdr.payloadLen ) +// { +// UF_VOLUME_VAL_RESP_DATA_PAYLOAD_T respPayload; +// +// memcpy( &uFVolumeMl, message->payload, sizeof( F32 ) ); +// uFVolumeL = uFVolumeMl / (F32)ML_PER_LITER; +// +// // Validate given UF volume +// accepted = setTreatmentParameterF32( TREATMENT_PARAM_UF_VOLUME, uFVolumeL ); +// +// if ( TRUE == accepted ) +// { +// U32 treatmentDuration = getTreatmentParameterU32( TREATMENT_PARAM_TREATMENT_DURATION ); +// +// // store the user set ultrafiltration volume in pre-treatment parameters setup, if it is validated, otherwise keep the initial 0.0 +// origTreatmentParams.uFVolume_L = uFVolumeL; +// +// if ( treatmentDuration > 0 ) +// { +// F32 uFRate = uFVolumeMl / (F32)treatmentDuration; +// +// if ( ( uFRate > MAX_UF_RATE_ML_MIN ) || ( uFRate < MIN_UF_RATE_ML_MIN ) ) +// { +// accepted = FALSE; +// rejReason = REQUEST_REJECT_REASON_UF_RATE_OUT_OF_RANGE; +// } +// } +// else +// { +// accepted = FALSE; +// rejReason = REQUEST_REJECT_REASON_TREATMENT_TIME_LESS_THAN_MINIMUM; +// } +// } +// else +// { +// rejReason = REQUEST_REJECT_REASON_UF_VOLUME_OUT_OF_RANGE; +// } +// +// // Respond to set UF volume request message +// uFVolumeL = getTreatmentParameterF32( TREATMENT_PARAM_UF_VOLUME ); +// uFVolumeMl = uFVolumeL * (F32)ML_PER_LITER; +// respPayload.accepted = accepted; +// respPayload.rejReason = rejReason; +// respPayload.ufVolumeMl = uFVolumeMl; +// sendMessage( MSG_ID_TD_RESP_ULTRAFILTRATION_VOLUME_TO_VALIDATE, COMM_BUFFER_OUT_CAN_TD_2_UI, (U08*)(&respPayload), sizeof( UF_VOLUME_VAL_RESP_DATA_PAYLOAD_T ) ); +// // setUserSetUFVolumeStatus( accepted ); // TODO - tell pre-tx whether UF volume has been set and accepted +// } +// +// return accepted; +//} + /*********************************************************************//** * @brief * The resetTreatmentParameters function resets the Treatment Parameters @@ -692,45 +912,45 @@ return treatParamsConfirmed; } -/*********************************************************************//** - * @brief - * The signalUserConfirmationOfTreatmentParameters function sets the user - * confirmation flag signaling user has confirmed or rejected treatment - * parameters. - * @details \b Inputs: none - * @details \b Outputs: treatParamsConfirmed - * @param message confirmation message from UI which includes the user - * confirmation or restTreamentParameters. - * @return TRUE if confirmation/rejection accepted, FALSE if not - *************************************************************************/ -BOOL signalUserConfirmationOfTreatmentParameters( MESSAGE_T *message ) -{ - BOOL confirmed = FALSE; - BOOL result = FALSE; +///*********************************************************************//** +// * @brief +// * The signalUserConfirmationOfTreatmentParameters function sets the user +// * confirmation flag signaling user has confirmed or rejected treatment +// * parameters. +// * @details \b Inputs: none +// * @details \b Outputs: treatParamsConfirmed +// * @param message confirmation message from UI which includes the user +// * confirmation or restTreamentParameters. +// * @return TRUE if confirmation/rejection accepted, FALSE if not +// *************************************************************************/ +//BOOL signalUserConfirmationOfTreatmentParameters( MESSAGE_T *message ) +//{ +// BOOL confirmed = FALSE; +// BOOL result = FALSE; +// +// if ( sizeof( BOOL ) == message->hdr.payloadLen ) +// { +// memcpy( &confirmed, message->payload, sizeof( BOOL ) ); +// if ( TRUE == confirmed ) +// { +// // ModePreTreat uses this via getTreatParamsConfirmed() +// treatParamsConfirmed = TRUE; +// } +// else +// { +// // Rejected – clear session +// resetTreatmentParameters(); +// } +// result = TRUE; +// } +// else +// { +// result = FALSE; +// } +// +// return result; +//} - if ( sizeof( BOOL ) == message->hdr.payloadLen ) - { - memcpy( &confirmed, message->payload, sizeof( BOOL ) ); - if ( TRUE == confirmed ) - { - // ModePreTreat uses this via getTreatParamsConfirmed() - treatParamsConfirmed = TRUE; - } - else - { - // Rejected – clear session - resetTreatmentParameters(); - } - result = TRUE; - } - else - { - result = FALSE; - } - - return result; -} - /*********************************************************************//** * @brief * The extractTreatmentParamsFromPayload function extracts the individual @@ -839,6 +1059,16 @@ { // switch( param ) // { +// case TREATMENT_PARAM_TREATMENT_MODALITY: +// result = ( ( value.uInt >= hdInstitutionalRecord.minTxModality ) && +// ( value.uInt <= hdInstitutionalRecord.maxBloodFlowMLPM ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_HDF_TREATMENT_MODE: +// result = ( ( value.uInt >= hdInstitutionalRecord.minHDFTxMode ) && +// ( value.uInt <= hdInstitutionalRecord.maxHDFTxMode ) ? TRUE : FALSE ); +// break; +// // case TREATMENT_PARAM_BLOOD_FLOW: // result = ( ( value.uInt >= hdInstitutionalRecord.minBloodFlowMLPM ) && // ( value.uInt <= hdInstitutionalRecord.maxBloodFlowMLPM ) ? TRUE : FALSE ); @@ -856,36 +1086,79 @@ // result |= ( TRUE == getTestConfigStatus( TEST_CONFIG_ENABLE_ONE_MINUTE_TREATMENT ) ? TRUE : FALSE ); // break; // -// case TREATMENT_PARAM_SALINE_BOLUS_VOLUME: -// result = ( ( value.uInt >= hdInstitutionalRecord.minSalineBolusVolumeML ) && -// ( value.uInt <= hdInstitutionalRecord.maxSalineBolusVolumeML ) ? TRUE : FALSE ); +// case TREATMENT_PARAM_HEPARIN_DELIVERY_DURATION: +// result = ( ( value.uInt >= hdInstitutionalRecord.minHepDeliveryDurationMIN ) && +// ( value.uInt <= hdInstitutionalRecord.maxHepDeliveryDurationMIN ) ? TRUE : FALSE ); +// result |= ( stagedParams[ TREATMENT_PARAM_HEPARIN_DELIVERY_RATE ].sFlt <= NEARLY_ZERO ? TRUE : FALSE ); // break; // -// case TREATMENT_PARAM_DIALYSATE_TEMPERATURE: -// result = ( ( value.sFlt >= hdInstitutionalRecord.minDialysateTempC ) && -// ( value.sFlt <= hdInstitutionalRecord.maxDialysateTempC ) ? TRUE : FALSE ); +// case TREATMENT_PARAM_DRY_BICARB_CART_SIZE: +// result = ( ( value.uInt >= hdInstitutionalRecord.minDryBicarbSize ) && +// ( value.uInt <= hdInstitutionalRecord.maxDryBicarbSize ) ? TRUE : FALSE ); // break; // -// case TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW: -// result = ( ( value.sInt >= hdInstitutionalRecord.minArtPressLimitWindowMMHG ) && -// ( value.sInt <= hdInstitutionalRecord.maxArtPressLimitWindowMMHG ) ? TRUE : FALSE ); +// case TREATMENT_PARAM_SODIUM: +// result = ( ( value.uInt >= hdInstitutionalRecord.minSodium ) && +// ( value.uInt <= hdInstitutionalRecord.maxSodium ) ? TRUE : FALSE ); // break; // -// case TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW: -// result = ( ( value.sInt >= hdInstitutionalRecord.minVenPressLimitWindowMMHG ) && -// ( value.sInt <= hdInstitutionalRecord.maxVenPressLimitWindowMMHG ) ? TRUE : FALSE ); +// case TREATMENT_PARAM_BICARBONATE: +// result = ( ( value.uInt >= hdInstitutionalRecord.minBicarbonate ) && +// ( value.uInt <= hdInstitutionalRecord.maxBicarbonate ) ? TRUE : FALSE ); // break; // -// case TREATMENT_PARAM_VEN_PRES_LIMIT_ASYMMETRIC: -// result = ( ( value.sInt >= hdInstitutionalRecord.minVenAsymPressLimitMMHG ) && -// ( value.sInt <= hdInstitutionalRecord.maxVenAsymPressLimitMMHG ) ? TRUE : FALSE ); +// case TREATMENT_PARAM_DIALYZER_TYPE: +// result = ( ( value.uInt >= hdInstitutionalRecord.minDialyzerType ) && +// ( value.uInt <= hdInstitutionalRecord.maxDialyzerType ) ? TRUE : FALSE ); // break; // -// case TREATMENT_PARAM_TMP_PRES_LIMIT_WINDOW: -// result = ( ( value.sInt >= hdInstitutionalRecord.minTmpPressLimitWindowMMHG ) && -// ( value.sInt <= hdInstitutionalRecord.maxTmpPressLimitWindowMMHG ) ? TRUE : FALSE ); +// case TREATMENT_PARAM_FLUID_BOLUS_VOLUME: +// result = ( ( value.uInt >= hdInstitutionalRecord.minFluidBolusVolumeML ) && +// ( value.uInt <= hdInstitutionalRecord.maxFluidBolusVolumeML ) ? TRUE : FALSE ); // break; // +// case TREATMENT_PARAM_PRIME_DISCARD_VOLUME: +// result = ( ( value.uInt >= hdInstitutionalRecord.minPrimeDiscardVolumeML ) && +// ( value.uInt <= hdInstitutionalRecord.maxPrimeDiscardVolumeML ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_PRIME_RINSEBACK_VOLUME: +// result = ( ( value.uInt >= hdInstitutionalRecord.minPrimeRinsebackVolumeML ) && +// ( value.uInt <= hdInstitutionalRecord.maxPrimeRinsebackVolumeML ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_HEPATITIS_B: +// result = ( ( value.uInt >= hdInstitutionalRecord.minHepatitisBStatus ) && +// ( value.uInt <= hdInstitutionalRecord.maxHepatitisBStatus ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_ACID_CONCENTRATE: +// result = ( ( value.uInt >= hdInstitutionalRecord.minAcidConcentrateType ) && +// ( value.uInt <= hdInstitutionalRecord.maxAcidConcentrateType ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_SUBST_FLUID_VOLUME: +// result = ( ( value.sFlt >= hdInstitutionalRecord.minSubstFluidL ) && +// ( value.sFlt <= hdInstitutionalRecord.maxSubstFluidL ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME: +// result = ( ( value.sFlt >= hdInstitutionalRecord.minHepBolusVolumeML ) && +// ( value.sFlt <= hdInstitutionalRecord.maxHepBolusVolumeML ) ? TRUE : FALSE ); +// result |= ( fabs( value.sFlt ) <= NEARLY_ZERO ? TRUE : FALSE ); // Even if the minimum is not 0, 0 is accepted meaning heparin can be turned off +// break; +// +// case TREATMENT_PARAM_HEPARIN_DELIVERY_RATE: +// result = ( ( value.sFlt >= hdInstitutionalRecord.minHepDeliveryRateMLHR ) && +// ( value.sFlt <= hdInstitutionalRecord.maxHepDeliveryRateMLHR ) ? TRUE : FALSE ); +// result |= ( fabs( value.sFlt ) <= NEARLY_ZERO ? TRUE : FALSE ); // Even if the minimum is not 0, 0 is accepted meaning heparin can be turned off +// break; +// +// case TREATMENT_PARAM_DIALYSATE_TEMPERATURE: +// result = ( ( value.sFlt >= hdInstitutionalRecord.minDialysateTempC ) && +// ( value.sFlt <= hdInstitutionalRecord.maxDialysateTempC ) ? TRUE : FALSE ); +// break; +// // case TREATMENT_PARAM_UF_VOLUME: // result = ( ( value.sFlt >= hdInstitutionalRecord.minUFVolumeL ) && ( value.sFlt <= hdInstitutionalRecord.maxUFVolumeL ) ? TRUE : FALSE ); // result |= ( fabs( value.sFlt ) <= NEARLY_ZERO ? TRUE : FALSE ); // There might be a minimum UF volume set in the institutional record but a treatment with 0 vol should be allowed @@ -906,11 +1179,6 @@ //#ifndef _VECTORCAST_ // // Right now, all the F32 and S32 data types are covered in the institutional record and therefore, there is no test case that is either F32 or S32 // // and gets here so it is removed from VectorCAST to be able to achieve 100% coverage of the function -// else if ( CRITICAL_DATA_TYPE_S32 == TREAT_PARAMS_PROPERTIES[ param ].dataType ) -// { -// result = ( ( value.sInt >= TREAT_PARAMS_PROPERTIES[ param ].min.sInt ) && -// ( value.sInt <= TREAT_PARAMS_PROPERTIES[ param ].max.sInt ) ? TRUE : FALSE ); -// } // else // { // result = ( ( value.sFlt >= TREAT_PARAMS_PROPERTIES[ param ].min.sFlt ) && @@ -929,64 +1197,79 @@ /*********************************************************************//** * @brief - * The getS32TreatmentParamLowerRangeLimit function returns the lower range - * limit for a given signed integer treatment parameter. + * The isSysConfigTreatmentParamInRange function determines whether a given treatment + * parameter is in range. * @details \b Alarm: ALARM_ID_TD_SOFTWARE_FAULT if given param is invalid - * @details \b Inputs: treatmentParameters[] + * @details \b Inputs: hdInstitutionalRecord * @details \b Outputs: none - * @param param ID of parameter to get lower range limit for - * @return lower range limit for given signed integer treatment parameter + * @param param ID of parameter to check range for + * @return TRUE if given treatment parameter is in range, FALSE if not *************************************************************************/ -S32 getS32TreatmentParamLowerRangeLimit( TREATMENT_PARAM_T param ) +BOOL isSysConfigTreatmentParamInRange( SYS_CONFIG_TREATMENT_PARAM_T param ) { - S32 result = 0; + BOOL result = TRUE; // TODO FALSE; - if ( param < NUM_OF_TREATMENT_PARAMS ) - { - CRITICAL_DATAS_T value; - // getInstitutionalRecordEdgeValue( param, &value, TRUE ); TODO - value = treatmentParameters[ param ].minimum; - result = value.sInt; - } - else - { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_TREATMENT_PARAMS_INVALID_GET_S32_PARAM_MIN_LIMIT, (U32)param ) - } +// switch( param ) +// { +// case TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW: +// result = ( ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].min.uInt <= hdInstitutionalRecord.minArtPressLimitWindowMMHG ) && +// ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].max.uInt >= hdInstitutionalRecord.maxArtPressLimitWindowMMHG ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW: +// result = ( ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].min.uInt <= hdInstitutionalRecord.minVenPressLimitWindowMMHG ) && +// ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].max.uInt >= hdInstitutionalRecord.maxVenPressLimitWindowMMHG ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_VEN_PRES_LIMIT_ASYMMETRIC: +// result = ( ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].min.uInt <= hdInstitutionalRecord.minVenAsymPressLimitMMHG ) && +// ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].max.uInt >= hdInstitutionalRecord.maxVenAsymPressLimitMMHG ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_TMP_PRES_LIMIT_WINDOW: +// result = ( ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].min.uInt <= hdInstitutionalRecord.minTmpPressLimitWindowMMHG ) && +// ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].max.uInt >= hdInstitutionalRecord.maxTmpPressLimitWindowMMHG ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_RINSEBACK_FLOW_RATE: +// result = ( ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].min.uInt <= hdInstitutionalRecord.minRinsebackFlowMLPM ) && +// ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].max.uInt >= hdInstitutionalRecord.maxRinsebackFlowMLPM ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_SYSTOLIC_BP_LOW_ALARM_LIMIT: +// result = ( ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].min.uInt <= hdInstitutionalRecord.minSystolicBPLowMMHG ) && +// ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].max.uInt >= hdInstitutionalRecord.maxSystolicBPLowMMHG ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_SYSTOLIC_BP_HIGH_ALARM_LIMIT: +// result = ( ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].min.uInt <= hdInstitutionalRecord.minSystolicBPHighMMHG ) && +// ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].max.uInt >= hdInstitutionalRecord.maxSystolicBPHighMMHG ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_HEART_RATE_LOW_ALARM_LIMIT: +// result = ( ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].min.uInt <= hdInstitutionalRecord.minHearRateLowBPM ) && +// ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].max.uInt >= hdInstitutionalRecord.maxHearRateLowBPM ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_HEART_RATE_HIGH_ALARM_LIMIT: +// result = ( ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].min.uInt <= hdInstitutionalRecord.minHearRateHighBPM ) && +// ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].max.uInt >= hdInstitutionalRecord.maxHearRateHighBPM ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_PRES_ALARM_PERSISTENCE: +// result = ( ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].min.uInt <= hdInstitutionalRecord.minPresPersistenceSEC ) && +// ( SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].max.uInt >= hdInstitutionalRecord.maxPresPersistenceSEC ) ? TRUE : FALSE ); +// break; +// +// default: +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_TREATMENT_PARAMS_INVALID_PARAM, (U32)param ) +// break; return result; } /*********************************************************************//** * @brief - * The getS32TreatmentParamUpperRangeLimit function returns the upper range - * limit for a given signed integer treatment parameter. - * @details \b Alarm: ALARM_ID_TD_SOFTWARE_FAULT if given param is invalid. - * @details \b Inputs: treatmentParameters[] - * @details \b Outputs: none - * @param param ID of parameter to get upper range limit for - * @return upper range limit for given signed integer treatment parameter - *************************************************************************/ -S32 getS32TreatmentParamUpperRangeLimit( TREATMENT_PARAM_T param ) -{ - S32 result = 0; - - if ( param < NUM_OF_TREATMENT_PARAMS ) - { - CRITICAL_DATAS_T value; -// getInstitutionalRecordEdgeValue( param, &value, FALSE ); // TODO - value = treatmentParameters[ param ].maximum; - result = value.sInt; - } - else - { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_TREATMENT_PARAMS_INVALID_GET_S32_PARAM_MAX_LIMIT, (U32)param ) - } - - return result; -} - -/*********************************************************************//** - * @brief * The getU32TreatmentParamLowerRangeLimit function returns the lower range * limit for a given unsigned integer treatment parameter. * @details \b Alarm: ALARM_ID_TD_SOFTWARE_FAULT if given param is invalid. @@ -1103,51 +1386,109 @@ /*********************************************************************//** * @brief - * The getS32DefaultTreatmentParamEdge function returns the min or max of + * The getU32DefaultTreatmentParamEdge function returns the min or max of * the default treatment parameters * @details \b Inputs: TREAT_PARAMS_PROPERTIES[] * @details \b Outputs: none * @param param ID of parameter * @param isMin to indicate whether minimum is needed for maximum * @return the requested min or max value *************************************************************************/ -S32 getS32DefaultTreatmentParamEdge( TREATMENT_PARAM_T param, BOOL isMin ) +U32 getU32DefaultTreatmentParamEdge( TREATMENT_PARAM_T param, BOOL isMin ) { - S32 value = ( TRUE == isMin ? TREAT_PARAMS_PROPERTIES[ param ].min.sInt : TREAT_PARAMS_PROPERTIES[ param ].max.sInt ); + U32 value = ( TRUE == isMin ? TREAT_PARAMS_PROPERTIES[ param ].min.uInt : TREAT_PARAMS_PROPERTIES[ param ].max.uInt ); return value; } /*********************************************************************//** * @brief - * The getU32DefaultTreatmentParamEdge function returns the min or max of + * The getF32DefaultTreatmentParamEdge function returns the min or max of * the default treatment parameters * @details \b Inputs: TREAT_PARAMS_PROPERTIES[] * @details \b Outputs: none * @param param ID of parameter * @param isMin to indicate whether minimum is needed for maximum * @return the requested min or max value *************************************************************************/ -U32 getU32DefaultTreatmentParamEdge( TREATMENT_PARAM_T param, BOOL isMin ) +F32 getF32DefaultTreatmentParamEdge( TREATMENT_PARAM_T param, BOOL isMin ) { - U32 value = ( TRUE == isMin ? TREAT_PARAMS_PROPERTIES[ param ].min.uInt : TREAT_PARAMS_PROPERTIES[ param ].max.uInt ); + F32 value = ( TRUE == isMin ? TREAT_PARAMS_PROPERTIES[ param ].min.sFlt : TREAT_PARAMS_PROPERTIES[ param ].max.sFlt ); return value; } /*********************************************************************//** * @brief - * The getF32DefaultTreatmentParamEdge function returns the min or max of + * The getU32SysConfigTreatmentParamLowerRangeLimit function returns the lower range + * limit for a given unsigned integer system configured treatment parameter. + * @details \b Alarm: ALARM_ID_TD_SOFTWARE_FAULT if given param is invalid. + * @details \b Inputs: sysConfigTreatmentParameters[] + * @details \b Outputs: none + * @param param ID of parameter to get lower range limit for + * @return lower range limit for given unsigned integer treatment parameter + *************************************************************************/ +U32 getU32SysConfigTreatmentParamLowerRangeLimit( SYS_CONFIG_TREATMENT_PARAM_T param ) +{ + U32 result = 0; + + if ( param < NUM_OF_SYS_CONFIG_TREATMENT_PARAMS ) + { + CRITICAL_DATAS_T value; +// getInstitutionalRecordEdgeValue( param, &value, TRUE ); // TODO + value = sysConfigTreatmentParameters[ param ].minimum; + result = value.uInt; + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_TREATMENT_PARAMS_INVALID_GET_U32_PARAM_MIN_LIMIT, (U32)param ) + } + + return result; +} + +/*********************************************************************//** + * @brief + * The getU32SysConfigTreatmentParamUpperRangeLimit function returns the upper range + * limit for a given unsigned integer system configured treatment parameter. + * @details \b Alarm: ALARM_ID_TD_SOFTWARE_FAULT if given param is invalid. + * @details \b Inputs: sysConfigTreatmentParameters[] + * @details \b Outputs: none + * @param param ID of parameter to get upper range limit for + * @return upper range limit for given unsigned integer treatment parameter + *************************************************************************/ +U32 getU32SysConfigTreatmentParamUpperRangeLimit( SYS_CONFIG_TREATMENT_PARAM_T param ) +{ + U32 result = 0; + + if ( param < NUM_OF_SYS_CONFIG_TREATMENT_PARAMS ) + { + CRITICAL_DATAS_T value; +// getInstitutionalRecordEdgeValue( param, &value, FALSE ); // TODO + value = sysConfigTreatmentParameters[ param ].maximum; + result = value.uInt; + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_TREATMENT_PARAMS_INVALID_GET_U32_PARAM_MAX_LIMIT, (U32)param ) + } + + return result; +} + +/*********************************************************************//** + * @brief + * The getU32DefaultSysConfigTreatmentParamEdge function returns the min or max of * the default treatment parameters - * @details \b Inputs: TREAT_PARAMS_PROPERTIES[] + * @details \b Inputs: SYS_CONFIG_TREAT_PARAMS_PROPERTIES[] * @details \b Outputs: none * @param param ID of parameter * @param isMin to indicate whether minimum is needed for maximum * @return the requested min or max value *************************************************************************/ -F32 getF32DefaultTreatmentParamEdge( TREATMENT_PARAM_T param, BOOL isMin ) +U32 getU32DefaultSysConfigTreatmentParamEdge( SYS_CONFIG_TREATMENT_PARAM_T param, BOOL isMin ) { - F32 value = ( TRUE == isMin ? TREAT_PARAMS_PROPERTIES[ param ].min.sFlt : TREAT_PARAMS_PROPERTIES[ param ].max.sFlt ); + U32 value = ( TRUE == isMin ? SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].min.uInt : SYS_CONFIG_TREAT_PARAMS_PROPERTIES[ param ].max.uInt ); return value; } @@ -1187,14 +1528,10 @@ { result = setTreatmentParameterU32( (TREATMENT_PARAM_T)payload.paramID, payload.value.uInt ); } - else if ( (TREATMENT_PARAM_T)payload.paramID >= TREATMENT_PARAM_FIRST_F32 ) + else { result = setTreatmentParameterF32( (TREATMENT_PARAM_T)payload.paramID, payload.value.sFlt ); } - else - { - result = setTreatmentParameterS32( (TREATMENT_PARAM_T)payload.paramID, payload.value.sInt ); - } } } @@ -1219,16 +1556,16 @@ // Verify payload length if ( 0 == message->hdr.payloadLen ) { - CURRENT_TREATMENT_PARAMS_DATA_PAYLOAD_T payload; + TREATMENT_PARAMS_DATA_PAYLOAD_T payload; TREATMENT_PARAM_T param; // Build and publish current treatment parameters record for ( param = (TREATMENT_PARAM_T)0; param < NUM_OF_TREATMENT_PARAMS; param++ ) { stagedParams[ param ] = treatmentParameters[ param ].data; } - memcpy( (U08*)&payload, (U08*)&stagedParams[0], sizeof( CURRENT_TREATMENT_PARAMS_DATA_PAYLOAD_T ) ); - sendMessage( MSG_ID_TD_RSP_CURRENT_TREATMENT_PARAMETERS, COMM_BUFFER_OUT_CAN_PC, (U08*)&payload, sizeof( CURRENT_TREATMENT_PARAMS_DATA_PAYLOAD_T ) ); + memcpy( (U08*)&payload, (U08*)&stagedParams[0], sizeof( TREATMENT_PARAMS_DATA_PAYLOAD_T ) ); + sendMessage( MSG_ID_TD_RSP_CURRENT_TREATMENT_PARAMETERS, COMM_BUFFER_OUT_CAN_PC, (U08*)&payload, sizeof( TREATMENT_PARAMS_DATA_PAYLOAD_T ) ); result = TRUE; }