Index: firmware/App/Drivers/BPDriver.c =================================================================== diff -u -r143f7b732efbb9efdc690757823e711b5022b29d -r12fa9b72d8e338b624879c284488a04b17115762 --- firmware/App/Drivers/BPDriver.c (.../BPDriver.c) (revision 143f7b732efbb9efdc690757823e711b5022b29d) +++ firmware/App/Drivers/BPDriver.c (.../BPDriver.c) (revision 12fa9b72d8e338b624879c284488a04b17115762) @@ -17,7 +17,9 @@ #include "AlarmMgmtTD.h" #include "BPDriver.h" +#include "Common.h" #include "FpgaTD.h" +#include "TaskGeneral.h" /** * @addtogroup BPDriver @@ -32,14 +34,24 @@ #define BP_MODULE_BUSY_MASK 0x80 ///< Blood Pressure module busy mask #define BP_RESP_CODE_BPDATA 0x07 ///< Blood pressure response code indicating BP data is available. #define BP_MODULE_BUSY_CLEAR 0 ///< Blood pressure module buy clear +#define BP_COMMAND_CLEAR_DELAY_TICKS ( ( 10 / TASK_GENERAL_INTERVAL ) + 1 ) +#define BP_FPGA_CMD_GIVEN_MASK 0x10 +#define BP_MODULE_CMD_STARTED_MASK 0x01 +#define BP_MODULE_CMD_IN_PROGRESS_MASK 0x02 /// Blood pressure driver states. typedef enum { - BP_DRIVER_IDLE_STATE = 0, ///< Idle state. - BP_DRIVER_MEASURE_STATE, ///< Measurement state. - BP_DRIVER_GET_DATA_STATE, ///< Get data state. - NUM_OF_BP_DRIVER_STATES ///< Number of BP driver states. + BP_DRIVER_IDLE_STATE = 0, + BP_DRIVER_CLEAR_CMD_STATE, + BP_DRIVER_WAIT_CLEAR_CMD_STATE, + BP_DRIVER_SEND_CMD_STATE, + BP_DRIVER_WAIT_FPGA_ACK_STATE, + BP_DRIVER_CLEAR_CMD_AFTER_ACK_STATE, + BP_DRIVER_WAIT_MODULE_START_STATE, + BP_DRIVER_WAIT_MEASUREMENT_COMPLETE_STATE, + BP_DRIVER_GET_DATA_STATE, + NUM_OF_BP_DRIVER_STATES } BP_DRIVER_STATE_T; // ********** private data ********** @@ -52,12 +64,20 @@ static BOOL requestPedsBPMeasurement; ///< Request pediatric BP measurement static BOOL requestAbortBPMeasurement; ///< Request abort BP measurement static BOOL bpCuffConnected; ///< Blood pressure cuff connection +static U08 pendingBPCommand; ///< Pending BP command +static U08 bpCommandClearCtr; ///< Command clear delay counter // ********** private function prototypes ********** static U08 getBPResponseCode( void ); static BP_DRIVER_STATE_T handleBPDriverIdleState( void ); -static BP_DRIVER_STATE_T handleBPDriverMeasureState( void ); +static BP_DRIVER_STATE_T handleBPDriverClearCmdState( void ); +static BP_DRIVER_STATE_T handleBPDriverWaitClearCmdState( void ); +static BP_DRIVER_STATE_T handleBPDriverSendCmdState( void ); +static BP_DRIVER_STATE_T handleBPDriverWaitFpgaAckState( void ); +static BP_DRIVER_STATE_T handleBPDriverClearCmdAfterAckState( void ); +static BP_DRIVER_STATE_T handleBPDriverWaitModuleStartState( void ); +static BP_DRIVER_STATE_T handleBPDriverWaitMeasurementCompleteState( void ); static BP_DRIVER_STATE_T handleBPDriverGetDataState( void ); /*********************************************************************//** @@ -79,6 +99,8 @@ bpResults.systolic = 0; bpResults.diastolic = 0; bpResults.heartRate = 0; + pendingBPCommand = (U08)BP_CMD_IDLE; + bpCommandClearCtr = 0; } /*********************************************************************//** @@ -104,18 +126,42 @@ ***************************************************************************/ void execBPDriver( void ) { - bpCuffConnected = ( getNIBPControlStatus() != 0 ); + bpCuffConnected = ( getNIBPControlStatus() != 0 ) ? TRUE : FALSE; switch ( bpDriverState ) { case BP_DRIVER_IDLE_STATE: bpDriverState = handleBPDriverIdleState(); break; - case BP_DRIVER_MEASURE_STATE: - bpDriverState = handleBPDriverMeasureState(); + case BP_DRIVER_CLEAR_CMD_STATE: + bpDriverState = handleBPDriverClearCmdState(); break; + case BP_DRIVER_WAIT_CLEAR_CMD_STATE: + bpDriverState = handleBPDriverWaitClearCmdState(); + break; + + case BP_DRIVER_SEND_CMD_STATE: + bpDriverState = handleBPDriverSendCmdState(); + break; + + case BP_DRIVER_WAIT_FPGA_ACK_STATE: + bpDriverState = handleBPDriverWaitFpgaAckState(); + break; + + case BP_DRIVER_CLEAR_CMD_AFTER_ACK_STATE: + bpDriverState = handleBPDriverClearCmdAfterAckState(); + break; + + case BP_DRIVER_WAIT_MODULE_START_STATE: + bpDriverState = handleBPDriverWaitModuleStartState(); + break; + + case BP_DRIVER_WAIT_MEASUREMENT_COMPLETE_STATE: + bpDriverState = handleBPDriverWaitMeasurementCompleteState(); + break; + case BP_DRIVER_GET_DATA_STATE: bpDriverState = handleBPDriverGetDataState(); break; @@ -142,60 +188,147 @@ if ( TRUE == requestAdultBPMeasurement ) { - SEND_EVENT_WITH_2_U32_DATA( TD_EVENT_BUTTON, BP_DRIVER_IDLE_STATE, BP_DRIVER_MEASURE_STATE ) + SEND_EVENT_WITH_2_U32_DATA( TD_EVENT_BUTTON, BP_DRIVER_IDLE_STATE, BP_DRIVER_CLEAR_CMD_STATE ); requestAdultBPMeasurement = FALSE; bpMeasurementReady = FALSE; bpDriverError = FALSE; - setNIBPCommand( (U08)BP_CMD_START_BP ); - nextState = BP_DRIVER_MEASURE_STATE; + pendingBPCommand = (U08)BP_CMD_START_BP; + nextState = BP_DRIVER_CLEAR_CMD_STATE; } else if ( TRUE == requestPedsBPMeasurement ) { requestPedsBPMeasurement = FALSE; bpMeasurementReady = FALSE; bpDriverError = FALSE; - setNIBPCommand( (U08)BP_CMD_START_PEDS_BP ); - nextState = BP_DRIVER_MEASURE_STATE; + pendingBPCommand = (U08)BP_CMD_START_PEDS_BP; + nextState = BP_DRIVER_CLEAR_CMD_STATE; } else if ( TRUE == requestAbortBPMeasurement ) { requestAbortBPMeasurement = FALSE; - setNIBPCommand( (U08)BP_CMD_ABORT_BP ); + pendingBPCommand = (U08)BP_CMD_ABORT_BP; + nextState = BP_DRIVER_CLEAR_CMD_STATE; } return nextState; } /*********************************************************************//** * @brief -* The handleBPDriverMeasureState function executes the BP driver -* measurement state handling. +* The handleBPDriverClearCmdState function clears the BP command ready bit. * @details \b Inputs: none -* @details \b Outputs: setNIBPCommand, bpDriverState, bpDriverError +* @details \b Outputs: setNIBPCommand, bpCommandClearCtr * @return next BP driver state ***************************************************************************/ -static BP_DRIVER_STATE_T handleBPDriverMeasureState( void ) +static BP_DRIVER_STATE_T handleBPDriverClearCmdState( void ) { - BP_DRIVER_STATE_T nextState = BP_DRIVER_MEASURE_STATE; + BP_DRIVER_STATE_T nextState = BP_DRIVER_WAIT_CLEAR_CMD_STATE; - if ( BP_MODULE_BUSY_CLEAR == ( getNIBPStatusResponse() & BP_MODULE_BUSY_MASK ) ) + setNIBPCommand( (U08)BP_CMD_IDLE ); + bpCommandClearCtr = 0; + + return nextState; +} + +/*********************************************************************//** +* @brief +* The handleBPDriverWaitClearCmdState function waits after clearing the +* BP command ready bit. +* @details \b Inputs: bpCommandClearCtr +* @details \b Outputs: bpCommandClearCtr +* @return next BP driver state +***************************************************************************/ +static BP_DRIVER_STATE_T handleBPDriverWaitClearCmdState( void ) +{ + BP_DRIVER_STATE_T nextState = BP_DRIVER_WAIT_CLEAR_CMD_STATE; + + bpCommandClearCtr++; + if ( bpCommandClearCtr >= BP_COMMAND_CLEAR_DELAY_TICKS ) { - U32 respCode = getBPResponseCode(); + bpCommandClearCtr = 0; + nextState = BP_DRIVER_SEND_CMD_STATE; + } - SEND_EVENT_WITH_2_U32_DATA( TD_EVENT_BUTTON, 11, respCode ) - // Verify BP measurement data is available - if ( BP_RESP_CODE_BPDATA == respCode ) + return nextState; +} + +/*********************************************************************//** +* @brief +* The handleBPDriverSendCmdState function sends the pending BP command. +* @details \b Inputs: pendingBPCommand +* @details \b Outputs: setNIBPCommand +* @return next BP driver state +***************************************************************************/ +static BP_DRIVER_STATE_T handleBPDriverSendCmdState( void ) +{ + BP_DRIVER_STATE_T nextState = BP_DRIVER_WAIT_FPGA_ACK_STATE; + + setNIBPCommand( pendingBPCommand ); + + return nextState; +} + +/*********************************************************************//** +* @brief +* The handleBPDriverWaitFpgaAckState function waits for FPGA command +* acknowledge. +* @details \b Inputs: getNIBPControlStatus +* @details \b Outputs: none +* @return next BP driver state +***************************************************************************/ +static BP_DRIVER_STATE_T handleBPDriverWaitFpgaAckState( void ) +{ + BP_DRIVER_STATE_T nextState = BP_DRIVER_WAIT_FPGA_ACK_STATE; + + if ( 0 != ( getNIBPControlStatus() & BP_FPGA_CMD_GIVEN_MASK ) ) + { + nextState = BP_DRIVER_CLEAR_CMD_AFTER_ACK_STATE; + } + + return nextState; +} + +/*********************************************************************//** +* @brief +* The handleBPDriverClearCmdAfterAckState function clears the BP command +* ready bit after FPGA acknowledge. +* @details \b Inputs: none +* @details \b Outputs: setNIBPCommand +* @return next BP driver state +***************************************************************************/ +static BP_DRIVER_STATE_T handleBPDriverClearCmdAfterAckState( void ) +{ + BP_DRIVER_STATE_T nextState = BP_DRIVER_WAIT_MODULE_START_STATE; + + setNIBPCommand( (U08)BP_CMD_IDLE ); + + return nextState; +} + +/*********************************************************************//** +* @brief +* The handleBPDriverWaitModuleStartState function waits for the BP module +* to signal that the command started. +* @details \b Inputs: getNIBPStatusResponse, pendingBPCommand +* @details \b Outputs: none +* @return next BP driver state +***************************************************************************/ +static BP_DRIVER_STATE_T handleBPDriverWaitModuleStartState( void ) +{ + BP_DRIVER_STATE_T nextState = BP_DRIVER_WAIT_MODULE_START_STATE; + + if ( 0 != ( getNIBPStatusResponse() & BP_MODULE_CMD_STARTED_MASK ) ) + { + if ( ( (U08)BP_CMD_START_BP == pendingBPCommand ) || ( (U08)BP_CMD_START_PEDS_BP == pendingBPCommand ) ) { - SEND_EVENT_WITH_2_U32_DATA( TD_EVENT_BUTTON, BP_DRIVER_MEASURE_STATE, BP_DRIVER_GET_DATA_STATE ) - setNIBPCommand( (U08)BP_CMD_GET_BP_DATA ); + nextState = BP_DRIVER_WAIT_MEASUREMENT_COMPLETE_STATE; + } + else if ( (U08)BP_CMD_GET_BP_DATA == pendingBPCommand ) + { nextState = BP_DRIVER_GET_DATA_STATE; } - // Check whether BP module error occurred - else if ( BP_MODULE_BUSY_CLEAR != ( getNIBPStatusResponse() & BP_MODULE_ERROR_MASK ) ) + else { - SEND_EVENT_WITH_2_U32_DATA( TD_EVENT_BUTTON, BP_DRIVER_MEASURE_STATE, BP_DRIVER_IDLE_STATE ) - bpDriverError = TRUE; - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, getNIBPStatusResponse(), bpDriverState ); nextState = BP_DRIVER_IDLE_STATE; } } @@ -205,30 +338,53 @@ /*********************************************************************//** * @brief -* The handleBPDriverGetDataState function retrieves blood pressure -* measurement results. +* The handleBPDriverWaitMeasurementCompleteState function waits for the +* BP measurement command to complete. * @details \b Inputs: getNIBPStatusResponse -* @details \b Outputs: bpMeasurementReady +* @details \b Outputs: pendingBPCommand * @return next BP driver state ***************************************************************************/ -static BP_DRIVER_STATE_T handleBPDriverGetDataState( void ) +static BP_DRIVER_STATE_T handleBPDriverWaitMeasurementCompleteState( void ) { - BP_DRIVER_STATE_T nextState = BP_DRIVER_GET_DATA_STATE; + BP_DRIVER_STATE_T nextState = BP_DRIVER_WAIT_MEASUREMENT_COMPLETE_STATE; - if ( ( getNIBPStatusResponse() & BP_MODULE_BUSY_MASK ) == 0 ) + if ( 0 == ( getNIBPStatusResponse() & BP_MODULE_CMD_IN_PROGRESS_MASK ) ) { - SEND_EVENT_WITH_2_U32_DATA( TD_EVENT_BUTTON, BP_DRIVER_GET_DATA_STATE, 11 ) - bpResults.systolic = getNIBPSystolicPressure(); - bpResults.diastolic = getNIBPDiastolicPressure(); - bpResults.heartRate = getNIBPHeartRate(); - bpMeasurementReady = TRUE; - nextState = BP_DRIVER_IDLE_STATE; + pendingBPCommand = (U08)BP_CMD_GET_BP_DATA; + nextState = BP_DRIVER_CLEAR_CMD_STATE; } + else if ( 0 != ( getNIBPStatusResponse() & BP_MODULE_ERROR_MASK ) ) + { + bpDriverError = TRUE; + nextState = BP_DRIVER_IDLE_STATE; + } return nextState; } /*********************************************************************//** +* @brief +* The handleBPDriverGetDataState function retrieves blood pressure +* measurement results. +* @details \b Inputs: FPGA NIBP blood pressure registers +* @details \b Outputs: bpResults, bpMeasurementReady +* @return next BP driver state +***************************************************************************/ +static BP_DRIVER_STATE_T handleBPDriverGetDataState( void ) +{ + BP_DRIVER_STATE_T nextState = BP_DRIVER_IDLE_STATE; + + SEND_EVENT_WITH_2_U32_DATA( TD_EVENT_BUTTON, BP_DRIVER_GET_DATA_STATE, 11 ); + bpResults.systolic = (U32)getNIBPSystolicPressure(); + bpResults.diastolic = (U32)getNIBPDiastolicPressure(); + bpResults.heartRate = (U32)getNIBPHeartRate(); + bpMeasurementReady = TRUE; + pendingBPCommand = (U08)BP_CMD_IDLE; + + return nextState; +} + +/*********************************************************************//** * @brief * The startAdultBPMeasurement function requests an adult blood pressure * measurement. Index: firmware/App/Modes/ModeTreatment.c =================================================================== diff -u -r9c833ef5623ce842267e284d958820ac0dc3a7fc -r12fa9b72d8e338b624879c284488a04b17115762 --- firmware/App/Modes/ModeTreatment.c (.../ModeTreatment.c) (revision 9c833ef5623ce842267e284d958820ac0dc3a7fc) +++ firmware/App/Modes/ModeTreatment.c (.../ModeTreatment.c) (revision 12fa9b72d8e338b624879c284488a04b17115762) @@ -17,6 +17,7 @@ #include "AirTrap.h" //#include "BloodFlow.h" +#include "BPModule.h" #include "Bubbles.h" #include "Buttons.h" #include "DDInterface.h" @@ -181,6 +182,7 @@ { // Initialize treatment mode each time we transition to it initTreatmentMode(); + initBPModule(); // Initialize treatment sub-modes each time we transition to treatment mode initBloodPrime(); initDialysis(); @@ -502,6 +504,8 @@ // Manage air trap control execAirTrapMonitorTreatment(); + // Execute Blood pressure module + execBPModule(); // Call fluid bolus execFluidBolus(); Index: firmware/App/Services/AlarmMgmtSWFaults.h =================================================================== diff -u -r9c833ef5623ce842267e284d958820ac0dc3a7fc -r12fa9b72d8e338b624879c284488a04b17115762 --- firmware/App/Services/AlarmMgmtSWFaults.h (.../AlarmMgmtSWFaults.h) (revision 9c833ef5623ce842267e284d958820ac0dc3a7fc) +++ firmware/App/Services/AlarmMgmtSWFaults.h (.../AlarmMgmtSWFaults.h) (revision 12fa9b72d8e338b624879c284488a04b17115762) @@ -196,6 +196,9 @@ SW_FAULT_ID_MODE_POST_TREATMENT_INVALID_STATE1 = 165, SW_FAULT_ID_MODE_POST_TX_AUTO_EJECT_INVALID_STATE = 166, SW_FAULT_ID_INVALID_FLUID_BOLUS_STATE = 167, + SW_FAULT_ID_INVALID_MESSAGE_PAYLOAD_LENGTH = 168, + SW_FAULT_ID_TD_BP_DRIVER_STATE = 169, + SW_FAULT_ID_TD_BP_MODULE_STATE = 170, NUM_OF_SW_FAULT_IDS } SW_FAULT_ID_T; Index: firmware/App/Services/FpgaTD.c =================================================================== diff -u -r41b06072545ff2013cbb16cd874da07ad563b10e -r12fa9b72d8e338b624879c284488a04b17115762 --- firmware/App/Services/FpgaTD.c (.../FpgaTD.c) (revision 41b06072545ff2013cbb16cd874da07ad563b10e) +++ firmware/App/Services/FpgaTD.c (.../FpgaTD.c) (revision 12fa9b72d8e338b624879c284488a04b17115762) @@ -71,6 +71,9 @@ #define FPGA_H18_BUBBLE_STATUS_MASK 0x0002 ///< Bit mask for venous air bubble detector input status. #define FPGA_H18_BUBBLE_SELF_TEST_CMD 0x08 ///< Bit for venous air bubble detector self-test command. +#define FPGA_NIBP_CMD_MASK 0x0F ///< Bit mask for NIBP command bits +#define FPGA_NIBP_CMD_RDY 0x10 ///< NIBP command ready pulse bit + /// Control bits to run syringe pump in reverse direction // TODO - move to syringe pump controller unit when implemented. static const U08 SYRINGE_PUMP_CONTROL_RUN_REVERSE = SYRINGE_PUMP_CONTROL_SLEEP_OFF | SYRINGE_PUMP_CONTROL_NOT_RESET | @@ -165,6 +168,18 @@ U32 baroTemperature; ///< Reg 372. Baro temperature value in counts. U08 baroReadCount; ///< Reg 376. Baro read count. U08 baroErrorCount; ///< Reg 377. Baro error count. + U08 notUsed; ///< Reg 378. + U08 sPumpDacRdByte2; ///< Reg 379. + U08 sPumpDacRdByte3; ///< Reg 380. + U08 sPumpDacRdByte4; ///< Reg 381. + U08 sPumpDacRdByte5; ///< Reg 382. + U08 sPumpDacRdByte6; ///< Reg 383. + U08 nibpCtlStatus; ///< Reg 384. NIBP control status register. + U08 nibpStatusResp; ///< Reg 385. NIBP response status register. + S16 cuffPressure; ///< Reg 386. NIBP cuff pressure in mmHg. + U16 bpSystolic; ///< Reg 388. Systolic BP in mmHg. + U16 bpDiastolic; ///< Reg 390. Diastolic BP in mmHg. + U16 bpHr; ///< Reg 392. Heart rate in BPM. } FPGA_SENSORS_T; /// Record structure for FPGA continuous priority writes. @@ -192,8 +207,9 @@ U08 h10Control; ///< Reg 33. H10 Syringe pump control register. U32 h10Speed; ///< Reg 34. H10 Syringe pump time between step toggle (1/2 step period). U16 h10DACData; ///< Reg 38. H10 Syringe pump DAC data (12 bits). - U16 h10DACControl; ///< Reg 40. H10 Syringe pump ADC and DAC control register. - U16 h12Period; ///< Reg 42. H12 Air pump time period for each count in PWM register. + U08 h10DACControl; ///< Reg 40. H10 Syringe pump ADC and DAC control register. + U16 nibpCtl; ///< Reg 41. NIBP control register. + U16 nibpInflate; ///< Reg 42. NIBP inflate pressure register. U32 h5SetSpeed; ///< Reg 44. H5 ejector motor set speed. } FPGA_ACTUATORS_T; @@ -950,21 +966,6 @@ /*********************************************************************//** * @brief - * The setH12AirPumpMotorPWMCntTime function sets the air pump motor PWM count - * time in increments of 10 nS. The PWM period will then be 255 x given - * value x 10 nS. - * @details \b Inputs: fpgaActuatorSetPoints.h12Period - * @details \b Outputs: fpgaActuatorSetPoints.h12Period - * @param tenNS The time associated with each PWM count in power level setting. - * @return none - *************************************************************************/ -void setH12AirPumpMotorPWMCntTime( U16 tenNS ) -{ - fpgaActuatorSetPoints.h12Period = tenNS; -} - -/*********************************************************************//** - * @brief * The H18BubbleDetected function determines whether H18 bubble detector * sensor is currently detecting a bubble. * @details \b Inputs: fpgaSensorReadings @@ -1364,9 +1365,8 @@ *************************************************************************/ void setFPGASyringePumpControlFlags( U08 bitFlags ) { - fpgaActuatorSetPoints.h10Control = bitFlags; + return fpgaActuatorSetPoints.h10Control = bitFlags; } - /*********************************************************************//** * @brief * The setFPGASyringePumpADCandDACControlFlags function sets the syringe pump @@ -1575,4 +1575,114 @@ return fpgaSensorReadings.h10DACEEProm; } +/*********************************************************************//** +* @brief +* The setNIBPCommand function sets the FPGA NIBP command bits and pulses +* the command ready bit to notify the FPGA that a new NIBP command is +* available. +* @details \b Inputs: command +* @details \b Outputs: fpgaActuatorSetPoints.nibpCtl +* @return none +*************************************************************************/ +void setNIBPCommand( U08 command ) +{ + fpgaActuatorSetPoints.nibpCtl &= ~FPGA_NIBP_CMD_MASK; + fpgaActuatorSetPoints.nibpCtl |= ( (U16)command & FPGA_NIBP_CMD_MASK ); + if ( 0 == command ) + { + fpgaActuatorSetPoints.nibpCtl &= ~FPGA_NIBP_CMD_RDY; + } + else + { + fpgaActuatorSetPoints.nibpCtl |= FPGA_NIBP_CMD_RDY; + } +} + +/*********************************************************************//** +* @brief +* The setNIBPInflatePressure function sets the initial NIBP cuff inflate +* pressure register. +* @details \b Inputs: pressure +* @details \b Outputs: fpgaActuatorSetPoints.nibpInflate +* @return none +*************************************************************************/ +void setNIBPInflatePressure( U16 pressure ) +{ + fpgaActuatorSetPoints.nibpInflate = pressure; +} + +/********************************************************************//** + * @brief + * The getNIBPControlStatus function returns the FPGA NIBP control status. + * @details \b Inputs: fpgaSensorReadings.nibpCtlStatus + * @details \b Outputs: none + * @return FPGA NIBP control status register. + ***************************************************************************/ +U08 getNIBPControlStatus( void ) +{ + return fpgaSensorReadings.nibpCtlStatus; +} + +/*********************************************************************//** + * @brief + * The getNIBPStatusResponse function returns the FPGA NIBP response status. + * @details \b Inputs: fpgaSensorReadings.nibpStatusResp + * @details \b Outputs: none + * @return FPGA NIBP response status register. + ***************************************************************************/ +U08 getNIBPStatusResponse( void ) +{ + return fpgaSensorReadings.nibpStatusResp; +} + +/*********************************************************************//** +* @brief +* The getNIBPCuffPressure function returns the FPGA NIBP cuff pressure. +* @details \b Inputs: fpgaSensorReadings.cuffPressure +* @details \b Outputs: none +* @return NIBP cuff pressure in mmHg. +*************************************************************************/ +S16 getNIBPCuffPressure( void ) +{ + return fpgaSensorReadings.cuffPressure; +} + +/*********************************************************************//** +* @brief +* The getNIBPSystolicPressure function returns the FPGA systolic blood +* pressure measurement. +* @details \b Inputs: fpgaSensorReadings.bpSystolic +* @details \b Outputs: none +* @return Systolic blood pressure in mmHg. +*************************************************************************/ +U16 getNIBPSystolicPressure( void ) +{ + return fpgaSensorReadings.bpSystolic; +} + +/*********************************************************************//** +* @brief +* The getNIBPDiastolicPressure function returns the FPGA diastolic blood +* pressure measurement. +* @details \b Inputs: fpgaSensorReadings.bpDiastolic +* @details \b Outputs: none +* @return Diastolic blood pressure in mmHg. +*************************************************************************/ +U16 getNIBPDiastolicPressure( void ) +{ + return fpgaSensorReadings.bpDiastolic; +} + +/*********************************************************************//** +* @brief +* The getNIBPHeartRate function returns the FPGA heart rate measurement. +* @details \b Inputs: fpgaSensorReadings.bpHr +* @details \b Outputs: none +* @return Heart rate in BPM. +*************************************************************************/ +U16 getNIBPHeartRate( void ) +{ + return fpgaSensorReadings.bpHr; +} + /**@}*/ Index: firmware/App/Services/Messaging.c =================================================================== diff -u -r9c833ef5623ce842267e284d958820ac0dc3a7fc -r12fa9b72d8e338b624879c284488a04b17115762 --- firmware/App/Services/Messaging.c (.../Messaging.c) (revision 9c833ef5623ce842267e284d958820ac0dc3a7fc) +++ firmware/App/Services/Messaging.c (.../Messaging.c) (revision 12fa9b72d8e338b624879c284488a04b17115762) @@ -22,6 +22,7 @@ #include "AlarmMgmt.h" #include "BloodFlow.h" #include "Bubbles.h" +#include "BPModule.h" #include "Buttons.h" #include "Compatible.h" #include "CpldInterface.h" @@ -132,6 +133,7 @@ { MSG_ID_UI_TREATMENT_SET_POINT_BLOOD_FLOW_CHANGE_REQUEST, &bloodPrimeHandleBloodFlowChangeRequest }, { MSG_ID_UI_ADJUST_DISPOSABLES_CONFIRM_REQUEST, &handleAutoLoadRequest }, { MSG_ID_UI_ADJUST_DISPOSABLES_REMOVAL_CONFIRM_REQUEST, &handleAutoEjectRequest }, + { MSG_ID_UI_BLOOD_PRESSURE_REQUEST, &bpModuleHandleVitalsRequest }, { MSG_ID_FFU_SIGNAL_TD_UPDATE_AVAILABLE, &handleUpdateAvailable }, { MSG_ID_UI_FLUID_BOLUS_REQUEST, &handleFluidBolusRequest }, { MSG_ID_TD_SOFTWARE_RESET_REQUEST, &testTDSoftwareResetRequest },