Index: firmware/App/Modes/ModePreTreat.c =================================================================== diff -u -rbbd48b033ef7307a30815e490eb28825c7afcc2b -ra89b071a59a5575e9bcd1b04d133ec318e24a411 --- firmware/App/Modes/ModePreTreat.c (.../ModePreTreat.c) (revision bbd48b033ef7307a30815e490eb28825c7afcc2b) +++ firmware/App/Modes/ModePreTreat.c (.../ModePreTreat.c) (revision a89b071a59a5575e9bcd1b04d133ec318e24a411) @@ -8,7 +8,7 @@ * @file ModePreTreat.c * * @author (last) Vijay Pamula -* @date (last) 14-Jul-2026 +* @date (last) 17-Aug-2026 * * @author (original) Dara Navaei * @date (original) 25-Sep-2025 @@ -21,10 +21,13 @@ #include "Buttons.h" #include "DDInterface.h" #include "HemoDiaFiltration.h" +#include "Messaging.h" #include "ModePreTreat.h" #include "OperationModes.h" +#include "StatePreTxHeparinSetup.h" #include "StatePreTxRecirculate.h" #include "SyringePump.h" +#include "TaskGeneral.h" #include "Timers.h" #include "TubeSetInstall.h" #include "TxParams.h" @@ -36,21 +39,45 @@ * @{ */ +// ********** private definitions ********** + +/// Interval (ms/task time) at which the Pre-Treatment state data is published on the CAN bus. +#define PRE_TREATMENT_STATE_DATA_PUB_INTERVAL ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) + +/// Initial offset used to stagger the Pre-Treatment state data broadcast. +#define PRE_TREATMENT_STATE_DATA_PUB_INITIAL_OFFSET 5U + +#define PRE_TX_DEFAULT_QD_ML_MIN 400 ///< Default dialysate flow rate during recirculation when Rx is not entered in mL/min. +#define PRE_TX_INTERMEDIATE_QD_ML_MIN 300 ///< Intermediate dialysate flow rate for low prescribed Qd in mL/min. +#define PRE_TX_LOW_QD_THRESHOLD_ML_MIN 200 ///< Maximum prescribed Qd requiring the intermediate Qd transition in mL/min. +#define PRE_TX_LOW_QD_TRANSITION_TIME_MS ( 4 * SEC_PER_MIN * MS_PER_SECOND ) ///< Low Qd transition time before applying the prescribed Qd in milliseconds. + // ********** private data ********** static TD_PRE_TREATMENT_MODE_STATE_T currentPreTreatmentState; ///< Current Pre-Treatment sub-state static BOOL goToInstallStateRequested; ///< Flag indicating a request to transition to Install state. -static BOOL continueFromRecirculateRequested; ///< Flag indicating a request to transition to Patient Connection state. +static BOOL continueFromRecirculateRequested; ///< Flag indicating a request to transition to Confirm Rx state. +static BOOL continueFromHeparinSetupRequested; ///< Flag indicating a request to transition to Patient Connection state. +static BOOL treatmentStartRequested; ///< Flag indicating the UI requested treatment start. +static U32 preTreatmentStateBroadcastTimerCtr; ///< Pre-Treatment state data broadcast timer counter. +static OVERRIDE_U32_T preTreatmentStatePublishInterval; ///< Pre-Treatment state data publication interval override. +static BOOL lowQdTransitionActive; ///< Flag indicating low Qd transition is active. +static U32 lowQdTransitionStartTime; ///< Start time of the low Qd transition. +static BOOL defaultQdApplied; ///< Flag indicating default Qd has been applied while Rx is unavailable. +static BOOL preTreatmentRxUpdated; ///< Flag indicating a new or updated Rx was received. // ********** private function prototypes ********** -static void setPreTreatStateTransition( void ); ///< Configure actuators and variables for Pre-Treatment state transitions. -static TD_PRE_TREATMENT_MODE_STATE_T handleInstallState( void ); ///< Handle Install state during Pre-Treatment -static TD_PRE_TREATMENT_MODE_STATE_T handleSelfTestDryState( void ); ///< Handle Self Test Dry state during Pre-Treatment -static TD_PRE_TREATMENT_MODE_STATE_T handlePrimeState( void ); ///< Handle Prime state during Pre-Treatment -static TD_PRE_TREATMENT_MODE_STATE_T handleRecirculateState( void ); ///< Handle Recirculate state during Pre-Treatment -static TD_PRE_TREATMENT_MODE_STATE_T handleRxState( void ); ///< Handle Confirm Rx state during Pre-Treatment -static TD_PRE_TREATMENT_MODE_STATE_T handlePatientConnectionState( void ); ///< Handle Patient Connection state during Pre-Treatment +static void setPreTreatStateTransition( void ); +static TD_PRE_TREATMENT_MODE_STATE_T handleInstallState( void ); +static TD_PRE_TREATMENT_MODE_STATE_T handleSelfTestDryState( void ); +static TD_PRE_TREATMENT_MODE_STATE_T handlePrimeState( void ); +static TD_PRE_TREATMENT_MODE_STATE_T handleRecirculateState( void ); +static TD_PRE_TREATMENT_MODE_STATE_T handleRxState( void ); +static TD_PRE_TREATMENT_MODE_STATE_T handleHeparinSetupState( void ); +static TD_PRE_TREATMENT_MODE_STATE_T handlePatientConnectionState( void ); +static void handlePreTreatmentQdTransition( void ); +static void publishPreTreatmentStates( void ); /*********************************************************************//** * @brief @@ -64,9 +91,26 @@ { // Start a fresh Treatment Parameters session for this run. initTreatmentParameters(); + initPreTxHeparinSetup(); + currentPreTreatmentState = TD_PRE_TREATMENT_TUBING_SET_INSTALL_STATE; goToInstallStateRequested = FALSE; continueFromRecirculateRequested = FALSE; + continueFromHeparinSetupRequested = FALSE; + treatmentStartRequested = FALSE; + lowQdTransitionActive = FALSE; + lowQdTransitionStartTime = 0U; + defaultQdApplied = FALSE; + preTreatmentRxUpdated = FALSE; + preTreatmentStateBroadcastTimerCtr = PRE_TREATMENT_STATE_DATA_PUB_INITIAL_OFFSET; + + preTreatmentStatePublishInterval = (OVERRIDE_U32_T) + { + PRE_TREATMENT_STATE_DATA_PUB_INTERVAL, + PRE_TREATMENT_STATE_DATA_PUB_INTERVAL, + PRE_TREATMENT_STATE_DATA_PUB_INTERVAL, + 0 + }; } /*********************************************************************//** @@ -136,20 +180,32 @@ currentPreTreatmentState = handleRecirculateState(); break; + case TD_PRE_TREATMENT_HEPARIN_SETUP_STATE: + currentPreTreatmentState = handleHeparinSetupState(); + break; + case TD_PRE_TREATMENT_PATIENT_CONNECTION_STATE: - // currentPreTreatmentState = handlePatientConnectionState(); + currentPreTreatmentState = handlePatientConnectionState(); break; default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_PRE_TREATMENT_INVALID_STATE, (U32)currentPreTreatmentState ); + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, + SW_FAULT_ID_MODE_PRE_TREATMENT_INVALID_STATE, + (U32)currentPreTreatmentState ); break; } + if ( currentPreTreatmentState > TD_PRE_TREATMENT_PRIME_STATE ) + { + handlePreTreatmentQdTransition(); + } if ( prevPreTreatmentState != currentPreTreatmentState ) { setPreTreatStateTransition(); } + publishPreTreatmentStates(); + return (U32)currentPreTreatmentState; } @@ -187,16 +243,32 @@ // No action required. break; + case TD_PRE_TREATMENT_HEPARIN_SETUP_STATE: + // Heparin Setup transition is already handled in handleRxState(). + break; + case TD_PRE_TREATMENT_RECIRCULATE_STATE: // No action required. break; case TD_PRE_TREATMENT_PATIENT_CONNECTION_STATE: - // TODO: actuator configuration + signalBloodPumpHardStop(); + setValvePosition( H1_VALV, VALVE_POSITION_B_OPEN ); + setValvePosition( H19_VALV, VALVE_POSITION_C_CLOSE ); + setAirPumpState( AIR_PUMP_STATE_OFF, AIR_PUMP_MOTOR_OFF ); + set3WayValveState( H13_VALV, VALVE_3WAY_COMMON_TO_CLOSED_STATE ); + set3WayValveState( H20_VALV, VALVE_3WAY_COMMON_TO_CLOSED_STATE ); + stopSyringePump(); + + // TODO: Set H5 ejector Off. + // TODO: Command DD to bypass dialyzer, set QDt to prescribed rate, + // Quf to 0, and Qs to 0. break; default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_PRE_TREATMENT_INVALID_STATE, (U32)currentPreTreatmentState ); + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, + SW_FAULT_ID_MODE_PRE_TREATMENT_INVALID_STATE, + (U32)currentPreTreatmentState ); break; } } @@ -214,12 +286,12 @@ { TD_PRE_TREATMENT_MODE_STATE_T state = TD_PRE_TREATMENT_TUBING_SET_INSTALL_STATE; - // call tube set install service to auto-load tube set + // Call Tube Set Install Service to auto-load the tube set. execTubeSetInstall(); if ( TRUE == isTubeSetInstallComplete() ) { - state = TD_PRE_TREATMENT_SELF_TEST_DRY_STATE; + state = TD_PRE_TREATMENT_SELF_TEST_DRY_STATE ; } return state; @@ -285,12 +357,30 @@ if ( TRUE == continueFromRecirculateRequested ) { continueFromRecirculateRequested = FALSE; + state = TD_PRE_TREATMENT_CONFIRM_RX_STATE; + } - // TODO: Change to TD_PRE_TREATMENT_PATIENT_CONNECTION_STATE - // when Patient Connection state is implemented. - // state = TD_PRE_TREATMENT_PATIENT_CONNECTION_STATE; + return state; +} - requestNewOperationMode( MODE_TREA ); +/*********************************************************************//** + * @brief + * The handleHeparinSetupState function executes the Heparin Setup state of + * pre-treatment mode. + * @details \b Inputs: continueFromHeparinSetupRequested. + * @details \b Outputs: continueFromHeparinSetupRequested + * @return next Pre-Treatment mode state. + *************************************************************************/ +static TD_PRE_TREATMENT_MODE_STATE_T handleHeparinSetupState( void ) +{ + TD_PRE_TREATMENT_MODE_STATE_T state = TD_PRE_TREATMENT_HEPARIN_SETUP_STATE; + + execPreTxHeparinSetup(); + + if ( TRUE == continueFromHeparinSetupRequested ) + { + continueFromHeparinSetupRequested = FALSE; + state = TD_PRE_TREATMENT_PATIENT_CONNECTION_STATE; } return state; @@ -308,58 +398,155 @@ { BOOL paramsValid = getValidTreatParamsReceived(); BOOL paramsConfirmed = getTreatParamsConfirmed(); + BOOL heparinIsPrescribed = ( ( getTreatmentParameterF32( TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME ) > 0.0F ) || + ( getTreatmentParameterF32( TREATMENT_PARAM_HEPARIN_DELIVERY_RATE ) > 0.0F ) ) ? TRUE : FALSE; BOOL isDialysateGoodToDeliver = TRUE; // TODO replace TRUE with getDialysateGoodToDeliverStatus() when we are ready F32 bicarbConvFactor = BICARBONATE_CONVERSION_FACTOR; F32 presUFVolumeL = 0.0F; F32 presUFRateMlMin = 0.0F; + U32 prescribedQd = 0U; + F32 prescribedDialTemp = 0.0F; + F32 ddQd = 0.0F; + F32 ddDialTemp = 0.0F; U32 ddSubMode = getDDSubMode(); TD_PRE_TREATMENT_MODE_STATE_T state = TD_PRE_TREATMENT_CONFIRM_RX_STATE; DD_OP_MODE_T ddOpMode = getDDOpMode(); - // Valid + confirmed – move to next state: Recirculate State + // Valid + confirmed – move to Heparin Setup or Patient Connection. if ( ( TRUE == paramsValid ) && ( TRUE == paramsConfirmed ) ) { - // TODO this command of requesting dialysate delivery will move to appropriate state in pre-treatment once implemented if ( ( ddOpMode == DD_MODE_PREG ) && ( ddSubMode == DD_PRE_GEN_DIALYSATE_WAIT_FOR_GEND ) ) { presUFVolumeL = getTreatmentParameterF32( TREATMENT_PARAM_UF_VOLUME ); presUFRateMlMin = ( presUFVolumeL * (F32)ML_PER_LITER ) / (F32)getTreatmentParameterU32( TREATMENT_PARAM_TREATMENT_DURATION ); + prescribedQd = getTreatmentParameterU32( TREATMENT_PARAM_DIALYSATE_FLOW ); + prescribedDialTemp = getTreatmentParameterF32( TREATMENT_PARAM_DIALYSATE_TEMPERATURE ); + + ddQd = (F32)prescribedQd; + ddDialTemp = prescribedDialTemp; + + if ( ( prescribedQd <= PRE_TX_LOW_QD_THRESHOLD_ML_MIN ) && + ( ( TRUE == lowQdTransitionActive ) || ( TRUE == preTreatmentRxUpdated ) ) ) + { + ddQd = (F32)PRE_TX_INTERMEDIATE_QD_ML_MIN; + ddDialTemp = prescribedDialTemp + 1.0F; + } + // Direct DD to generate dialysate and bypass while priming blood - cmdStartGenerateDialysate( (F32)getTreatmentParameterU32( TREATMENT_PARAM_DIALYSATE_FLOW ), presUFRateMlMin, 0.0, - getTreatmentParameterF32( TREATMENT_PARAM_DIALYSATE_TEMPERATURE ), TRUE, + cmdStartGenerateDialysate( ddQd, + presUFRateMlMin, + ddDialTemp, + TRUE, getTreatmentParameterF32( TREATMENT_PARAM_ACID_CONCENTRATE_CONV_FACTOR ), bicarbConvFactor, getTreatmentParameterU32( TREATMENT_PARAM_SODIUM ), getTreatmentParameterU32( TREATMENT_PARAM_BICARBONATE ) ); } + if ( TRUE == heparinIsPrescribed ) + { + transitionToPreTxHeparinSetup(); + state = TD_PRE_TREATMENT_HEPARIN_SETUP_STATE; + } + else + { + state = TD_PRE_TREATMENT_PATIENT_CONNECTION_STATE; + } + } - state = TD_PRE_TREATMENT_RECIRCULATE_STATE; - } - - return state; + return state; } /*********************************************************************//** * @brief * The handlePatientConnectionState function executes the Patient - * Connection state of pre-treatment mode. - * @details \b Inputs: TODO fill up if any - * @details \b Outputs: TODO fill up if any - * @return next Pre-Treatment mode state. + * Connection pre-treatment step. + * @details \b Inputs: treatmentStartRequested. + * @details \b Outputs: Requests transition to Treatment Mode when the + * UI Start Treatment request is received. + * @return current Pre-Treatment mode state. *************************************************************************/ static TD_PRE_TREATMENT_MODE_STATE_T handlePatientConnectionState( void ) { TD_PRE_TREATMENT_MODE_STATE_T state = TD_PRE_TREATMENT_PATIENT_CONNECTION_STATE; - // TODO : after implementing this state, place the transition in the right place + if ( TRUE == treatmentStartRequested ) + { + treatmentStartRequested = FALSE; + requestNewOperationMode( MODE_TREA ); + } - //requestNewOperationMode( MODE_TREA ); - return state; } /*********************************************************************//** * @brief + * The handlePreTreatmentQdTransition function manages the dialysate flow + * and temperature transition after priming is complete. + * @details \b Inputs: preTreatmentRxUpdated, lowQdTransitionActive, + * lowQdTransitionStartTime, defaultQdApplied, treatment parameters. + * @details \b Outputs: preTreatmentRxUpdated, lowQdTransitionActive, + * lowQdTransitionStartTime, defaultQdApplied, dialysate flow rate, + * dialysate target temperature. + * @return none. + *************************************************************************/ +static void handlePreTreatmentQdTransition( void ) +{ + U32 prescribedQd; + F32 prescribedDialTemp; + + if ( TRUE != getValidTreatParamsReceived() ) + { + if ( TRUE != defaultQdApplied ) + { + cmdChangeQd( PRE_TX_DEFAULT_QD_ML_MIN ); + defaultQdApplied = TRUE; + } + } + else + { + prescribedQd = getTreatmentParameterU32( TREATMENT_PARAM_DIALYSATE_FLOW ); + prescribedDialTemp = getTreatmentParameterF32( TREATMENT_PARAM_DIALYSATE_TEMPERATURE ); + + if ( TRUE == preTreatmentRxUpdated ) + { + preTreatmentRxUpdated = FALSE; + defaultQdApplied = FALSE; + + if ( prescribedQd <= PRE_TX_LOW_QD_THRESHOLD_ML_MIN ) + { + if ( TRUE != lowQdTransitionActive ) + { + cmdChangeQd( PRE_TX_INTERMEDIATE_QD_ML_MIN ); + + lowQdTransitionStartTime = getMSTimerCount(); + lowQdTransitionActive = TRUE; + } + + cmdChangeDialysateTemperature( prescribedDialTemp + 1.0F ); + } + else + { + cmdChangeQd( prescribedQd ); + cmdChangeDialysateTemperature( prescribedDialTemp ); + + lowQdTransitionActive = FALSE; + } + } + + if ( ( TRUE == lowQdTransitionActive ) && + ( TRUE == didTimeout( lowQdTransitionStartTime, + PRE_TX_LOW_QD_TRANSITION_TIME_MS ) ) ) + { + cmdChangeQd( prescribedQd ); + cmdChangeDialysateTemperature( prescribedDialTemp ); + + lowQdTransitionActive = FALSE; + } + } +} + +/*********************************************************************//** + * @brief * The PreTxRequestTubeSetInstall function signals a request to transition * the Pre-Treatment mode state machine to Install state. * @details \b Inputs: none @@ -374,7 +561,7 @@ /*********************************************************************//** * @brief * The PreTxRequestContinueFromRecirculate function signals a request to - * transition the Pre-Treatment mode state machine to Patient Connection state. + * transition the Pre-Treatment mode state machine to Confirm Rx state. * @details \b Inputs: none * @details \b Outputs: continueFromRecirculateRequested * @return none @@ -386,32 +573,199 @@ /*********************************************************************//** * @brief + * The PreTxRequestContinueFromHeparinSetupRequested function signals a request to + * transition the Pre-Treatment mode state machine to Patient Connection state. + * @details \b Inputs: none + * @details \b Outputs: continueFromHeparinSetupRequested + * @return none + *************************************************************************/ +void PreTxRequestContinueFromHeparinSetupRequested( void ) +{ + continueFromHeparinSetupRequested = TRUE; +} + +/*********************************************************************//** +* @brief +* The handleStartTreatmentRequest function handles the UI request to +* start treatment. +* @details \b Message \b Received: MSG_ID_UI_START_TREATMENT_REQUEST. +* @details \b Message \b Sent: MSG_ID_TD_START_TREATMENT_RESPONSE. +* @details \b Inputs: current operation mode and Pre-Treatment state. +* @details \b Outputs: treatmentStartRequested. +* @param message Pointer to the received Start Treatment request message. +* @return TRUE if the request was accepted, otherwise FALSE. +*************************************************************************/ +BOOL handleStartTreatmentRequest( MESSAGE_T *message ) +{ + TD_OP_MODE_T mode = getCurrentOperationMode(); + TD_PRE_TREATMENT_MODE_STATE_T preTxState = currentPreTreatmentState; + U32 payloadLen = message->hdr.payloadLen; + BOOL accepted = FALSE; + UI_RESPONSE_PAYLOAD_T response; + + response.accepted = FALSE; + response.rejectionReason = REQUEST_REJECT_REASON_ACTION_DISABLED_IN_CURRENT_STATE; + + if ( ( 0U == payloadLen ) && ( MODE_PRET == mode ) && + ( TD_PRE_TREATMENT_PATIENT_CONNECTION_STATE == preTxState ) ) + + { + treatmentStartRequested = TRUE; + accepted = TRUE; + response.accepted = TRUE; + response.rejectionReason = REQUEST_REJECT_REASON_NONE; + } + + sendMessage( MSG_ID_TD_START_TREATMENT_RESPONSE, COMM_BUFFER_OUT_CAN_TD_2_UI, + (U08 *)&response, sizeof( UI_RESPONSE_PAYLOAD_T ) ); + + return accepted; +} + +/*********************************************************************//** +* @brief +* The signalPreTreatmentBackoutToStandby function handles a request to +* back out of Pre-Treatment to Standby. +* @details \b Inputs: current operation mode, currentPreTreatmentState, +* and Tube Set Install state. +* @details \b Outputs: Requests Standby Mode when backout is allowed. +* @return TRUE if the request is accepted, otherwise FALSE. +*************************************************************************/ +BOOL signalPreTreatmentBackoutToStandby( void ) +{ + BOOL accepted = FALSE; + + if ( ( MODE_PRET == getCurrentOperationMode() ) && + ( TD_PRE_TREATMENT_TUBING_SET_INSTALL_STATE == currentPreTreatmentState ) && + ( TRUE == isTubeSetInstallAwaitingConfirmation() ) ) + { + requestNewOperationMode( MODE_STAN ); + accepted = TRUE; + } + + return accepted; +} + +/*********************************************************************//** + * @brief + * The signalPreTreatmentRxUpdated function signals that a new or updated + * treatment prescription has been received during Pre-Treatment. + * @details \b Inputs: none. + * @details \b Outputs: preTreatmentRxUpdated. + * @return none. + *************************************************************************/ +void signalPreTreatmentRxUpdated( void ) +{ + preTreatmentRxUpdated = TRUE; +} + +/*********************************************************************//** + * @brief * The signalAlarmActionToPreTreatmentMode function executes the given alarm action * as appropriate while in Pre-Treatment Mode. - * @details \b Inputs: currentPreTreatmentState - * @details \b Outputs: given alarm action executed - * @param action ID of alarm action to execute + * @details \b Inputs: currentPreTreatmentState and current Heparin Setup sub-state. + * @details \b Outputs: Alarm action handled for the active Pre-Treatment state. + * @param action ID of alarm action to execute. * @return none *************************************************************************/ void signalAlarmActionToPreTreatmentMode( ALARM_ACTION_T action ) { switch ( action ) { case ALARM_ACTION_STOP: - // TODO add logic once we have pre-treatment mode developed + // TODO add logic once we have pre-treatment mode developed. break; case ALARM_ACTION_RESUME: - if ( TD_PRE_TREATMENT_RECIRCULATE_STATE == currentPreTreatmentState ) - { + if ( TD_PRE_TREATMENT_RECIRCULATE_STATE == currentPreTreatmentState ) + { signalResumePreTxRecirculate(); - } - break; + } + else if ( TD_PRE_TREATMENT_HEPARIN_SETUP_STATE == currentPreTreatmentState ) + { + signalResumePreTxHeparinSetup(); + } + else + { + // No action required. + } + break; + case ALARM_ACTION_ACK: + if ( ( TD_PRE_TREATMENT_HEPARIN_SETUP_STATE == currentPreTreatmentState ) && + ( TRUE == isPreTxHeparinAwaitingSyringeLoadConfirmation() ) && + ( FALSE == isAlarmActive( ALARM_ID_TD_PRE_TX_HEPARIN_LOAD_SYRINGE ) ) ) + { + // OK on the Load Syringe clear-only alarm confirms that + // the syringe was loaded and resumes the paused state. + signalResumePreTxHeparinSetup(); + } + break; + default: - // do not handle other actions in pre-treatment mode + // Do not handle other actions in Pre-Treatment mode. break; } } +/*********************************************************************//** + * @brief + * The publishPreTreatmentStates function publishes the current + * Pre-Treatment state and associated sub-state data to the UI. + * @details \b Inputs: currentPreTreatmentState, preTreatmentStatePublishInterval + * preTreatmentStateBroadcastTimerCtr. + * @details \b Outputs: preTreatmentStateBroadcastTimerCtr. + * @return none + *************************************************************************/ +static void publishPreTreatmentStates( void ) +{ + if ( ++preTreatmentStateBroadcastTimerCtr >= getU32OverrideValue( &preTreatmentStatePublishInterval ) ) + { + PRE_TREATMENT_STATES_DATA_PAYLOAD_T payload = { 0 }; + + preTreatmentStateBroadcastTimerCtr = 0; + + payload.mSubMode = (U32)currentPreTreatmentState; + payload.mInstallState = (U32)getTubeSetInstallState(); + payload.mSelfTestDryState = 0; + payload.mPrimeState = 0; + payload.mRecirculateState = getPreTxRecirculateState(); + payload.mConfirmRxState = 0; + payload.mHeparinState = 0; + payload.mPatientConnectionState = 0; + + broadcastData( MSG_ID_TD_PRE_TREATMENT_STATES_DATA, + COMM_BUFFER_OUT_CAN_TD_BROADCAST, + (U08 *)&payload, + sizeof( PRE_TREATMENT_STATES_DATA_PAYLOAD_T ) ); + } +} + + +/************************************************************************* + * TEST SUPPORT FUNCTIONS + *************************************************************************/ + + +/*********************************************************************//** + * @brief + * The testPreTreatmentStatePublishIntervalOverride function overrides or + * resets the Pre-Treatment state data publication interval. + * @details \b Inputs: message + * @details \b Outputs: preTreatmentStatePublishInterval + * @param message Override message from Dial-in containing the interval + * in milliseconds, or a reset command. + * @return TRUE if the override or reset is successful, otherwise FALSE. + *************************************************************************/ +BOOL testPreTreatmentStatePublishIntervalOverride( MESSAGE_T *message ) +{ + BOOL result = FALSE; + + result = u32BroadcastIntervalOverride( message, + &preTreatmentStatePublishInterval, + TASK_GENERAL_INTERVAL ); + + return result; +} + /**@}*/