Index: firmware/App/Services/TxParams.c =================================================================== diff -u -r6f02ff4686ec9dfc60247e9ed3fc9c5cc7771543 -ra58dc5a4e066d593aab0570006fc93b7a8689a22 --- firmware/App/Services/TxParams.c (.../TxParams.c) (revision 6f02ff4686ec9dfc60247e9ed3fc9c5cc7771543) +++ firmware/App/Services/TxParams.c (.../TxParams.c) (revision a58dc5a4e066d593aab0570006fc93b7a8689a22) @@ -47,6 +47,7 @@ #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 /// Record for range and default of treatment parameters. typedef struct @@ -70,10 +71,15 @@ U32 bloodFlowRate_mL_min; ///< Original blood flow rate (in mL/min) set by user before treatment start U32 dialysateFlowRate_mL_min; ///< Original dialysate flow rate (in mL/min) set by user before treatment start U32 treatmentDuration_min; ///< Original treatment duration (in min) set by user before treatment start - S32 arterialPressureLimitWindow_mmHg; ///< Original alarm limit window for arterial pressure (in mmHg) set by user before treatment start - S32 venousPressureLimitWindow_mmHg; ///< Original alarm limit window for venous pressure (in mmHg) set by user before treatment start - S32 venousPressureLimitAsymmetric_mmHg; ///< Original alarm limit asymmetric for venous pressure (in mmHg) set by user before treatment start - S32 tmpLimitWindow_mmHg; ///< Original alarm limit window for trans-membrane pressure (in mmHg) set by user before treatment start + U32 arterialPressureLimitWindow_mmHg; ///< Original alarm limit window for arterial pressure (in mmHg) set by user before treatment start + U32 venousPressureLimitWindow_mmHg; ///< Original alarm limit window for venous pressure (in mmHg) set by user before treatment start + U32 venousPressureLimitAsymmetric_mmHg; ///< Original alarm limit asymmetric for venous pressure (in mmHg) set by user before treatment start + U32 tmpLimitWindow_mmHg; ///< Original alarm limit window for trans-membrane pressure (in mmHg) set by user before treatment start + U32 systolicBPLowAlarmLimit_mmHg; ///< Original systolic BP low alarm limit (in mmHg) set by user before treatment start + U32 systolicBPHighAlarmLimit_mmHg; ///< Original systolic BP high alarm limit (in mmHg) set by user before treatment start + U32 heartRateLowAlarmLimit_BPM; ///< Original heart rate low alarm limit (in BPM) set by user before treatment start + U32 heartRateHighAlarmLimit_BPM; ///< Original heart rate high alarm limit (in BPM) set by user before treatment start + U32 pressureAlarmPersistence_sec; ///< Original pressure alarm persistence (in seconds) set by user before treatment start F32 uFVolume_L; ///< Original ultrafiltration volume (in L) set by user before treatment start } ADJ_TREATMENT_PARAMS_T; @@ -105,25 +111,38 @@ 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=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=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=100}, {.uInt=500}, {.uInt=200} }, // TREATMENT_PARAM_RINSEBACK_FLOW_RATE + { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=3}, {.uInt=0} }, // TREATMENT_PARAM_HEPATITIS_B + { 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 + { 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.0}, {.sFlt=4.0}, {.sFlt=2.0} }, // TREATMENT_PARAM_ACID_K_PLUS + { CRITICAL_DATA_TYPE_F32, {.sFlt=0.0}, {.sFlt=3.50}, {.sFlt=2.50} }, // TREATMENT_PARAM_ACID_CA2_PLUS { CRITICAL_DATA_TYPE_F32, {.sFlt=0.0}, {.sFlt=8.0}, {.sFlt=0.0} }, // TREATMENT_PARAM_UF_VOLUME }; @@ -150,6 +169,8 @@ // ********** 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 void extractTreatmentParamsFromPayload( TREATMENT_PARAMS_DATA_PAYLOAD_T payload ); @@ -190,6 +211,11 @@ origTreatmentParams.venousPressureLimitWindow_mmHg = 0; origTreatmentParams.venousPressureLimitAsymmetric_mmHg = 0; origTreatmentParams.tmpLimitWindow_mmHg = 0; + origTreatmentParams.systolicBPLowAlarmLimit_mmHg = 0; + origTreatmentParams.systolicBPHighAlarmLimit_mmHg = 0; + origTreatmentParams.heartRateLowAlarmLimit_BPM = 0; + origTreatmentParams.heartRateHighAlarmLimit_BPM = 0; + origTreatmentParams.pressureAlarmPersistence_sec = 0; origTreatmentParams.uFVolume_L = 0.0F; } @@ -233,44 +259,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,35 +326,6 @@ /*********************************************************************//** * @brief - * The getTreatmentParameterS32 function gets the value of 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 treatment parameter to get signed integer value for - * @return value of given signed integer treatment parameter - *************************************************************************/ -S32 getTreatmentParameterS32( TREATMENT_PARAM_T param ) -{ - S32 result = 1; - - // Validate parameter - if ( ( param >= TREATMENT_PARAM_FIRST_INT ) && ( param <= TREATMENT_PARAM_LAST_INT ) ) - { - CRITICAL_DATAS_T data = getCriticalData( &treatmentParameters[ param ] ); - - result = data.sInt; - } - else - { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_TREATMENT_PARAMS_INVALID_GET_S32_PARAM, (U32)param ) - } - - return result; -} - -/*********************************************************************//** - * @brief * 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 @@ -396,16 +355,16 @@ /*********************************************************************//** * @brief - * The getTreatmentParameterS32DefaultValue function gets the defaultvalue - * of a given signed integer treatment parameter. - * @details \b Inputs: 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 + * The getTreatmentParameterU32DefaultValue function gets the defaultvalue + * of a given unsigned integer treatment parameter. + * @details Inputs: treatmentParameters[] + * @details Outputs: none + * @param param ID of treatment parameter to get unsigned integer default value for + * @return default value of given unsigned integer treatment parameter *************************************************************************/ -S32 getTreatmentParameterS32DefaultValue( TREATMENT_PARAM_T param ) +U32 getTreatmentParameterU32DefaultValue( TREATMENT_PARAM_T param ) { - return TREAT_PARAMS_PROPERTIES[ param ].def.sInt; + return TREAT_PARAMS_PROPERTIES[ param ].def.uInt; } /*********************************************************************//** @@ -481,6 +440,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_K_PLUS: +// case TREATMENT_PARAM_ACID_CA2_PLUS: +// 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 +538,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,27 +612,27 @@ { 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; // 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; } @@ -839,6 +900,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 +927,134 @@ // 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_SODIUM: +// result = ( ( value.uInt >= hdInstitutionalRecord.minSodium ) && +// ( value.uInt <= hdInstitutionalRecord.maxSodium ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_BICARBONATE: +// result = ( ( value.uInt >= hdInstitutionalRecord.minBicarbonate ) && +// ( value.uInt <= hdInstitutionalRecord.maxBicarbonate ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_DIALYZER_TYPE: +// result = ( ( value.uInt >= hdInstitutionalRecord.minDialyzerType ) && +// ( value.uInt <= hdInstitutionalRecord.maxDialyzerType ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_FLUID_BOLUS_VOLUME: +// result = ( ( value.uInt >= hdInstitutionalRecord.minFluidBolusVolumeML ) && +// ( value.uInt <= hdInstitutionalRecord.maxFluidBolusVolumeML ) ? TRUE : FALSE ); +// break; +// // case TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW: -// result = ( ( value.sInt >= hdInstitutionalRecord.minArtPressLimitWindowMMHG ) && -// ( value.sInt <= hdInstitutionalRecord.maxArtPressLimitWindowMMHG ) ? TRUE : FALSE ); +// result = ( ( value.uInt >= hdInstitutionalRecord.minArtPressLimitWindowMMHG ) && +// ( value.uInt <= hdInstitutionalRecord.maxArtPressLimitWindowMMHG ) ? TRUE : FALSE ); // break; // // case TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW: -// result = ( ( value.sInt >= hdInstitutionalRecord.minVenPressLimitWindowMMHG ) && -// ( value.sInt <= hdInstitutionalRecord.maxVenPressLimitWindowMMHG ) ? TRUE : FALSE ); +// result = ( ( value.uInt >= hdInstitutionalRecord.minVenPressLimitWindowMMHG ) && +// ( value.uInt <= hdInstitutionalRecord.maxVenPressLimitWindowMMHG ) ? TRUE : FALSE ); // break; // // case TREATMENT_PARAM_VEN_PRES_LIMIT_ASYMMETRIC: -// result = ( ( value.sInt >= hdInstitutionalRecord.minVenAsymPressLimitMMHG ) && -// ( value.sInt <= hdInstitutionalRecord.maxVenAsymPressLimitMMHG ) ? TRUE : FALSE ); +// result = ( ( value.uInt >= hdInstitutionalRecord.minVenAsymPressLimitMMHG ) && +// ( value.uInt <= hdInstitutionalRecord.maxVenAsymPressLimitMMHG ) ? TRUE : FALSE ); // break; // // case TREATMENT_PARAM_TMP_PRES_LIMIT_WINDOW: -// result = ( ( value.sInt >= hdInstitutionalRecord.minTmpPressLimitWindowMMHG ) && -// ( value.sInt <= hdInstitutionalRecord.maxTmpPressLimitWindowMMHG ) ? TRUE : FALSE ); +// result = ( ( value.uInt >= hdInstitutionalRecord.minTmpPressLimitWindowMMHG ) && +// ( value.uInt <= hdInstitutionalRecord.maxTmpPressLimitWindowMMHG ) ? 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_RINSEBACK_FLOW_RATE: +// result = ( ( value.uInt >= hdInstitutionalRecord.minRinsebackFlowMLPM ) && +// ( value.uInt <= hdInstitutionalRecord.maxRinsebackFlowMLPM ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_HEPATITIS_B: +// result = ( ( value.uInt >= hdInstitutionalRecord.minHepatitisBStatus ) && +// ( value.uInt <= hdInstitutionalRecord.maxHepatitisBStatus ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_SYSTOLIC_BP_LOW_ALARM_LIMIT: +// result = ( ( value.uInt >= hdInstitutionalRecord.minSystolicBPLowMMHG ) && +// ( value.uInt <= hdInstitutionalRecord.maxSystolicBPLowMMHG ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_SYSTOLIC_BP_HIGH_ALARM_LIMIT: +// result = ( ( value.uInt >= hdInstitutionalRecord.minSystolicBPHighMMHG ) && +// ( value.uInt <= hdInstitutionalRecord.maxSystolicBPHighMMHG ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_HEART_RATE_LOW_ALARM_LIMIT: +// result = ( ( value.uInt >= hdInstitutionalRecord.minHearRateLowBPM ) && +// ( value.uInt <= hdInstitutionalRecord.maxHearRateLowBPM ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_HEART_RATE_HIGH_ALARM_LIMIT: +// result = ( ( value.uInt >= hdInstitutionalRecord.minHearRateHighBPM ) && +// ( value.uInt <= hdInstitutionalRecord.maxHearRateHighBPM ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_PRES_ALARM_PERSISTENCE: +// result = ( ( value.uInt >= hdInstitutionalRecord.minPresPersistenceSEC ) && +// ( value.uInt <= hdInstitutionalRecord.maxPresPersistenceSEC ) ? 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_ACID_K_PLUS: +// result = ( ( value.sFlt >= hdInstitutionalRecord.minAcidKMEQL ) && +// ( value.sFlt <= hdInstitutionalRecord.maxAcidKMEQL ) ? TRUE : FALSE ); +// break; +// +// case TREATMENT_PARAM_ACID_CA2_PLUS: +// result = ( ( value.sFlt >= hdInstitutionalRecord.minAcidCa2MEQL ) && +// ( value.sFlt <= hdInstitutionalRecord.maxAcidCa2MEQL ) ? 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 +1075,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 ) && @@ -920,7 +1084,7 @@ // } } else - { + {; SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_TREATMENT_PARAMS_INVALID_PARAM, (U32)param ) } @@ -929,64 +1093,6 @@ /*********************************************************************//** * @brief - * The getS32TreatmentParamLowerRangeLimit function returns the lower 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 lower range limit for - * @return lower range limit for given signed integer treatment parameter - *************************************************************************/ -S32 getS32TreatmentParamLowerRangeLimit( TREATMENT_PARAM_T param ) -{ - S32 result = 0; - - 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 ) - } - - 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,23 +1209,6 @@ /*********************************************************************//** * @brief - * The getS32DefaultTreatmentParamEdge 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 ) -{ - S32 value = ( TRUE == isMin ? TREAT_PARAMS_PROPERTIES[ param ].min.sInt : TREAT_PARAMS_PROPERTIES[ param ].max.sInt ); - - return value; -} - -/*********************************************************************//** - * @brief * The getU32DefaultTreatmentParamEdge function returns the min or max of * the default treatment parameters * @details \b Inputs: TREAT_PARAMS_PROPERTIES[] @@ -1187,14 +1276,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 ); - } } }