MainController Class Reference

Controls breathing cycle. More...

#include <main_controller.h>

Public Member Functions
	MainController ()
	Default constructor. More...
void	setup ()
	Initialize actuators. More...
void	initRespiratoryCycle ()
	Begin a respiratory cycle. More...
void	endRespiratoryCycle (uint32_t p_currentMillis)
	End a respiratory cycle. More...
void	updateTick (uint32_t p_tick)
	Input a tick number. More...
void	updatePressure (int16_t p_currentPressure)
	Input a pressure reading. More...
void	updateInspiratoryFlow (int32_t p_currentInspiratoryFlow)
	Input an inspiratory flow reading. More...
void	updateExpiratoryFlow (int32_t p_currentExpiratoryFlow)
	Input an expiratory flow reading. More...
void	updateFakeExpiratoryFlow ()
	Calculate expiratory flow from pressure and valve angle. More...
void	compute ()
	Perform the pressure control. More...
void	onVentilationModeSet (uint16_t p_ventilationControllerMode)
	Set ventilation mode. More...
void	onInspiratoryTriggerFlowSet (uint16_t p_inspiratoryTriggerFlow)
	Set inspiratory trigger flow. More...
void	onExpiratoryTriggerFlowSet (uint16_t p_expiratoryTriggerFlow)
	Set expiratory trigger flow. More...
void	onTiMinSet (uint16_t p_tiMin)
	Set min inspiratory time. More...
void	onTiMaxSet (uint16_t p_tiMax)
	Set max inspiratory time. More...
void	onLowInspiratoryMinuteVolumeAlarmThresholdSet (uint16_t p_lowInspiratoryMinuteVolumeAlarmThreshold)
	Set alarm threshold for low inspiratory minute volume. More...
void	onHighInspiratoryMinuteVolumeAlarmThresholdSet (uint16_t p_highInspiratoryMinuteVolumeAlarmThreshold)
	Set alarm threshold for high inspiratory minute volume. More...
void	onLowExpiratoryMinuteVolumeAlarmThresholdSet (uint16_t p_lowExpiratoryMinuteVolumeAlarmThreshold)
	Set alarm threshold for low expiratory minute volume. More...
void	onHighExpiratoryMinuteVolumeAlarmThresholdSet (uint16_t p_highExpiratoryMinuteVolumeAlarmThreshold)
	Set alarm threshold for high expiratory minute volume. More...
void	onlowRespiratoryRateAlarmThresholdSet (uint16_t p_lowRespiratoryRateAlarmThreshold)
	Set alarm threshold for low respiratory rate. More...
void	onhighRespiratoryRateAlarmThresholdSet (uint16_t p_highRespiratoryRateAlarmThreshold)
	Set alarm threshold for high respiratory rate. More...
void	onTargetTidalVolumeSet (uint16_t p_targetTidalVolume)
	Set target tidal volume (used in VC modes) More...
void	onLowTidalVolumeAlarmThresholdSet (uint16_t p_lowTidalVolumeAlarmThreshold)
	Set threshold on tidal volume below which an alarm is raised. More...
void	onHighTidalVolumeAlarmThresholdSet (uint16_t p_highTidalVolumeAlarmThreshold)
	Set threshold on tidal volume for which an alarm is raised. More...
void	onPlateauDurationSet (uint16_t p_plateauDuration)
	Set the duration of Pause at the end of expiration in VC modes. More...
void	onLeakAlarmThresholdSet (uint16_t p_leakAlarmThreshold)
	Set the threshold for leak that raise the alarm. More...
void	onTargetInspiratoryFlow (uint16_t p_targetInspiratoryFlow)
	Set the inspiratory flow target. More...
void	onInspiratoryDuration (uint16_t p_inspiratoryDuration)
	Set the inspiration duration. More...
void	onCycleDecrease ()
	Decrease the desired number of cycles per minute. More...
void	onCycleIncrease ()
	Increase the desired number of cycles per minute. More...
void	onCycleSet (uint16_t p_cpm)
	Set the desired number of cycles per minute. More...
void	onPeepPressureDecrease ()
	Decrease the minimal PEEP desired. More...
void	onPeepPressureIncrease ()
	Increase the minimal PEEP desired. More...
void	onPeepSet (int16_t p_peep)
	Set the desired PEEP. More...
void	onPlateauPressureDecrease ()
	Decrease the desired plateau pressure. More...
void	onPlateauPressureIncrease ()
	Increase the desired plateau pressure. More...
void	onPlateauPressureSet (int16_t p_plateauPressure)
	Set the desired plateau pressure. More...
void	onPeakPressureDecrease ()
	Decrease the desired peak pressure. More...
void	onPeakPressureIncrease ()
	Increase the desired peak pressure. More...
void	onExpiratoryTermSet (uint16_t p_expiratoryTerm)
	Set the desired expiratory term. More...
void	onTriggerModeEnabledSet (uint16_t p_triggerEnabled)
	Enable or disable expiratory trigger mode. More...
void	onTriggerOffsetSet (uint16_t p_triggerOffset)
	Set the desired offset for expiratory trigger. More...
void	onPatientHeight (int16_t p_patientHeight)
	Set the desired patient height. More...
void	onPeakPressureAlarmThreshold (int16_t p_peakPressureAlarmThreshold)
	Set the desired threshold for max peak pressure. More...
void	onPatientGender (int16_t p_patientGender)
	Set the desired patient gender. More...
void	onPatientComputePreset ()
	Updates patient computed params. More...
int32_t	patientHeight () const
int16_t	tidalVolumeCommand () const
int16_t	plateauDurationCommand () const
int16_t	peakPressureCommand () const
	Get the desired max peak. More...
int16_t	plateauPressureCommand () const
	Get the desired plateau pressure. More...
int16_t	peepCommand () const
	Get the desired PEEP. More...
uint16_t	cyclesPerMinuteCommand () const
	Get the desired number of cycles per minute. More...
const int16_t	pressureTriggerOffsetCommand () const
	Get the value of the inspiratory trigger pressure command. More...
const bool	triggerModeEnabledCommand ()
	Get the enabling state of trigger mode. More...
const int16_t	inspiratoryTriggerFlowCommand () const
	Get the value of the inspiratory trigger flow command. More...
const int16_t	expiratoryTriggerFlowCommand () const
	Get the value of the expiratory trigger flow command. More...
const int16_t	tiMinCommand () const
	Get the value of the minimum duration of inspiration in ms. More...
const int16_t	tiMaxCommand () const
	Get the value of the max duration of inspiration in ms. More...
const int32_t	targetInspiratoryFlowCommand () const
	get target inspiratory flow in mL/min (used in VC modes) More...
const int16_t	inspiratoryDurationCommand () const
	Get duration of inspiration command. More...
int16_t	tidalVolumeNextCommand () const
	Get the desired tidal Volume for the next cycle (used in VC modes) More...
int16_t	plateauDurationNextCommand () const
int16_t	peakPressureNextCommand () const
	Get the desired max peak for the next cycle. More...
int16_t	plateauPressureNextCommand () const
	Get the desired plateau pressure for the next cycle. More...
int16_t	peepNextCommand () const
	Get the desired PEEP for the next cycle. More...
uint16_t	cyclesPerMinuteNextCommand () const
	Get the desired number of cycles per minute for the next cycle. More...
const int16_t	pressureTriggerOffsetNextCommand () const
	Get the value of the inspiratory trigger pressure command for the next cycle. More...
const bool	triggerModeEnabledNextCommand ()
	Get the enabling state of trigger mode for the next cycle. More...
const int16_t	inspiratoryTriggerFlowNextCommand () const
	Get the value of the inspiratory trigger flow command for the next cycle. More...
const int16_t	expiratoryTriggerFlowNextCommand () const
	Get the value of the expiratory trigger flow command for the next cycle. More...
const int16_t	tiMinNextCommand () const
	Get the value of the minimum duration of inspiration in ms for the next cycle. More...
const int16_t	tiMaxNextCommand () const
	Get the value of the max duration of inspiration in ms for the next cycle. More...
const int32_t	targetInspiratoryFlowNextCommand () const
	get target inspiratory flow in mL/min (used in VC modes) for next cycle More...
const int16_t	inspiratoryDurationNextCommand () const
	Get duration of inspiration command fo next cycle. More...
const VentilationController *	ventilationControllerNextCommand () const
	Ventilation controller pointer for the next cycle. More...
int16_t	peakPressureMeasure () const
	Get the measured peak pressure. More...
int16_t	rebouncePeakPressureMeasure () const
	Get the measured rebounce peak pressure. More...
int16_t	plateauPressureMeasure () const
	Get the measured plateau pressure. More...
int16_t	peepMeasure () const
	Get the measured PEEP. More...
uint16_t	cyclesPerMinuteMeasure () const
	Get the desired number of cycles per minute. More...
uint16_t	tidalVolumeMeasure () const
	Get the measured Tidal Volume. Updated only at the end of inspiration. More...
int32_t	currentDeliveredVolume () const
	Get the measured Tidal Volume. Updated in real time. More...
uint32_t	cycleNumber () const
	Get the number of past cycles since the beginning. More...
uint16_t	ticksPerCycle () const
	Get the duration of a cycle in ticks. More...
uint32_t	ticksPerInhalation () const
	Get the duration of an inhalation in ticks. More...
void	ticksPerInhalationSet (uint32_t p_ticksPerInhalation)
	Get the duration of an inhalation in ticks. More...
int16_t	pressure () const
	Get the current measured pressure. More...
int32_t	inspiratoryFlow () const
	Get the current inspiratoryFlow. More...
int32_t	expiratoryFlow () const
	Get the current expiratoryFlow. More...
int32_t	dt () const
	Get the delta of time since the last cycle (in ms) More...
uint32_t	tick () const
	Get the tick number of the current cycle. More...
int32_t	pressureCommand () const
	Get the pressure command. More...
CyclePhases	phase () const
	Get the current cycle phase. More...
const bool	triggered () const
	Get the state of the inspiratory trigger. More...
const void	setTrigger (bool triggerValue)
	Reset the trigger to false. More...
const bool	isPeepDetected ()
	Get if the PEEP has been detected during this cycle. More...
int16_t *	lastPressureValues ()
	Get last pressure values. More...
uint16_t	lastPressureValuesIndex ()
	Get last pressure values index. More...
void	updateDt (int32_t p_dt)
	Input the real duration since the last pressure controller computation. More...
void	updateCurrentDeliveredVolume (int32_t p_currentDeliveredVolume)
	Input the current delivered volume in inspiratory branch since beginning of the respiratory cycle. More...
void	updateCurrentExpiratoryVolume (int32_t p_expiratoryVolume)
void	reachSafetyPosition ()
	Put actuators in safety position. More...
void	stop (uint32_t p_currentMillis)
	Stop the breathing. More...
void	sendStopMessageToUi ()
	Send a "stopped" telemetry message. More...
void	sendMachineState ()
	Send a "machine state snapshot" telemetry message. More...

Private Member Functions
void	updatePhase ()
	Update the cycle phase. More...
void	inhale ()
	Perform the pressure control and compute the actuators commands during the inhalation phase. More...
void	exhale ()
	Perform the pressure control and compute the actuators commands during the exhalation phase. More...
void	computeTickParameters ()
	Compute various cycle durations given the desired number of cycles per minute. More...
void	executeCommands ()
	Send the computed commands to actuators. More...
void	checkCycleAlarm ()
	At the end of a respiratory cycle, check if some alarms are triggered. More...
void	calculateBlowerIncrement ()
void	printDebugValues ()
	Print debug values, used to tweak PID, and triggers. More...

Private Attributes
uint32_t	m_tick
	Actual tick number (given by the main state machine) More...
uint16_t	m_cyclesPerMinuteCommand
	Actual desired number of cycles per minute. More...
uint16_t	m_cyclesPerMinuteNextCommand
	Number of cycles per minute desired by the operator for the next cycle. More...
uint32_t	m_cyclesPerMinuteMeasure
	Measured number of cycles per minute. More...
uint32_t	m_lastBreathPeriodsMs [NUMBER_OF_BREATH_PERIOD]
	Period durations of last beathings. More...
uint32_t	m_lastBreathPeriodsMsIndex
	Index for the m_lastBreathPeriodsMs array. More...
uint32_t	m_lastEndOfRespirationDateMs
	Date of the last ending of a respiration. More...
int16_t	m_peakPressureCommand
	Actual desired peak pressure. More...
int16_t	m_peakPressureMeasure
	Measured value of peak pressure. More...
int16_t	m_rebouncePeakPressureMeasure
	Measured value of rebounce peak pressure. More...
int16_t	m_peakPressureNextCommand
	Peak pressure desired by the operator for the next cycle. More...
int16_t	m_plateauPressureCommand
	Actual desired plateau pressure. More...
int16_t	m_plateauPressureNextCommand
	Plateau pressure desired by the operator for the next cycle. More...
int16_t	m_plateauPressureMeasure
	Measured value of the plateau pressure. More...
int16_t	m_plateauPressureToDisplay
	Measured value of the plateau pressure for display. More...
int64_t	m_PlateauMeasureSum
	Sum for calulating plateau value. More...
uint16_t	m_PlateauMeasureCount
	Count for calulating plateau value. More...
uint32_t	m_plateauDurationMs
	Duration of the plateau. More...
int16_t	m_peepCommand
	Actual desired PEEP. More...
int16_t	m_peepNextCommand
	Desired PEEP for the next cycle. More...
int16_t	m_peepMeasure
	Measured value of the PEEP. More...
bool	m_isPeepDetected
	Is PEEP pressure detected in the cycle? More...
int16_t	m_pressureTriggerOffsetCommand
	Actual pressure trigger offset. More...
int16_t	m_pressureTriggerOffsetNextCommand
	Desired pressure trigger offset for the next cycle. More...
bool	m_triggered
	Is inspiratory triggered or not? More...
bool	m_triggerModeEnabledCommand
	Actual state of enabling of trigger mode. More...
bool	m_triggerModeEnabledNextCommand
	Desired state of enabling of trigger mode for the next cycle. More...
bool	m_tidalVolumeAlreadyRead
	True if Tidal volume has already been read during cycle. More...
uint16_t	m_expiratoryTermCommand
	Actual expiratory term. More...
uint16_t	m_expiratoryTermNextCommand
	Desired expiratory term for the next cycle. More...
int16_t	m_inspiratoryTriggerFlowCommand
	Desired inspiratory trigger flow. More...
int16_t	m_inspiratoryTriggerFlowNextCommand
	Desired inspiratory trigger flow for next cycle. More...
int16_t	m_expiratoryTriggerFlowCommand
	Desired expiratory trigger flow (in percent of max flow) More...
int16_t	m_expiratoryTriggerFlowNextCommand
	Desired expiratory trigger flow for next cycle (in percent of max flow) More...
int16_t	m_tiMinCommand
	Minimum duration of inspiration in ms. More...
int16_t	m_tiMaxCommand
	Max duration of inspiration in ms. More...
int16_t	m_tiMinNextCommand
	Minimum duration of inspiration in ms for next cycle. More...
int16_t	m_tiMaxNextCommand
	Max duration of inspiration in ms for next cycle. More...
VentilationController *	m_ventilationController
	Ventilation controller in use (for everything related to breathing control) More...
VentilationController *	m_ventilationControllerNextCommand
	Ventilation controller for the next cycle. More...
VentilationController *	m_ventilationControllersTable [NUMBER_OF_VENTILATION_MODES+1u]
	Array containing pointers to different ventilation controllers. More...
VentilationModes	m_ventilationControllerMode
int16_t	m_tidalVolumeMeasure
	Measured value of the Tidal volume (volume of air pushed in patient lungs in last inspiration) More...
int16_t	m_tidalVolumeCommand
	Tidal volume command (used in VC modes) More...
int16_t	m_tidalVolumeNextCommand
	Tidal volume command for next cycle. More...
int16_t	m_plateauDurationCommand
	Plateau duration command (used in VC modes) More...
int16_t	m_plateauDurationNextCommand
	Plateau duration command for next cycle. More...
int32_t	m_targetInspiratoryFlowCommand
	inspiratory flow required (used in VC modes) More...
int32_t	m_targetInspiratoryFlowNextCommand
	inspiratory flow required (used in VC modes) for next cycle More...
int16_t	m_inspiratoryDurationCommand
	Duration of inspiration. More...
int16_t	m_inspiratoryDurationNextCommand
	Duration of inspiration. More...
int32_t	m_lowInspiratoryMinuteVolumeAlarmThresholdCommand
	Threshold for low inspiratory minute volume alarm. More...
int32_t	m_lowInspiratoryMinuteVolumeAlarmThresholdNextCommand
	Threshold for low inspiratory minute volume alarm for next cycle. More...
int32_t	m_highInspiratoryMinuteVolumeAlarmThresholdCommand
	Threshold for high inspiratory minute volume alarm. More...
int32_t	m_highInspiratoryMinuteVolumeAlarmThresholdNextCommand
	Threshold for high inspiratory minute volume alarm for next cycle. More...
int32_t	m_lowExpiratoryMinuteVolumeAlarmThresholdCommand
	Threshold for low inspiratory minute volume alarm. More...
int32_t	m_lowExpiratoryMinuteVolumeAlarmThresholdNextCommand
	Threshold for low inspiratory minute volume alarm for next cycle. More...
int32_t	m_highExpiratoryMinuteVolumeAlarmThresholdCommand
	Threshold for high inspiratory minute volume alarm. More...
int32_t	m_highExpiratoryMinuteVolumeAlarmThresholdNextCommand
	Threshold for high inspiratory minute volume alarm for next cycle. More...
int32_t	m_lowRespiratoryRateAlarmThresholdCommand
	Threshold for low respiratory rate. More...
int32_t	m_lowRespiratoryRateAlarmThresholdNextCommand
	Threshold for low respiratory rate for next cycle. More...
int32_t	m_highRespiratoryRateAlarmThresholdCommand
	Threshold for low respiratory rate. More...
int32_t	m_highRespiratoryRateAlarmThresholdNextCommand
	Threshold for low respiratory rate for next cycle. More...
int32_t	m_lowTidalVolumeAlarmThresholdCommand
	Threshold for low tidal Volume Alarm. More...
int32_t	m_lowTidalVolumeAlarmThresholdNextCommand
	Threshold for low tidal Volume Alarm next cycle. More...
int32_t	m_highTidalVolumeAlarmThresholdCommand
	Threshold for high tidal Volume Alarm. More...
int32_t	m_highTidalVolumeAlarmThresholdNextCommand
	Threshold for high tidal Volume Alarm next cycle. More...
int32_t	m_leakAlarmThresholdCommand
	Threshold for leak alarm. More...
int32_t	m_leakAlarmThresholdNextCommand
	Threshold for leak alarm for next cycle. More...
int16_t	m_peakPressureAlarmThresholdCommand
	Threshold for peak pressure alarm. More...
int16_t	m_peakPressureAlarmThresholdNextCommand
	Threshold for peak pressure alarmfor next cycle. More...
int32_t	m_expiratoryVolume
	Volume expired by the patient during the exhalation phase. More...
uint16_t	m_ticksPerCycle
	Number of hundredth of second per cycle. More...
uint32_t	m_ticksPerInhalation
	Number of hundredth of second per inhalation. More...
int16_t	m_pressure
	Measured pressure. More...
int32_t	m_inspiratoryFlow
	Measured inspiratory flow. More...
int32_t	m_maxInspiratoryFlow
	Measured max inspiratory flow. More...
int32_t	m_expiratoryFlow
	Measured inspiratory flow. More...
int32_t	m_maxExpiratoryFlow
	Measured max inspiratory flow. More...
int32_t	m_lastMaxExpiratoryFlow
	Measured max inspiratory flow. More...
int32_t	m_currentDeliveredVolume
	Current delivered volume by the blower. More...
int16_t	m_inhalationLastPressure
	Last pressure of inhalation. More...
uint32_t	m_inspiratoryValveAngle
	Blower valve angle at peak. More...
CyclePhases	m_phase
	Current respiratory cycle phase. More...
uint32_t	m_cycleNb
	Number of elapsed cycles since beginning. More...
int32_t	m_dt
	Time since the last computation (in microsecond) More...
int32_t	m_pressureCommand
	Requested pressure at a given point in time. More...
int16_t	m_lastPressureValues [MAX_PRESSURE_SAMPLES]
	Last pressure values. More...
uint16_t	m_lastPressureValuesIndex
	Last pressure index. More...
uint32_t	m_sumOfPressures
	Sum of the current cycle's pressures. More...
uint16_t	m_numberOfPressures
	Number of the current cycle's pressures. More...
int32_t	m_patientHeight
int32_t	m_patientGender

Detailed Description

Controls breathing cycle.

Definition at line 36 of file main_controller.h.

Constructor & Destructor Documentation

MainController()

MainController::MainController

(

)

Default constructor.

Definition at line 26 of file main_controller.cpp.

                               {
    m_tick = 0;
    m_phase = CyclePhases::INHALATION;
 
    m_inspiratoryFlow = 0;
    m_maxInspiratoryFlow = 0;
    m_expiratoryFlow = 0;
    m_maxExpiratoryFlow = 0;
    m_lastMaxExpiratoryFlow = 0;
    m_currentDeliveredVolume = 0;
    m_expiratoryVolume = 0;
 
    m_cyclesPerMinuteCommand = DEFAULT_CYCLE_PER_MINUTE_COMMAND;
    m_cyclesPerMinuteNextCommand = DEFAULT_CYCLE_PER_MINUTE_COMMAND;
    m_peakPressureCommand = DEFAULT_PEAK_PRESSURE_COMMAND;
    m_peakPressureNextCommand = DEFAULT_PEAK_PRESSURE_COMMAND;
    m_plateauPressureCommand = DEFAULT_PLATEAU_COMMAND;
    m_plateauPressureNextCommand = DEFAULT_PLATEAU_COMMAND;
    m_peepCommand = DEFAULT_PEEP_COMMAND;
    m_peepNextCommand = DEFAULT_PEEP_COMMAND;
    m_tidalVolumeCommand = DEFAULT_TIDAL_VOLUME_COMMAND;
    m_tidalVolumeNextCommand = DEFAULT_TIDAL_VOLUME_COMMAND;
    m_plateauDurationCommand = DEFAULT_PLATEAU_DURATION_COMMAND;
    m_plateauDurationNextCommand = DEFAULT_PLATEAU_DURATION_COMMAND;
    m_inspiratoryTriggerFlowCommand = DEFAULT_INSPIRATORY_TRIGGER_FLOW_COMMAND;
    m_inspiratoryTriggerFlowNextCommand = DEFAULT_INSPIRATORY_TRIGGER_FLOW_COMMAND;
    m_expiratoryTriggerFlowCommand = DEFAULT_EXPIRATORY_TRIGGER_FLOW_COMMAND;
    m_expiratoryTriggerFlowNextCommand = DEFAULT_EXPIRATORY_TRIGGER_FLOW_COMMAND;
    m_tiMinCommand = DEFAULT_MIN_INSPIRATION_DURATION_COMMAND;
    m_tiMinNextCommand = DEFAULT_MIN_INSPIRATION_DURATION_COMMAND;
    m_tiMaxCommand = DEFAULT_MAX_INSPIRATION_DURATION_COMMAND;
    m_tiMaxNextCommand = DEFAULT_MAX_INSPIRATION_DURATION_COMMAND;
    m_targetInspiratoryFlowCommand = DEFAULT_TARGET_FLOW_COMMAND;
    m_targetInspiratoryFlowNextCommand = DEFAULT_TARGET_FLOW_COMMAND;
    m_inspiratoryDurationCommand = DEFAULT_INSPIRATORY_DURATION;
    m_inspiratoryDurationNextCommand = DEFAULT_INSPIRATORY_DURATION;
 
    m_pressureTriggerOffsetCommand = DEFAULT_TRIGGER_OFFSET;
    m_pressureTriggerOffsetNextCommand = DEFAULT_TRIGGER_OFFSET;
    m_triggerModeEnabledCommand = TRIGGER_MODE_ENABLED_BY_DEFAULT;
    m_triggerModeEnabledNextCommand = TRIGGER_MODE_ENABLED_BY_DEFAULT;
    m_expiratoryTermCommand = DEFAULT_EXPIRATORY_TERM_COMMAND;
    m_expiratoryTermNextCommand = DEFAULT_EXPIRATORY_TERM_COMMAND;
 
    m_lowInspiratoryMinuteVolumeAlarmThresholdCommand =
        DEFAULT_LOW_INSPIRATORY_MINUTE_VOLUME_ALARM_THRESHOLD;
    m_lowInspiratoryMinuteVolumeAlarmThresholdNextCommand =
        DEFAULT_LOW_INSPIRATORY_MINUTE_VOLUME_ALARM_THRESHOLD;
 
    m_highInspiratoryMinuteVolumeAlarmThresholdCommand =
        DEFAULT_HIGH_INSPIRATORY_MINUTE_VOLUME_ALARM_THRESHOLD;
    m_highInspiratoryMinuteVolumeAlarmThresholdNextCommand =
        DEFAULT_HIGH_INSPIRATORY_MINUTE_VOLUME_ALARM_THRESHOLD;
 
    m_lowExpiratoryMinuteVolumeAlarmThresholdCommand =
        DEFAULT_LOW_EXPIRATORY_MINUTE_VOLUME_ALARM_THRESHOLD;
    m_lowExpiratoryMinuteVolumeAlarmThresholdNextCommand =
        DEFAULT_LOW_EXPIRATORY_MINUTE_VOLUME_ALARM_THRESHOLD;
 
    m_highExpiratoryMinuteVolumeAlarmThresholdCommand =
        DEFAULT_HIGH_EXPIRATORY_MINUTE_VOLUME_ALARM_THRESHOLD;
    m_highExpiratoryMinuteVolumeAlarmThresholdNextCommand =
        DEFAULT_HIGH_EXPIRATORY_MINUTE_VOLUME_ALARM_THRESHOLD;
 
    m_highRespiratoryRateAlarmThresholdCommand = DEFAULT_HIGH_RESPIRATORY_RATE_ALARM_THRESHOLD;
    m_highRespiratoryRateAlarmThresholdNextCommand = DEFAULT_HIGH_RESPIRATORY_RATE_ALARM_THRESHOLD;
 
    m_lowRespiratoryRateAlarmThresholdCommand = DEFAULT_LOW_RESPIRATORY_RATE_ALARM_THRESHOLD;
    m_lowRespiratoryRateAlarmThresholdNextCommand = DEFAULT_LOW_RESPIRATORY_RATE_ALARM_THRESHOLD;
 
    m_lowTidalVolumeAlarmThresholdCommand = DEFAULT_LOW_TIDAL_VOLUME_ALARM_THRESHOLD;
    m_lowTidalVolumeAlarmThresholdNextCommand = DEFAULT_LOW_TIDAL_VOLUME_ALARM_THRESHOLD;
 
    m_highTidalVolumeAlarmThresholdCommand = DEFAULT_HIGH_TIDAL_VOLUME_ALARM_THRESHOLD;
    m_highTidalVolumeAlarmThresholdNextCommand = DEFAULT_HIGH_TIDAL_VOLUME_ALARM_THRESHOLD;
 
    m_leakAlarmThresholdNextCommand = DEFAULT_LEAK_ALARM_THRESHOLD;
    m_leakAlarmThresholdCommand = DEFAULT_LEAK_ALARM_THRESHOLD;
 
    m_peakPressureAlarmThresholdCommand = DEFAULT_PEAK_PRESSURE_ALARM_THRESHOLD;
    m_peakPressureAlarmThresholdNextCommand = DEFAULT_PEAK_PRESSURE_ALARM_THRESHOLD;
 
    m_ventilationControllersTable[PC_CMV] = &pcCmvController;
    m_ventilationControllersTable[PC_AC] = &pcAcController;
    m_ventilationControllersTable[VC_CMV] = &vcCmvController;
    m_ventilationControllersTable[PC_VSAI] = &pcVsaiController;
    m_ventilationControllersTable[VC_AC] = &vcAcController;
 
    m_ventilationControllerMode = PC_AC;
 
    m_ventilationController = m_ventilationControllersTable[m_ventilationControllerMode];
    m_ventilationControllerNextCommand = m_ventilationControllersTable[m_ventilationControllerMode];
 
    m_lastEndOfRespirationDateMs = 0;
    m_peakPressureMeasure = CONST_INITIAL_ZERO_PRESSURE;
    m_rebouncePeakPressureMeasure = 0;
    m_inhalationLastPressure = 0;
    m_plateauPressureMeasure = CONST_INITIAL_ZERO_PRESSURE;
    m_plateauPressureToDisplay = CONST_INITIAL_ZERO_PRESSURE;
    m_peepMeasure = CONST_INITIAL_ZERO_PRESSURE;
    m_cyclesPerMinuteMeasure = DEFAULT_CYCLE_PER_MINUTE_COMMAND;
    m_tidalVolumeMeasure = CONST_INITIAL_ZERO_VOLUME;
 
    m_pressure = CONST_INITIAL_ZERO_PRESSURE;
    m_pressureCommand = CONST_INITIAL_ZERO_PRESSURE;
 
    m_cycleNb = 0;
 
    m_dt = MAIN_CONTROLLER_COMPUTE_PERIOD_MICROSECONDS;
 
    m_sumOfPressures = 0;
    m_numberOfPressures = 0;
    m_PlateauMeasureSum = 0;
    m_PlateauMeasureCount = 0;
 
    m_triggered = false;
    m_isPeepDetected = false;
    m_tidalVolumeAlreadyRead = false;
    m_plateauDurationMs = 0;
 
    m_patientHeight = 0;
    m_patientGender = 0;
 
    m_inspiratoryValveAngle = VALVE_CLOSED_STATE;
 
    computeTickParameters();
 
    m_lastPressureValuesIndex = 0;
    for (uint8_t i = 0u; i < MAX_PRESSURE_SAMPLES; i++) {
        m_lastPressureValues[i] = 0;
    }
 
    m_lastBreathPeriodsMsIndex = 0;
    for (uint8_t i = 0u; i < NUMBER_OF_BREATH_PERIOD; i++) {
        m_lastBreathPeriodsMs[i] = (1000u * 60u) / m_cyclesPerMinuteCommand;
    }
}

Member Function Documentation

calculateBlowerIncrement()

void MainController::calculateBlowerIncrement ( )

private

checkCycleAlarm()

void MainController::checkCycleAlarm ( )

private

At the end of a respiratory cycle, check if some alarms are triggered.

Definition at line 528 of file main_controller.cpp.

                                     {
    // RCM-SW-1 + RCM-SW-14: check if plateau is reached
    int16_t minPlateauBeforeAlarm =
        (m_plateauPressureCommand * (100 - ALARM_THRESHOLD_DIFFERENCE_PERCENT)) / 100;
    int16_t maxPlateauBeforeAlarm =
        (m_plateauPressureCommand * (100 + ALARM_THRESHOLD_DIFFERENCE_PERCENT)) / 100;
    if ((m_plateauPressureMeasure < minPlateauBeforeAlarm)
        || (m_plateauPressureMeasure > maxPlateauBeforeAlarm)) {
        alarmController.detectedAlarm(RCM_SW_1, m_cycleNb, m_plateauPressureCommand, m_pressure);
        alarmController.detectedAlarm(RCM_SW_14, m_cycleNb, m_plateauPressureCommand, m_pressure);
    } else {
        alarmController.notDetectedAlarm(RCM_SW_1);
        alarmController.notDetectedAlarm(RCM_SW_14);
    }
 
    // RCM-SW-2 + RCM-SW-19: check is mean pressure was < 2 cmH2O
    int16_t meanPressure = m_sumOfPressures / m_numberOfPressures;
    if (meanPressure <= ALARM_THRESHOLD_MIN_PRESSURE) {
        alarmController.detectedAlarm(RCM_SW_2, m_cycleNb, ALARM_THRESHOLD_MIN_PRESSURE,
                                      m_pressure);
        alarmController.detectedAlarm(RCM_SW_19, m_cycleNb, ALARM_THRESHOLD_MIN_PRESSURE,
                                      m_pressure);
    } else {
        alarmController.notDetectedAlarm(RCM_SW_2);
        alarmController.notDetectedAlarm(RCM_SW_19);
    }
 
    // RCM-SW-3 + RCM-SW-15
    int16_t PeepBeforeAlarm = m_peepCommand - ALARM_THRESHOLD_DIFFERENCE_PRESSURE;
    int16_t maxPeepBeforeAlarm = m_peepCommand + ALARM_THRESHOLD_DIFFERENCE_PRESSURE;
    if ((m_peepMeasure < PeepBeforeAlarm) || (m_peepMeasure > maxPeepBeforeAlarm)) {
        alarmController.detectedAlarm(RCM_SW_3, m_cycleNb, m_peepCommand, m_pressure);
        alarmController.detectedAlarm(RCM_SW_15, m_cycleNb, m_peepCommand, m_pressure);
    } else {
        alarmController.notDetectedAlarm(RCM_SW_3);
        alarmController.notDetectedAlarm(RCM_SW_15);
    }
 
    // RC-SW-4 & 5 : Inspiratory minute Volume is too low/high
    int32_t inspiratoryMinuteVolume =
        m_tidalVolumeMeasure * static_cast<int32_t>(m_cyclesPerMinuteMeasure);  // In mL/min
    if (inspiratoryMinuteVolume < m_lowInspiratoryMinuteVolumeAlarmThresholdCommand) {
        alarmController.detectedAlarm(RCM_SW_4, m_cycleNb,
                                      m_lowInspiratoryMinuteVolumeAlarmThresholdCommand,
                                      inspiratoryMinuteVolume);
        alarmController.notDetectedAlarm(RCM_SW_5);
    } else if (inspiratoryMinuteVolume > m_highInspiratoryMinuteVolumeAlarmThresholdCommand) {
        alarmController.detectedAlarm(RCM_SW_5, m_cycleNb,
                                      m_highInspiratoryMinuteVolumeAlarmThresholdCommand,
                                      inspiratoryMinuteVolume);
        alarmController.notDetectedAlarm(RCM_SW_4);
    } else {
        alarmController.notDetectedAlarm(RCM_SW_4);
        alarmController.notDetectedAlarm(RCM_SW_5);
    }
 
    // RC-SW-6 & 7 : Expiratory minute Volume is too low/high
    int32_t expiratoryMinuteVolume =
        m_expiratoryVolume * static_cast<int32_t>(m_cyclesPerMinuteMeasure);  // In mL/min
    if (expiratoryMinuteVolume < m_lowExpiratoryMinuteVolumeAlarmThresholdCommand) {
        alarmController.detectedAlarm(RCM_SW_6, m_cycleNb,
                                      m_lowExpiratoryMinuteVolumeAlarmThresholdCommand,
                                      expiratoryMinuteVolume);
        alarmController.notDetectedAlarm(RCM_SW_7);
    } else if (expiratoryMinuteVolume > m_highExpiratoryMinuteVolumeAlarmThresholdCommand) {
        alarmController.detectedAlarm(RCM_SW_7, m_cycleNb,
                                      m_highInspiratoryMinuteVolumeAlarmThresholdCommand,
                                      expiratoryMinuteVolume);
        alarmController.notDetectedAlarm(RCM_SW_6);
    } else {
        alarmController.notDetectedAlarm(RCM_SW_6);
        alarmController.notDetectedAlarm(RCM_SW_7);
    }
 
    // RC-SW-8 & 9 : Respiratory rate is too low/high
    if (static_cast<int32_t>(m_cyclesPerMinuteMeasure)
        < m_lowRespiratoryRateAlarmThresholdCommand) {
        alarmController.detectedAlarm(RCM_SW_8, m_cycleNb,
                                      m_lowRespiratoryRateAlarmThresholdCommand,
                                      m_cyclesPerMinuteMeasure);
        alarmController.notDetectedAlarm(RCM_SW_9);
    } else if (static_cast<int32_t>(m_cyclesPerMinuteMeasure)
               > m_highRespiratoryRateAlarmThresholdCommand) {
        alarmController.detectedAlarm(RCM_SW_9, m_cycleNb,
                                      m_highRespiratoryRateAlarmThresholdCommand,
                                      m_cyclesPerMinuteMeasure);
        alarmController.notDetectedAlarm(RCM_SW_8);
    } else {
        alarmController.notDetectedAlarm(RCM_SW_8);
        alarmController.notDetectedAlarm(RCM_SW_9);
    }
 
    // RC-SW-20 & 21 : tidal Volume is too low/high
    if (m_tidalVolumeMeasure < m_lowTidalVolumeAlarmThresholdCommand) {
        alarmController.detectedAlarm(RCM_SW_20, m_cycleNb, m_lowTidalVolumeAlarmThresholdCommand,
                                      m_tidalVolumeMeasure);
        alarmController.notDetectedAlarm(RCM_SW_21);
    } else if (m_tidalVolumeMeasure > m_highTidalVolumeAlarmThresholdCommand) {
        alarmController.detectedAlarm(RCM_SW_21, m_cycleNb, m_highTidalVolumeAlarmThresholdCommand,
                                      m_tidalVolumeMeasure);
        alarmController.notDetectedAlarm(RCM_SW_20);
    } else {
        alarmController.notDetectedAlarm(RCM_SW_20);
        alarmController.notDetectedAlarm(RCM_SW_21);
    }
 
    // RCM_SW_10 : Leak is too high
    int32_t leakPerMinute = (m_currentDeliveredVolume - m_expiratoryVolume)
                            * static_cast<int32_t>(m_cyclesPerMinuteMeasure);  // In mL/min
    if (leakPerMinute > m_leakAlarmThresholdCommand) {
        alarmController.detectedAlarm(RCM_SW_10, m_cycleNb, m_leakAlarmThresholdNextCommand,
                                      leakPerMinute);
    } else {
        alarmController.notDetectedAlarm(RCM_SW_10);
    }
 
    if (m_peakPressureMeasure > m_peakPressureAlarmThresholdCommand) {
        alarmController.detectedAlarm(RCM_SW_22, m_cycleNb, m_peakPressureAlarmThresholdCommand,
                                      m_pressure);
    } else {
        alarmController.notDetectedAlarm(RCM_SW_22);
    }
 
    if (m_lastMaxExpiratoryFlow < (m_maxInspiratoryFlow / MIN_EXPIRATORY_FLOW_OFFSET)) {
        alarmController.detectedAlarm(RCM_SW_23, m_cycleNb,
                                      m_maxInspiratoryFlow / MIN_EXPIRATORY_FLOW_OFFSET,
                                      m_lastMaxExpiratoryFlow);
    } else {
        alarmController.notDetectedAlarm(RCM_SW_23);
    }
}

compute()

void MainController::compute

(

)

Perform the pressure control.

Parameters

p_tick

Duration in hundredth of second from the begining of the cycle

Definition at line 248 of file main_controller.cpp.

                             {
    // Update the cycle phase
    updatePhase();
 
    // Compute metrics for alarms
    m_sumOfPressures += static_cast<uint32_t>(m_pressure);
    m_numberOfPressures++;
 
    // Store last pressure values only every 10ms
    uint32_t moduloValue = max(1u, (10u / MAIN_CONTROLLER_COMPUTE_PERIOD_MS));
    if ((m_tick % moduloValue) == 0u) {
        // Store the current pressure to compute aggregates
        m_lastPressureValues[m_lastPressureValuesIndex] = m_pressure;
        m_lastPressureValuesIndex++;
 
        // Start over if we reached the max samples number
        if (m_lastPressureValuesIndex >= static_cast<uint16_t>(MAX_PRESSURE_SAMPLES)) {
            m_lastPressureValuesIndex = 0;
        }
    }
 
    // Act accordingly
    switch (m_phase) {
    case CyclePhases::INHALATION:
        inhale();
        m_inhalationLastPressure = m_pressure;
        break;
 
    case CyclePhases::EXHALATION:
        exhale();
        break;
 
    default:
        // Do nothing
        break;
    }
 
    alarmController.updateCoreData(m_tick, m_pressure, m_phase, m_cycleNb);
 
    // Send data snaphshot only every 10 ms
    if ((m_tick % moduloValue) == 0u) {
        sendDataSnapshot(m_tick, max((int16_t)0, m_pressure), m_phase, inspiratoryValve.position,
                         expiratoryValve.position, blower.getSpeed() / 100u, getBatteryLevel(),
                         max(int32_t(0), m_inspiratoryFlow / 10),
                         max(int32_t(0), m_expiratoryFlow / 10));
    }
 
    executeCommands();
 
#ifdef MASS_FLOW_METER_ENABLED
    // Measure volume only during inspiration
    // Add 100 ms to allow valve to close completely
    if ((m_tick > (m_ticksPerInhalation + (100u / MAIN_CONTROLLER_COMPUTE_PERIOD_MS)))
        && !m_tidalVolumeAlreadyRead) {
        m_tidalVolumeAlreadyRead = true;
        int32_t volume = m_currentDeliveredVolume;
        m_tidalVolumeMeasure =
            ((volume > 0xFFFE) || (volume < 0)) ? 0xFFFFu : static_cast<uint16_t>(volume);
    }
 
#else
    m_tidalVolumeMeasure = UINT16_MAX;
#endif
    printDebugValues();
}

computeTickParameters()

void MainController::computeTickParameters ( )

private

Compute various cycle durations given the desired number of cycles per minute.

• duration of a cycle in hundredth of second

• duration of the inhalation phase in hundredth of second

  Note

  Inhalation lasts 1/3 of a cycle while exhalation lasts 2/3 of a cycle

Definition at line 501 of file main_controller.cpp.

                                           {
    m_plateauDurationMs = m_inspiratoryDurationCommand;
 
    m_ticksPerCycle =
        60u * (1000000u / MAIN_CONTROLLER_COMPUTE_PERIOD_MICROSECONDS) / m_cyclesPerMinuteCommand;
    m_ticksPerInhalation =
        (m_plateauDurationMs * 1000000u / MAIN_CONTROLLER_COMPUTE_PERIOD_MICROSECONDS) / 1000u;
}

currentDeliveredVolume()

int32_t MainController::currentDeliveredVolume ( ) const

inline

Get the measured Tidal Volume. Updated in real time.

Definition at line 343 of file main_controller.h.

{ return m_currentDeliveredVolume; }

cycleNumber()

uint32_t MainController::cycleNumber ( ) const

inline

Get the number of past cycles since the beginning.

Definition at line 346 of file main_controller.h.

{ return m_cycleNb; }

cyclesPerMinuteCommand()

uint16_t MainController::cyclesPerMinuteCommand ( ) const

inline

Get the desired number of cycles per minute.

Definition at line 261 of file main_controller.h.

{ return m_cyclesPerMinuteCommand; }

cyclesPerMinuteMeasure()

uint16_t MainController::cyclesPerMinuteMeasure ( ) const

inline

Get the desired number of cycles per minute.

Definition at line 339 of file main_controller.h.

{ return m_cyclesPerMinuteMeasure; }

cyclesPerMinuteNextCommand()

uint16_t MainController::cyclesPerMinuteNextCommand ( ) const

inline

Get the desired number of cycles per minute for the next cycle.

Definition at line 298 of file main_controller.h.

{ return m_cyclesPerMinuteNextCommand; }

dt()

int32_t MainController::dt ( ) const

inline

Get the delta of time since the last cycle (in ms)

Definition at line 369 of file main_controller.h.

{ return m_dt; }

endRespiratoryCycle()

void MainController::endRespiratoryCycle

(

uint32_t

p_currentMillis

)

End a respiratory cycle.

Definition at line 372 of file main_controller.cpp.

                                                                 {
    // Compute the respiratory rate: average on NUMBER_OF_BREATH_PERIOD breaths
    uint32_t currentMillis = p_currentMillis;
    m_lastBreathPeriodsMs[m_lastBreathPeriodsMsIndex] =
        currentMillis - m_lastEndOfRespirationDateMs;
    m_lastBreathPeriodsMsIndex++;
    if (m_lastBreathPeriodsMsIndex >= NUMBER_OF_BREATH_PERIOD) {
        m_lastBreathPeriodsMsIndex = 0;
    }
    uint32_t sum = 0;
    for (uint8_t i = 0u; i < NUMBER_OF_BREATH_PERIOD; i++) {
        sum += m_lastBreathPeriodsMs[i];
    }
    // Add "+(sum-1u)" to round instead of truncate
    m_cyclesPerMinuteMeasure = (((NUMBER_OF_BREATH_PERIOD * 60u) * 1000u) + (sum - 1u)) / sum;
    m_lastEndOfRespirationDateMs = currentMillis;
 
    // Plateau pressure is the mean pressure during plateau
    m_plateauPressureMeasure = max(0, static_cast<int16_t>(m_PlateauMeasureSum)
                                          / static_cast<int16_t>(m_PlateauMeasureCount));
 
    checkCycleAlarm();
 
    m_plateauPressureToDisplay = m_plateauPressureMeasure;
 
    // Send telemetry machine state snapshot message
    sendMachineState();
 
    m_ventilationController->endCycle();
}

executeCommands()

void MainController::executeCommands ( )

private

Send the computed commands to actuators.

Definition at line 510 of file main_controller.cpp.

                                     {
    if (m_pressure
        > (m_peakPressureAlarmThresholdCommand + AIR_EXHAUST_THRESHOLD_FROM_PEAK_PRESSURE_ALARM)) {
        inspiratoryValve.close();
        expiratoryValve.open();
        alarmController.detectedAlarm(RCM_SW_18, m_cycleNb,
                                      m_peakPressureAlarmThresholdCommand
                                          + AIR_EXHAUST_THRESHOLD_FROM_PEAK_PRESSURE_ALARM,
                                      m_pressure);
    } else {
        alarmController.notDetectedAlarm(RCM_SW_18);
    }
 
    inspiratoryValve.execute();
    expiratoryValve.execute();
    blower.execute();
}

exhale()

void MainController::exhale ( )

private

Perform the pressure control and compute the actuators commands during the exhalation phase.

Definition at line 346 of file main_controller.cpp.

                            {
    // Control loop
    m_ventilationController->exhale();
 
    // Compute the PEEP pressure
    int16_t minValue = m_lastPressureValues[0u];
    int16_t maxValue = m_lastPressureValues[0u];
    int16_t totalValues = m_lastPressureValues[0u];
    for (uint8_t index = 1u; index < MAX_PRESSURE_SAMPLES; index++) {
        minValue = min(minValue, m_lastPressureValues[index]);
        maxValue = max(maxValue, m_lastPressureValues[index]);
        totalValues += m_lastPressureValues[index];
    }
 
    // Update PEEP value, when pressure is stable and close to target pressure
    if (((maxValue - minValue) < 5) && (abs(m_pressure - m_peepCommand) < 30)) {
        m_isPeepDetected = true;
        m_peepMeasure = max(0, totalValues / static_cast<int16_t>(MAX_PRESSURE_SAMPLES));
    }
 
    // This case is usefull when PEEP is never detected during the cycle
    if (!m_isPeepDetected) {
        m_peepMeasure = max(static_cast<int16_t>(0), m_pressure);
    }
}

expiratoryFlow()

int32_t MainController::expiratoryFlow ( ) const

inline

Get the current expiratoryFlow.

Definition at line 366 of file main_controller.h.

{ return m_expiratoryFlow; }

expiratoryTriggerFlowCommand()

const int16_t MainController::expiratoryTriggerFlowCommand ( ) const

inline

Get the value of the expiratory trigger flow command.

Definition at line 273 of file main_controller.h.

                                                              {
        return m_expiratoryTriggerFlowCommand;
    }

expiratoryTriggerFlowNextCommand()

const int16_t MainController::expiratoryTriggerFlowNextCommand ( ) const

inline

Get the value of the expiratory trigger flow command for the next cycle.

Definition at line 310 of file main_controller.h.

                                                                  {
        return m_expiratoryTriggerFlowNextCommand;
    }

inhale()

void MainController::inhale ( )

private

Perform the pressure control and compute the actuators commands during the inhalation phase.

Definition at line 325 of file main_controller.cpp.

                            {
    // Control loop
    m_ventilationController->inhale();
 
    // Update peak pressure and rebounce peak pressure
    if (m_pressure > m_peakPressureMeasure) {
        m_peakPressureMeasure = max((int16_t)0, m_pressure);
        m_rebouncePeakPressureMeasure = m_pressure;
    } else if (m_pressure < m_rebouncePeakPressureMeasure) {
        m_rebouncePeakPressureMeasure = m_pressure;
    } else {
        // Do nothing
    }
 
    // Compute plateau at the end of the cycle
    if (m_tick > (m_ticksPerInhalation - (200u / MAIN_CONTROLLER_COMPUTE_PERIOD_MS))) {
        m_PlateauMeasureSum += m_pressure;
        m_PlateauMeasureCount += 1u;
    }
}

initRespiratoryCycle()

void MainController::initRespiratoryCycle

(

)

Begin a respiratory cycle.

Definition at line 175 of file main_controller.cpp.

                                          {
    m_expiratoryVolume = 0;
    DBG_DO(Serial.println("Init respiratory cycle");)
    m_cycleNb++;
    m_plateauPressureMeasure = 0;
 
    m_peakPressureMeasure = 0;
    m_triggered = false;
    m_isPeepDetected = false;
    m_tidalVolumeAlreadyRead = false;
 
    // Update new settings at the beginning of the respiratory cycle
    m_cyclesPerMinuteCommand = m_cyclesPerMinuteNextCommand;
    m_peepCommand = m_peepNextCommand;
    m_plateauPressureCommand = m_plateauPressureNextCommand;
    m_triggerModeEnabledCommand = m_triggerModeEnabledNextCommand;
    m_pressureTriggerOffsetCommand = m_pressureTriggerOffsetNextCommand;
    m_expiratoryTermCommand = m_expiratoryTermNextCommand;
    m_tidalVolumeCommand = m_tidalVolumeNextCommand;
    m_plateauDurationCommand = m_plateauDurationNextCommand;
    m_inspiratoryTriggerFlowCommand = m_inspiratoryTriggerFlowNextCommand;
    m_expiratoryTriggerFlowCommand = m_expiratoryTriggerFlowNextCommand;
    m_tiMaxCommand = m_tiMaxNextCommand;
    m_tiMinCommand = m_tiMinNextCommand;
    m_targetInspiratoryFlowCommand = m_targetInspiratoryFlowNextCommand;
    m_inspiratoryDurationCommand = m_inspiratoryDurationNextCommand;
 
    m_lowInspiratoryMinuteVolumeAlarmThresholdCommand =
        m_lowInspiratoryMinuteVolumeAlarmThresholdNextCommand;
    m_highInspiratoryMinuteVolumeAlarmThresholdCommand =
        m_highInspiratoryMinuteVolumeAlarmThresholdNextCommand;
 
    m_lowExpiratoryMinuteVolumeAlarmThresholdCommand =
        m_lowExpiratoryMinuteVolumeAlarmThresholdNextCommand;
    m_highExpiratoryMinuteVolumeAlarmThresholdCommand =
        m_highExpiratoryMinuteVolumeAlarmThresholdNextCommand;
 
    m_lowRespiratoryRateAlarmThresholdCommand = m_lowRespiratoryRateAlarmThresholdNextCommand;
    m_highRespiratoryRateAlarmThresholdCommand = m_highRespiratoryRateAlarmThresholdNextCommand;
 
    m_highTidalVolumeAlarmThresholdCommand = m_highTidalVolumeAlarmThresholdNextCommand;
    m_lowTidalVolumeAlarmThresholdCommand = m_lowTidalVolumeAlarmThresholdNextCommand;
 
    m_leakAlarmThresholdCommand = m_leakAlarmThresholdNextCommand;
    m_peakPressureAlarmThresholdCommand = m_peakPressureAlarmThresholdNextCommand;
 
    // Run setup of the controller only if different from previous cycle
    if (m_ventilationController != m_ventilationControllerNextCommand) {
        m_ventilationController = m_ventilationControllerNextCommand;
        m_ventilationController->setup();
        alarmController.updateEnabledAlarms(m_ventilationController->enabledAlarms());
    }
 
    computeTickParameters();
 
    for (uint8_t i = 0u; i < MAX_PRESSURE_SAMPLES; i++) {
        m_lastPressureValues[i] = 0;
    }
    m_lastPressureValuesIndex = 0;
 
    m_sumOfPressures = 0u;
    m_numberOfPressures = 0u;
 
    m_PlateauMeasureSum = 0u;
    m_PlateauMeasureCount = 0u;
 
    m_maxInspiratoryFlow = 0;
    m_lastMaxExpiratoryFlow = m_maxExpiratoryFlow;
    m_maxExpiratoryFlow = 0;
 
    m_ventilationController->initCycle();
}

inspiratoryDurationCommand()

const int16_t MainController::inspiratoryDurationCommand ( ) const

inline

Get duration of inspiration command.

Definition at line 285 of file main_controller.h.

{ return m_inspiratoryDurationCommand; }

inspiratoryDurationNextCommand()

const int16_t MainController::inspiratoryDurationNextCommand ( ) const

inline

Get duration of inspiration command fo next cycle.

Definition at line 322 of file main_controller.h.

                                                                {
        return m_inspiratoryDurationNextCommand;
    }

inspiratoryFlow()

int32_t MainController::inspiratoryFlow ( ) const

inline

Get the current inspiratoryFlow.

Definition at line 363 of file main_controller.h.

{ return m_inspiratoryFlow; }

inspiratoryTriggerFlowCommand()

const int16_t MainController::inspiratoryTriggerFlowCommand ( ) const

inline

Get the value of the inspiratory trigger flow command.

Definition at line 269 of file main_controller.h.

                                                               {
        return m_inspiratoryTriggerFlowCommand;
    }

inspiratoryTriggerFlowNextCommand()

const int16_t MainController::inspiratoryTriggerFlowNextCommand ( ) const

inline

Get the value of the inspiratory trigger flow command for the next cycle.

Definition at line 306 of file main_controller.h.

                                                                   {
        return m_inspiratoryTriggerFlowNextCommand;
    }

isPeepDetected()

const bool MainController::isPeepDetected ( )

inline

Get if the PEEP has been detected during this cycle.

Definition at line 387 of file main_controller.h.

{ return m_isPeepDetected; }

lastPressureValues()

int16_t* MainController::lastPressureValues ( )

inline

Get last pressure values.

Definition at line 390 of file main_controller.h.

{ return m_lastPressureValues; }

lastPressureValuesIndex()

uint16_t MainController::lastPressureValuesIndex ( )

inline

Get last pressure values index.

Definition at line 393 of file main_controller.h.

{ return m_lastPressureValuesIndex; }

onCycleDecrease()

void MainController::onCycleDecrease

(

)

Decrease the desired number of cycles per minute.

Definition at line 754 of file main_controller.cpp.

                                     {
    DBG_DO(Serial.println("Cycle --");)
 
    m_cyclesPerMinuteNextCommand = m_cyclesPerMinuteNextCommand - 1u;
 
    if (m_cyclesPerMinuteNextCommand < CONST_MIN_CYCLE) {
        m_cyclesPerMinuteNextCommand = CONST_MIN_CYCLE;
    }
    // Send acknowledgment to the UI
    sendControlAck(4, m_cyclesPerMinuteNextCommand);
}

onCycleIncrease()

void MainController::onCycleIncrease

(

)

Increase the desired number of cycles per minute.

Definition at line 766 of file main_controller.cpp.

                                     {
    DBG_DO(Serial.println("Cycle ++");)
 
    m_cyclesPerMinuteNextCommand = m_cyclesPerMinuteNextCommand + 1u;
 
    if (m_cyclesPerMinuteNextCommand > CONST_MAX_CYCLE) {
        m_cyclesPerMinuteNextCommand = CONST_MAX_CYCLE;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(4, m_cyclesPerMinuteNextCommand);
}

onCycleSet()

void MainController::onCycleSet

(

uint16_t

p_cpm

)

Set the desired number of cycles per minute.

Parameters

p_cpm

Desired number of cycles per minute

Definition at line 780 of file main_controller.cpp.

                                              {
    if (p_cpm < CONST_MIN_CYCLE) {
        m_cyclesPerMinuteNextCommand = CONST_MIN_CYCLE;
    } else if (p_cpm > CONST_MAX_CYCLE) {
        m_cyclesPerMinuteNextCommand = CONST_MAX_CYCLE;
    } else {
        m_cyclesPerMinuteNextCommand = p_cpm;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(4, m_cyclesPerMinuteNextCommand);
}

onExpiratoryTermSet()

void MainController::onExpiratoryTermSet

(

uint16_t

p_expiratoryTerm

)

Set the desired expiratory term.

Parameters

p_expiratoryTerm

Expiration term in the "Inspiration/Expiration" ratio given that Inspiration = 10

Definition at line 936 of file main_controller.cpp.

                                                                  {
    if (p_expiratoryTerm > CONST_MAX_EXPIRATORY_TERM) {
        m_expiratoryTermNextCommand = CONST_MAX_EXPIRATORY_TERM;
    } else if (p_expiratoryTerm < CONST_MIN_EXPIRATORY_TERM) {
        m_expiratoryTermNextCommand = CONST_MIN_EXPIRATORY_TERM;
    } else {
        m_expiratoryTermNextCommand = p_expiratoryTerm;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(5, m_expiratoryTermNextCommand);
}

onExpiratoryTriggerFlowSet()

void MainController::onExpiratoryTriggerFlowSet

(

uint16_t

p_expiratoryTriggerFlow

)

Set expiratory trigger flow.

Definition at line 987 of file main_controller.cpp.

                                                                                {
    // CONST_MIN_EXPIRATORY_TRIGGER_FLOW might not be equal to 0
    // cppcheck-suppress unsignedPositive
    if ((p_expiratoryTriggerFlow >= CONST_MIN_EXPIRATORY_TRIGGER_FLOW)
        && (p_expiratoryTriggerFlow <= CONST_MAX_EXPIRATORY_TRIGGER_FLOW)) {
        m_expiratoryTriggerFlowNextCommand = p_expiratoryTriggerFlow;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(11, m_expiratoryTriggerFlowNextCommand);
}

onHighExpiratoryMinuteVolumeAlarmThresholdSet()

void MainController::onHighExpiratoryMinuteVolumeAlarmThresholdSet

(

uint16_t

p_highExpiratoryMinuteVolumeAlarmThreshold

)

Set alarm threshold for high expiratory minute volume.

Definition at line 1073 of file main_controller.cpp.

                                                         {
    if ((p_highExpiratoryMinuteVolumeAlarmThreshold
         >= CONST_MIN_HIGH_EXPIRATORY_MINUTE_VOLUME_ALARM_THRESHOLD)
        && (p_highExpiratoryMinuteVolumeAlarmThreshold
            <= CONST_MAX_HIGH_EXPIRATORY_MINUTE_VOLUME_ALARM_THRESHOLD)) {
        m_highExpiratoryMinuteVolumeAlarmThresholdNextCommand =
            1000 * (int32_t)p_highExpiratoryMinuteVolumeAlarmThreshold;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(17, m_highExpiratoryMinuteVolumeAlarmThresholdNextCommand / 1000);
}

onHighInspiratoryMinuteVolumeAlarmThresholdSet()

void MainController::onHighInspiratoryMinuteVolumeAlarmThresholdSet

(

uint16_t

p_highInspiratoryMinuteVolumeAlarmThreshold

)

Set alarm threshold for high inspiratory minute volume.

Definition at line 1040 of file main_controller.cpp.

                                                          {
    if ((p_highInspiratoryMinuteVolumeAlarmThreshold
         >= CONST_MIN_HIGH_INSPIRATORY_MINUTE_VOLUME_ALARM_THRESHOLD)
        && (p_highInspiratoryMinuteVolumeAlarmThreshold
            <= CONST_MAX_HIGH_INSPIRATORY_MINUTE_VOLUME_ALARM_THRESHOLD)) {
        m_highInspiratoryMinuteVolumeAlarmThresholdNextCommand =
            1000 * (int32_t)p_highInspiratoryMinuteVolumeAlarmThreshold;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(15, m_highInspiratoryMinuteVolumeAlarmThresholdNextCommand / 1000);
}

onhighRespiratoryRateAlarmThresholdSet()

void MainController::onhighRespiratoryRateAlarmThresholdSet

(

uint16_t

p_highRespiratoryRateAlarmThreshold

)

Set alarm threshold for high respiratory rate.

Definition at line 1100 of file main_controller.cpp.

                                                  {
    if ((p_highRespiratoryRateAlarmThreshold >= CONST_MIN_HIGH_RESPIRATORY_RATE_ALARM_THRESHOLD)
        && (p_highRespiratoryRateAlarmThreshold
            <= CONST_MAX_HIGH_RESPIRATORY_RATE_ALARM_THRESHOLD)) {
        m_highRespiratoryRateAlarmThresholdNextCommand = p_highRespiratoryRateAlarmThreshold;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(19, m_highRespiratoryRateAlarmThresholdNextCommand);
}

onHighTidalVolumeAlarmThresholdSet()

void MainController::onHighTidalVolumeAlarmThresholdSet

(

uint16_t

p_highTidalVolumeAlarmThreshold

)

Set threshold on tidal volume for which an alarm is raised.

Definition at line 1136 of file main_controller.cpp.

                                                                                                {
    if ((p_highTidalVolumeAlarmThreshold >= CONST_MIN_HIGH_TIDAL_VOLUME_ALARM_THRESHOLD)
        && (p_highTidalVolumeAlarmThreshold <= CONST_MAX_HIGH_TIDAL_VOLUME_ALARM_THRESHOLD)) {
        m_highTidalVolumeAlarmThresholdNextCommand = p_highTidalVolumeAlarmThreshold;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(22, m_highTidalVolumeAlarmThresholdNextCommand);
}

onInspiratoryDuration()

void MainController::onInspiratoryDuration

(

uint16_t

p_inspiratoryDuration

)

Set the inspiration duration.

Definition at line 1183 of file main_controller.cpp.

                                                                         {
    if ((p_inspiratoryDuration >= CONST_MIN_INSPIRATORY_DURATION)
        && (p_inspiratoryDuration <= CONST_MAX_INSPIRATORY_DURATION)) {
        m_inspiratoryDurationNextCommand = p_inspiratoryDuration;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(26, m_inspiratoryDurationNextCommand);
}

onInspiratoryTriggerFlowSet()

void MainController::onInspiratoryTriggerFlowSet

(

uint16_t

p_inspiratoryTriggerFlow

)

Set inspiratory trigger flow.

Definition at line 974 of file main_controller.cpp.

                                                                                  {
    // CONST_MIN_INSPIRATORY_TRIGGER_FLOW might not be equal to 0
    // cppcheck-suppress unsignedPositive
    if ((p_inspiratoryTriggerFlow >= CONST_MIN_INSPIRATORY_TRIGGER_FLOW)
        && (p_inspiratoryTriggerFlow <= CONST_MAX_INSPIRATORY_TRIGGER_FLOW)) {
        m_inspiratoryTriggerFlowNextCommand = p_inspiratoryTriggerFlow;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(10, m_inspiratoryTriggerFlowNextCommand);
}

onLeakAlarmThresholdSet()

void MainController::onLeakAlarmThresholdSet

(

uint16_t

p_leakAlarmThreshold

)

Set the threshold for leak that raise the alarm.

Definition at line 1160 of file main_controller.cpp.

                                                                          {
    if ((p_leakAlarmThreshold >= CONST_MIN_LEAK_ALARM_THRESHOLD)
        && (p_leakAlarmThreshold <= CONST_MIN_LEAK_ALARM_THRESHOLD)) {
        m_leakAlarmThresholdNextCommand = 10u * p_leakAlarmThreshold;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(24, m_leakAlarmThresholdNextCommand / 10);
}

onLowExpiratoryMinuteVolumeAlarmThresholdSet()

void MainController::onLowExpiratoryMinuteVolumeAlarmThresholdSet

(

uint16_t

p_lowExpiratoryMinuteVolumeAlarmThreshold

)

Set alarm threshold for low expiratory minute volume.

Definition at line 1055 of file main_controller.cpp.

                                                        {
    // CONST_MIN_LOW_EXPIRATORY_MINUTE_VOLUME_ALARM_THRESHOLD might not be equal to 0
    if ((p_lowExpiratoryMinuteVolumeAlarmThreshold
         // cppcheck-suppress unsignedPositive ;
         >= CONST_MIN_LOW_EXPIRATORY_MINUTE_VOLUME_ALARM_THRESHOLD)
        && (p_lowExpiratoryMinuteVolumeAlarmThreshold
            <= CONST_MAX_LOW_EXPIRATORY_MINUTE_VOLUME_ALARM_THRESHOLD)) {
        m_lowExpiratoryMinuteVolumeAlarmThresholdNextCommand =
            // cppcheck-suppress cert-INT31-c ;
            1000 * (int32_t)p_lowExpiratoryMinuteVolumeAlarmThreshold;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(16, m_lowExpiratoryMinuteVolumeAlarmThresholdNextCommand / 1000);
}

onLowInspiratoryMinuteVolumeAlarmThresholdSet()

void MainController::onLowInspiratoryMinuteVolumeAlarmThresholdSet

(

uint16_t

p_lowInspiratoryMinuteVolumeAlarmThreshold

)

Set alarm threshold for low inspiratory minute volume.

Definition at line 1022 of file main_controller.cpp.

                                                         {
    // CONST_MIN_LOW_INSPIRATORY_MINUTE_VOLUME_ALARM_THRESHOLD might not be equal to 0
    if ((p_lowInspiratoryMinuteVolumeAlarmThreshold
         // cppcheck-suppress unsignedPositive ;
         >= CONST_MIN_LOW_INSPIRATORY_MINUTE_VOLUME_ALARM_THRESHOLD)
        && (p_lowInspiratoryMinuteVolumeAlarmThreshold
            <= CONST_MAX_LOW_INSPIRATORY_MINUTE_VOLUME_ALARM_THRESHOLD)) {
        m_lowInspiratoryMinuteVolumeAlarmThresholdNextCommand =
            // cppcheck-suppress cert-INT31-c ;
            1000 * (int32_t)p_lowInspiratoryMinuteVolumeAlarmThreshold;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(14, m_lowInspiratoryMinuteVolumeAlarmThresholdNextCommand / 1000);
}

onlowRespiratoryRateAlarmThresholdSet()

void MainController::onlowRespiratoryRateAlarmThresholdSet

(

uint16_t

p_lowRespiratoryRateAlarmThreshold

)

Set alarm threshold for low respiratory rate.

Definition at line 1088 of file main_controller.cpp.

                                                 {
    if ((p_lowRespiratoryRateAlarmThreshold >= CONST_MIN_LOW_RESPIRATORY_RATE_ALARM_THRESHOLD)
        && (p_lowRespiratoryRateAlarmThreshold <= CONST_MAX_LOW_RESPIRATORY_RATE_ALARM_THRESHOLD)) {
        m_lowRespiratoryRateAlarmThresholdNextCommand = p_lowRespiratoryRateAlarmThreshold;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(18, m_lowRespiratoryRateAlarmThresholdNextCommand);
}

onLowTidalVolumeAlarmThresholdSet()

void MainController::onLowTidalVolumeAlarmThresholdSet

(

uint16_t

p_lowTidalVolumeAlarmThreshold

)

Set threshold on tidal volume below which an alarm is raised.

Definition at line 1123 of file main_controller.cpp.

                                                                                              {
    // CONST_MIN_LOW_TIDAL_VOLUME_ALARM_THRESHOLD might not be equal to 0
    // cppcheck-suppress unsignedPositive ;
    if ((p_lowTidalVolumeAlarmThreshold >= CONST_MIN_LOW_TIDAL_VOLUME_ALARM_THRESHOLD)
        && (p_lowTidalVolumeAlarmThreshold <= CONST_MAX_LOW_TIDAL_VOLUME_ALARM_THRESHOLD)) {
        m_lowTidalVolumeAlarmThresholdNextCommand = p_lowTidalVolumeAlarmThreshold;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(21, m_lowTidalVolumeAlarmThresholdNextCommand);
}

onPatientComputePreset()

void MainController::onPatientComputePreset

(

)

Updates patient computed params.

Definition at line 1235 of file main_controller.cpp.

                                            {
    int32_t theoricalWeight = 0;
    int32_t tidalVolume = 0;
 
    // Male
    if (m_patientGender == 0) {
        theoricalWeight = 23 * (m_patientHeight * m_patientHeight) / 10000;
    } else {
        theoricalWeight = 21 * (m_patientHeight * m_patientHeight) / 10000;
    }
 
    tidalVolume = theoricalWeight * 7;
 
    tidalVolume = tidalVolume - (tidalVolume % 10);
 
    m_tidalVolumeNextCommand = tidalVolume;
    m_peepNextCommand = 50u;
    m_cyclesPerMinuteNextCommand = DEFAULT_CYCLE_PER_MINUTE_COMMAND;
    m_plateauPressureNextCommand = m_peepNextCommand + ((172 * tidalVolume) / 1000);
 
    m_lowInspiratoryMinuteVolumeAlarmThresholdNextCommand =
        (static_cast<int32_t>(m_cyclesPerMinuteCommand) * tidalVolume) - 1500;
    m_highInspiratoryMinuteVolumeAlarmThresholdNextCommand =
        (static_cast<int32_t>(m_cyclesPerMinuteCommand) * tidalVolume) + 1500;
    m_lowExpiratoryMinuteVolumeAlarmThresholdNextCommand =
        (static_cast<int32_t>(m_cyclesPerMinuteCommand) * tidalVolume) - 1500;
    m_highExpiratoryMinuteVolumeAlarmThresholdNextCommand =
        (static_cast<int32_t>(m_cyclesPerMinuteCommand) * tidalVolume) + 1500;
    m_highRespiratoryRateAlarmThresholdNextCommand = m_cyclesPerMinuteCommand + 4u;
    m_lowRespiratoryRateAlarmThresholdNextCommand = m_cyclesPerMinuteCommand - 4u;
    m_lowTidalVolumeAlarmThresholdNextCommand = tidalVolume - 100;
    m_highTidalVolumeAlarmThresholdNextCommand = tidalVolume + 100;
    m_peakPressureAlarmThresholdNextCommand =
        m_plateauPressureNextCommand + PEAK_PRESSURE_ALARM_THRESHOLD_OFFSET_FROM_PLATEAU;
}

onPatientGender()

void MainController::onPatientGender

(

int16_t

p_patientGender

)

Set the desired patient gender.

Parameters

p_patientGender

patient gender 0 = male, 1 = female

Definition at line 1220 of file main_controller.cpp.

                                                            {
    if ((p_patientGender >= CONST_MIN_PATIENT_GENDER)
        && (p_patientGender <= CONST_MAX_PATIENT_GENDER)) {
        m_patientGender = p_patientGender;
    } else {
        m_patientGender = DEFAULT_PATIENT_GENDER;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(29, m_patientGender);
 
    mainController.onPatientComputePreset();
}

onPatientHeight()

void MainController::onPatientHeight

(

int16_t

p_patientHeight

)

Set the desired patient height.

Parameters

p_patientHeight

Desired patient height in cm

Definition at line 1205 of file main_controller.cpp.

                                                            {
    if ((p_patientHeight >= CONST_MIN_PATIENT_HEIGHT)
        && (p_patientHeight <= CONST_MAX_PATIENT_HEIGHT)) {
        m_patientHeight = p_patientHeight;
    } else {
        m_patientHeight = DEFAULT_PATIENT_HEIGHT;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(28, m_patientHeight);
 
    mainController.onPatientComputePreset();
}

onPeakPressureAlarmThreshold()

void MainController::onPeakPressureAlarmThreshold

(

int16_t

p_peakPressureAlarmThreshold

)

Set the desired threshold for max peak pressure.

Parameters

p_peakPressureAlarmThreshold

Desired threshold in mmH2O

Definition at line 1194 of file main_controller.cpp.

                                                                                      {
    if ((p_peakPressureAlarmThreshold >= CONST_MIN_PEAK_PRESSURE_ALARM_THRESHOLD)
        && (p_peakPressureAlarmThreshold <= CONST_MAX_PEAK_PRESSURE_ALARM_THRESHOLD)) {
        m_peakPressureAlarmThresholdNextCommand = p_peakPressureAlarmThreshold;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(30, m_peakPressureAlarmThresholdNextCommand);
}

onPeakPressureDecrease()

void MainController::onPeakPressureDecrease

(

)

Decrease the desired peak pressure.

Deprecated:

Peak pressure is now based on plateau pressure

Definition at line 885 of file main_controller.cpp.

                                            {
    DBG_DO(Serial.println("Peak Pressure --");)
#if DEBUG != 0
    switch (m_ventilationControllerMode) {
    case PC_CMV:
        m_ventilationControllerMode = PC_CMV;
        break;
    case PC_AC:
        m_ventilationControllerMode = PC_CMV;
        break;
    case VC_CMV:
        m_ventilationControllerMode = PC_AC;
        break;
    case PC_VSAI:
        m_ventilationControllerMode = VC_CMV;
        break;
    default:
        // Do nothing
        break;
    }
    m_ventilationControllerNextCommand = m_ventilationControllersTable[m_ventilationControllerMode];
 
#endif
}

onPeakPressureIncrease()

void MainController::onPeakPressureIncrease

(

)

Increase the desired peak pressure.

Deprecated:

Peak pressure is now based on plateau pressure

Definition at line 910 of file main_controller.cpp.

                                            {
    DBG_DO(Serial.println("Peak Pressure ++");)
#if DEBUG != 0
    switch (m_ventilationControllerMode) {
    case PC_CMV:
        m_ventilationControllerMode = PC_AC;
        break;
    case PC_AC:
        m_ventilationControllerMode = VC_CMV;
        break;
    case VC_CMV:
        m_ventilationControllerMode = PC_VSAI;
        break;
    case PC_VSAI:
        m_ventilationControllerMode = PC_VSAI;
        break;
    default:
        // Do nothing
        break;
    }
    m_ventilationControllerNextCommand = m_ventilationControllersTable[m_ventilationControllerMode];
 
#endif
}

onPeepPressureDecrease()

void MainController::onPeepPressureDecrease

(

)

Decrease the minimal PEEP desired.

Definition at line 793 of file main_controller.cpp.

                                            {
    DBG_DO(Serial.println("Peep Pressure --");)
 
    if (m_peepNextCommand >= 10) {
        m_peepNextCommand = m_peepNextCommand - 10;
    } else {
        // Do nothing
    }
 
    // Send acknowledgment to the UI
    sendControlAck(3, m_peepNextCommand);
}

onPeepPressureIncrease()

void MainController::onPeepPressureIncrease

(

)

Increase the minimal PEEP desired.

Definition at line 806 of file main_controller.cpp.

                                            {
    DBG_DO(Serial.println("Peep Pressure ++");)
 
    // Peep target should be lower than plateau target
    if ((m_peepNextCommand + 10) < m_plateauPressureNextCommand) {
        m_peepNextCommand = m_peepNextCommand + 10;
    }
 
    if (m_peepNextCommand > CONST_MAX_PEEP_PRESSURE) {
        m_peepNextCommand = CONST_MAX_PEEP_PRESSURE;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(3, m_peepNextCommand);
}

onPeepSet()

void MainController::onPeepSet

(

int16_t

p_peep

)

Set the desired PEEP.

Parameters

p_peep

Desired PEEP in mmH2O

Definition at line 823 of file main_controller.cpp.

                                             {
    if (p_peep > CONST_MAX_PEEP_PRESSURE) {
        m_peepNextCommand = CONST_MAX_PEEP_PRESSURE;
        // cppcheck-suppress unsignedLessThanZero ; CONST_MIN_PEEP_PRESSURE might not be equal to 0
    } else if (p_peep < CONST_MIN_PEEP_PRESSURE) {
        m_peepNextCommand = CONST_MIN_PEEP_PRESSURE;
    } else {
        m_peepNextCommand = p_peep;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(3, m_peepNextCommand);
}

onPlateauDurationSet()

void MainController::onPlateauDurationSet

(

uint16_t

p_plateauDuration

)

Set the duration of Pause at the end of expiration in VC modes.

Definition at line 1147 of file main_controller.cpp.

                                                                    {
    // CONST_MIN_PLATEAU_DURATION might not be equal to 0
    // cppcheck-suppress unsignedPositive ;
    if ((p_plateauDuration >= CONST_MIN_PLATEAU_DURATION)
        && (p_plateauDuration <= CONST_MAX_PLATEAU_DURATION)) {
        m_plateauDurationNextCommand = p_plateauDuration;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(23, m_plateauDurationNextCommand);
}

onPlateauPressureDecrease()

void MainController::onPlateauPressureDecrease

(

)

Decrease the desired plateau pressure.

Definition at line 837 of file main_controller.cpp.

                                               {
    DBG_DO(Serial.println("Plateau Pressure --");)
 
    if ((m_plateauPressureNextCommand - 10) > m_peepNextCommand) {
        m_plateauPressureNextCommand = m_plateauPressureNextCommand - 10;
    }
 
    if (m_plateauPressureNextCommand < CONST_MIN_PLATEAU_PRESSURE) {
        m_plateauPressureNextCommand = CONST_MIN_PLATEAU_PRESSURE;
    }
 
    m_peakPressureAlarmThresholdNextCommand =
        m_plateauPressureNextCommand + PEAK_PRESSURE_ALARM_THRESHOLD_OFFSET_FROM_PLATEAU;
 
    // Send acknowledgment to the UI
    sendControlAck(2, m_plateauPressureNextCommand);
}

onPlateauPressureIncrease()

void MainController::onPlateauPressureIncrease

(

)

Increase the desired plateau pressure.

Definition at line 855 of file main_controller.cpp.

                                               {
    DBG_DO(Serial.println("Plateau Pressure ++");)
 
    m_plateauPressureNextCommand = m_plateauPressureNextCommand + 10;
 
    m_plateauPressureNextCommand =
        min(m_plateauPressureNextCommand, static_cast<int16_t>(CONST_MAX_PLATEAU_PRESSURE));
    m_peakPressureAlarmThresholdNextCommand =
        m_plateauPressureNextCommand + PEAK_PRESSURE_ALARM_THRESHOLD_OFFSET_FROM_PLATEAU;
 
    // Send acknowledgment to the UI
    sendControlAck(2, m_plateauPressureNextCommand);
}

onPlateauPressureSet()

void MainController::onPlateauPressureSet

(

int16_t

p_plateauPressure

)

Set the desired plateau pressure.

Parameters

p_plateauPressure

Desired plateau pressure in mmH2O

Definition at line 870 of file main_controller.cpp.

                                                                   {
    if (p_plateauPressure > CONST_MAX_PLATEAU_PRESSURE) {
        m_plateauPressureNextCommand = CONST_MAX_PLATEAU_PRESSURE;
    } else if (p_plateauPressure < CONST_MIN_PLATEAU_PRESSURE) {
        m_plateauPressureNextCommand = CONST_MIN_PLATEAU_PRESSURE;
    } else {
        m_plateauPressureNextCommand = p_plateauPressure;
    }
    m_peakPressureAlarmThresholdNextCommand =
        m_plateauPressureNextCommand + PEAK_PRESSURE_ALARM_THRESHOLD_OFFSET_FROM_PLATEAU;
 
    // Send acknowledgment to the UI
    sendControlAck(2, m_plateauPressureNextCommand);
}

onTargetInspiratoryFlow()

void MainController::onTargetInspiratoryFlow

(

uint16_t

p_targetInspiratoryFlow

)

Set the inspiratory flow target.

Definition at line 1171 of file main_controller.cpp.

                                                                             {
    int32_t temporaryValue = static_cast<int32_t>(p_targetInspiratoryFlow) * 1000;
    if ((temporaryValue >= CONST_MIN_INSPIRATORY_FLOW)
        && (temporaryValue <= CONST_MAX_INSPIRATORY_FLOW)) {
        m_targetInspiratoryFlowNextCommand = temporaryValue;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(25, static_cast<uint16_t>(m_targetInspiratoryFlowNextCommand / 1000));
}

onTargetTidalVolumeSet()

void MainController::onTargetTidalVolumeSet

(

uint16_t

p_targetTidalVolume

)

Set target tidal volume (used in VC modes)

Definition at line 1113 of file main_controller.cpp.

                                                                        {
    if ((p_targetTidalVolume >= CONST_MIN_TIDAL_VOLUME)
        && (p_targetTidalVolume <= CONST_MAX_TIDAL_VOLUME)) {
        m_tidalVolumeNextCommand = p_targetTidalVolume;
    }
    // Send acknowledgment to the UI
    sendControlAck(20, m_tidalVolumeNextCommand);
}

onTiMaxSet()

void MainController::onTiMaxSet

(

uint16_t

p_tiMax

)

Set max inspiratory time.

Definition at line 1011 of file main_controller.cpp.

                                                {
    if ((p_tiMax >= CONST_MIN_MAX_INSPIRATION_DURATION)
        && (p_tiMax <= CONST_MAX_MAX_INSPIRATION_DURATION)) {
        m_tiMaxNextCommand = p_tiMax;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(13, m_tiMaxNextCommand);
}

onTiMinSet()

void MainController::onTiMinSet

(

uint16_t

p_tiMin

)

Set min inspiratory time.

Definition at line 1000 of file main_controller.cpp.

                                                {
    if ((p_tiMin >= CONST_MIN_MIN_INSPIRATION_DURATION)
        && (p_tiMin <= CONST_MAX_MIN_INSPIRATION_DURATION)) {
        m_tiMinNextCommand = p_tiMin;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(12, m_tiMinNextCommand);
}

onTriggerModeEnabledSet()

void MainController::onTriggerModeEnabledSet

(

uint16_t

p_triggerEnabled

)

Enable or disable expiratory trigger mode.

Parameters

p_triggerEnabled

0: disable trigger mode, 1: enable trigger mode

Definition at line 950 of file main_controller.cpp.

                                                                      {
    if ((p_triggerEnabled == 0u) || (p_triggerEnabled == 1u)) {
        m_triggerModeEnabledNextCommand = p_triggerEnabled;
    }
    // Send acknowledgment to the UI
    sendControlAck(6, m_triggerModeEnabledNextCommand);
}

onTriggerOffsetSet()

void MainController::onTriggerOffsetSet

(

uint16_t

p_triggerOffset

)

Set the desired offset for expiratory trigger.

Parameters

p_triggerOffset

Desired trigger offset in mmH2O

Definition at line 959 of file main_controller.cpp.

                                                                {
    if (p_triggerOffset > CONST_MAX_TRIGGER_OFFSET) {
        m_pressureTriggerOffsetNextCommand = CONST_MAX_TRIGGER_OFFSET;
        // cppcheck-suppress unsignedLessThanZero
    } else if (p_triggerOffset < CONST_MIN_TRIGGER_OFFSET) {
        m_pressureTriggerOffsetNextCommand = CONST_MIN_TRIGGER_OFFSET;
    } else {
        m_pressureTriggerOffsetNextCommand = p_triggerOffset;
    }
 
    // Send acknowledgment to the UI
    sendControlAck(7, m_pressureTriggerOffsetNextCommand);
}

onVentilationModeSet()

void MainController::onVentilationModeSet

(

uint16_t

p_ventilationControllerMode

)

Set ventilation mode.

Definition at line 741 of file main_controller.cpp.

                                                                              {
    // cppcheck-suppress misra-c2012-10.4
    if ((m_ventilationControllerMode >= 1u)
        // cppcheck-suppress misra-c2012-10.4
        && (m_ventilationControllerMode <= NUMBER_OF_VENTILATION_MODES)) {
        m_ventilationControllerMode = static_cast<VentilationModes>(p_ventilationControllerMode);
        m_ventilationControllerNextCommand =
            m_ventilationControllersTable[m_ventilationControllerMode];
    }
    // Send acknowledgment to the UI
    sendControlAck(1, m_ventilationControllerMode);
}

patientHeight()

int32_t MainController::patientHeight ( ) const

inline

Definition at line 249 of file main_controller.h.

{ return m_patientHeight; }

peakPressureCommand()

int16_t MainController::peakPressureCommand ( ) const

inline

Get the desired max peak.

Definition at line 255 of file main_controller.h.

{ return m_peakPressureCommand; }

peakPressureMeasure()

int16_t MainController::peakPressureMeasure ( ) const

inline

Get the measured peak pressure.

Definition at line 331 of file main_controller.h.

{ return m_peakPressureMeasure; }

peakPressureNextCommand()

int16_t MainController::peakPressureNextCommand ( ) const

inline

Get the desired max peak for the next cycle.

Definition at line 292 of file main_controller.h.

{ return m_peakPressureNextCommand; }

peepCommand()

int16_t MainController::peepCommand ( ) const

inline

Get the desired PEEP.

Definition at line 259 of file main_controller.h.

{ return m_peepNextCommand; }

peepMeasure()

int16_t MainController::peepMeasure ( ) const

inline

Get the measured PEEP.

Definition at line 337 of file main_controller.h.

{ return m_peepMeasure; }

peepNextCommand()

int16_t MainController::peepNextCommand ( ) const

inline

Get the desired PEEP for the next cycle.

Definition at line 296 of file main_controller.h.

{ return m_peepNextCommand; }

phase()

CyclePhases MainController::phase ( ) const

inline

Get the current cycle phase.

Definition at line 378 of file main_controller.h.

{ return m_phase; }

plateauDurationCommand()

int16_t MainController::plateauDurationCommand ( ) const

inline

Definition at line 253 of file main_controller.h.

{ return m_plateauDurationCommand; }

plateauDurationNextCommand()

int16_t MainController::plateauDurationNextCommand ( ) const

inline

Definition at line 290 of file main_controller.h.

{ return m_plateauDurationNextCommand; }

plateauPressureCommand()

int16_t MainController::plateauPressureCommand ( ) const

inline

Get the desired plateau pressure.

Definition at line 257 of file main_controller.h.

{ return m_plateauPressureCommand; }

plateauPressureMeasure()

int16_t MainController::plateauPressureMeasure ( ) const

inline

Get the measured plateau pressure.

Definition at line 335 of file main_controller.h.

{ return m_plateauPressureMeasure; }

plateauPressureNextCommand()

int16_t MainController::plateauPressureNextCommand ( ) const

inline

Get the desired plateau pressure for the next cycle.

Definition at line 294 of file main_controller.h.

{ return m_plateauPressureNextCommand; }

pressure()

int16_t MainController::pressure ( ) const

inline

Get the current measured pressure.

Definition at line 360 of file main_controller.h.

{ return m_pressure; }

pressureCommand()

int32_t MainController::pressureCommand ( ) const

inline

Get the pressure command.

Definition at line 375 of file main_controller.h.

{ return m_pressureCommand; }

pressureTriggerOffsetCommand()

const int16_t MainController::pressureTriggerOffsetCommand ( ) const

inline

Get the value of the inspiratory trigger pressure command.

Definition at line 263 of file main_controller.h.

                                                              {
        return m_pressureTriggerOffsetCommand;
    }

pressureTriggerOffsetNextCommand()

const int16_t MainController::pressureTriggerOffsetNextCommand ( ) const

inline

Get the value of the inspiratory trigger pressure command for the next cycle.

Definition at line 300 of file main_controller.h.

                                                                  {
        return m_pressureTriggerOffsetNextCommand;
    }

printDebugValues()

void MainController::printDebugValues ( )

private

Print debug values, used to tweak PID, and triggers.

Definition at line 403 of file main_controller.cpp.

                                      {
#if DEBUG == 2
    Serial.print(m_pressure);
    Serial.print(",");
    Serial.print(m_pressureCommand);
    Serial.print(",");
    Serial.print(m_inspiratoryFlow / 100);  // division by 100 for homogenous scale in debug
    Serial.print(",");
    Serial.print(m_expiratoryFlow / 100);  // division by 100 for homogenous scale in debug
    Serial.print(",");
    Serial.print(inspiratoryValve.command);
    Serial.print(",");
    Serial.print(expiratoryValve.command);
    Serial.print(",");
    Serial.print(blower.getSpeed() / 10);  // division by 10 for homogenous scale in debug
    Serial.println();
#endif
}

reachSafetyPosition()

void MainController::reachSafetyPosition

(

)

Put actuators in safety position.

Definition at line 660 of file main_controller.cpp.

                                         {
    inspiratoryValve.open();
    expiratoryValve.open();
    executeCommands();
}

rebouncePeakPressureMeasure()

int16_t MainController::rebouncePeakPressureMeasure ( ) const

inline

Get the measured rebounce peak pressure.

Definition at line 333 of file main_controller.h.

{ return m_rebouncePeakPressureMeasure; }

sendMachineState()

void MainController::sendMachineState

(

)

Send a "machine state snapshot" telemetry message.

Definition at line 715 of file main_controller.cpp.

                                      {
    // Send the next command, because command has not been updated yet (will be at the beginning of
    // the next cycle)
    sendMachineStateSnapshot(
        m_cycleNb, mmH2OtoCmH2O(m_peakPressureNextCommand),
        mmH2OtoCmH2O(m_plateauPressureNextCommand), mmH2OtoCmH2O(m_peepNextCommand),
        m_cyclesPerMinuteNextCommand, m_peakPressureMeasure, m_plateauPressureToDisplay,
        m_peepMeasure, alarmController.triggeredAlarms(), m_tidalVolumeMeasure,
        m_expiratoryTermNextCommand, m_triggerModeEnabledNextCommand,
        m_pressureTriggerOffsetNextCommand, m_cyclesPerMinuteMeasure, alarmController.isSnoozed(),
        readCpuLoadPercent(), m_ventilationControllerMode, m_inspiratoryTriggerFlowNextCommand,
        m_expiratoryTriggerFlowNextCommand, m_tiMinNextCommand, m_tiMaxNextCommand,
        m_lowInspiratoryMinuteVolumeAlarmThresholdNextCommand / 1000,
        m_highInspiratoryMinuteVolumeAlarmThresholdNextCommand / 1000,
        m_lowExpiratoryMinuteVolumeAlarmThresholdNextCommand / 1000,
        m_highExpiratoryMinuteVolumeAlarmThresholdNextCommand / 1000,
        m_lowRespiratoryRateAlarmThresholdNextCommand,
        m_highRespiratoryRateAlarmThresholdNextCommand, m_tidalVolumeNextCommand,
        m_lowTidalVolumeAlarmThresholdNextCommand, m_highTidalVolumeAlarmThresholdNextCommand,
        m_plateauDurationNextCommand, m_leakAlarmThresholdNextCommand / 10,
        static_cast<uint8_t>(m_targetInspiratoryFlowNextCommand / 1000),
        m_inspiratoryDurationNextCommand, m_ticksPerInhalation * MAIN_CONTROLLER_COMPUTE_PERIOD_MS,
        getBatteryLevelX100(), 26226u, m_patientHeight, m_patientGender,
        m_peakPressureAlarmThresholdNextCommand);
}

sendStopMessageToUi()

void MainController::sendStopMessageToUi

(

)

Send a "stopped" telemetry message.

Definition at line 666 of file main_controller.cpp.

                                         {
    sendStoppedMessage(
        mmH2OtoCmH2O(m_peakPressureNextCommand), mmH2OtoCmH2O(m_plateauPressureNextCommand),
        mmH2OtoCmH2O(m_peepNextCommand), m_cyclesPerMinuteNextCommand, m_expiratoryTermNextCommand,
        m_triggerModeEnabledNextCommand, m_pressureTriggerOffsetNextCommand,
        alarmController.isSnoozed(), readCpuLoadPercent(), m_ventilationControllerMode,
        m_inspiratoryTriggerFlowNextCommand, m_expiratoryTriggerFlowNextCommand, m_tiMinNextCommand,
        m_tiMaxNextCommand, m_lowInspiratoryMinuteVolumeAlarmThresholdNextCommand / 1000,
        m_highInspiratoryMinuteVolumeAlarmThresholdNextCommand / 1000,
        m_lowExpiratoryMinuteVolumeAlarmThresholdNextCommand / 1000,
        m_highExpiratoryMinuteVolumeAlarmThresholdNextCommand / 1000,
        m_lowRespiratoryRateAlarmThresholdNextCommand,
        m_highRespiratoryRateAlarmThresholdNextCommand, m_tidalVolumeNextCommand,
        m_lowTidalVolumeAlarmThresholdNextCommand, m_highTidalVolumeAlarmThresholdNextCommand,
        m_plateauDurationNextCommand, m_leakAlarmThresholdNextCommand / 10,
        static_cast<uint8_t>(m_targetInspiratoryFlowNextCommand / 1000),
        m_inspiratoryDurationNextCommand, getBatteryLevelX100(), alarmController.triggeredAlarms(),
        26226u, m_patientHeight, m_patientGender, m_peakPressureAlarmThresholdNextCommand);
}

setTrigger()

const void MainController::setTrigger ( bool  triggerValue )

inline

Reset the trigger to false.

Definition at line 384 of file main_controller.h.

{ m_triggered = triggerValue; }

setup()

void MainController::setup

(

)

Initialize actuators.

Definition at line 164 of file main_controller.cpp.

                           {
    DBG_DO(Serial.println(VERSION);)
    DBG_DO(Serial.println("Setup the controller");)
 
    reachSafetyPosition();
 
    m_ventilationController->setup();
 
    alarmController.updateEnabledAlarms(m_ventilationController->enabledAlarms());
}

stop()

void MainController::stop

(

uint32_t

p_currentMillis

)

Stop the breathing.

Definition at line 686 of file main_controller.cpp.

                                                  {
    blower.stop();
    sendStopMessageToUi();
    // When stopped, open the valves
    reachSafetyPosition();
    m_lastEndOfRespirationDateMs = p_currentMillis;
 
    // Stop alarms related to breathing cycle
    alarmController.notDetectedAlarm(RCM_SW_1);
    alarmController.notDetectedAlarm(RCM_SW_2);
    alarmController.notDetectedAlarm(RCM_SW_3);
    alarmController.notDetectedAlarm(RCM_SW_4);
    alarmController.notDetectedAlarm(RCM_SW_5);
    alarmController.notDetectedAlarm(RCM_SW_6);
    alarmController.notDetectedAlarm(RCM_SW_7);
    alarmController.notDetectedAlarm(RCM_SW_8);
    alarmController.notDetectedAlarm(RCM_SW_9);
    alarmController.notDetectedAlarm(RCM_SW_10);
    alarmController.notDetectedAlarm(RCM_SW_14);
    alarmController.notDetectedAlarm(RCM_SW_15);
    alarmController.notDetectedAlarm(RCM_SW_18);
    alarmController.notDetectedAlarm(RCM_SW_19);
    alarmController.notDetectedAlarm(RCM_SW_20);
    alarmController.notDetectedAlarm(RCM_SW_21);
    alarmController.notDetectedAlarm(RCM_SW_22);
    alarmController.notDetectedAlarm(RCM_SW_23);
    digitalWrite(PIN_LED_START, LED_START_INACTIVE);
}

targetInspiratoryFlowCommand()

const int32_t MainController::targetInspiratoryFlowCommand ( ) const

inline

get target inspiratory flow in mL/min (used in VC modes)

Definition at line 281 of file main_controller.h.

                                                              {
        return m_targetInspiratoryFlowCommand;
    }

targetInspiratoryFlowNextCommand()

const int32_t MainController::targetInspiratoryFlowNextCommand ( ) const

inline

get target inspiratory flow in mL/min (used in VC modes) for next cycle

Definition at line 318 of file main_controller.h.

                                                                  {
        return m_targetInspiratoryFlowNextCommand;
    }

tick()

uint32_t MainController::tick ( ) const

inline

Get the tick number of the current cycle.

Definition at line 372 of file main_controller.h.

{ return m_tick; }

ticksPerCycle()

uint16_t MainController::ticksPerCycle ( ) const

inline

Get the duration of a cycle in ticks.

Definition at line 349 of file main_controller.h.

{ return m_ticksPerCycle; }

ticksPerInhalation()

uint32_t MainController::ticksPerInhalation ( ) const

inline

Get the duration of an inhalation in ticks.

Definition at line 352 of file main_controller.h.

{ return m_ticksPerInhalation; }

ticksPerInhalationSet()

void MainController::ticksPerInhalationSet ( uint32_t  p_ticksPerInhalation )

inline

Get the duration of an inhalation in ticks.

Definition at line 355 of file main_controller.h.

                                                                     {
        m_ticksPerInhalation = p_ticksPerInhalation;
    }

tidalVolumeCommand()

int16_t MainController::tidalVolumeCommand ( ) const

inline

Definition at line 251 of file main_controller.h.

{ return m_tidalVolumeCommand; }

tidalVolumeMeasure()

uint16_t MainController::tidalVolumeMeasure ( ) const

inline

Get the measured Tidal Volume. Updated only at the end of inspiration.

Definition at line 341 of file main_controller.h.

{ return m_tidalVolumeMeasure; }

tidalVolumeNextCommand()

int16_t MainController::tidalVolumeNextCommand ( ) const

inline

Get the desired tidal Volume for the next cycle (used in VC modes)

Definition at line 288 of file main_controller.h.

{ return m_tidalVolumeNextCommand; }

tiMaxCommand()

const int16_t MainController::tiMaxCommand ( ) const

inline

Get the value of the max duration of inspiration in ms.

Definition at line 279 of file main_controller.h.

{ return m_tiMaxCommand; }

tiMaxNextCommand()

const int16_t MainController::tiMaxNextCommand ( ) const

inline

Get the value of the max duration of inspiration in ms for the next cycle.

Definition at line 316 of file main_controller.h.

{ return m_tiMaxNextCommand; }

tiMinCommand()

const int16_t MainController::tiMinCommand ( ) const

inline

Get the value of the minimum duration of inspiration in ms.

Definition at line 277 of file main_controller.h.

{ return m_tiMinCommand; }

tiMinNextCommand()

const int16_t MainController::tiMinNextCommand ( ) const

inline

Get the value of the minimum duration of inspiration in ms for the next cycle.

Definition at line 314 of file main_controller.h.

{ return m_tiMinNextCommand; }

triggered()

const bool MainController::triggered ( ) const

inline

Get the state of the inspiratory trigger.

Definition at line 381 of file main_controller.h.

{ return m_triggered; }

triggerModeEnabledCommand()

const bool MainController::triggerModeEnabledCommand ( )

inline

Get the enabling state of trigger mode.

Definition at line 267 of file main_controller.h.

{ return m_triggerModeEnabledCommand; }

triggerModeEnabledNextCommand()

const bool MainController::triggerModeEnabledNextCommand ( )

inline

Get the enabling state of trigger mode for the next cycle.

Definition at line 304 of file main_controller.h.

{ return m_triggerModeEnabledNextCommand; }

updateCurrentDeliveredVolume()

void MainController::updateCurrentDeliveredVolume

(

int32_t

p_currentDeliveredVolume

)

Input the current delivered volume in inspiratory branch since beginning of the respiratory cycle.

Parameters

p_currentDeliveredVolume

Delivered Volume in mL/s

Definition at line 489 of file main_controller.cpp.

                                                                                  {
    if (p_currentDeliveredVolume != MASS_FLOW_ERROR_VALUE) {
        m_currentDeliveredVolume = p_currentDeliveredVolume;
    }
}

updateCurrentExpiratoryVolume()

void MainController::updateCurrentExpiratoryVolume

(

int32_t

p_expiratoryVolume

)

Definition at line 495 of file main_controller.cpp.

                                                                             {
    if (p_expiratoryVolume != MASS_FLOW_ERROR_VALUE) {
        m_expiratoryVolume = p_expiratoryVolume;
    }
}

updateDt()

void MainController::updateDt

(

int32_t

p_dt

)

Input the real duration since the last pressure controller computation.

Parameters

p_dt	Duration in microsecond

Definition at line 424 of file main_controller.cpp.

{ m_dt = p_dt; }

updateExpiratoryFlow()

void MainController::updateExpiratoryFlow

(

int32_t

p_currentExpiratoryFlow

)

Input an expiratory flow reading.

Parameters

p_currentExpiratoryFlow

Measured expiratory flow

Definition at line 439 of file main_controller.cpp.

                                                                         {
    if (p_currentExpiratoryFlow != MASS_FLOW_ERROR_VALUE) {
        m_expiratoryFlow = p_currentExpiratoryFlow;
 
        if (m_expiratoryFlow >= m_maxExpiratoryFlow) {
            m_maxExpiratoryFlow = m_expiratoryFlow;
        }
    }
}

updateFakeExpiratoryFlow()

void MainController::updateFakeExpiratoryFlow

(

)

Calculate expiratory flow from pressure and valve angle.

Definition at line 450 of file main_controller.cpp.

                                              {
    // get section in mm2 x 100
    int32_t A2MultiplyBy100 = expiratoryValve.getSectionBigHoseX100();
    int32_t A1MultiplyBy100 = 7853;
    int32_t rhoMultiplyBy10 = 12;
    int32_t pressure = max(int32_t(0), m_pressure - int32_t(50));
    int32_t divider = (rhoMultiplyBy10
                       * (10000
                          - (100 * A2MultiplyBy100 / A1MultiplyBy100)
                                * (100 * A2MultiplyBy100 / A1MultiplyBy100)));
    int32_t tempRatioX100 = (divider <= 0) ? 0 : (100 * (2 * pressure * 980000 / divider));
    m_expiratoryFlow =
        (tempRatioX100 < 0) ? 0 : (A2MultiplyBy100 * sqrt(tempRatioX100) * 60) / 1000;
    /*if (openning == 125) {
        m_expiratoryFlow = 0;
    } else {
        int32_t aMultiplyBy100 =
            ((((-585 * openning) * openning) / 100000) + ((118 * openning) / 100)) - 62;
        int32_t bMultiplyBy100 = ((((195 * openning) * openning) / 100) + 33300 - (489 * openning));
        int32_t cMultiplyBy100 = 279000 - (2170 * openning);
 
        int32_t p = m_pressure;
        m_expiratoryFlow =
            (((aMultiplyBy100 * p) * p) + (bMultiplyBy100 * p) + cMultiplyBy100) / 100;
    }*/
 
    /*Serial.print(A2MultiplyBy100);
    Serial.print(",");
    Serial.print(m_pressure);
    Serial.print(",");
    Serial.print(tempRatioX100);
    Serial.print(",");
    Serial.print(m_expiratoryFlow);
    Serial.print(",");
    Serial.println();*/
 
    m_expiratoryVolume += ((m_expiratoryFlow / 60) * m_dt) / 1000000;
}

updateInspiratoryFlow()

void MainController::updateInspiratoryFlow

(

int32_t

p_currentInspiratoryFlow

)

Input an inspiratory flow reading.

Parameters

p_currentInspiratoryFlow

Measured inspiratory flow

Definition at line 428 of file main_controller.cpp.

                                                                           {
    if (p_currentInspiratoryFlow != MASS_FLOW_ERROR_VALUE) {
        m_inspiratoryFlow = p_currentInspiratoryFlow;
 
        if (m_inspiratoryFlow >= m_maxInspiratoryFlow) {
            m_maxInspiratoryFlow = m_inspiratoryFlow;
        }
    }
}

updatePhase()

void MainController::updatePhase ( )

private

Update the cycle phase.

Parameters

p_tick

Duration from the begining of the cycle in hundredth of second

Definition at line 314 of file main_controller.cpp.

                                 {
    if (m_tick < m_ticksPerInhalation) {
        m_phase = CyclePhases::INHALATION;
        m_pressureCommand = m_plateauPressureCommand;
 
    } else {
        m_phase = CyclePhases::EXHALATION;
        m_pressureCommand = m_peepCommand;
    }
}

updatePressure()

void MainController::updatePressure

(

int16_t

p_currentPressure

)

Input a pressure reading.

Parameters

p_currentPressure

Measured pressure

Definition at line 422 of file main_controller.cpp.

{ m_pressure = p_currentPressure; }

updateTick()

void MainController::updateTick

(

uint32_t

p_tick

)

Input a tick number.

Parameters

p_tick

Tick number

Definition at line 426 of file main_controller.cpp.

{ m_tick = p_tick; }

ventilationControllerNextCommand()

const VentilationController* MainController::ventilationControllerNextCommand ( ) const

inline

Ventilation controller pointer for the next cycle.

Definition at line 326 of file main_controller.h.

                                                                                 {
        return m_ventilationControllerNextCommand;
    }

Member Data Documentation

m_currentDeliveredVolume

int32_t MainController::m_currentDeliveredVolume

private

Current delivered volume by the blower.

Note

This is not equal to Vt, because of recirculation during exhale

Definition at line 692 of file main_controller.h.

m_cycleNb

uint32_t MainController::m_cycleNb

private

Number of elapsed cycles since beginning.

Definition at line 704 of file main_controller.h.

m_cyclesPerMinuteCommand

uint16_t MainController::m_cyclesPerMinuteCommand

private

Actual desired number of cycles per minute.

Definition at line 467 of file main_controller.h.

m_cyclesPerMinuteMeasure

uint32_t MainController::m_cyclesPerMinuteMeasure

private

Measured number of cycles per minute.

Definition at line 471 of file main_controller.h.

m_cyclesPerMinuteNextCommand

uint16_t MainController::m_cyclesPerMinuteNextCommand

private

Number of cycles per minute desired by the operator for the next cycle.

Definition at line 469 of file main_controller.h.

m_dt

int32_t MainController::m_dt

private

Time since the last computation (in microsecond)

Definition at line 707 of file main_controller.h.

m_expiratoryFlow

int32_t MainController::m_expiratoryFlow

private

Measured inspiratory flow.

Definition at line 679 of file main_controller.h.

m_expiratoryTermCommand

uint16_t MainController::m_expiratoryTermCommand

private

Actual expiratory term.

E term of the I:E ratio. I = 10, and E is in [10;60]

Definition at line 547 of file main_controller.h.

m_expiratoryTermNextCommand

uint16_t MainController::m_expiratoryTermNextCommand

private

Desired expiratory term for the next cycle.

Definition at line 549 of file main_controller.h.

m_expiratoryTriggerFlowCommand

int16_t MainController::m_expiratoryTriggerFlowCommand

private

Desired expiratory trigger flow (in percent of max flow)

Definition at line 557 of file main_controller.h.

m_expiratoryTriggerFlowNextCommand

int16_t MainController::m_expiratoryTriggerFlowNextCommand

private

Desired expiratory trigger flow for next cycle (in percent of max flow)

Definition at line 559 of file main_controller.h.

m_expiratoryVolume

int32_t MainController::m_expiratoryVolume

private

Volume expired by the patient during the exhalation phase.

Definition at line 661 of file main_controller.h.

m_highExpiratoryMinuteVolumeAlarmThresholdCommand

int32_t MainController::m_highExpiratoryMinuteVolumeAlarmThresholdCommand

private

Threshold for high inspiratory minute volume alarm.

Definition at line 622 of file main_controller.h.

m_highExpiratoryMinuteVolumeAlarmThresholdNextCommand

int32_t MainController::m_highExpiratoryMinuteVolumeAlarmThresholdNextCommand

private

Threshold for high inspiratory minute volume alarm for next cycle.

Definition at line 625 of file main_controller.h.

m_highInspiratoryMinuteVolumeAlarmThresholdCommand

int32_t MainController::m_highInspiratoryMinuteVolumeAlarmThresholdCommand

private

Threshold for high inspiratory minute volume alarm.

Definition at line 610 of file main_controller.h.

m_highInspiratoryMinuteVolumeAlarmThresholdNextCommand

int32_t MainController::m_highInspiratoryMinuteVolumeAlarmThresholdNextCommand

private

Threshold for high inspiratory minute volume alarm for next cycle.

Definition at line 613 of file main_controller.h.

m_highRespiratoryRateAlarmThresholdCommand

int32_t MainController::m_highRespiratoryRateAlarmThresholdCommand

private

Threshold for low respiratory rate.

Definition at line 634 of file main_controller.h.

m_highRespiratoryRateAlarmThresholdNextCommand

int32_t MainController::m_highRespiratoryRateAlarmThresholdNextCommand

private

Threshold for low respiratory rate for next cycle.

Definition at line 637 of file main_controller.h.

m_highTidalVolumeAlarmThresholdCommand

int32_t MainController::m_highTidalVolumeAlarmThresholdCommand

private

Threshold for high tidal Volume Alarm.

Definition at line 645 of file main_controller.h.

m_highTidalVolumeAlarmThresholdNextCommand

int32_t MainController::m_highTidalVolumeAlarmThresholdNextCommand

private

Threshold for high tidal Volume Alarm next cycle.

Definition at line 648 of file main_controller.h.

m_inhalationLastPressure

int16_t MainController::m_inhalationLastPressure

private

Last pressure of inhalation.

Definition at line 695 of file main_controller.h.

m_inspiratoryDurationCommand

int16_t MainController::m_inspiratoryDurationCommand

private

Duration of inspiration.

Definition at line 599 of file main_controller.h.

m_inspiratoryDurationNextCommand

int16_t MainController::m_inspiratoryDurationNextCommand

private

Duration of inspiration.

Definition at line 601 of file main_controller.h.

m_inspiratoryFlow

int32_t MainController::m_inspiratoryFlow

private

Measured inspiratory flow.

Definition at line 673 of file main_controller.h.

m_inspiratoryTriggerFlowCommand

int16_t MainController::m_inspiratoryTriggerFlowCommand

private

Desired inspiratory trigger flow.

Definition at line 552 of file main_controller.h.

m_inspiratoryTriggerFlowNextCommand

int16_t MainController::m_inspiratoryTriggerFlowNextCommand

private

Desired inspiratory trigger flow for next cycle.

Definition at line 554 of file main_controller.h.

m_inspiratoryValveAngle

uint32_t MainController::m_inspiratoryValveAngle

private

Blower valve angle at peak.

Definition at line 698 of file main_controller.h.

m_isPeepDetected

bool MainController::m_isPeepDetected

private

Is PEEP pressure detected in the cycle?

Definition at line 526 of file main_controller.h.

m_lastBreathPeriodsMs

uint32_t MainController::m_lastBreathPeriodsMs[NUMBER_OF_BREATH_PERIOD]

private

Period durations of last beathings.

Note

Used to compute cpm with a moving mean on several cycles

Definition at line 477 of file main_controller.h.

m_lastBreathPeriodsMsIndex

uint32_t MainController::m_lastBreathPeriodsMsIndex

private

Index for the m_lastBreathPeriodsMs array.

Definition at line 479 of file main_controller.h.

m_lastEndOfRespirationDateMs

uint32_t MainController::m_lastEndOfRespirationDateMs

private

Date of the last ending of a respiration.

Definition at line 481 of file main_controller.h.

m_lastMaxExpiratoryFlow

int32_t MainController::m_lastMaxExpiratoryFlow

private

Measured max inspiratory flow.

Definition at line 685 of file main_controller.h.

m_lastPressureValues

int16_t MainController::m_lastPressureValues[MAX_PRESSURE_SAMPLES]

private

Last pressure values.

Definition at line 713 of file main_controller.h.

m_lastPressureValuesIndex

uint16_t MainController::m_lastPressureValuesIndex

private

Last pressure index.

Definition at line 716 of file main_controller.h.

m_leakAlarmThresholdCommand

int32_t MainController::m_leakAlarmThresholdCommand

private

Threshold for leak alarm.

Definition at line 651 of file main_controller.h.

m_leakAlarmThresholdNextCommand

int32_t MainController::m_leakAlarmThresholdNextCommand

private

Threshold for leak alarm for next cycle.

Definition at line 653 of file main_controller.h.

m_lowExpiratoryMinuteVolumeAlarmThresholdCommand

int32_t MainController::m_lowExpiratoryMinuteVolumeAlarmThresholdCommand

private

Threshold for low inspiratory minute volume alarm.

Definition at line 616 of file main_controller.h.

m_lowExpiratoryMinuteVolumeAlarmThresholdNextCommand

int32_t MainController::m_lowExpiratoryMinuteVolumeAlarmThresholdNextCommand

private

Threshold for low inspiratory minute volume alarm for next cycle.

Definition at line 619 of file main_controller.h.

m_lowInspiratoryMinuteVolumeAlarmThresholdCommand

int32_t MainController::m_lowInspiratoryMinuteVolumeAlarmThresholdCommand

private

Threshold for low inspiratory minute volume alarm.

Definition at line 604 of file main_controller.h.

m_lowInspiratoryMinuteVolumeAlarmThresholdNextCommand

int32_t MainController::m_lowInspiratoryMinuteVolumeAlarmThresholdNextCommand

private

Threshold for low inspiratory minute volume alarm for next cycle.

Definition at line 607 of file main_controller.h.

m_lowRespiratoryRateAlarmThresholdCommand

int32_t MainController::m_lowRespiratoryRateAlarmThresholdCommand

private

Threshold for low respiratory rate.

Definition at line 628 of file main_controller.h.

m_lowRespiratoryRateAlarmThresholdNextCommand

int32_t MainController::m_lowRespiratoryRateAlarmThresholdNextCommand

private

Threshold for low respiratory rate for next cycle.

Definition at line 631 of file main_controller.h.

m_lowTidalVolumeAlarmThresholdCommand

int32_t MainController::m_lowTidalVolumeAlarmThresholdCommand

private

Threshold for low tidal Volume Alarm.

Definition at line 640 of file main_controller.h.

m_lowTidalVolumeAlarmThresholdNextCommand

int32_t MainController::m_lowTidalVolumeAlarmThresholdNextCommand

private

Threshold for low tidal Volume Alarm next cycle.

Definition at line 642 of file main_controller.h.

m_maxExpiratoryFlow

int32_t MainController::m_maxExpiratoryFlow

private

Measured max inspiratory flow.

Definition at line 682 of file main_controller.h.

m_maxInspiratoryFlow

int32_t MainController::m_maxInspiratoryFlow

private

Measured max inspiratory flow.

Definition at line 676 of file main_controller.h.

m_numberOfPressures

uint16_t MainController::m_numberOfPressures

private

Number of the current cycle's pressures.

Definition at line 722 of file main_controller.h.

m_patientGender

int32_t MainController::m_patientGender

private

Definition at line 728 of file main_controller.h.

m_patientHeight

int32_t MainController::m_patientHeight

private

Definition at line 725 of file main_controller.h.

m_peakPressureAlarmThresholdCommand

int16_t MainController::m_peakPressureAlarmThresholdCommand

private

Threshold for peak pressure alarm.

Definition at line 656 of file main_controller.h.

m_peakPressureAlarmThresholdNextCommand

int16_t MainController::m_peakPressureAlarmThresholdNextCommand

private

Threshold for peak pressure alarmfor next cycle.

Definition at line 658 of file main_controller.h.

m_peakPressureCommand

int16_t MainController::m_peakPressureCommand

private

Actual desired peak pressure.

Definition at line 484 of file main_controller.h.

m_peakPressureMeasure

int16_t MainController::m_peakPressureMeasure

private

Measured value of peak pressure.

Definition at line 486 of file main_controller.h.

m_peakPressureNextCommand

int16_t MainController::m_peakPressureNextCommand

private

Peak pressure desired by the operator for the next cycle.

Definition at line 490 of file main_controller.h.

m_peepCommand

int16_t MainController::m_peepCommand

private

Actual desired PEEP.

Definition at line 520 of file main_controller.h.

m_peepMeasure

int16_t MainController::m_peepMeasure

private

Measured value of the PEEP.

Definition at line 524 of file main_controller.h.

m_peepNextCommand

int16_t MainController::m_peepNextCommand

private

Desired PEEP for the next cycle.

Definition at line 522 of file main_controller.h.

m_phase

CyclePhases MainController::m_phase

private

Current respiratory cycle phase.

Definition at line 701 of file main_controller.h.

m_plateauDurationCommand

int16_t MainController::m_plateauDurationCommand

private

Plateau duration command (used in VC modes)

Definition at line 590 of file main_controller.h.

m_plateauDurationMs

uint32_t MainController::m_plateauDurationMs

private

Duration of the plateau.

Note

This setting is used in trigger mode

Definition at line 517 of file main_controller.h.

m_plateauDurationNextCommand

int16_t MainController::m_plateauDurationNextCommand

private

Plateau duration command for next cycle.

Definition at line 592 of file main_controller.h.

m_PlateauMeasureCount

uint16_t MainController::m_PlateauMeasureCount

private

Count for calulating plateau value.

Definition at line 511 of file main_controller.h.

m_PlateauMeasureSum

int64_t MainController::m_PlateauMeasureSum

private

Sum for calulating plateau value.

Definition at line 509 of file main_controller.h.

m_plateauPressureCommand

int16_t MainController::m_plateauPressureCommand

private

Actual desired plateau pressure.

Definition at line 493 of file main_controller.h.

m_plateauPressureMeasure

int16_t MainController::m_plateauPressureMeasure

private

Measured value of the plateau pressure.

Note

Can sometimes have the special value of MAXINT

Definition at line 501 of file main_controller.h.

m_plateauPressureNextCommand

int16_t MainController::m_plateauPressureNextCommand

private

Plateau pressure desired by the operator for the next cycle.

Definition at line 495 of file main_controller.h.

m_plateauPressureToDisplay

int16_t MainController::m_plateauPressureToDisplay

private

Measured value of the plateau pressure for display.

Note

Special value of MAXINT in m_plateauPressureMeasure is replaced by 0

Definition at line 507 of file main_controller.h.

m_pressure

int16_t MainController::m_pressure

private

Measured pressure.

Definition at line 670 of file main_controller.h.

m_pressureCommand

int32_t MainController::m_pressureCommand

private

Requested pressure at a given point in time.

Definition at line 710 of file main_controller.h.

m_pressureTriggerOffsetCommand

int16_t MainController::m_pressureTriggerOffsetCommand

private

Actual pressure trigger offset.

Definition at line 529 of file main_controller.h.

m_pressureTriggerOffsetNextCommand

int16_t MainController::m_pressureTriggerOffsetNextCommand

private

Desired pressure trigger offset for the next cycle.

Definition at line 531 of file main_controller.h.

m_rebouncePeakPressureMeasure

int16_t MainController::m_rebouncePeakPressureMeasure

private

Measured value of rebounce peak pressure.

Definition at line 488 of file main_controller.h.

m_sumOfPressures

uint32_t MainController::m_sumOfPressures

private

Sum of the current cycle's pressures.

Definition at line 719 of file main_controller.h.

m_targetInspiratoryFlowCommand

int32_t MainController::m_targetInspiratoryFlowCommand

private

inspiratory flow required (used in VC modes)

Definition at line 595 of file main_controller.h.

m_targetInspiratoryFlowNextCommand

int32_t MainController::m_targetInspiratoryFlowNextCommand

private

inspiratory flow required (used in VC modes) for next cycle

Definition at line 597 of file main_controller.h.

m_tick

uint32_t MainController::m_tick

private

Actual tick number (given by the main state machine)

Definition at line 464 of file main_controller.h.

m_ticksPerCycle

uint16_t MainController::m_ticksPerCycle

private

Number of hundredth of second per cycle.

Definition at line 664 of file main_controller.h.

m_ticksPerInhalation

uint32_t MainController::m_ticksPerInhalation

private

Number of hundredth of second per inhalation.

Definition at line 667 of file main_controller.h.

m_tidalVolumeAlreadyRead

bool MainController::m_tidalVolumeAlreadyRead

private

True if Tidal volume has already been read during cycle.

Definition at line 541 of file main_controller.h.

m_tidalVolumeCommand

int16_t MainController::m_tidalVolumeCommand

private

Tidal volume command (used in VC modes)

Definition at line 585 of file main_controller.h.

m_tidalVolumeMeasure

int16_t MainController::m_tidalVolumeMeasure

private

Measured value of the Tidal volume (volume of air pushed in patient lungs in last inspiration)

Definition at line 582 of file main_controller.h.

m_tidalVolumeNextCommand

int16_t MainController::m_tidalVolumeNextCommand

private

Tidal volume command for next cycle.

Definition at line 587 of file main_controller.h.

m_tiMaxCommand

int16_t MainController::m_tiMaxCommand

private

Max duration of inspiration in ms.

Definition at line 564 of file main_controller.h.

m_tiMaxNextCommand

int16_t MainController::m_tiMaxNextCommand

private

Max duration of inspiration in ms for next cycle.

Definition at line 568 of file main_controller.h.

m_tiMinCommand

int16_t MainController::m_tiMinCommand

private

Minimum duration of inspiration in ms.

Definition at line 562 of file main_controller.h.

m_tiMinNextCommand

int16_t MainController::m_tiMinNextCommand

private

Minimum duration of inspiration in ms for next cycle.

Definition at line 566 of file main_controller.h.

m_triggered

bool MainController::m_triggered

private

Is inspiratory triggered or not?

Definition at line 533 of file main_controller.h.

m_triggerModeEnabledCommand

bool MainController::m_triggerModeEnabledCommand

private

Actual state of enabling of trigger mode.

Definition at line 536 of file main_controller.h.

m_triggerModeEnabledNextCommand

bool MainController::m_triggerModeEnabledNextCommand

private

Desired state of enabling of trigger mode for the next cycle.

Definition at line 538 of file main_controller.h.

m_ventilationController

VentilationController* MainController::m_ventilationController

private

Ventilation controller in use (for everything related to breathing control)

Definition at line 571 of file main_controller.h.

m_ventilationControllerMode

VentilationModes MainController::m_ventilationControllerMode

private

Definition at line 578 of file main_controller.h.

m_ventilationControllerNextCommand

VentilationController* MainController::m_ventilationControllerNextCommand

private

Ventilation controller for the next cycle.

Definition at line 573 of file main_controller.h.

m_ventilationControllersTable

VentilationController* MainController::m_ventilationControllersTable[NUMBER_OF_VENTILATION_MODES+1u]

private

Array containing pointers to different ventilation controllers.

Definition at line 576 of file main_controller.h.

---

The documentation for this class was generated from the following files:

• includes/main_controller.h
• srcs/main_controller.cpp