Index: firmware/App/Controllers/PresOccl.c =================================================================== diff -u -r27f3db92495948d4c1192421c1b0c20338c4a034 -r88fd90befbce61886ae47ad7d20ec863319cfa34 --- firmware/App/Controllers/PresOccl.c (.../PresOccl.c) (revision 27f3db92495948d4c1192421c1b0c20338c4a034) +++ firmware/App/Controllers/PresOccl.c (.../PresOccl.c) (revision 88fd90befbce61886ae47ad7d20ec863319cfa34) @@ -118,9 +118,9 @@ /*********************************************************************//** * @brief - * The initPresOccl function initializes the initPresOccl module. + * The initPresOccl function initializes the PresOccl module. * @details Inputs: none - * @details Outputs: initPresOccl module initialized. + * @details Outputs: PresOccl module initialized. * @return none *************************************************************************/ void initPresOccl( void ) @@ -461,7 +461,7 @@ * @details Outputs: none * @return the current pressure/occlusion data publication interval (in task intervals). *************************************************************************/ -U32 getPublishPresOcclDataInterval( void ) +static U32 getPublishPresOcclDataInterval( void ) { U32 result = presOcclDataPublishInterval.data; Index: firmware/App/Controllers/SyringePump.c =================================================================== diff -u --- firmware/App/Controllers/SyringePump.c (revision 0) +++ firmware/App/Controllers/SyringePump.c (revision 88fd90befbce61886ae47ad7d20ec863319cfa34) @@ -0,0 +1,763 @@ +/************************************************************************** +* +* Copyright (c) 2019-2020 Diality Inc. - All Rights Reserved. +* +* THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN +* WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. +* +* @file SyringePump.c +* +* @author (last) Sean Nash +* @date (last) 02-Mar-2021 +* +* @author (original) Sean Nash +* @date (original) 02-Mar-2021 +* +***************************************************************************/ + +#include "AlarmMgmt.h" +#include "FPGA.h" +#include "ModeTreatmentParams.h" +#include "OperationModes.h" +#include "PersistentAlarm.h" +#include "SyringePump.h" +#include "SystemCommMessages.h" +#include "TaskPriority.h" +#include "Timers.h" + +/** + * @addtogroup SyringePump + * @{ + */ + +// ********** private definitions ********** + +/// Default publication interval for syringe pump data. +#define SYRINGE_PUMP_DATA_PUB_INTERVAL ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) + +#define BD_SYRINGE_ID_MM 14.02 ///< Inner diameter (in mm) of supported BD syringe. + +#define MIN_HEPARIN_CONTINUOUS_RATE 0.1 ///< Minimum continuous Heparin flow rate (in mL/hr). +#define MAX_HEPARIN_CONTINUOUS_RATE 1.0 ///< Maximum continuous Heparin flow rate (in mL/hr). +#define MIN_HEPARIN_BOLUS_RATE 1.2 ///< Minimum Heparin bolus flow rate (in mL/hr). +#define MAX_HEPARIN_BOLUS_RATE 24.0 ///< Maximum Heparin bolus flow rate (in mL/hr). +#define MAX_SYRINGE_PUMP_RAMP_RATE 10000.0 ///< Maximum ramp rate (micro steps per second) for syringe pump. TODO - get from Systems + +#define SYRINGE_OCCLUSION_THRESHOLD_MV 3000.0 ///< Force sensor threshold (in mV) above which an occlusion is detected. TODO - get from Systems + +#define SYRINGE_PUMP_RATE_ALARM_PERSISTENCE ( 1 * MS_PER_SECOND ) ///< Alarm persistence period for syringe pump speed check alarms. + +#define STEPS_TO_MICROSTEPS( s ) ( (s) * 32.0 ) ///< Macro conversion from steps to microsteps. +#define MICROSTEPS_TO_STEPS( m ) ( (m) / 32.0 ) ///< Macro conversion from microsteps to steps. + +#define SYRINGE_PUMP_ADC_REF_V 3.3 ///< Syringe pump ADC reference voltage. +#define SYRINGE_PUMP_ADC_FULL_SCALE_BITS 1024.0 ///< Syringe pump ADC has 1024 full scale counts (10-bit) per channel. +#define SYRINGE_PUMP_DAC_FULL_SCALE_BITS 4096 ///< Syringe pump DAC has has 4096 full scale counts (12-bit). + +// Bit definitions for syringe pump control register +#define SYRINGE_PUMP_CONTROL_SLEEP_OFF 0x40 ///< Syringe pump control register bit for sleep mode (active low). +#define SYRINGE_PUMP_CONTROL_NOT_RESET 0x20 ///< Syringe pump control register bit for resetting stepper motor (active low). +#define SYRINGE_PUMP_CONTROL_ENABLE 0x00 ///< Syringe pump control register bit mask for enable. +#define SYRINGE_PUMP_CONTROL_DISABLE 0x10 ///< Syringe pump control register bit for enable (active low). +#define SYRINGE_PUMP_CONTROL_REVERSE_DIR 0x08 ///< Syringe pump control register bit for direction (0=fwd, 1=rev). +#define SYRINGE_PUMP_CONTROL_FORWARD_DIR 0x00 ///< Syringe pump control register bit mask for forward direction. +#define SYRINGE_PUMP_CONTROL_32TH_STEP 0x03 ///< Syringe pump control register bits for 1/32 micro-stepping mode. +// Bit definitions for syringe pump ADC/DAC control register +#define SYRINGE_PUMP_ADC_DAC_CONTROL_WR_ADC_SETUP 0x04 ///< Syringe pump ADC/DAC control bit for re-write ADC setup registers to ADC. +#define SYRINGE_PUMP_ADC_DAC_CONTROL_RD_DAC_ON_ADC 0x02 ///< Syringe pump ADC/DAC control bit for reading (once) DAC setting from device. +#define SYRINGE_PUMP_ADC_DAC_CONTROL_ENABLE_DAC 0x01 ///< Syringe pump ADC/DAC control bit for write DAC setting to device (ADC reads are off). +#define SYRINGE_PUMP_ADC_DAC_CONTROL_ENABLE_ADC 0x00 ///< Syringe pump ADC/DAC control bit mask for enable ADC reads. +// Bit definitions for syringe pump ADC/DAC status register +#define SYRINGE_PUMP_ADC_DAC_ERROR_COUNT_DAC_WR_DONE 0x80 ///< Syringe pump ADC/DAC error status bit for DAC write done. +#define SYRINGE_PUMP_ADC_DAC_ERROR_COUNT_DAC_WR_ERROR 0x40 ///< Syringe pump ADC/DAC error status bit for DAC write error. +#define SYRINGE_PUMP_ADC_DAC_ERROR_COUNT_MASK 0x3F ///< Syringe pump ADC/DAC error status count bit-mask. +// Bit definitions for syringe pump encoder status register +#define SYRINGE_PUMP_ENCODER_STATUS_DIRECTION 0x80 ///< Syringe pump encoder status direction bit (0-Fwd, 1=Rev). +#define SYRINGE_PUMP_ENCODER_STATUS_ERROR_COUNT_MASK 0x3F ///< Syringe pump encoder status error count bit-mask. +// Stepper motor toggle time for zero speed (stopped) +#define SYRINGE_PUMP_MICROSTEP_TOGGLE_TIME_FOR_STOP 0xFFFFFFFF ///< Syringe pump microstep toggle time setting to indicate zero speed (stopped). + +/// Control bits to run syringe pump in reverse direction +static const U08 SYRINGE_PUMP_CONTROL_RUN_REVERSE = SYRINGE_PUMP_CONTROL_SLEEP_OFF | + SYRINGE_PUMP_CONTROL_NOT_RESET | + SYRINGE_PUMP_CONTROL_ENABLE | + SYRINGE_PUMP_CONTROL_REVERSE_DIR | + SYRINGE_PUMP_CONTROL_32TH_STEP; +/// Control bits to run syringe pump in forward direction +static const U08 SYRINGE_PUMP_CONTROL_RUN_FORWARD = SYRINGE_PUMP_CONTROL_SLEEP_OFF | + SYRINGE_PUMP_CONTROL_NOT_RESET | + SYRINGE_PUMP_CONTROL_ENABLE | + SYRINGE_PUMP_CONTROL_FORWARD_DIR | + SYRINGE_PUMP_CONTROL_32TH_STEP; + +/// Defined states for the syringe pump control state machine. +typedef enum SyringePump_States +{ + SYRINGE_PUMP_INIT_STATE = 0, ///< Syringe pump initialize state + SYRINGE_PUMP_OFF_STATE, ///< Syringe pump off state + SYRINGE_PUMP_RETRACT_STATE, ///< Syringe pump retract state + SYRINGE_PUMP_SEEK_STATE, ///< Syringe pump seek plunger state + SYRINGE_PUMP_PRIME_STATE, ///< Syringe pump prime state + SYRINGE_PUMP_HEP_BOLUS_STATE, ///< Syringe pump bolus delivery of Heparin state + SYRINGE_PUMP_HEP_CONTINUOUS_STATE, ///< Syringe pump continuous delivery of Heparin state + SYRINGE_PUMP_CONFIG_FORCE_SENSOR_STATE, ///< Syringe pump configure DAC gain for force sensor state + NUM_OF_SYRINGE_PUMP_STATES ///< Number of syringe pump control states +} SYRINGE_PUMP_STATE_T; + +/// Defined states for the pressure and occlusion self-test state machine. +typedef enum Syringe_Pump_Self_Test_States +{ + SYRINGE_PUMP_SELF_TEST_STATE_START = 0, ///< Self test start state. + SYRINGE_PUMP_TEST_STATE_IN_PROGRESS, ///< Self test in progress state. + SYRINGE_PUMP_TEST_STATE_COMPLETE, ///< Self test completed state. + NUM_OF_SYRINGE_PUMP_SELF_TEST_STATES ///< Number of syringe pump self-test states. +} SYRINGE_PUMP_SELF_TEST_STATE_T; + +// ********** private data ********** + +static SYRINGE_PUMP_STATE_T syringePumpState; ///< Current state of syringe pump control state machine. +static U32 syringePumpDataPublicationTimerCounter; ///< Used to schedule syringe pump data publication to CAN bus. + +/// Interval (in ms) at which to publish syringe pump data to CAN bus. +static OVERRIDE_U32_T syringePumpDataPublishInterval = { SYRINGE_PUMP_DATA_PUB_INTERVAL, SYRINGE_PUMP_DATA_PUB_INTERVAL, 0, 0 }; +static OVERRIDE_F32_T syringePumpMeasRate = {0.0, 0.0, 0.0, 0 }; ///< Measured rate for syringe pump (in mL/hr). +static OVERRIDE_F32_T syringePumpMeasForce = {0.0, 0.0, 0.0, 0 }; ///< Measured driver force (in mV). +static OVERRIDE_F32_T syringePumpMeasSyringeDetectionSwitch = {0, 0, 0, 0 }; ///< Measured syringe detect switch (in mV). +static OVERRIDE_F32_T syringePumpMeasHome = {0.0, 0.0, 0.0, 0 }; ///< Measured optical home (in mV). +static OVERRIDE_S32_T syringePumpPosition = {0, 0, 0, 0 }; ///< Encoder based position (in steps). +static OVERRIDE_F32_T syringePumpVolumeDelivered = {0.0, 0.0, 0.0, 0 }; ///< Measured volume delivered (in mL). + +static F32 syringePumpSetRate; ///< Set rate for syringe pump (in mL/hr). +static F32 syringePumpSetSpeed; ///< Set speed for syringe pump (in steps/sec). +static F32 syringePumpMeasSpeed; ///< Measured speed for syringe pump (in steps/sec). +static F32 syringePumpSafetyVolumeDelivered; ///< Calculated volume (in mL) (from set rate over time). +static S32 syringePumpHomePositionOffset; ///< FPGA reported position when at home postion. + +static BOOL syringePumpHasBeenHomed; ///< Flag indicates whether syringe pump has been homed at least once (indicates position is known). +static BOOL syringePumpRetractRequested; ///< Flag indicates a retract operation is requested. +static BOOL syringePumpPrimeRequested; ///< Flag indicates plunger seek and Heparin prime operations are requested. +static BOOL syringePumpBolusRequested; ///< Flag indicates start or resume of a Heparin bolus operation is requested. +static BOOL syringePumpContinuousRequested; ///< Flag indicates start or resume of a Heparin continuous delivery operation is requested. + +static U08 lastSyringePumpADCReadCtr; ///< Remember last ADC read counter to check new reads are fresh. + +static SYRINGE_PUMP_SELF_TEST_STATE_T syringePumpSelfTestState; ///< Current syringe pump self-test state. +static U32 syringePumpSelfTestTimerCount; ///< Timer counter for syringe pump self-test. + +// TODO - test code +static U32 xTimerCtr; + +// ********** private function prototypes ********** + +static void resetSyringePumpRequestFlags( void ); +static void execSyringePumpMonitor( void ); +static SYRINGE_PUMP_STATE_T handleSyringePumpInitState( void ); +static SYRINGE_PUMP_STATE_T handleSyringePumpOffState( void ); +static SYRINGE_PUMP_STATE_T handleSyringePumpRetractState( void ); +static SYRINGE_PUMP_STATE_T handleSyringePumpSeekState( void ); +static SYRINGE_PUMP_STATE_T handleSyringePumpPrimeState( void ); +static SYRINGE_PUMP_STATE_T handleSyringePumpBolusState( void ); +static SYRINGE_PUMP_STATE_T handleSyringePumpContinuousState( void ); +static SYRINGE_PUMP_STATE_T handleSyringePumpCalibrateForceSensorState( void ); +static void publishSyringePumpData( void ); +static U32 getPublishSyringePumpDataInterval( void ); +static S32 getSyringePumpPosition( void ); +static F32 getSyringePumpVolumeDelivered( void ); +static F32 getSyringePumpMeasRate( void ); +static F32 getSyringePumpSyringeDetectorMv( void ); +static F32 getSyringePumpHomeDetectorMv( void ); +static F32 getSyringePumpForceMv( void ); + +/*********************************************************************//** + * @brief + * The initSyringePump function initializes the syringe pump module. + * @details Inputs: none + * @details Outputs: syringe pump module initialized. + * @return none + *************************************************************************/ +void initSyringePump( void ) +{ + syringePumpState = SYRINGE_PUMP_INIT_STATE; + syringePumpSelfTestState = SYRINGE_PUMP_SELF_TEST_STATE_START; + + syringePumpSetRate = 0.0; + syringePumpSetSpeed = 0.0; + syringePumpMeasSpeed = 0.0; + syringePumpSafetyVolumeDelivered = 0.0; + syringePumpHomePositionOffset = 0; + + syringePumpHasBeenHomed = FALSE; + resetSyringePumpRequestFlags(); + + syringePumpDataPublicationTimerCounter = 0; + syringePumpSelfTestTimerCount = 0; + + lastSyringePumpADCReadCtr = 0; +} + +static void resetSyringePumpRequestFlags( void ) +{ + syringePumpRetractRequested = FALSE; + syringePumpPrimeRequested = FALSE; + syringePumpBolusRequested = FALSE; + syringePumpContinuousRequested = FALSE; +} + +void stopSyringePump( void ) +{ + syringePumpSetRate = 0.0; + setFPGASyringePumpStepToggleTime( SYRINGE_PUMP_MICROSTEP_TOGGLE_TIME_FOR_STOP ); +} + +BOOL retractSyringePump( void ) +{ + if ( SYRINGE_PUMP_OFF_STATE == syringePumpState ) + { + syringePumpSetRate = 0.0; // TODO - what is retract rate in mL/hr? + syringePumpRetractRequested = TRUE; + } + + return syringePumpRetractRequested; +} + +BOOL primeSyringePump( void ) +{ + if ( SYRINGE_PUMP_OFF_STATE == syringePumpState ) + { + syringePumpSetRate = 0.0; // TODO - what is seek rate in mL/hr? + syringePumpPrimeRequested = TRUE; + } + + return syringePumpPrimeRequested; +} + +BOOL startHeparinBolus( F32 flowRate ) +{ + if ( ( flowRate >= MIN_HEPARIN_BOLUS_RATE ) && ( flowRate <= MAX_HEPARIN_BOLUS_RATE ) ) + { + if ( SYRINGE_PUMP_OFF_STATE == syringePumpState ) + { + syringePumpSetRate = flowRate; + syringePumpBolusRequested = TRUE; + } + } + else + { + // TODO - s/w fault + } + + return syringePumpBolusRequested; +} + +BOOL startHeparinContinuous( F32 flowRate ) +{ + if ( ( flowRate >= MIN_HEPARIN_CONTINUOUS_RATE ) && ( flowRate <= MAX_HEPARIN_CONTINUOUS_RATE ) ) + { + if ( SYRINGE_PUMP_OFF_STATE == syringePumpState ) + { + syringePumpSetRate = flowRate; + syringePumpContinuousRequested = TRUE; + } + } + else + { + // TODO - s/w fault + } + + return syringePumpContinuousRequested; +} + +/*********************************************************************//** + * @brief + * The getPublishSyringePumpDataInterval function gets the syringe pump data + * publication interval. + * @details Inputs: syringePumpDataPublishInterval + * @details Outputs: none + * @return the current syringe pump data publication interval (in task intervals). + *************************************************************************/ +static U32 getPublishSyringePumpDataInterval( void ) +{ + U32 result = syringePumpDataPublishInterval.data; + + if ( OVERRIDE_KEY == syringePumpDataPublishInterval.override ) + { + result = syringePumpDataPublishInterval.ovData; + } + + return result; +} + +static F32 getSyringePumpVolumeDelivered( void ) +{ + F32 result = syringePumpVolumeDelivered.data; + + if ( OVERRIDE_KEY == syringePumpVolumeDelivered.override ) + { + result = syringePumpVolumeDelivered.ovData; + } + + return result; +} + +static F32 getSyringePumpMeasRate( void ) +{ + F32 result = syringePumpMeasRate.data; + + if ( OVERRIDE_KEY == syringePumpMeasRate.override ) + { + result = syringePumpMeasRate.ovData; + } + + return result; +} + +static S32 getSyringePumpPosition( void ) +{ + S32 result = syringePumpPosition.data; + + if ( OVERRIDE_KEY == syringePumpPosition.override ) + { + result = syringePumpPosition.ovData; + } + + return result; +} + +static F32 getSyringePumpSyringeDetectorMv( void ) +{ + F32 result = syringePumpMeasSyringeDetectionSwitch.data; + + if ( OVERRIDE_KEY == syringePumpMeasSyringeDetectionSwitch.override ) + { + result = syringePumpMeasSyringeDetectionSwitch.ovData; + } + + return result; +} + +static F32 getSyringePumpHomeDetectorMv( void ) +{ + F32 result = syringePumpMeasHome.data; + + if ( OVERRIDE_KEY == syringePumpMeasHome.override ) + { + result = syringePumpMeasHome.ovData; + } + + return result; +} + +/*********************************************************************//** + * @brief + * The getSyringePumpForceMv function gets the current syringe pump force. + * @details Inputs: syringePumpMeasForce + * @details Outputs: none + * @return the current syringe pump force (in mV). + *************************************************************************/ +static F32 getSyringePumpForceMv( void ) +{ + F32 result = syringePumpMeasForce.data; + + if ( OVERRIDE_KEY == syringePumpMeasForce.override ) + { + result = syringePumpMeasForce.ovData; + } + + return result; +} + +static void execSyringePumpMonitor( void ) +{ + S32 encPosition = getFPGASyringePumpEncoderPosition(); + U08 pmpStatus = getFPGASyringePumpStatus(); + U08 encStatus = getFPGASyringePumpEncoderStatus(); + U08 adcReadCtr = getFPGASyringePumpADCReadCounter(); + U08 adcDACStatus= getFPGASyringePumpADCandDACStatus(); + + // get latest ADC data and convert to mV + syringePumpMeasHome.data = ( (F32)getFPGASyringePumpADCChannel2() * SYRINGE_PUMP_ADC_REF_V ) / SYRINGE_PUMP_ADC_FULL_SCALE_BITS; + syringePumpMeasSyringeDetectionSwitch.data = ( (F32)getFPGASyringePumpADCChannel1() * SYRINGE_PUMP_ADC_REF_V ) / SYRINGE_PUMP_ADC_FULL_SCALE_BITS; + syringePumpMeasForce.data = ( (F32)getFPGASyringePumpADCChannel0() * SYRINGE_PUMP_ADC_REF_V ) / SYRINGE_PUMP_ADC_FULL_SCALE_BITS; + // apply home offset to encoder position + syringePumpPosition.data = encPosition - syringePumpHomePositionOffset; + + // check ADC read is fresh + if ( lastSyringePumpADCReadCtr == adcReadCtr ) + { + // TODO - fault + } + lastSyringePumpADCReadCtr = adcReadCtr; +} + +/*********************************************************************//** + * @brief + * The execSyringePump function executes the syringe pump control state machine. + * @details Inputs: syringePumpState + * @details Outputs: syringePumpState + * @return none + *************************************************************************/ +void execSyringePump( void ) +{ + // Execute syringe pump monitor + execSyringePumpMonitor(); + + // Execute syringe pump control state machine + switch ( syringePumpState ) + { + case SYRINGE_PUMP_INIT_STATE: + syringePumpState = handleSyringePumpInitState(); + break; + + case SYRINGE_PUMP_OFF_STATE: + syringePumpState = handleSyringePumpOffState(); + break; + + case SYRINGE_PUMP_RETRACT_STATE: + syringePumpState = handleSyringePumpRetractState(); + break; + + case SYRINGE_PUMP_SEEK_STATE: + syringePumpState = handleSyringePumpSeekState(); + break; + + case SYRINGE_PUMP_PRIME_STATE: + syringePumpState = handleSyringePumpPrimeState(); + break; + + case SYRINGE_PUMP_HEP_BOLUS_STATE: + syringePumpState = handleSyringePumpBolusState(); + break; + + case SYRINGE_PUMP_HEP_CONTINUOUS_STATE: + syringePumpState = handleSyringePumpContinuousState(); + break; + + case SYRINGE_PUMP_CONFIG_FORCE_SENSOR_STATE: + syringePumpState = handleSyringePumpCalibrateForceSensorState(); + break; + + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, 0, syringePumpState ) // TODO - replace 0 with appropriate enum + break; + } + + // Publish syringe pump data on interval + publishSyringePumpData(); +} + +/*********************************************************************//** + * @brief + * The handleSyringePumpInitState function handles the pres/occl initialize state + * of the syringe pump control state machine. + * @details Inputs: TBD + * @details Outputs: TBD + * @return next state + *************************************************************************/ +static SYRINGE_PUMP_STATE_T handleSyringePumpInitState( void ) +{ + SYRINGE_PUMP_STATE_T result = SYRINGE_PUMP_OFF_STATE; + + // Set FPGA rate to zero + setFPGASyringePumpStepToggleTime( SYRINGE_PUMP_MICROSTEP_TOGGLE_TIME_FOR_STOP ); + // Set FPGA control bits for ADC/DAC + setFPGASyringePumpADCandDACControlFlags( SYRINGE_PUMP_ADC_DAC_CONTROL_RD_DAC_ON_ADC | SYRINGE_PUMP_ADC_DAC_CONTROL_ENABLE_ADC ); + // Set FPGA control bits for stepper motor (enable, no sleep, dir=FWD, ...) + setFPGASyringePumpControlFlags( SYRINGE_PUMP_CONTROL_RUN_REVERSE ); + + return result; +} + +/*********************************************************************//** + * @brief + * The handleSyringePumpOffState function handles the pres/occl initialize state + * of the syringe pump control state machine. + * @details Inputs: TBD + * @details Outputs: TBD + * @return next state + *************************************************************************/ +static SYRINGE_PUMP_STATE_T handleSyringePumpOffState( void ) +{ + SYRINGE_PUMP_STATE_T result = SYRINGE_PUMP_OFF_STATE; + + // TODO - check position is not changing while stopped + + // Check for request flags + if ( TRUE == syringePumpRetractRequested ) + { + result = SYRINGE_PUMP_RETRACT_STATE; + } + else if ( TRUE == syringePumpPrimeRequested ) + { + result = SYRINGE_PUMP_SEEK_STATE; + } + else if ( TRUE == syringePumpBolusRequested ) + { + result = SYRINGE_PUMP_HEP_BOLUS_STATE; + } + else if ( TRUE == syringePumpContinuousRequested ) + { + result = SYRINGE_PUMP_HEP_CONTINUOUS_STATE; + } + + if ( result != SYRINGE_PUMP_OFF_STATE ) + { + if ( SYRINGE_PUMP_RETRACT_STATE == result ) + { + // Set fpga direction to reverse + setFPGASyringePumpControlFlags( SYRINGE_PUMP_CONTROL_RUN_REVERSE ); + } + else + { + // Set fpga direction to forward + setFPGASyringePumpControlFlags( SYRINGE_PUMP_CONTROL_RUN_FORWARD ); + } + // Set fpga rate to set rate converted to microstep interval in uSec/2 + setFPGASyringePumpStepToggleTime( syringePumpSetRate ); // TODO - convert set rate (mL/hr) to miscrostep toggle time + } + + // TODO - test code + xTimerCtr = 0; + + return result; +} + +/*********************************************************************//** + * @brief + * The handleSyringePumpRetractState function handles the pres/occl initialize state + * of the syringe pump control state machine. + * @details Inputs: TBD + * @details Outputs: TBD + * @return next state + *************************************************************************/ +static SYRINGE_PUMP_STATE_T handleSyringePumpRetractState( void ) +{ + SYRINGE_PUMP_STATE_T result = SYRINGE_PUMP_RETRACT_STATE; + + // TODO - timer is test code, 3.0 is placeholder for home threshold, 1.0 is placeholder for syringe detected threshold + if ( ( ++xTimerCtr > 100 ) || ( getSyringePumpHomeDetectorMv() > 3.0 ) || ( getSyringePumpSyringeDetectorMv() < 1.0 ) ) + { // Retract reached home + setFPGASyringePumpStepToggleTime( SYRINGE_PUMP_MICROSTEP_TOGGLE_TIME_FOR_STOP ); + if ( getSyringePumpHomeDetectorMv() > 3.0 ) + { + syringePumpHomePositionOffset = getFPGASyringePumpEncoderPosition(); + syringePumpPosition.data = 0; + } + else + { + // TODO - alarm + } + result = SYRINGE_PUMP_OFF_STATE; + } + + return result; +} + +/*********************************************************************//** + * @brief + * The handleSyringePumpSeekState function handles the pres/occl initialize state + * of the syringe pump control state machine. + * @details Inputs: TBD + * @details Outputs: TBD + * @return next state + *************************************************************************/ +static SYRINGE_PUMP_STATE_T handleSyringePumpSeekState( void ) +{ + SYRINGE_PUMP_STATE_T result = SYRINGE_PUMP_SEEK_STATE; + + return result; +} +//void setFPGASyringePumpControlFlags( U08 bitFlags ); +//void setFPGASyringePumpADCandDACControlFlags( U08 bitFlags ); +//void setFPGASyringePumpDACOutputLevel( U16 counts ); +//void setFPGASyringePumpStepToggleTime( U32 microSeconds ); +//U08 getFPGASyringePumpStatus( void ); +//U08 getFPGASyringePumpADCReadCounter( void ); +//U08 getFPGASyringePumpADCandDACStatus( void ); +//U08 getFPGASyringePumpEncoderStatus( void ); +//U32 getFPGASyringePumpEncoderPosition( void ); +//U16 getFPGASyringePumpADCChannel0( void ); +//U16 getFPGASyringePumpADCChannel1( void ); +//U16 getFPGASyringePumpADCChannel2( void ); +//U16 getFPGASyringePumpADCChannel3( void ); +//// Bit definitions for syringe pump control register +//#define SYRINGE_PUMP_CONTROL_SLEEP_OFF 0x40 ///< Syringe pump control register bit for sleep mode (active low). +//#define SYRINGE_PUMP_CONTROL_NOT_RESET 0x20 ///< Syringe pump control register bit for resetting stepper motor (active low). +//#define SYRINGE_PUMP_CONTROL_ENABLE 0x00 ///< Syringe pump control register bit mask for enable. +//#define SYRINGE_PUMP_CONTROL_DISABLE 0x10 ///< Syringe pump control register bit for enable (active low). +//#define SYRINGE_PUMP_CONTROL_REVERSE_DIR 0x08 ///< Syringe pump control register bit for direction (0=fwd, 1=rev). +//#define SYRINGE_PUMP_CONTROL_FORWARD_DIR 0x00 ///< Syringe pump control register bit mask for forward direction. +//#define SYRINGE_PUMP_CONTROL_32TH_STEP 0x03 ///< Syringe pump control register bits for 1/32 micro-stepping mode. +//// Bit definitions for syringe pump ADC/DAC control register +//#define SYRINGE_PUMP_ADC_DAC_CONTROL_WR_ADC_SETUP 0x04 ///< Syringe pump ADC/DAC control bit for re-write ADC setup registers to ADC. +//#define SYRINGE_PUMP_ADC_DAC_CONTROL_RD_DAC_ON_ADC 0x02 ///< Syringe pump ADC/DAC control bit for reading (once) DAC setting from device. +//#define SYRINGE_PUMP_ADC_DAC_CONTROL_ENABLE_DAC 0x01 ///< Syringe pump ADC/DAC control bit for write DAC setting to device (ADC reads are off). +//#define SYRINGE_PUMP_ADC_DAC_CONTROL_ENABLE_ADC 0x00 ///< Syringe pump ADC/DAC control bit mask for enable ADC reads. +//// Bit definitions for syringe pump ADC/DAC status register +//#define SYRINGE_PUMP_ADC_DAC_ERROR_COUNT_DAC_WR_DONE 0x80 ///< Syringe pump ADC/DAC error status bit for DAC write done. +//#define SYRINGE_PUMP_ADC_DAC_ERROR_COUNT_DAC_WR_ERROR 0x40 ///< Syringe pump ADC/DAC error status bit for DAC write error. +//#define SYRINGE_PUMP_ADC_DAC_ERROR_COUNT_MASK 0x3F ///< Syringe pump ADC/DAC error status count bit-mask. +//// Bit definitions for syringe pump encoder status register +//#define SYRINGE_PUMP_ENCODER_STATUS_DIRECTION 0x80 ///< Syringe pump encoder status direction bit (0-Fwd, 1=Rev). +//#define SYRINGE_PUMP_ENCODER_STATUS_ERROR_COUNT_MASK 0x3F ///< Syringe pump encoder status error count bit-mask. + +/*********************************************************************//** + * @brief + * The handleSyringePumpPrimeState function handles the pres/occl initialize state + * of the syringe pump control state machine. + * @details Inputs: TBD + * @details Outputs: TBD + * @return next state + *************************************************************************/ +static SYRINGE_PUMP_STATE_T handleSyringePumpPrimeState( void ) +{ + SYRINGE_PUMP_STATE_T result = SYRINGE_PUMP_PRIME_STATE; + + return result; +} + +/*********************************************************************//** + * @brief + * The handleSyringePumpBolusState function handles the pres/occl initialize state + * of the syringe pump control state machine. + * @details Inputs: TBD + * @details Outputs: TBD + * @return next state + *************************************************************************/ +static SYRINGE_PUMP_STATE_T handleSyringePumpBolusState( void ) +{ + SYRINGE_PUMP_STATE_T result = SYRINGE_PUMP_HEP_BOLUS_STATE; + + return result; +} + +/*********************************************************************//** + * @brief + * The handleSyringePumpContinuousState function handles the continuous state + * of the syringe pump control state machine. + * @details Inputs: TBD + * @details Outputs: TBD + * @return next state + *************************************************************************/ +static SYRINGE_PUMP_STATE_T handleSyringePumpContinuousState( void ) +{ + SYRINGE_PUMP_STATE_T result = SYRINGE_PUMP_HEP_CONTINUOUS_STATE; + + return result; +} + +/*********************************************************************//** + * @brief + * The handleSyringePumpCalibrateForceSensorState function handles the + * calibrate force sensor state of the syringe pump control state machine. + * of the pressure/occlusion monitor state machine. + * @details Inputs: TBD + * @details Outputs: TBD + * @return next state + *************************************************************************/ +static SYRINGE_PUMP_STATE_T handleSyringePumpCalibrateForceSensorState( void ) +{ + SYRINGE_PUMP_STATE_T result = SYRINGE_PUMP_CONFIG_FORCE_SENSOR_STATE; + + return result; +} + +/*********************************************************************//** + * @brief + * The publishSyringePumpData function publishes syringe pump data at the + * set interval. + * @details Inputs: latest syringe pump data, syringePumpDataPublicationTimerCounter + * @details Outputs: Syringe pump data are published to CAN bus. + * @return none + *************************************************************************/ +static void publishSyringePumpData( void ) +{ + // Publish syringe pump data on interval + if ( ++syringePumpDataPublicationTimerCounter >= getPublishSyringePumpDataInterval() ) + { + SYRINGE_PUMP_DATA_PAYLOAD_T data; + + data.syringePumpMeasForce = getSyringePumpForceMv(); + data.syringePumpMeasHome = getSyringePumpHomeDetectorMv(); + data.syringePumpMeasRate = getSyringePumpMeasRate(); + data.syringePumpMeasSwitch = getSyringePumpSyringeDetectorMv(); + data.syringePumpPosition = getSyringePumpPosition(); + data.syringePumpSetRate = syringePumpSetRate; + data.syringePumpState = (U32)syringePumpState; + data.syringePumpVolumeDelivered = getSyringePumpVolumeDelivered(); + + broadcastSyringePumpData( data ); + syringePumpDataPublicationTimerCounter = 0; + } +} + +/*********************************************************************//** + * @brief + * The execSyringePumpTest function executes the state machine for the + * syringe pump self-test. + * @details Inputs: none + * @details Outputs: none + * @return the current state of the syringe pump self-test. + *************************************************************************/ +SELF_TEST_STATUS_T execSyringePumpTest( void ) +{ + SELF_TEST_STATUS_T result = SELF_TEST_STATUS_FAILED; + + // TODO - implement self-test(s) + + return result; +} + + +/************************************************************************* + * TEST SUPPORT FUNCTIONS + *************************************************************************/ + + +/*********************************************************************//** + * @brief + * The testSetSyringePumpDataPublishIntervalOverride function overrides the + * syringe pump data publish interval. + * @details Inputs: none + * @details Outputs: syringePumpDataPublishInterval + * @param value override syringe pump data publish interval with (in ms) + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testSetSyringePumpDataPublishIntervalOverride( U32 value ) +{ + BOOL result = FALSE; + + if ( TRUE == isTestingActivated() ) + { + U32 intvl = value / TASK_PRIORITY_INTERVAL; + + result = TRUE; + syringePumpDataPublishInterval.ovData = intvl; + syringePumpDataPublishInterval.override = OVERRIDE_KEY; + } + + return result; +} + +/*********************************************************************//** + * @brief + * The testResetSyringePumpDataPublishIntervalOverride function resets the override + * of the syringe pump data publish interval. + * @details Inputs: none + * @details Outputs: syringePumpDataPublishInterval + * @return TRUE if override reset successful, FALSE if not + *************************************************************************/ +BOOL testResetSyringePumpDataPublishIntervalOverride( void ) +{ + BOOL result = FALSE; + + if ( TRUE == isTestingActivated() ) + { + result = TRUE; + syringePumpDataPublishInterval.override = OVERRIDE_RESET; + syringePumpDataPublishInterval.ovData = syringePumpDataPublishInterval.ovInitData; + } + + return result; +} + +/**@}*/ Index: firmware/App/Controllers/SyringePump.h =================================================================== diff -u --- firmware/App/Controllers/SyringePump.h (revision 0) +++ firmware/App/Controllers/SyringePump.h (revision 88fd90befbce61886ae47ad7d20ec863319cfa34) @@ -0,0 +1,68 @@ +/************************************************************************** +* +* Copyright (c) 2019-2020 Diality Inc. - All Rights Reserved. +* +* THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN +* WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. +* +* @file SyringePump.h +* +* @author (last) Sean Nash +* @date (last) 02-Mar-2021 +* +* @author (original) Sean Nash +* @date (original) 02-Mar-2021 +* +***************************************************************************/ + +#ifndef __SYRINGE_PUMP_H__ +#define __SYRINGE_PUMP_H__ + +#include "HDCommon.h" + +/** + * @defgroup SyringePump SyringePump + * @brief Syringe pump controller/monitor module. Controls the syringe pump + * and monitors status. + * + * @addtogroup SyringePump + * @{ + */ + +// ********** public definitions ********** + +/// Payload record structure for the pressure & occlusions data message. +typedef struct +{ + U32 syringePumpState; + F32 syringePumpSetRate; + F32 syringePumpMeasRate; + S32 syringePumpPosition; + F32 syringePumpVolumeDelivered; + F32 syringePumpMeasHome; + F32 syringePumpMeasSwitch; + F32 syringePumpMeasForce; +} SYRINGE_PUMP_DATA_PAYLOAD_T; + +// ********** public function prototypes ********** + +void initSyringePump( void ); +void execSyringePump( void ); + +void stopSyringePump( void ); +BOOL retractSyringePump( void ); +BOOL primeSyringePump( void ); +BOOL startHeparinBolus( F32 flowRate ); +BOOL startHeparinContinuous( F32 flowRate ); + +BOOL isSyringeDetected( void ); +BOOL isSyringePumpHome( void ); + +SELF_TEST_STATUS_T execSyringePumpTest( void ); + +BOOL testSetSyringePumpDataPublishIntervalOverride( U32 value ); +BOOL testResetSyringePumpDataPublishIntervalOverride( void ); + +/**@}*/ + +#endif Index: firmware/App/Services/FPGA.c =================================================================== diff -u -rf7b149d8b8c9ea6ac58e4739101693d251d7a355 -r88fd90befbce61886ae47ad7d20ec863319cfa34 --- firmware/App/Services/FPGA.c (.../FPGA.c) (revision f7b149d8b8c9ea6ac58e4739101693d251d7a355) +++ firmware/App/Services/FPGA.c (.../FPGA.c) (revision 88fd90befbce61886ae47ad7d20ec863319cfa34) @@ -169,13 +169,15 @@ U16 VDiPWMTarget; ///< Reg 374. PWM target duty cycle for VDi pinch valve. U16 VDoPWMTarget; ///< Reg 376. PWM target duty cycle for VDo pinch valve. U16 VSparePWMTarget; ///< Reg 378. PWM target duty cycle for Vspare pinch valve. - U16 SyringePumpStatus; ///< Reg 380. Syringe pump status register - U16 SyringePumpEncStatus; ///< Reg 382. Syringe pump encoder status - U32 SyringePumpEncPosition; ///< Reg 384. Syringe pump encoder position - U16 sPumpAdcDataReadChannel0; ///< Reg 388. - U16 sPumpAdcDataReadCh1; ///< Reg 390. - U16 sPumpAdcDataReadCh2; ///< Reg 392. - U16 sPumpAdcDataReadCh3; ///< Reg 394. + U08 syringePumpStatus; ///< Reg 380. Syringe pump status register. + U08 syringePumpADCReadCounter; ///< Reg 381. Syringe pump ADC read counter. + U08 syringePumpADCandDACStatus; ///< Reg 382. Syringe pump ADC and DAC status register. + U08 syringePumpEncoderStatus; ///< Reg 383. Syringe pump encoder status register. + U32 syringePumpEncPosition; ///< Reg 384. Syringe pump encoder position + U16 syringePumpAdcDataReadCh0; ///< Reg 388. Syringe pump ADC channel 0 register (10 bit). + U16 syringePumpAdcDataReadCh1; ///< Reg 390. Syringe pump ADC channel 1 register (10 bit). + U16 syringePumpAdcDataReadCh2; ///< Reg 392. Syringe pump ADC channel 2 register (10 bit). + U16 syringePumpAdcDataReadCh3; ///< Reg 394. Syringe pump ADC channel 3 register (10 bit). U16 VBASpeed; ///< Reg 396. VBA pinch valve speed (Register VAUX0) U16 VBVSpeed; ///< Reg 398. VBV pinch valve speed (Register VAUX1) U16 VBVCurrent; ///< Reg 400. VBV pinch valve current (Register VAUX2) @@ -203,7 +205,11 @@ U16 VDiPWMFixed; ///< Reg 28. VDi PWM set to fixed current by setting fixed PWM duty cycle. Range 750 to 4250. < 2500 is reverse direction. U16 VDoPWMFixed; ///< Reg 30. VDo PWM set to fixed current by setting fixed PWM duty cycle. Range 750 to 4250. < 2500 is reverse direction. U16 VSparePWMFixed; ///< Reg 32. Vspare PWM set to fixed current by setting fixed PWM duty cycle. Range 750 to 4250. < 2500 is reverse direction. - U08 AlarmControl; ///< Reg 34. Alarm (audio) control register. + U08 alarmControl; ///< Reg 34. Alarm (audio) control register. + U08 syringePumpControl; ///< Reg 35. Syringe pump control register. + U32 syringePumpStepToggleTime; ///< Reg 36. Syringe pump step time toggle register. Sets time between step toggle which dictates stepper motor speed. + U16 syringePumpDACOut; ///< Reg 40. Syringe pump DAC output level (12-bit). + U08 syringePumpADCandDACControl; ///< Reg 42. Syringe pump ADC and DAC control register. } FPGA_ACTUATORS_T; // TODO clean up the struct @@ -302,7 +308,7 @@ memset( &fpgaHeader, 0, sizeof(FPGA_HEADER_T) ); memset( &fpgaSensorReadings, 0, sizeof(FPGA_SENSORS_T) ); memset( &fpgaActuatorSetPoints, 0, sizeof(FPGA_ACTUATORS_T) ); - fpgaActuatorSetPoints.AlarmControl = (U08)MIN_ALARM_VOLUME_ATTENUATION << 2; // Start alarm audio volume at maximum + fpgaActuatorSetPoints.alarmControl = (U08)MIN_ALARM_VOLUME_ATTENUATION << 2; // Start alarm audio volume at maximum // Initialize fpga comm buffers memset( &fpgaWriteCmdBuffer, 0, FPGA_WRITE_CMD_BUFFER_LEN ); @@ -1077,15 +1083,15 @@ U08 audioCmd = (U08)state; audioCmd |= ( (U08)volumeLevel << 2 ); - fpgaActuatorSetPoints.AlarmControl = audioCmd; + fpgaActuatorSetPoints.alarmControl = audioCmd; } else { U08 audioCmd = (U08)ALARM_PRIORITY_HIGH; // Set alarm audio to high priority, max volume for safety since s/w seems to be having trouble setting audio correctly audioCmd |= ( (U08)MIN_ALARM_VOLUME_ATTENUATION << 2 ); - fpgaActuatorSetPoints.AlarmControl = audioCmd; + fpgaActuatorSetPoints.alarmControl = audioCmd; // S/w fault to indicate issue w/ s/w SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_FPGA_INVALID_ALARM_AUDIO_PARAM, volumeLevel ) @@ -1330,6 +1336,71 @@ return fpgaSensorReadings.venousPressure; } +void setFPGASyringePumpControlFlags( U08 bitFlags ) +{ + fpgaActuatorSetPoints.syringePumpControl = bitFlags; +} + +void setFPGASyringePumpADCandDACControlFlags( U08 bitFlags ) +{ + fpgaActuatorSetPoints.syringePumpADCandDACControl = bitFlags; +} + +void setFPGASyringePumpDACOutputLevel( U16 counts ) +{ + fpgaActuatorSetPoints.syringePumpDACOut = counts; +} + +void setFPGASyringePumpStepToggleTime( U32 microSeconds ) +{ + fpgaActuatorSetPoints.syringePumpStepToggleTime = microSeconds; +} + +U08 getFPGASyringePumpStatus( void ) +{ + return fpgaSensorReadings.syringePumpStatus; +} + +U08 getFPGASyringePumpADCReadCounter( void ) +{ + return fpgaSensorReadings.syringePumpADCReadCounter; +} + +U08 getFPGASyringePumpADCandDACStatus( void ) +{ + return fpgaSensorReadings.syringePumpADCandDACStatus; +} + +U08 getFPGASyringePumpEncoderStatus( void ) +{ + return fpgaSensorReadings.syringePumpEncoderStatus; +} + +U32 getFPGASyringePumpEncoderPosition( void ) +{ + return fpgaSensorReadings.syringePumpEncPosition; +} + +U16 getFPGASyringePumpADCChannel0( void ) +{ + return fpgaSensorReadings.syringePumpAdcDataReadCh0; +} + +U16 getFPGASyringePumpADCChannel1( void ) +{ + return fpgaSensorReadings.syringePumpAdcDataReadCh1; +} + +U16 getFPGASyringePumpADCChannel2( void ) +{ + return fpgaSensorReadings.syringePumpAdcDataReadCh2; +} + +U16 getFPGASyringePumpADCChannel3( void ) +{ + return fpgaSensorReadings.syringePumpAdcDataReadCh3; +} + /*********************************************************************//** * @brief * The getFPGAAccelAxes function gets the accelerometer axis readings. Index: firmware/App/Services/FPGA.h =================================================================== diff -u -rf7b149d8b8c9ea6ac58e4739101693d251d7a355 -r88fd90befbce61886ae47ad7d20ec863319cfa34 --- firmware/App/Services/FPGA.h (.../FPGA.h) (revision f7b149d8b8c9ea6ac58e4739101693d251d7a355) +++ firmware/App/Services/FPGA.h (.../FPGA.h) (revision 88fd90befbce61886ae47ad7d20ec863319cfa34) @@ -69,6 +69,20 @@ U16 getFPGADialInPumpOcclusion( void ); U16 getFPGADialOutPumpOcclusion( void ); +void setFPGASyringePumpControlFlags( U08 bitFlags ); +void setFPGASyringePumpADCandDACControlFlags( U08 bitFlags ); +void setFPGASyringePumpDACOutputLevel( U16 counts ); +void setFPGASyringePumpStepToggleTime( U32 microSeconds ); +U08 getFPGASyringePumpStatus( void ); +U08 getFPGASyringePumpADCReadCounter( void ); +U08 getFPGASyringePumpADCandDACStatus( void ); +U08 getFPGASyringePumpEncoderStatus( void ); +U32 getFPGASyringePumpEncoderPosition( void ); +U16 getFPGASyringePumpADCChannel0( void ); +U16 getFPGASyringePumpADCChannel1( void ); +U16 getFPGASyringePumpADCChannel2( void ); +U16 getFPGASyringePumpADCChannel3( void ); + void getFPGAAccelAxes( S16 *x, S16 *y, S16 *z ); void getFPGAAccelMaxes( S16 *xm, S16*ym, S16*zm ); void getFPGAAccelStatus( U16 *cnt, U16 *accelFPGAFaultReg ); Index: firmware/App/Services/SystemCommMessages.c =================================================================== diff -u -r27f3db92495948d4c1192421c1b0c20338c4a034 -r88fd90befbce61886ae47ad7d20ec863319cfa34 --- firmware/App/Services/SystemCommMessages.c (.../SystemCommMessages.c) (revision 27f3db92495948d4c1192421c1b0c20338c4a034) +++ firmware/App/Services/SystemCommMessages.c (.../SystemCommMessages.c) (revision 88fd90befbce61886ae47ad7d20ec863319cfa34) @@ -1021,6 +1021,34 @@ result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_BROADCAST, ACK_NOT_REQUIRED ); return result; +} + +/*********************************************************************//** + * @brief + * The broadcastSyringePumpData function constructs a syringe pump data + * msg to be broadcast and queues the msg for transmit on the appropriate CAN channel. + * @details Inputs: none + * @details Outputs: syringe pump data msg constructed and queued. + * @param data syringe pump data record + * @return TRUE if msg successfully queued for transmit, FALSE if not + *************************************************************************/ +BOOL broadcastSyringePumpData( SYRINGE_PUMP_DATA_PAYLOAD_T data ) +{ + BOOL result; + MESSAGE_T msg; + U08 *payloadPtr = msg.payload; + + // Create a message record + blankMessage( &msg ); + msg.hdr.msgID = MSG_ID_HD_SYRINGE_PUMP_DATA; + msg.hdr.payloadLen = sizeof( SYRINGE_PUMP_DATA_PAYLOAD_T ); + + memcpy( payloadPtr, &data, sizeof( SYRINGE_PUMP_DATA_PAYLOAD_T ) ); + + // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer + result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_BROADCAST, ACK_NOT_REQUIRED ); + + return result; } /*********************************************************************//** Index: firmware/App/Services/SystemCommMessages.h =================================================================== diff -u -r27f3db92495948d4c1192421c1b0c20338c4a034 -r88fd90befbce61886ae47ad7d20ec863319cfa34 --- firmware/App/Services/SystemCommMessages.h (.../SystemCommMessages.h) (revision 27f3db92495948d4c1192421c1b0c20338c4a034) +++ firmware/App/Services/SystemCommMessages.h (.../SystemCommMessages.h) (revision 88fd90befbce61886ae47ad7d20ec863319cfa34) @@ -32,6 +32,7 @@ #include "NVDataMgmt.h" #include "PresOccl.h" #include "Rinseback.h" +#include "SyringePump.h" #include "Valves.h" /** @@ -235,7 +236,10 @@ BOOL broadcastDialInFlowData( DIALIN_PUMP_STATUS_PAYLOAD_T *dialInData ); // MSG_ID_DIALYSATE_OUT_FLOW_DATA -BOOL broadcastDialOutFlowData( DIAL_OUT_FLOW_DATA_T *dialOutFlowData ); +BOOL broadcastDialOutFlowData( DIAL_OUT_FLOW_DATA_T *dialOutFlowData ); + +// MSG_ID_HD_SYRINGE_PUMP_DATA +BOOL broadcastSyringePumpData( SYRINGE_PUMP_DATA_PAYLOAD_T data ); // MSG_ID_PRESSURE_OCCLUSION_DATA BOOL broadcastPresOcclData( PRESSURE_OCCLUSION_DATA_T data );