Index: firmware/App/HDCommon.h =================================================================== diff -u -r8fdca8ef380555c6c93e30b517258988333ffd89 -rc6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2 --- firmware/App/HDCommon.h (.../HDCommon.h) (revision 8fdca8ef380555c6c93e30b517258988333ffd89) +++ firmware/App/HDCommon.h (.../HDCommon.h) (revision c6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2) @@ -30,15 +30,15 @@ // ********** build switches ********** #ifndef _RELEASE_ -#define UF_TEST_ENABLED 1 // ultrafiltration test build (hard codes treatment params, re-purposes off/stop buttons) +//#define UF_TEST_ENABLED 1 // ultrafiltration test build (hard codes treatment params, re-purposes off/stop buttons) //#define UF_TEST_WITH_DG 1 // ultrafiltration test build (sets up DG in standby mode) #ifndef _VECTORCAST_ // #define RM46_EVAL_BOARD_TARGET 1 // limited build runs on RM46 eval board // #define BREADBOARD_TARGET 1 // old breadboard system build - no longer used? // #define SIMULATE_UI 1 // build w/o requirement that UI be there // #define TASK_TIMING_OUTPUT_ENABLED 1 // re-purposes alarm lamp pins for task timing -// #define SKIP_POST 1 // skip POST tests - all pass - #define LIMITED_NVDATA_CRC_CHECKS 1 // only perform POST CRC checks on nv-data records that are implemented so far + #define SKIP_POST 1 // skip POST tests - all pass +// #define LIMITED_NVDATA_CRC_CHECKS 1 // only perform POST CRC checks on nv-data records that are implemented so far // #define DISABLE_ACCELS 1 // disable accelerometer POST and monitoring #define DISABLE_CRC_ERROR 1 // do not error on bad CRC for CAN messages #define DISABLE_ACK_ERRORS 1 // do not error on failure of other node(s) to ACK a message @@ -51,7 +51,7 @@ // #define RAW_FLOW_SENSOR_DATA 1 // test build will not filter flow sensor data // #define READ_FPGA_ASYNC_DATA 1 // test build reads non-priority register page every other time // #define FLOW_DEBUG 1 // test build sends flow, signal strength, and occlusion readings to debug UART - #define EMC_TEST_BUILD 1 // EMC test build - HD/DG run separately but connected, HD pumps toggle on/off w/ stop button +// #define EMC_TEST_BUILD 1 // EMC test build - HD/DG run separately but connected, HD pumps toggle on/off w/ stop button #define ALARMS_DEBUG 1 // triggered alarms sent to debug UART #include Index: firmware/App/Modes/Dialysis.c =================================================================== diff -u -r9302e1bd2413cbf99e80ac51aac38502d94801d9 -rc6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2 --- firmware/App/Modes/Dialysis.c (.../Dialysis.c) (revision 9302e1bd2413cbf99e80ac51aac38502d94801d9) +++ firmware/App/Modes/Dialysis.c (.../Dialysis.c) (revision c6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2) @@ -168,8 +168,8 @@ { lastUFTimeStamp = getMSTimerCount(); setDialOutUFVolumes( refUFVolume, measUFVolume ); - setBloodPumpTargetFlowRate( setBloodFlowRate, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_CLOSED_LOOP ); - setDialInPumpTargetFlowRate( setDialysateFlowRate, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_CLOSED_LOOP ); + setBloodPumpTargetFlowRate( setBloodFlowRate, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP ); + setDialInPumpTargetFlowRate( setDialysateFlowRate, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP ); setDialOutPumpTargetRate( setDialysateFlowRate + (S32)setUFRate, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_CLOSED_LOOP ); // TODO - Heparin pump } Index: firmware/App/Modes/ModeStandby.c =================================================================== diff -u -r9302e1bd2413cbf99e80ac51aac38502d94801d9 -rc6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2 --- firmware/App/Modes/ModeStandby.c (.../ModeStandby.c) (revision 9302e1bd2413cbf99e80ac51aac38502d94801d9) +++ firmware/App/Modes/ModeStandby.c (.../ModeStandby.c) (revision c6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2) @@ -43,12 +43,14 @@ // ********** private data ********** -static HD_STANDBY_STATE_T currentStandbyState; ///< Current state (sub-mode) of standby mode. +static HD_STANDBY_STATE_T currentStandbyState; ///< Current state (sub-mode) of standby mode. +static BOOL treatStartReqReceived = FALSE; ///< Flag indicates user has requested initiation of a treatment + // ********** private function prototypes ********** -/************************************************************************* - * @brief initStandbyMode +/*********************************************************************//** + * @brief * The initStandbyMode function initializes the Standby Mode module. * @details * Inputs : none @@ -58,10 +60,11 @@ void initStandbyMode( void ) { currentStandbyState = STANDBY_START_STATE; + treatStartReqReceived = FALSE; } -/************************************************************************* - * @brief transitionToStandbyMode +/*********************************************************************//** + * @brief * The transitionToStandbyMode function prepares for transition to standby mode. * @details * Inputs : none @@ -74,21 +77,20 @@ initStandbyMode(); initDGInterface(); -#ifndef UF_TEST_ENABLED + // pumps should be off setBloodPumpTargetFlowRate( 0, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_CLOSED_LOOP ); setDialInPumpTargetFlowRate( 0, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_CLOSED_LOOP ); - setDialOutPumpTargetRate( 0, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP ); + setDialOutPumpTargetRate( 0, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_CLOSED_LOOP ); +#ifdef EMC_TEST_BUILD + enableValvesPIDControl(0); // enable valves #endif #ifdef RM46_EVAL_BOARD_TARGET start = getMSTimerCount(); #endif -#ifdef EMC_TEST_BUILD // TODO - test code - enableValvesPIDControl(0); // enable valves -#endif } -/************************************************************************* - * @brief execStandbyMode +/*********************************************************************//** + * @brief * The execStandbyMode function executes the Standby Mode state machine. * @details * Inputs : none @@ -101,7 +103,7 @@ static U32 toggle = 0; static BOOL button_state = FALSE; #endif -BOOL stop = isStopButtonPressed(); + BOOL stop = isStopButtonPressed(); DG_OP_MODE_T dgOpMode = getDGOpMode(); // TODO - the DG mode & sub-mode come as a pair at interval - they MUST be kept together. U32 dgSubMode = getDGSubMode(); @@ -200,14 +202,19 @@ switch ( currentStandbyState ) { case STANDBY_START_STATE: + currentStandbyState = STANDBY_WAIT_FOR_TREATMENT_STATE; // temporary test code - TODO - remove later homeBloodPump(); homeDialInPump(); homeDialOutPump(); - currentStandbyState = STANDBY_WAIT_FOR_TREATMENT_STATE; break; case STANDBY_WAIT_FOR_TREATMENT_STATE: + if ( TRUE == treatStartReqReceived ) + { + requestNewOperationMode( MODE_TPAR ); + treatStartReqReceived = FALSE; + } // TODO - test code if ( TRUE == stop ) { @@ -255,8 +262,6 @@ break; } } -#else - requestNewOperationMode( MODE_TPAR ); #endif } #ifdef EMC_TEST_BUILD @@ -281,4 +286,26 @@ return currentStandbyState; } +/*********************************************************************//** + * @brief + * The signalUserStartingTreatment function handles user initiation of a \n + * treatment. + * @details + * Inputs : none + * Outputs : requested mode transition to treatment parameters mode + * @return TRUE if signal accepted, FALSE if not + *************************************************************************/ +BOOL signalUserStartingTreatment( void ) +{ + BOOL result = FALSE; + + if ( ( MODE_STAN == getCurrentOperationMode() ) && ( STANDBY_WAIT_FOR_TREATMENT_STATE == currentStandbyState ) ) + { + treatStartReqReceived = TRUE; + result = TRUE; + } + + return result; +} + /**@}*/ Index: firmware/App/Modes/ModeStandby.h =================================================================== diff -u -rde5a0d43bdef611d963d11855bc958a8d8899a09 -rc6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2 --- firmware/App/Modes/ModeStandby.h (.../ModeStandby.h) (revision de5a0d43bdef611d963d11855bc958a8d8899a09) +++ firmware/App/Modes/ModeStandby.h (.../ModeStandby.h) (revision c6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2) @@ -35,6 +35,8 @@ void transitionToStandbyMode( void ); // prepares for transition to standby mode U32 execStandbyMode( void ); // execute the standby mode state machine (call from OperationModes) +BOOL signalUserStartingTreatment( void ); // User has initiated a treatment - go to treatment parameters mode + /**@}*/ #endif Index: firmware/App/Modes/ModeTreatmentParams.c =================================================================== diff -u -r9302e1bd2413cbf99e80ac51aac38502d94801d9 -rc6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2 --- firmware/App/Modes/ModeTreatmentParams.c (.../ModeTreatmentParams.c) (revision 9302e1bd2413cbf99e80ac51aac38502d94801d9) +++ firmware/App/Modes/ModeTreatmentParams.c (.../ModeTreatmentParams.c) (revision c6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2) @@ -22,44 +22,82 @@ #include "DialOutFlow.h" #include "ModeTreatmentParams.h" #include "OperationModes.h" +#include "SystemCommMessages.h" #include "Utilities.h" #ifdef RM46_EVAL_BOARD_TARGET #include "Timers.h" static U32 start; #endif - /** - * @addtogroup HDTreatmentParamsMode - * @{ - */ +/** + * @addtogroup HDTreatmentParamsMode + * @{ + */ // ********** private definitions ********** +#define MAX_DIALYSATE_VOLUME_ML ( 150 * ML_PER_LITER ) ///< Maximum dialysate volume (in mL) +#define MIN_PRESSURE_ALARM_LIMIT_DELTA_MMHG ( 25 ) ///< Minimum pressure alarm limit delta (in mmHg) + +/// Record for range and default of treatment parameters. +typedef struct +{ + CRITICAL_DATA_TYPES_T dataType; ///< Data type for the treatment parameter + CRITICAL_DATAS_T min; ///< minimum of range + CRITICAL_DATAS_T max; ///< maximum of range + CRITICAL_DATAS_T def; ///< default value +} TREATMENT_PARAMS_PROPERTIES_T; + // ********** private data ********** -static HD_TREATMENT_PARAMS_MODE_STATE_T treatParamsState; ///< Current state of treatment parameters mode state machine. +static HD_TREATMENT_PARAMS_MODE_STATE_T currentTreatmentParamsState; ///< Current state of treatment parameters mode state machine. +/// Treatment parameter properties (types, ranges and defaults). +const TREATMENT_PARAMS_PROPERTIES_T treatParamsRanges[ NUM_OF_TREATMENT_PARAMS ] = +{ + { CRITICAL_DATA_TYPE_U32, {.uInt=100}, {.uInt=1500}, {.uInt=10} }, // TREATMENT_PARAM_BLOOD_FLOW + { CRITICAL_DATA_TYPE_U32, {.uInt=100}, {.uInt=1600}, {.uInt=10} }, // TREATMENT_PARAM_DIALYSATE_FLOW + { CRITICAL_DATA_TYPE_U32, {.uInt=60}, {.uInt=1480}, {.uInt=10} }, // TREATMENT_PARAM_TREATMENT_DURATION + { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=1120}, {.uInt=10} }, // TREATMENT_PARAM_HEPARIN_PRE_STOP_TIME + { CRITICAL_DATA_TYPE_U32, {.uInt=100}, {.uInt=1300}, {.uInt=1100} }, // TREATMENT_PARAM_SALINE_BOLUS_VOLUME + { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=12}, {.uInt=10} }, // TREATMENT_PARAM_ACID_CONCENTRATE + { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=10}, {.uInt=10} }, // TREATMENT_PARAM_BICARB_CONCENTRATE + { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=13}, {.uInt=10} }, // TREATMENT_PARAM_DIALYZER_TYPE + { CRITICAL_DATA_TYPE_S32, {.sInt=-300}, {.sInt=200}, {.sInt=-300} }, // TREATMENT_PARAM_ART_PRESSURE_LOW_LIMIT + { CRITICAL_DATA_TYPE_S32, {.sInt=-300}, {.sInt=200}, {.sInt=100} }, // TREATMENT_PARAM_ART_PRESSURE_HIGH_LIMIT + { CRITICAL_DATA_TYPE_S32, {.sInt=-100}, {.sInt=600}, {.sInt=-100} }, // TREATMENT_PARAM_VEN_PRESSURE_LOW_LIMIT + { CRITICAL_DATA_TYPE_S32, {.sInt=-100}, {.sInt=600}, {.sInt=400} }, // TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT + { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=160}, {.uInt=130} }, // TREATMENT_PARAM_BP_MEAS_INTERVAL + { CRITICAL_DATA_TYPE_U32, {.uInt=50}, {.uInt=1150}, {.uInt=175} }, // TREATMENT_PARAM_RINSEBACK_FLOW_RATE + { CRITICAL_DATA_TYPE_F32, {.sFlt=0.0}, {.sFlt=1.0}, {.sFlt=0.0} }, // TREATMENT_PARAM_HEPARIN_DISPENSE_RATE + { CRITICAL_DATA_TYPE_F32, {.sFlt=0.0}, {.sFlt=2.0}, {.sFlt=0.0} }, // TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME + { 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=8.0}, {.sFlt=0.0} }, // TREATMENT_PARAM_UF_VOLUME +}; + // 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. // original treatment parameter values (for those that can be changed during treatment) -static U32 origBloodFlowRate_mL_min; ///< Originally set (before treatment) blood flow rate (in mL/min). -static U32 origDialysateFlowRate_mL_min; ///< Originally set (before treatment) dialysate flow rate (in mL/min). -static U32 origTreatmentDuration_min; ///< Originally set (before treatment) treatment duration (in min). -static U32 origArterialPressureLowLimit_mmHg; ///< Originally set (before treatment) arterial pressure lower alarm limit (in mmHg). -static U32 origArterialPressureHighLimit_mmHg; ///< Originally set (before treatment) arterial pressure upper alarm limit (in mmHg). -static U32 origVenousPressureLowLimit_mmHg; ///< Originally set (before treatment) venous pressure lower alarm limit (in mmHg). -static U32 origVenousPressureHighLimit_mmHg; ///< Originally set (before treatment) venous pressure upper alarm limit (in mmHg). -static F32 origUFVolume_L; ///< Originally set (before treatment) ultrafiltration volume (in liters). +static ADJ_TREATMENT_PARAMS_T origTreatmentParams; ///< Originally set (before treatment) treatment parameters. +static BOOL validTreatParamsReceived = FALSE; ///< Flag indicates user has provided treatment parameters. +static BOOL treatParamsConfirmed = FALSE; ///< Flag indicates user has confirmed the treatment parameters. +static BOOL treatmentCancelled = FALSE; ///< Flag indicates user has cancelled the treatment. + // ********** private function prototypes ********** static void resetAllTreatmentParameters( void ); static HD_TREATMENT_PARAMS_MODE_STATE_T handleWaitForUI2SendState( void ); static HD_TREATMENT_PARAMS_MODE_STATE_T handleWaitForUI2ConfirmState( void ); +static BOOL checkTreatmentParamsInRange( U32 *reasons ); +static BOOL checkTreatmentParamsDependencies( U32 *reasons ); +static BOOL isTreatmentParamInRange( TREATMENT_PARAM_T param, CRITICAL_DATAS_T value ); +static void extractTreatmentParamsFromPayload( TREATMENT_PARAMS_DATA_PAYLOAD_T payload ); -/************************************************************************* - * @brief initOpParamsMode +/*********************************************************************//** + * @brief * The initOpParamsMode function initializes the Operating Parameters Mode module. * @details * Inputs : none @@ -68,113 +106,449 @@ *************************************************************************/ void initTreatParamsMode( void ) { - treatParamsState = HD_TREATMENT_PARAMS_MODE_STATE_START; + currentTreatmentParamsState = HD_TREATMENT_PARAMS_MODE_STATE_START; } -/************************************************************************* - * @brief transitionToOpParamsMode +/*********************************************************************//** + * @brief * The transitionToOpParamsMode function prepares for transition to operating \n * parameters mode. * @details * Inputs : none - * Outputs : + * Outputs : Treatment Parameters mode reset prior to starting * @return none *************************************************************************/ void transitionToTreatParamsMode( void ) { // reset all treatment parameters when transitioning to this mode resetAllTreatmentParameters(); + validTreatParamsReceived = FALSE; + treatParamsConfirmed = FALSE; + treatmentCancelled = FALSE; + // temporary test code. TODO - remove later -#ifndef UF_TEST_ENABLED - setBloodPumpTargetFlowRate( 300, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP ); - setDialInPumpTargetFlowRate( 300, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP ); - setDialOutPumpTargetRate( 325, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP ); -#endif #ifdef RM46_EVAL_BOARD_TARGET start = getMSTimerCount(); #endif } +/*********************************************************************//** + * @brief + * The resetAllTreatmentParameters function resets treatment parameters \n + * to default values. + * @details + * Inputs : none + * Outputs : All treatment parameters reset to default values. + * @return none + *************************************************************************/ static void resetAllTreatmentParameters( void ) { - U32 i; + U32 param; - for ( i = 0; i < NUM_OF_TREATMENT_PARAMS; i++ ) + for ( param = 0; param < NUM_OF_TREATMENT_PARAMS; param++ ) { - resetCriticalData( &treatmentParameters[ i ] ); + resetCriticalData( &treatmentParameters[ param ] ); + // set each treatment parameter to default value + setCriticalData( &treatmentParameters[ param ], treatParamsRanges[ param ].def ); + // set staged parameter values to zero + stagedParams[ param ].uInt = 0; } - origBloodFlowRate_mL_min = 0; - origDialysateFlowRate_mL_min = 0; - origTreatmentDuration_min = 0; - origArterialPressureLowLimit_mmHg = 0; - origArterialPressureHighLimit_mmHg = 0; - origVenousPressureLowLimit_mmHg = 0; - origVenousPressureHighLimit_mmHg = 0; - origUFVolume_L = 0.0; + // zero original parameter values + origTreatmentParams.bloodFlowRate_mL_min = 0; + origTreatmentParams.dialysateFlowRate_mL_min = 0; + origTreatmentParams.treatmentDuration_min = 0; + origTreatmentParams.arterialPressureLowLimit_mmHg = 0; + origTreatmentParams.arterialPressureHighLimit_mmHg = 0; + origTreatmentParams.venousPressureLowLimit_mmHg = 0; + origTreatmentParams.venousPressureHighLimit_mmHg = 0; + origTreatmentParams.uFVolume_L = 0.0; } -/************************************************************************* - * @brief execOpParamsMode - * The execFaultMode function executes the Operating Parameters Mode state machine. +/*********************************************************************//** + * @brief + * The signalUserConfirmationOfTreatmentParameters function sets the user \n + * confirmation flag signaling user has confirmed treatment parameters. * @details * Inputs : none - * Outputs : - * @return current state (sub-mode) + * Outputs : treatParamsConfirmed + * @return TRUE if confirmation accepted, FALSE if not *************************************************************************/ -U32 execTreatParamsMode( void ) +BOOL signalUserConfirmationOfTreatmentParameters( void ) { - BOOL stop = isStopButtonPressed(); + BOOL result = FALSE; -#ifdef UF_TEST_ENABLED - requestNewOperationMode( MODE_PRET ); -#endif -#ifdef RM46_EVAL_BOARD_TARGET - if ( TRUE == didTimeout( start, 5000U ) ) + if ( ( MODE_TPAR == getCurrentOperationMode() ) && ( HD_TREATMENT_PARAMS_MODE_STATE_WAIT_4_UI_2_CONFIRM == currentTreatmentParamsState ) ) { - requestNewOperationMode( MODE_PRET ); + treatParamsConfirmed = TRUE; + result = TRUE; } -#endif + return result; +} + +/*********************************************************************//** + * @brief + * The signalUserCancelTreatment function sets the cancelled treatment \n + * flag signaling the user has cancelled the treatment. + * @details + * Inputs : none + * Outputs : treatmentCancelled + * @return TRUE if cancel accepted, FALSE if not + *************************************************************************/ +BOOL signalUserCancelTreatment( void ) +{ + BOOL result = FALSE; + + if ( MODE_TPAR == getCurrentOperationMode() ) + { + treatmentCancelled = TRUE; + result = TRUE; + } + + return result; +} + +/*********************************************************************//** + * @brief + * The execFaultMode function executes the Operating Parameters Mode state machine. + * @details + * Inputs : treatParamsState + * Outputs : treatParamsState + * @return current state (sub-mode) + *************************************************************************/ +U32 execTreatParamsMode( void ) +{ + BOOL stop = isStopButtonPressed(); + #ifndef UF_TEST_ENABLED // execute mode state machine - switch ( treatParamsState ) + switch ( currentTreatmentParamsState ) { case HD_TREATMENT_PARAMS_MODE_STATE_START: - treatParamsState = HD_TREATMENT_PARAMS_MODE_STATE_WAIT_4_UI_2_SEND; + currentTreatmentParamsState = HD_TREATMENT_PARAMS_MODE_STATE_WAIT_4_UI_2_SEND; break; case HD_TREATMENT_PARAMS_MODE_STATE_WAIT_4_UI_2_SEND: + currentTreatmentParamsState = handleWaitForUI2SendState(); break; case HD_TREATMENT_PARAMS_MODE_STATE_WAIT_4_UI_2_CONFIRM: + currentTreatmentParamsState = handleWaitForUI2ConfirmState(); break; default: // TODO - s/w fault break; } +#else + requestNewOperationMode( MODE_PRET ); #endif +#ifdef RM46_EVAL_BOARD_TARGET + if ( TRUE == didTimeout( start, 5000U ) ) + { + requestNewOperationMode( MODE_PRET ); + } +#endif - return (U32)treatParamsState; + return (U32)currentTreatmentParamsState; } +/*********************************************************************//** + * @brief + * The handleWaitForUI2SendState function handles the wait for UI to send \n + * treatment parameters state of treatment parameters mode. + * @details + * Inputs : + * Outputs : + * @return current state (sub-mode) + *************************************************************************/ static HD_TREATMENT_PARAMS_MODE_STATE_T handleWaitForUI2SendState( void ) { HD_TREATMENT_PARAMS_MODE_STATE_T result = HD_TREATMENT_PARAMS_MODE_STATE_WAIT_4_UI_2_SEND; + if ( TRUE == treatmentCancelled ) + { + // go back to standby mode + requestNewOperationMode( MODE_STAN ); + + treatmentCancelled = FALSE; + } + else if ( TRUE == validTreatParamsReceived ) + { + // go to wait for user confirmation state + result = HD_TREATMENT_PARAMS_MODE_STATE_WAIT_4_UI_2_CONFIRM; + + validTreatParamsReceived = FALSE; + } + return result; } +/*********************************************************************//** + * @brief + * The handleWaitForUI2ConfirmState function handles the wait for UI to send \n + * user confirmation state of treatment parameters mode. + * @details + * Inputs : + * Outputs : + * @return current state (sub-mode) + *************************************************************************/ static HD_TREATMENT_PARAMS_MODE_STATE_T handleWaitForUI2ConfirmState( void ) { HD_TREATMENT_PARAMS_MODE_STATE_T result = HD_TREATMENT_PARAMS_MODE_STATE_WAIT_4_UI_2_CONFIRM; + // if user confirms treatment parameters, set them + if ( TRUE == treatParamsConfirmed ) + { + TREATMENT_PARAM_T param; + + // set all treatment parameters (except UF volume which is not yet received) + for ( param = TREATMENT_PARAM_FIRST_U32; param < TREATMENT_PARAM_UF_VOLUME; param++ ) + { + setCriticalData( &treatmentParameters[ param ], stagedParams[ param ] ); + } + // retain original settings for treatment that may be adjusted later during treatment + origTreatmentParams.bloodFlowRate_mL_min = treatmentParameters[ TREATMENT_PARAM_BLOOD_FLOW ].data.uInt; + origTreatmentParams.dialysateFlowRate_mL_min = treatmentParameters[ TREATMENT_PARAM_DIALYSATE_FLOW ].data.uInt; + origTreatmentParams.treatmentDuration_min = treatmentParameters[ TREATMENT_PARAM_TREATMENT_DURATION ].data.uInt; + origTreatmentParams.arterialPressureLowLimit_mmHg = treatmentParameters[ TREATMENT_PARAM_ART_PRESSURE_LOW_LIMIT ].data.sInt; + origTreatmentParams.arterialPressureHighLimit_mmHg = treatmentParameters[ TREATMENT_PARAM_ART_PRESSURE_HIGH_LIMIT ].data.sInt; + origTreatmentParams.venousPressureLowLimit_mmHg = treatmentParameters[ TREATMENT_PARAM_VEN_PRESSURE_LOW_LIMIT ].data.sInt; + origTreatmentParams.venousPressureHighLimit_mmHg = treatmentParameters[ TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT ].data.sInt; + + // go to pre-treatment mode + requestNewOperationMode( MODE_PRET ); + + treatParamsConfirmed = FALSE; + } + else if ( TRUE == treatmentCancelled ) + { + // go back to standby mode + requestNewOperationMode( MODE_STAN ); + + treatmentCancelled = FALSE; + } + return result; } +/*********************************************************************//** + * @brief + * The validateAndSetTreatmentParameters function validates received \n + * treatment parameters. + * @details + * Inputs : none + * Outputs : stagedParams[], response sent + * @param params payload record from treatment parameters message received from UI + * @return TRUE if received treatment parameters are valid, FALSE if not + *************************************************************************/ +BOOL validateAndSetTreatmentParameters( TREATMENT_PARAMS_DATA_PAYLOAD_T params ) +{ + BOOL paramsAreValid = FALSE; + BOOL paramsAreInRange, paramsAreConsistent; + U32 rejReasons[ NUM_OF_TREATMENT_PARAMS ]; + + // extract treatment parameters from given payload to staging array so we can more easily work with them + extractTreatmentParamsFromPayload( params ); + + // range check each treatment parameter + paramsAreInRange = checkTreatmentParamsInRange( &rejReasons[0] ); + + // validate dependencies + paramsAreConsistent = checkTreatmentParamsDependencies( &rejReasons[0] ); + + // determine overall validity of received treatment parameters + if ( ( TRUE == paramsAreInRange ) && ( TRUE == paramsAreConsistent ) ) + { + paramsAreValid = TRUE; + validTreatParamsReceived = TRUE; + } + + // respond to set treatment parameters request message + sendTreatmentParametersResponseMsg( paramsAreValid, (U08*)(&rejReasons[0]), + ( NUM_OF_TREATMENT_PARAMS - 1 ) * sizeof(U32) ); // UF vol. param not included in reject reasons + + return paramsAreValid; +} + +/*********************************************************************//** + * @brief + * The checkTreatmentParamsInRange function checks whether received \n + * treatment parameters are in range. + * @details + * Inputs : stagedParams[] + * Outputs : reasons[] + * @param reasons Pointer to array of reject reason codes for each parameter + * @return TRUE if treatment parameters are in range, FALSE if not + *************************************************************************/ +static BOOL checkTreatmentParamsInRange( U32 *reasons ) +{ + BOOL result = TRUE; + TREATMENT_PARAM_T param; + + // range check treatment parameters up to (but not including) UF volume + for ( param = TREATMENT_PARAM_FIRST_U32; param < TREATMENT_PARAM_UF_VOLUME; param++ ) + { + BOOL isParamInRange = isTreatmentParamInRange( param, stagedParams[ param ] ); + + reasons[ param ] = ( TRUE == isParamInRange ? REQUEST_REJECT_REASON_NONE : REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE ); + if ( FALSE == isParamInRange ) + { + result = FALSE; + } + } + + return result; +} + +/*********************************************************************//** + * @brief + * The checkTreatmentParamsDependencies function checks dependencies between \n + * received treatment parameters. + * @details + * Inputs : stagedParams[] + * Outputs : reasons[] + * @param reasons Pointer to array of reject reason codes for each parameter + * @return TRUE if treatment parameter dependencies are ok, FALSE if not + *************************************************************************/ +static BOOL checkTreatmentParamsDependencies( U32 *reasons ) +{ + BOOL result = TRUE; + U32 dialysateVolume_mL = stagedParams[ TREATMENT_PARAM_DIALYSATE_FLOW ].uInt * \ + stagedParams[ TREATMENT_PARAM_TREATMENT_DURATION ].uInt; + S32 arterialPresLimitDelta = stagedParams[ TREATMENT_PARAM_ART_PRESSURE_HIGH_LIMIT ].sInt - \ + stagedParams[ TREATMENT_PARAM_ART_PRESSURE_LOW_LIMIT ].sInt; + S32 venousPresLimitDelta = stagedParams[ TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT ].sInt - \ + stagedParams[ TREATMENT_PARAM_VEN_PRESSURE_LOW_LIMIT ].sInt; + + // check max dialysate volume dependency + if ( dialysateVolume_mL > MAX_DIALYSATE_VOLUME_ML ) + { + reasons[ TREATMENT_PARAM_DIALYSATE_FLOW ] = REQUEST_REJECT_REASON_DIAL_VOLUME_OUT_OF_RANGE; + result = FALSE; + } + + // check Heparin pre-stop vs. treatment duration + if ( stagedParams[ TREATMENT_PARAM_HEPARIN_PRE_STOP_TIME ].uInt > stagedParams[ TREATMENT_PARAM_TREATMENT_DURATION ].uInt ) + { + reasons[ TREATMENT_PARAM_HEPARIN_PRE_STOP_TIME ] = REQUEST_REJECT_REASON_HEPARIN_PRESTOP_EXCEEDS_DURATION; + result = FALSE; + } + + // check arterial alarm limits dependency + if ( arterialPresLimitDelta < MIN_PRESSURE_ALARM_LIMIT_DELTA_MMHG ) + { + reasons[ TREATMENT_PARAM_ART_PRESSURE_LOW_LIMIT ] = REQUEST_REJECT_REASON_ARTERIAL_PRESSURE_LOW_VS_HIGH; + reasons[ TREATMENT_PARAM_ART_PRESSURE_HIGH_LIMIT ] = REQUEST_REJECT_REASON_ARTERIAL_PRESSURE_LOW_VS_HIGH; + result = FALSE; + } + + // check venous alarm limits dependency + if ( venousPresLimitDelta < MIN_PRESSURE_ALARM_LIMIT_DELTA_MMHG ) + { + reasons[ TREATMENT_PARAM_VEN_PRESSURE_LOW_LIMIT ] = REQUEST_REJECT_REASON_VENOUS_PRESSURE_LOW_VS_HIGH; + reasons[ TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT ] = REQUEST_REJECT_REASON_VENOUS_PRESSURE_LOW_VS_HIGH; + result = FALSE; + } + + // TODO - check BP measurement interval when cuff connection status is provided by UI (min goes up to 15 if cuff connected, interval must be zero if not) + + return result; +} + +/*********************************************************************//** + * @brief + * The isTreatmentParamInRange function determines whether a given treatment \n + * parameter is in range. + * @details + * Inputs : treatParamsRanges[] + * Outputs : none + * @param param ID of parameter to check range for + * @param value value of parameter to check range for + * @return TRUE if given treatment parameter is in range, FALSE if not + *************************************************************************/ +static BOOL isTreatmentParamInRange( TREATMENT_PARAM_T param, CRITICAL_DATAS_T value ) +{ + BOOL result = FALSE; + + switch ( treatParamsRanges[ param ].dataType ) + { + case CRITICAL_DATA_TYPE_U32: + if ( value.uInt >= treatParamsRanges[ param ].min.uInt && value.uInt <= treatParamsRanges[ param ].max.uInt ) + { + result = TRUE; + } + break; + + case CRITICAL_DATA_TYPE_S32: + if ( value.sInt >= treatParamsRanges[ param ].min.sInt && value.sInt <= treatParamsRanges[ param ].max.sInt ) + { + result = TRUE; + } + break; + + case CRITICAL_DATA_TYPE_F32: + if ( value.sFlt >= treatParamsRanges[ param ].min.sFlt && value.sFlt <= treatParamsRanges[ param ].max.sFlt ) + { + result = TRUE; + } + break; + + default: + // TODO - s/w fault + break; + } + + return result; +} + +/*********************************************************************//** + * @brief + * The extractTreatmentParamsFromPayload function extracts the individual \n + * treatment parameters received from the UI into a staging array where \n + * they will be validated and stay until user confirms them. + * @details + * Inputs : none + * Outputs : stagedParams[] + * @param payload message payload record containing received treatment parameters + * @return none + *************************************************************************/ +static void extractTreatmentParamsFromPayload( TREATMENT_PARAMS_DATA_PAYLOAD_T payload ) +{ + // pull treatment parameters into data array so we can more easily work with them + stagedParams[ TREATMENT_PARAM_BLOOD_FLOW ].uInt = payload.bloodFlowRate_mL_min; + stagedParams[ TREATMENT_PARAM_DIALYSATE_FLOW ].uInt = payload.dialysateFlowRate_mL_min; + stagedParams[ TREATMENT_PARAM_TREATMENT_DURATION ].uInt = payload.treatmentDuration_min; + stagedParams[ TREATMENT_PARAM_HEPARIN_PRE_STOP_TIME ].uInt = payload.heparinPreStop_min; + stagedParams[ TREATMENT_PARAM_SALINE_BOLUS_VOLUME ].uInt = payload.salineBolusVolume_mL; + stagedParams[ TREATMENT_PARAM_ACID_CONCENTRATE ].uInt = payload.acidConcentrate; + stagedParams[ TREATMENT_PARAM_BICARB_CONCENTRATE ].uInt = payload.bicarbConcentrate; + stagedParams[ TREATMENT_PARAM_DIALYZER_TYPE ].uInt = payload.dialyzerType; + stagedParams[ TREATMENT_PARAM_ART_PRESSURE_LOW_LIMIT ].sInt = payload.arterialPressureLowLimit_mmHg; + stagedParams[ TREATMENT_PARAM_ART_PRESSURE_HIGH_LIMIT ].sInt = payload.arterialPressureHighLimit_mmHg; + stagedParams[ TREATMENT_PARAM_VEN_PRESSURE_LOW_LIMIT ].sInt = payload.venousPressureLowLimit_mmHg; + stagedParams[ TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT ].sInt = payload.venousPressureHighLimit_mmHg; + stagedParams[ TREATMENT_PARAM_BP_MEAS_INTERVAL ].uInt = payload.bloodPressureMeasurementInterval_min; + stagedParams[ TREATMENT_PARAM_RINSEBACK_FLOW_RATE ].uInt = payload.rinsebackFlowRate_mL_min; + stagedParams[ TREATMENT_PARAM_HEPARIN_DISPENSE_RATE ].sFlt = payload.heparinDispenseRate_mL_hr; + stagedParams[ TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME ].sFlt = payload.heparinBolusVolume_mL; + stagedParams[ TREATMENT_PARAM_DIALYSATE_TEMPERATURE ].sFlt = payload.dialysateTemperature_degC; +} + +/*********************************************************************//** + * @brief + * The setTreatmentParameterU32 function sets a given unsigned integer \n + * treatment parameter to a given value. + * @details + * Inputs : treatmentParameters[] + * Outputs : treatmentParameters[] + * @param param ID of treatment parameter to set unsigned integer value for + * @param value unsigned integer value to assign to given treatment parameter + * @return none + *************************************************************************/ void setTreatmentParameterU32( TREATMENT_PARAM_T param, U32 value ) { // validate parameter @@ -191,14 +565,52 @@ } } +/*********************************************************************//** + * @brief + * The setTreatmentParameterS32 function sets a given signed integer treatment \n + * parameter to a given value. + * @details + * Inputs : treatmentParameters[] + * 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 none + *************************************************************************/ +void setTreatmentParameterS32( TREATMENT_PARAM_T param, S32 value ) +{ + // validate parameter + if ( param <= TREATMENT_PARAM_LAST_U32 ) + { + CRITICAL_DATAS_T data = treatmentParameters[ param ].data; + + data.sInt = value; + setCriticalData( &treatmentParameters[ param ], data ); + } + else + { + // TODO - s/w fault + } +} + +/*********************************************************************//** + * @brief + * The setTreatmentParameterF32 sets a given floating point treatment parameter \n + * to a given value. + * @details + * Inputs : treatmentParameters[] + * Outputs : treatmentParameters[] + * @param param ID of treatment parameter to set floating point value for + * @param value floating point value to assign to given treatment parameter + * @return none + *************************************************************************/ void setTreatmentParameterF32( TREATMENT_PARAM_T param, F32 value ) { // validate parameter if ( param >= TREATMENT_PARAM_FIRST_F32 && param < NUM_OF_TREATMENT_PARAMS ) { CRITICAL_DATAS_T data = treatmentParameters[ param ].data; - data.flt = value; + data.sFlt = value; setCriticalData( &treatmentParameters[ param ], data ); } else @@ -207,6 +619,16 @@ } } +/*********************************************************************//** + * @brief + * The getTreatmentParameterU32 function gets the value of a given unsigned \n + * integer treatment parameter. + * @details + * Inputs : treatmentParameters[] + * Outputs : none + * @param param ID of treatment parameter to get unsigned integer value for + * @return value of given unsigned integer treatment parameter + *************************************************************************/ U32 getTreatmentParameterU32( TREATMENT_PARAM_T param ) { U32 result = 0; @@ -226,16 +648,26 @@ return result; } -F32 getTreatmentParameterF32( TREATMENT_PARAM_T param ) +/*********************************************************************//** + * @brief + * The getTreatmentParameterS32 function gets the value of a given signed \n + * integer treatment parameter. + * @details + * Inputs : treatmentParameters[] + * 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 ) { - F32 result = 0.0; + S32 result = 0; // validate parameter - if ( param >= TREATMENT_PARAM_FIRST_F32 && param < NUM_OF_TREATMENT_PARAMS ) + if ( param <= TREATMENT_PARAM_LAST_U32 ) { CRITICAL_DATAS_T data = getCriticalData( &treatmentParameters[ param ] ); - result = data.flt; + result = data.sInt; } else { @@ -245,44 +677,33 @@ return result; } -U32 getOrigBloodFlowRate_mL_min( void ) +/*********************************************************************//** + * @brief + * The getTreatmentParameterF32 function gets the value of a given floating point \n + * treatment parameter. + * @details + * Inputs : treatmentParameters[] + * Outputs : none + * @param param ID of treatment parameter to get floating point value for + * @return value of given floating point treatment parameter + *************************************************************************/ +F32 getTreatmentParameterF32( TREATMENT_PARAM_T param ) { - return origBloodFlowRate_mL_min; -} + F32 result = 0.0; -U32 getOrigDialysateFlowRate_mL_min( void ) -{ - return origDialysateFlowRate_mL_min; -} + // validate parameter + if ( param >= TREATMENT_PARAM_FIRST_F32 && param < NUM_OF_TREATMENT_PARAMS ) + { + CRITICAL_DATAS_T data = getCriticalData( &treatmentParameters[ param ] ); -U32 getOrigTreatmentDuration_min( void ) -{ - return origTreatmentDuration_min; -} + result = data.sFlt; + } + else + { + // TODO - s/w fault + } -U32 getOrigArterialPressureLowLimit_mmHg( void ) -{ - return origArterialPressureLowLimit_mmHg; + return result; } -U32 getOrigArterialPressureHighLimit_mmHg( void ) -{ - return origArterialPressureHighLimit_mmHg; -} - -U32 getOrigVenousPressureLowLimit_mmHg( void ) -{ - return origVenousPressureLowLimit_mmHg; -} - -U32 getOrigVenousPressureHighLimit_mmHg( void ) -{ - return origVenousPressureHighLimit_mmHg; -} - -F32 getOrigUFVolume_L( void ) -{ - return origUFVolume_L; -} - /**@}*/ Index: firmware/App/Modes/ModeTreatmentParams.h =================================================================== diff -u -rc84daa1f07003427fc5cdde8f5651434478f7313 -rc6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2 --- firmware/App/Modes/ModeTreatmentParams.h (.../ModeTreatmentParams.h) (revision c84daa1f07003427fc5cdde8f5651434478f7313) +++ firmware/App/Modes/ModeTreatmentParams.h (.../ModeTreatmentParams.h) (revision c6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2) @@ -54,30 +54,88 @@ TREATMENT_PARAM_FIRST_F32 = TREATMENT_PARAM_HEPARIN_DISPENSE_RATE, ///< First floating point treatment parameter TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME, ///< Heparin bolus volume (in mL) TREATMENT_PARAM_DIALYSATE_TEMPERATURE, ///< Dialysate temperature (in degC) - TREATMENT_PARAM_UF_VOLUME, ///< Ultrafiltration volume (in liters) + TREATMENT_PARAM_UF_VOLUME, ///< Ultrafiltration volume (in liters) - provided separately by UI NUM_OF_TREATMENT_PARAMS ///< Total number of treatment parameters } TREATMENT_PARAM_T; +/// Enumeration of dialyzer types. +typedef enum Dialyzer_Types +{ + DIALYZER_TYPE_NIPRO_ELISIO_H_17 = 0, ///< Nipro Elisio H17 dialyzer + DIALYZER_TYPE_NIPRO_ELISIO_H_19, ///< Nipro Elisio H19 dialyzer + DIALYZER_TYPE_FRESENIUS_OPTIFLUX_F160NRE, ///< Fresenius Optiflux F160NRe + DIALYZER_TYPE_FRESENIUS_OPTIFLUX_F180NRE, ///< Fresenius Optiflux F180NRe + NUM_OF_DIALYZER_TYPES ///< Number of dialyzer types +} DIALYZER_TYPE_T; + +/// Enumeration of acid concentrates. +typedef enum Acid_Concentrates +{ + ACID_CONC_TYPE_FRESENIUS_08_1251_1 = 0, ///< Fresensius Naturalyte Acid Concentrate 08-1251-1 + ACID_CONC_TYPE_FRESENIUS_08_2251_0, ///< Fresensius Naturalyte Acid Concentrate 08-1251-1 + ACID_CONC_TYPE_FRESENIUS_08_3251_9, ///< Fresensius Naturalyte Acid Concentrate 08-1251-1 + NUM_OF_ACID_CONC_TYPES ///< Number of acid concentrates +} ACID_CONCENTRATE_TYPE_T; + +/// Enumeration of bicarbonate concentrates. +typedef enum Bicarb_Concentrates +{ + BICARB_CONC_TYPE_FRESENIUS_CENTRISOL = 0, ///< Fresenius Centrisol Liquid Bicarbonate + NUM_OF_BICARB_CONC_TYPES ///< Number of bicarbonate concentrates +} BICARB_CONCENTRATE_TYPE_T; + +/// Record structure for a treatment parameters payload. +typedef struct +{ + U32 bloodFlowRate_mL_min; + U32 dialysateFlowRate_mL_min; + U32 treatmentDuration_min; + U32 heparinPreStop_min; + U32 salineBolusVolume_mL; + U32 acidConcentrate; + U32 bicarbConcentrate; + U32 dialyzerType; + S32 arterialPressureLowLimit_mmHg; + S32 arterialPressureHighLimit_mmHg; + S32 venousPressureLowLimit_mmHg; + S32 venousPressureHighLimit_mmHg; + U32 bloodPressureMeasurementInterval_min; + U32 rinsebackFlowRate_mL_min; + F32 heparinDispenseRate_mL_hr; + F32 heparinBolusVolume_mL; + F32 dialysateTemperature_degC; +} TREATMENT_PARAMS_DATA_PAYLOAD_T; + +/// Record structure for adjustable treatment parameters +typedef struct +{ + U32 bloodFlowRate_mL_min; + U32 dialysateFlowRate_mL_min; + U32 treatmentDuration_min; + S32 arterialPressureLowLimit_mmHg; + S32 arterialPressureHighLimit_mmHg; + S32 venousPressureLowLimit_mmHg; + S32 venousPressureHighLimit_mmHg; + F32 uFVolume_L; +} ADJ_TREATMENT_PARAMS_T; + // ********** private function prototypes ********** -void initTreatParamsMode( void ); // initialize this module -void transitionToTreatParamsMode( void ); // prepares for transition to treatment parameters mode -U32 execTreatParamsMode( void ); // execute the treatment parameters mode state machine (call from OperationModes) +void initTreatParamsMode( void ); // initialize this module +void transitionToTreatParamsMode( void ); // prepares for transition to treatment parameters mode +U32 execTreatParamsMode( void ); // execute the treatment parameters mode state machine (call from OperationModes) -void setTreatmentParameterU32( TREATMENT_PARAM_T param, U32 value ); // Set a specified integer treatment parameter value +BOOL validateAndSetTreatmentParameters( TREATMENT_PARAMS_DATA_PAYLOAD_T params ); // user provided treatment params to be set and validated +BOOL signalUserConfirmationOfTreatmentParameters( void ); // User has confirmed treatment parameters +BOOL signalUserCancelTreatment( void ); // User has cancelled treatment + +void setTreatmentParameterU32( TREATMENT_PARAM_T param, U32 value ); // Set a specified unsigned integer treatment parameter value +void setTreatmentParameterS32( TREATMENT_PARAM_T param, S32 value ); // Set a specified signed integer treatment parameter value void setTreatmentParameterF32( TREATMENT_PARAM_T param, F32 value ); // Set a specified floating point treatment parameter value -U32 getTreatmentParameterU32( TREATMENT_PARAM_T param ); // Get a specified integer treatment parameter -F32 getTreatmentParameterF32( TREATMENT_PARAM_T param ); // Get a specified floating point treatment parameter +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 -U32 getOrigBloodFlowRate_mL_min( void ); // Get originally set (before treatment) blood flow rate (in mL/min). -U32 getOrigDialysateFlowRate_mL_min( void ); // Get originally set (before treatment) dialysate flow rate (in mL/min). -U32 getOrigTreatmentDuration_min( void ); // Get originally set (before treatment) treatment duration (in min). -U32 getOrigArterialPressureLowLimit_mmHg( void ); // Get originally set (before treatment) arterial pressure lower alarm limit (in mmHg). -U32 getOrigArterialPressureHighLimit_mmHg( void ); // Get originally set (before treatment) arterial pressure upper alarm limit (in mmHg). -U32 getOrigVenousPressureLowLimit_mmHg( void ); // Get originally set (before treatment) venous pressure lower alarm limit (in mmHg). -U32 getOrigVenousPressureHighLimit_mmHg( void ); // Get originally set (before treatment) venous pressure upper alarm limit (in mmHg). -F32 getOrigUFVolume_L( void ); // Get originally set (before treatment) ultrafiltration volume (in liters). - /**@}*/ #endif Index: firmware/App/Services/AlarmMgmt.c =================================================================== diff -u -r9302e1bd2413cbf99e80ac51aac38502d94801d9 -rc6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2 --- firmware/App/Services/AlarmMgmt.c (.../AlarmMgmt.c) (revision 9302e1bd2413cbf99e80ac51aac38502d94801d9) +++ firmware/App/Services/AlarmMgmt.c (.../AlarmMgmt.c) (revision c6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2) @@ -136,6 +136,8 @@ { ALARM_PRIORITY_HIGH, ALM_ESC_4_MIN, ALARM_ID_BLOOD_SITTING_WARNING, FALSE, TRUE , FALSE, FALSE, FALSE, FALSE, FALSE, FALSE }, // ALARM_ID_DG_SHOCK { ALARM_PRIORITY_HIGH, 0, ALARM_ID_NO_ALARM, TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , FALSE }, // ALARM_ID_HD_ACCELEROMETER_FAILURE { ALARM_PRIORITY_HIGH, 0, ALARM_ID_NO_ALARM, TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , FALSE }, // ALARM_ID_DG_ACCELEROMETER_FAILURE + { ALARM_PRIORITY_HIGH, 0, ALARM_ID_NO_ALARM, TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , FALSE }, // ALARM_ID_DG_CRITICAL_DATA_ERROR + { ALARM_PRIORITY_HIGH, ALM_ESC_4_MIN, ALARM_ID_BLOOD_SITTING_WARNING, FALSE, TRUE , FALSE, FALSE, FALSE, FALSE, FALSE, FALSE }, // ALARM_ID_RO_REJECTION_RATIO_OUT_OF_RANGE }; /// A blank alarm data record for alarms that do not include alarm data when triggered. Index: firmware/App/Services/MessagePayloads.h =================================================================== diff -u -re28798081348b470495ec605fcadda4276f37c46 -rc6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2 --- firmware/App/Services/MessagePayloads.h (.../MessagePayloads.h) (revision e28798081348b470495ec605fcadda4276f37c46) +++ firmware/App/Services/MessagePayloads.h (.../MessagePayloads.h) (revision c6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2) @@ -56,9 +56,9 @@ typedef struct { - S32 xOffset; - S32 yOffset; - S32 zOffset; + F32 xOffset; + F32 yOffset; + F32 zOffset; } ACCEL_CAL_PAYLOAD_T; typedef struct Index: firmware/App/Services/SystemComm.c =================================================================== diff -u -r9302e1bd2413cbf99e80ac51aac38502d94801d9 -rc6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2 --- firmware/App/Services/SystemComm.c (.../SystemComm.c) (revision 9302e1bd2413cbf99e80ac51aac38502d94801d9) +++ firmware/App/Services/SystemComm.c (.../SystemComm.c) (revision c6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2) @@ -1202,8 +1202,20 @@ case MSG_ID_TESTER_LOGIN_REQUEST: handleTesterLogInRequest( message ); - break; - + break; + + case MSG_ID_UI_NEW_TREATMENT_PARAMS: + handleTreatmentParametersFromUI( message ); + break; + + case MSG_ID_UI_START_TREATMENT: + handleUIStartTreatmentMsg( message ); + break; + + case MSG_ID_UI_USER_CONFIRM_TREATMENT_PARAMS: + handleUIUserConfirmTreatmentParameters( message ); + break; + default: // TODO - unrecognized message ID received - ignore break; Index: firmware/App/Services/SystemCommMessages.c =================================================================== diff -u -r9302e1bd2413cbf99e80ac51aac38502d94801d9 -rc6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2 --- firmware/App/Services/SystemCommMessages.c (.../SystemCommMessages.c) (revision 9302e1bd2413cbf99e80ac51aac38502d94801d9) +++ firmware/App/Services/SystemCommMessages.c (.../SystemCommMessages.c) (revision c6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2) @@ -25,8 +25,10 @@ #include "DialInFlow.h" #include "Dialysis.h" #include "FPGA.h" -#include "MessagePayloads.h" -#include "ModeTreatment.h" +#include "MessagePayloads.h" +#include "ModeStandby.h" +#include "ModeTreatment.h" +#include "ModeTreatmentParams.h" #include "PresOccl.h" #include "SafetyShutdown.h" #include "SystemComm.h" @@ -1267,7 +1269,7 @@ memcpy( &payload, message->payload, sizeof(LOAD_CELL_READINGS_PAYLOAD_T) ); result = setNewLoadCellReadings( payload.res1PrimaryLoadCell, payload.res1BackupLoadCell, payload.res2PrimaryLoadCell, payload.res2BackupLoadCell ); - } + } // TODO - what to do if invalid payload length? // TODO - how to know if DG stops sending these? } @@ -1410,10 +1412,132 @@ { result = resumeUF(); } - } + } + sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, result ); } +/************************************************************************* + * @brief + * The handleUIStartTreatmentMsg function handles a treatment start/cancel \n + * message from the UI. + * @details + * Inputs : none + * Outputs : message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleUIStartTreatmentMsg( MESSAGE_T *message ) +{ + BOOL result = FALSE; + + if ( message->hdr.payloadLen == sizeof(U32) ) + { + U32 cmd; + + memcpy( &cmd, message->payload, sizeof(U32) ); + + if ( 0 == cmd ) // initiate treatment (go to treatment params mode) + { + result = signalUserStartingTreatment(); + } + else if ( 1 == cmd ) // cancel treatment (return from aborted treatment params mode) + { + result = signalUserCancelTreatment(); + } + else if ( 2 == cmd ) // start treatment + { + // TODO - handle when pre-treatment mode is ready for this + } + } + + sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, result ); +} + +/************************************************************************* + * @brief + * The handleTreatmentParametersFromUI function handles a treatment parameters \n + * set and validate request message from the UI. + * @details + * Inputs : none + * Outputs : message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTreatmentParametersFromUI( MESSAGE_T *message ) +{ + if ( message->hdr.payloadLen == sizeof(TREATMENT_PARAMS_DATA_PAYLOAD_T) ) + { + TREATMENT_PARAMS_DATA_PAYLOAD_T treatmentParams; + + memcpy( &treatmentParams, message->payload, sizeof(TREATMENT_PARAMS_DATA_PAYLOAD_T) ); + + if ( FALSE == validateAndSetTreatmentParameters( treatmentParams ) ) + { + sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE ); + } + } + else + { + sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE ); + } +} + +/************************************************************************* + * @brief + * The handleUIUserConfirmTreatmentParameters function handles a user confirmation \n + * of treatment parameters message from the UI. + * @details + * Inputs : none + * Outputs : message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleUIUserConfirmTreatmentParameters( MESSAGE_T *message ) +{ + BOOL result = FALSE; + + if ( 0 == message->hdr.payloadLen ) + { + result = signalUserConfirmationOfTreatmentParameters(); + } + + sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, result ); +} + +/************************************************************************* + * @brief + * The sendTreatmentParametersResponseMsg function constructs a treatment parameters \n + * response to the UI and queues the msg for transmit on the appropriate CAN channel. + * @details + * Inputs : none + * Outputs : Treatment parameters response msg constructed and queued. + * @param accepted T/F - are settings ok? + * @param rejectReasons reasons each parameter was rejected (if not accepted) + * @param byteLength number of bytes that array of reject reasons takes + * @return TRUE if msg successfully queued for transmit, FALSE if not + *************************************************************************/ +BOOL sendTreatmentParametersResponseMsg( BOOL accepted, U08 *rejectReasons, U32 byteLength ) +{ + BOOL result; + MESSAGE_T msg; + U08 *payloadPtr = msg.payload; + + // create a message record + blankMessage( &msg ); + msg.hdr.msgID = MSG_ID_HD_NEW_TREATMENT_PARAMS_RESPONSE; + msg.hdr.payloadLen = sizeof( BOOL ) + byteLength; + + memcpy( payloadPtr, &accepted, sizeof( BOOL ) ); + payloadPtr += sizeof( BOOL ); + memcpy( payloadPtr, rejectReasons, byteLength ); + + // 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_HD_2_UI, ACK_REQUIRED ); + + return result; +} + /************************************************************************* * @brief * The handleChangeUFSettingsRequest function handles a ultrafiltration \n @@ -1701,6 +1825,7 @@ if ( ( 3 == message->hdr.payloadLen ) && ( 0x31 == message->payload[ 0 ] ) && ( 0x32 == message->payload[ 1 ] ) && ( 0x33 == message->payload[ 2 ] ) ) { testerLoggedIn = TRUE; + checkInFromUI(); // allow tasks to begin normal processing when tester has logged in } else { Index: firmware/App/Services/SystemCommMessages.h =================================================================== diff -u -rc84daa1f07003427fc5cdde8f5651434478f7313 -rc6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2 --- firmware/App/Services/SystemCommMessages.h (.../SystemCommMessages.h) (revision c84daa1f07003427fc5cdde8f5651434478f7313) +++ firmware/App/Services/SystemCommMessages.h (.../SystemCommMessages.h) (revision c6f3b01d1b0a5e3fdf480a7ee205ca349e10d6d2) @@ -65,8 +65,20 @@ void handleDGPressuresData( MESSAGE_T *message ); // MSG_ID_DG_RESERVOIR_DATA: -void handleDGReservoirData( MESSAGE_T *message ); +void handleDGReservoirData( MESSAGE_T *message ); + +// MSG_ID_UI_START_TREATMENT +void handleUIStartTreatmentMsg( MESSAGE_T *message ); + +// MSG_ID_UI_NEW_TREATMENT_PARAMS +void handleTreatmentParametersFromUI( MESSAGE_T *message ); + +// MSG_ID_HD_NEW_TREATMENT_PARAMS_RESPONSE +BOOL sendTreatmentParametersResponseMsg( BOOL accepted, U08 *rejectReasons, U32 byteLength ); +// MSG_ID_UI_USER_CONFIRM_TREATMENT_PARAMS +void handleUIUserConfirmTreatmentParameters( MESSAGE_T *message ); + // MSG_ID_USER_UF_PAUSE_RESUME_REQUEST void handleUFPauseResumeRequest( MESSAGE_T *message );