Index: firmware/App/Modes/ModeStandby.c =================================================================== diff -u -reef41b7363d82763095a1317f1757f360f0d9ec1 -r30e46b4f07697652455fa861bcaa18f3d60ae11f --- firmware/App/Modes/ModeStandby.c (.../ModeStandby.c) (revision eef41b7363d82763095a1317f1757f360f0d9ec1) +++ firmware/App/Modes/ModeStandby.c (.../ModeStandby.c) (revision 30e46b4f07697652455fa861bcaa18f3d60ae11f) @@ -246,18 +246,19 @@ // If treatment start is requested by user, initiate treatment workflow (transition to treatment params mode). if ( TRUE == treatStartReqReceived ) { -// PRESSURE_LIMIT_CHANGE_RESPONSE_T respRecord = { TRUE, REQUEST_REJECT_REASON_NONE, 0, 0, 0 }; + PRESSURE_LIMIT_CHANGE_RESPONSE_T respRecord = { TRUE, REQUEST_REJECT_REASON_NONE, 0, 0, 0, 0 }; // Initialize treatment modes before starting a new treatment initPreTreatmentMode(); initTreatmentMode(); // initPostTreatmentMode(); resetAirTrap(); // Send UI default pressure settings since user is not asked to set them. -// respRecord.artPresLimitWindowmmHg = getTreatmentParameterS32DefaultValue( TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW ); -// respRecord.venPresLimitWindowmmHg = getTreatmentParameterS32DefaultValue( TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW ); -// respRecord.venPresLimitAsymmetricmmHg = getTreatmentParameterS32DefaultValue( TREATMENT_PARAM_VEN_PRES_LIMIT_ASYMMETRIC ); -// sendPressureLimitsChangeResponse( &respRecord ); + respRecord.artPresLimitWindowmmHg = getSysConfigTreatmentParameterU32DefaultValue( TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW ); + respRecord.venPresLimitWindowmmHg = getSysConfigTreatmentParameterU32DefaultValue( TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW ); + respRecord.venPresLimitAsymmetricmmHg = getSysConfigTreatmentParameterU32DefaultValue( TREATMENT_PARAM_VEN_PRES_LIMIT_ASYMMETRIC ); + respRecord.tmpPresLimitWindowmmHg = getSysConfigTreatmentParameterU32DefaultValue( TREATMENT_PARAM_TMP_PRES_LIMIT_WINDOW ); + sendPressureLimitsChangeResponse( &respRecord ); // Start treatment workflow with pretreatment mode requestNewOperationMode( MODE_PRET ); treatStartReqReceived = FALSE; Index: firmware/App/Modes/ModeTreatment.c =================================================================== diff -u -reef41b7363d82763095a1317f1757f360f0d9ec1 -r30e46b4f07697652455fa861bcaa18f3d60ae11f --- firmware/App/Modes/ModeTreatment.c (.../ModeTreatment.c) (revision eef41b7363d82763095a1317f1757f360f0d9ec1) +++ firmware/App/Modes/ModeTreatment.c (.../ModeTreatment.c) (revision 30e46b4f07697652455fa861bcaa18f3d60ae11f) @@ -20,6 +20,7 @@ #include "Bubbles.h" #include "Buttons.h" #include "DDInterface.h" +#include "Messaging.h" #include "ModeService.h" #include "ModeTreatment.h" //#include "NVDataMgmt.h" @@ -177,7 +178,7 @@ *************************************************************************/ U32 transitionToTreatmentMode( void ) { -// PRESSURE_LIMIT_CHANGE_RESPONSE_T respRecord; + PRESSURE_LIMIT_CHANGE_RESPONSE_T respRecord; // don't re-initialize treatment if tester is jumping to Tx mode // if ( getPreviousOperationMode() != MODE_PRET ) @@ -212,14 +213,16 @@ // Direct DD to generate dialysate and bypass while priming blood cmdStartGenerateDialysate( (F32)getTreatmentParameterU32( TREATMENT_PARAM_DIALYSATE_FLOW ), presUFRateLHr, getTreatmentParameterF32( TREATMENT_PARAM_DIALYSATE_TEMPERATURE ), TRUE, - (ACID_CONCENTRATE_TYPE_T)getTreatmentParameterU32( TREATMENT_PARAM_ACID_CONCENTRATE ), - (BICARB_CONCENTRATE_TYPE_T)getTreatmentParameterU32( TREATMENT_PARAM_BICARB_CONCENTRATE ) ); + getTreatmentParameterF32( TREATMENT_PARAM_ACID_CONCENTRATE_CONV_FACTOR ), + getTreatmentParameterU32( TREATMENT_PARAM_SODIUM ), + getTreatmentParameterU32( TREATMENT_PARAM_BICARBONATE ) ); // Read back limits for transmit to UI. -// respRecord.artPresLimitWindowmmHg = getTreatmentParameterS32( TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW ); -// respRecord.venPresLimitWindowmmHg = getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW ); -// respRecord.venPresLimitAsymmetricmmHg = getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRES_LIMIT_ASYMMETRIC ); + respRecord.artPresLimitWindowmmHg = getSysConfigTreatmentParameterU32( TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW ); + respRecord.venPresLimitWindowmmHg = getSysConfigTreatmentParameterU32( TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW ); + respRecord.venPresLimitAsymmetricmmHg = getSysConfigTreatmentParameterU32( TREATMENT_PARAM_VEN_PRES_LIMIT_ASYMMETRIC ); + respRecord.tmpPresLimitWindowmmHg = getSysConfigTreatmentParameterU32( TREATMENT_PARAM_TMP_PRES_LIMIT_WINDOW ); // Send response -// sendPressureLimitsChangeResponse( &respRecord ); + sendPressureLimitsChangeResponse( &respRecord ); return currentTreatmentState; } @@ -512,6 +515,35 @@ /*********************************************************************//** * @brief + * The sendPressureLimitsChangeResponse function constructs a change + * pressure limits response to the UI and queues the msg for transmit on the + * appropriate CAN channel. + * @details Inputs: none + * @details Outputs: Pressure limits change response msg constructed and queued. + * @param data response data record + * @return TRUE if msg successfully queued for transmit, FALSE if not + *************************************************************************/ +BOOL sendPressureLimitsChangeResponse( PRESSURE_LIMIT_CHANGE_RESPONSE_T *data ) +{ + BOOL result; + MESSAGE_T msg; + U08 *payloadPtr = msg.payload; + + // Create a message record + blankMessage( &msg ); + msg.hdr.msgID = MSG_ID_TD_PRESSURE_LIMITS_CHANGE_RESPONSE; + msg.hdr.payloadLen = sizeof( PRESSURE_LIMIT_CHANGE_RESPONSE_T ); + + memcpy( payloadPtr, (U08*)data, sizeof( PRESSURE_LIMIT_CHANGE_RESPONSE_T ) ); + + // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer + result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_TD_2_UI, ACK_REQUIRED ); + + return result; +} + +/*********************************************************************//** + * @brief * The handleTreatmentStartState function handles the Start state of * the Treatment Mode state machine. Should only pass through this state * once at very beginning of treatment. @@ -1080,7 +1112,7 @@ { SALINE_BOLUS_DATA_PAYLOAD_T data; - data.tgtSalineVolumeMl = getTreatmentParameterU32( TREATMENT_PARAM_SALINE_BOLUS_VOLUME ); + data.tgtSalineVolumeMl = getTreatmentParameterU32( TREATMENT_PARAM_FLUID_BOLUS_VOLUME ); data.cumSalineVolumeMl = 0.0F; // TODO data.bolSalineVolumeMl = 0.0F; // TODO Index: firmware/App/Modes/ModeTreatment.h =================================================================== diff -u -r395522dffef1348e176564925656012f529c1910 -r30e46b4f07697652455fa861bcaa18f3d60ae11f --- firmware/App/Modes/ModeTreatment.h (.../ModeTreatment.h) (revision 395522dffef1348e176564925656012f529c1910) +++ firmware/App/Modes/ModeTreatment.h (.../ModeTreatment.h) (revision 30e46b4f07697652455fa861bcaa18f3d60ae11f) @@ -85,13 +85,23 @@ U32 ufState; ///< Ultrafiltration state. } UF_DATA_PAYLOAD_T; +/// Payload record structure for the in-line pressure limits change response. +typedef struct +{ + BOOL accepted; ///< Accepted. + U32 rejReasonCode; ///< Rejection reason code number. + U32 artPresLimitWindowmmHg; ///< Arterial pressure limit window in mmHg. + U32 venPresLimitWindowmmHg; ///< Venous pressure limit window in mmHg. + U32 venPresLimitAsymmetricmmHg; ///< Venous pressure limit asymmetric in mmHg. + U32 tmpPresLimitWindowmmHg; ///< TMP pressure limit window in mmHg. +} PRESSURE_LIMIT_CHANGE_RESPONSE_T; +#pragma pack(pop) + /// Maximum time in this mode before blood sitting alarm given (in general task intervals). #define MAX_TIME_BLOOD_SITTING ( ( 5 * SEC_PER_MIN * MS_PER_SECOND ) / TASK_GENERAL_INTERVAL ) /// Maximum time in this mode before blood sitting warning given (in general task intervals). #define WARN_TIME_BLOOD_SITTING ( ( 4 * SEC_PER_MIN * MS_PER_SECOND ) / TASK_GENERAL_INTERVAL ) -#pragma pack(pop) - // ********** public function prototypes ********** void initTreatmentMode( void ); // Initialize this unit @@ -115,6 +125,9 @@ U32 getTreatmentStartTimeStamp( void ); // Get the treatment start time stamp U32 getTreatmentEndTimeStamp( void ); // Get the treatment end time stamp +// MSG_ID_TD_PRESSURE_LIMITS_CHANGE_RESPONSE +BOOL sendPressureLimitsChangeResponse( PRESSURE_LIMIT_CHANGE_RESPONSE_T *data ); + /**@}*/ #endif Index: firmware/App/Modes/StateTxDialysis.c =================================================================== diff -u -r6f02ff4686ec9dfc60247e9ed3fc9c5cc7771543 -r30e46b4f07697652455fa861bcaa18f3d60ae11f --- firmware/App/Modes/StateTxDialysis.c (.../StateTxDialysis.c) (revision 6f02ff4686ec9dfc60247e9ed3fc9c5cc7771543) +++ firmware/App/Modes/StateTxDialysis.c (.../StateTxDialysis.c) (revision 30e46b4f07697652455fa861bcaa18f3d60ae11f) @@ -101,9 +101,10 @@ *************************************************************************/ void transitionToDialysis( void ) { - F32 dialTemp = getTreatmentParameterF32( TREATMENT_PARAM_DIALYSATE_TEMPERATURE ); - U32 acidType = getTreatmentParameterU32( TREATMENT_PARAM_ACID_CONCENTRATE ); - U32 bicbType = getTreatmentParameterU32( TREATMENT_PARAM_BICARB_CONCENTRATE ); + F32 dialTemp = getTreatmentParameterF32( TREATMENT_PARAM_DIALYSATE_TEMPERATURE ); + F32 acidConvFactor = getTreatmentParameterF32( TREATMENT_PARAM_ACID_CONCENTRATE_CONV_FACTOR ); + U32 sodium = getTreatmentParameterU32( TREATMENT_PARAM_SODIUM ); + U32 bicarbonate = getTreatmentParameterU32( TREATMENT_PARAM_BICARBONATE ); doorClosedRequired( TRUE ); @@ -114,7 +115,7 @@ // Set actuators as appropriate for state cmdStartGenerateDialysate( setDialysateFlowRate, setUFRateLHr, dialTemp, FALSE, - (ACID_CONCENTRATE_TYPE_T)acidType, (BICARB_CONCENTRATE_TYPE_T)bicbType ); + acidConvFactor, sodium, bicarbonate ); transitionToDialysisState( currentDialysisState ); // Set substate for event Index: firmware/App/Monitors/Pressures.c =================================================================== diff -u -rb017f10001f67282ab6622e34d629ae2f884cdc9 -r30e46b4f07697652455fa861bcaa18f3d60ae11f --- firmware/App/Monitors/Pressures.c (.../Pressures.c) (revision b017f10001f67282ab6622e34d629ae2f884cdc9) +++ firmware/App/Monitors/Pressures.c (.../Pressures.c) (revision 30e46b4f07697652455fa861bcaa18f3d60ae11f) @@ -496,10 +496,10 @@ if ( PRESSURE_LIMITS_STATE_STABLE == currPresLimitsState ) { // apply pressure windows when stable - S32 artOffset = getTreatmentParameterS32( TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW ) / 2; - S32 venMinOffset = getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRES_LIMIT_ASYMMETRIC ); - S32 venMaxOffset = getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW ) - venMinOffset; - S32 tmpOffset = getTreatmentParameterS32( TREATMENT_PARAM_TMP_PRES_LIMIT_WINDOW ) / 2; + S32 artOffset = (S32)getSysConfigTreatmentParameterU32( TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW ) / 2; + S32 venMinOffset = (S32)getSysConfigTreatmentParameterU32( TREATMENT_PARAM_VEN_PRES_LIMIT_ASYMMETRIC ); + S32 venMaxOffset = (S32)getSysConfigTreatmentParameterU32( TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW ) - venMinOffset; + S32 tmpOffset = (S32)getSysConfigTreatmentParameterU32( TREATMENT_PARAM_TMP_PRES_LIMIT_WINDOW ) / 2; currentArterialMinLimit = stableArterialPressure - artOffset; currentArterialMinLimit = MAX( currentArterialMinLimit, ARTERIAL_PRESSURE_LIMIT_MIN_MMHG ); Index: firmware/App/Services/AlarmMgmtSWFaults.h =================================================================== diff -u -rc049177f4d18a4740a357941b48a833d7115b581 -r30e46b4f07697652455fa861bcaa18f3d60ae11f --- firmware/App/Services/AlarmMgmtSWFaults.h (.../AlarmMgmtSWFaults.h) (revision c049177f4d18a4740a357941b48a833d7115b581) +++ firmware/App/Services/AlarmMgmtSWFaults.h (.../AlarmMgmtSWFaults.h) (revision 30e46b4f07697652455fa861bcaa18f3d60ae11f) @@ -182,8 +182,9 @@ SW_FAULT_ID_VALVES_INVALID_VALVE_FINDING_EDGE = 151, SW_FAULT_ID_TD_VALVES_INVALID_FIND_DEENERGIZED_EDGE = 152, SW_FAULT_ID_BLOOD_PRIME_INVALID_STATE = 153, - SW_FAULT_ID_MODE_PRE_TREATMENT_INVALID_STATE = 148, - SW_FAULT_ID_TD_AIR_PUMP_DUTY_CYCLE_OUT_OF_RANGE = 149, + SW_FAULT_ID_MODE_PRE_TREATMENT_INVALID_STATE = 154, + SW_FAULT_ID_TD_AIR_PUMP_DUTY_CYCLE_OUT_OF_RANGE = 155, + SW_FAULT_ID_INVALID_TREATMENT_MODALITY = 156, NUM_OF_SW_FAULT_IDS } SW_FAULT_ID_T; Index: firmware/App/Services/DDInterface.c =================================================================== diff -u -r6f02ff4686ec9dfc60247e9ed3fc9c5cc7771543 -r30e46b4f07697652455fa861bcaa18f3d60ae11f --- firmware/App/Services/DDInterface.c (.../DDInterface.c) (revision 6f02ff4686ec9dfc60247e9ed3fc9c5cc7771543) +++ firmware/App/Services/DDInterface.c (.../DDInterface.c) (revision 30e46b4f07697652455fa861bcaa18f3d60ae11f) @@ -105,8 +105,9 @@ dialysateDeliveryCmdSet.ufRate = 0.0F; dialysateDeliveryCmdSet.dialTemp = 0.0F; dialysateDeliveryCmdSet.bypassDialyzer = TRUE; - dialysateDeliveryCmdSet.acidType = 0; - dialysateDeliveryCmdSet.bicarbType = 0; + dialysateDeliveryCmdSet.acidConvFactor = 0.0F; + dialysateDeliveryCmdSet.sodium = 0; + dialysateDeliveryCmdSet.bicarbonate = 0; } /**********************************************************************//** @@ -297,15 +298,16 @@ * @param bicarb Type of bicarbonate concentrate used. * @return none *************************************************************************/ -void cmdStartGenerateDialysate( F32 qd, F32 quf, F32 dialTemp, BOOL bypass, ACID_CONCENTRATE_TYPE_T acid, BICARB_CONCENTRATE_TYPE_T bicarb ) +void cmdStartGenerateDialysate( F32 qd, F32 quf, F32 dialTemp, BOOL bypass, F32 acidConvFactor, U32 sodium, U32 bicarbonate ) { dialysateDeliveryCmdSet.start = TRUE; dialysateDeliveryCmdSet.dialRate = qd; dialysateDeliveryCmdSet.ufRate = quf; dialysateDeliveryCmdSet.dialTemp = dialTemp; dialysateDeliveryCmdSet.bypassDialyzer = bypass; - dialysateDeliveryCmdSet.acidType = (U32)acid; - dialysateDeliveryCmdSet.bicarbType = (U32)bicarb; + dialysateDeliveryCmdSet.acidConvFactor = acidConvFactor; + dialysateDeliveryCmdSet.sodium = sodium; + dialysateDeliveryCmdSet.bicarbonate = bicarbonate; #ifndef TEST_UI_ONLY sendMessage( MSG_ID_DD_GEN_DIALYSATE_REQUEST_DATA, COMM_BUFFER_OUT_CAN_TD_2_DD, (U08*)(&dialysateDeliveryCmdSet), sizeof( DIALYSATE_DELIVERY_REQ_PAYLOAD_T ) ); Index: firmware/App/Services/DDInterface.h =================================================================== diff -u -r395522dffef1348e176564925656012f529c1910 -r30e46b4f07697652455fa861bcaa18f3d60ae11f --- firmware/App/Services/DDInterface.h (.../DDInterface.h) (revision 395522dffef1348e176564925656012f529c1910) +++ firmware/App/Services/DDInterface.h (.../DDInterface.h) (revision 30e46b4f07697652455fa861bcaa18f3d60ae11f) @@ -55,7 +55,7 @@ BOOL setDDOpMode( MESSAGE_T *message ); BOOL setDialysatePressure( MESSAGE_T *message ); -void cmdStartGenerateDialysate( F32 qd, F32 quf, F32 dialTemp, BOOL bypass, ACID_CONCENTRATE_TYPE_T acid, BICARB_CONCENTRATE_TYPE_T bicarb ); +void cmdStartGenerateDialysate( F32 qd, F32 quf, F32 dialTemp, BOOL bypass, F32 acidConvFactor, U32 sodium, U32 bicarbonate ); void cmdChangeQd( F32 qd ); void cmdChangeQuf( F32 quf ); void cmdBypassDialyzer( BOOL bypass ); Index: firmware/App/Services/Messaging.c =================================================================== diff -u -r72bc0d5f33dbb07afc8a7cd9015e4861c6c371a1 -r30e46b4f07697652455fa861bcaa18f3d60ae11f --- firmware/App/Services/Messaging.c (.../Messaging.c) (revision 72bc0d5f33dbb07afc8a7cd9015e4861c6c371a1) +++ firmware/App/Services/Messaging.c (.../Messaging.c) (revision 30e46b4f07697652455fa861bcaa18f3d60ae11f) @@ -107,9 +107,7 @@ { MSG_ID_UI_CHECK_IN, &handleUICheckIn }, { MSG_ID_DD_OP_MODE_DATA, &setDDOpMode }, { MSG_ID_DD_PRESSURES_DATA, &setDialysatePressure }, - { MSG_ID_UI_TREATMENT_PARAMS_TO_VALIDATE, &validateAndSetTreatmentParameters }, - { MSG_ID_UI_ULTRAFILTRATION_VOLUME_TO_VALIDATE, &validateAndSetUFVolume }, - { MSG_ID_UI_TREATMENT_PARAMS_CONFIRMED, &signalUserConfirmationOfTreatmentParameters }, + { MSG_ID_UI_TREATMENT_PARAMS_CONFIRMED, &validateAndSetTreatmentParameters }, { MSG_ID_UI_INITIATE_TREATMENT_WORKFLOW, &signalUserInitiateTreatment }, { MSG_ID_UI_UF_PAUSE_RESUME_REQUEST, &signalPauseResumeUF }, { MSG_ID_TESTER_LOGIN_REQUEST, &handleTesterLogInRequest }, 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; } Index: firmware/App/Services/TxParams.h =================================================================== diff -u -r6f02ff4686ec9dfc60247e9ed3fc9c5cc7771543 -r30e46b4f07697652455fa861bcaa18f3d60ae11f --- firmware/App/Services/TxParams.h (.../TxParams.h) (revision 6f02ff4686ec9dfc60247e9ed3fc9c5cc7771543) +++ firmware/App/Services/TxParams.h (.../TxParams.h) (revision 30e46b4f07697652455fa861bcaa18f3d60ae11f) @@ -41,25 +41,31 @@ /// Record structure for a treatment parameters payload from UI. typedef struct { + U32 treatmentModality; ///< User set treatment modality option + U32 hdfDilution; ///< User set HDF dilution option U32 bloodFlowRate_mL_min; ///< User set blood flow rate (in mL/min) U32 dialysateFlowRate_mL_min; ///< User set dialysate flow rate (in mL/min) U32 treatmentDuration_min; ///< User set treatment duration (in min) - U32 salineBolusVolume_mL; ///< User set saline bolus volume (in mL) - U32 hepStopTime_min; ///< User set Heparin stop time (in min) + U32 hepDeliveryDuration_min; ///< User set Heparin delivery duration (in min) U32 hepType; ///< User set Heparin type option - U32 acidConcentrate; ///< User set acid concentrate option - U32 bicarbConcentrate; ///< User set bicarbonate concentrate option + U32 dryBicarbCartSize; ///< User set dry bicarb cart size option + U32 sodium_mEq_L; ///< User set sodium (in mEq/L) + U32 bicarbonate_mEq_L; ///< User set bicarbonate (in mEq/L) U32 dialyzerType; ///< User set dialyzer type option + U32 fluidBolusVolume_mL; ///< User set fluid bolus volume (in mL) U32 bpInterval_min; ///< User set blood pressure measurement interval (in min) - U32 rinsebackFlowRate_mL_min; ///< User set rinseback flow rate (in mL/min) + U32 primeDiscardVolume_mL; ///< User set prime discard flow rate (in mL) U32 rinsebackVolume_mL; ///< User set rinseback volume (in mL) - S32 arterialPressureLimitWindow_mmHg; ///< User set alarm limit window for arterial pressure (in mmHg) - S32 venousPressureLimitWindow_mmHg; ///< User set alarm limit window for venous pressure (in mmHg) - S32 venousPressureLimitAsymmetric_mmHg; ///< User set alarm limit asymmetric for venous pressure (in mmHg) - S32 tmpLimitWindow_mmHg; ///< User set alarm limit window for trans-membrane pressure (in mmHg) - F32 dialysateTemperature_degC; ///< User set dialysate temperature (in deg C) - F32 hepDispenseRate_mL_hr; ///< User set Heparin dispense rate (in mL/hr) + U32 hepatitisBStatus; ///< User set Hepatitis B status option + U32 acidConcentrate; ///< User set acid concentrate option + F32 substitutionFluidVolume_L; ///< User set substitution fluid volume (in L) F32 hepBolusVolume_mL; ///< User set Heparin bolus volume (in mL) + F32 hepDeliveryRate_mL_hr; ///< User set Heparin delivery rate (in mL/hr) + F32 dialysateTemperature_degC; ///< User set dialysate temperature (in deg C) + F32 acidKConcentrateConvFactor; ///< User set acid concentrate conversion factor + F32 ufPreWeight; ///< User set patient pre weight prior to treatment (in Kilogram) + F32 ufEstimatedTargetWeight; ///< User set patient estimated target weight after the treatment (in Kilogram) + F32 ufVolume; ///< User set ultrafiltration volume (in L) } TREATMENT_PARAMS_DATA_PAYLOAD_T; /// Record structure for reporting all current treatment parameters to Dialin @@ -83,33 +89,34 @@ // ********** public function prototypes **************** BOOL setTreatmentParameterU32( TREATMENT_PARAM_T param, U32 value ); // Set a specified unsigned integer treatment parameter value -BOOL setTreatmentParameterS32( TREATMENT_PARAM_T param, S32 value ); // Set a specified signed integer treatment parameter value BOOL setTreatmentParameterF32( TREATMENT_PARAM_T param, F32 value ); // Set a specified floating point treatment parameter value U32 getTreatmentParameterU32( TREATMENT_PARAM_T param ); // Get a specified unsigned integer treatment parameter -S32 getTreatmentParameterS32( TREATMENT_PARAM_T param ); // Get a specified signed integer treatment parameter F32 getTreatmentParameterF32( TREATMENT_PARAM_T param ); // Get a specified floating point treatment parameter -S32 getTreatmentParameterS32DefaultValue( TREATMENT_PARAM_T param ); // Get the default value for a specified signed integer treatment parameter BOOL validateAndSetTreatmentParameters( MESSAGE_T *message ); // User provided treatment params to be set and validated -BOOL validateAndSetUFVolume( MESSAGE_T *message ); // User provided ultrafiltration volume to be set and validated +//BOOL validateAndSetUFVolume( MESSAGE_T *message ); // User provided ultrafiltration volume to be set and validated void resetTreatmentParameters( void ); // Reset all parameters to defaults -BOOL signalUserConfirmationOfTreatmentParameters( MESSAGE_T *message ); // Process UI confirm/reject Treatment parameters +//BOOL signalUserConfirmationOfTreatmentParameters( MESSAGE_T *message ); // Process UI confirm/reject Treatment parameters BOOL getValidTreatParamsReceived( void ); // Determine whether valid Treatment Parameters exist BOOL getTreatParamsConfirmed( void ); // Determine whether user confirmed the parameters BOOL isTreatmentParamInRange( TREATMENT_PARAM_T param, CRITICAL_DATAS_T value ); // Check range for a proposed treatment parameter value -S32 getS32TreatmentParamLowerRangeLimit( TREATMENT_PARAM_T param ); // Get lower range limit for signed integer treatment parameter -S32 getS32TreatmentParamUpperRangeLimit( TREATMENT_PARAM_T param ); // Get upper range limit for signed integer treatment parameter +BOOL isSysConfigTreatmentParamInRange( SYS_CONFIG_TREATMENT_PARAM_T param ); // Check system config treatment parameter from institutional records are in range U32 getU32TreatmentParamLowerRangeLimit( TREATMENT_PARAM_T param ); // Get lower range limit for unsigned integer treatment parameter U32 getU32TreatmentParamUpperRangeLimit( TREATMENT_PARAM_T param ); // Get upper range limit for unsigned integer treatment parameter F32 getF32TreatmentParamLowerRangeLimit( TREATMENT_PARAM_T param ); // Get lower range limit for floating point treatment parameter F32 getF32TreatmentParamUpperRangeLimit( TREATMENT_PARAM_T param ); // Get upper range limit for floating point treatment parameter -S32 getS32DefaultTreatmentParamEdge( TREATMENT_PARAM_T param, BOOL isMin ); // Get default min/max edge for signed integer treatment parameter U32 getU32DefaultTreatmentParamEdge( TREATMENT_PARAM_T param, BOOL isMin ); // Get default min/max edge for unsigned integer treatment parameter F32 getF32DefaultTreatmentParamEdge( TREATMENT_PARAM_T param, BOOL isMin ); // Get default min/max edge for floating point treatment parameter +U32 getU32SysConfigTreatmentParamLowerRangeLimit( SYS_CONFIG_TREATMENT_PARAM_T param ); // Get lower range limit for unsigned integer system configured treatment parameter +U32 getU32SysConfigTreatmentParamUpperRangeLimit( SYS_CONFIG_TREATMENT_PARAM_T param ); // Get upper range limit for unsigned integer system configured treatment parameter +U32 getU32DefaultSysConfigTreatmentParamEdge( SYS_CONFIG_TREATMENT_PARAM_T param, BOOL isMin ); // Get default min/max edge for unsigned integer system configured treatment parameter +U32 getSysConfigTreatmentParameterU32( SYS_CONFIG_TREATMENT_PARAM_T param ); // Get a specified unsigned integer system configured treatment parameter +U32 getSysConfigTreatmentParameterU32DefaultValue( SYS_CONFIG_TREATMENT_PARAM_T param ); // Get the default value for a specified unsigned integer system configured treatment parameter + U32 getDialyzerBloodVolume( DIALYZER_TYPE_T dialyzer ); // Get the blood side volume for a given dialyzer type U32 getDialyzerDialysateVolume( DIALYZER_TYPE_T dialyzer ); // Get the dialysate side volume for a given dialyzer type