PC_VSAI_Controller Class Reference

Controller for the VSAI mode. More...

#include <pc_vsai_controller.h>

Inheritance diagram for PC_VSAI_Controller:

Public Member Functions
	PC_VSAI_Controller ()
	Default constructor. More...
void	setup () override
	Initialize controller. More...
void	initCycle () override
	Begin a new breathing cycle. More...
void	inhale () override
	Control the inhalation. More...
void	exhale () override
	Control the exhalation. More...
void	endCycle () override
	End the current breathing cycle. More...
struct Alarms	enabledAlarms () const override
	List of alarms that must be enabled for this mode. More...

Private Member Functions
void	calculateBlowerIncrement ()
	Determine the blower speed to adopt for next cycle. More...
int32_t	PCinspiratoryPID (int32_t targetPressure, int32_t currentPressure, int32_t dt)
	PID to control the blower valve during some specific steps of the cycle. More...
int32_t	PCexpiratoryPID (int32_t targetPressure, int32_t currentPressure, int32_t dt)
	PID to control the patient valve during some specific steps of the cycle. More...

Private Attributes
uint16_t	m_triggerWindow
	Number of ticks from which it is possible to trigger a new inspiration. More...
bool	m_plateauPressureReached
	True if plateau pressure has been reached (but not necessarily converged) More...
uint16_t	m_blowerSpeed
	Current blower speed. More...
bool	m_reOpenInspiratoryValve
	True if we want to reopen the inspiratory valve to create a circulation flow able to detect inspiratory flow trigger. More...
int32_t	m_inspiratorySlope
	Slope of the inspiration open loop (in mmH2O/s) More...
int32_t	m_blowerIncrement
	Current blower speed increment (to apply at the beginning of the next cycle) More...
int32_t	m_inspiratoryPidIntegral
	Error of the last computation of the blower PID. More...
int32_t	m_inspiratoryPidLastError
	Error of the last computation of the blower PID. More...
bool	m_expiratoryPidFastMode
	Fast mode at start of expiration. More...
bool	m_inspiratoryPidFastMode
	Fast mode at start of inspiration. More...
int32_t	m_expiratoryPidIntegral
	Integral gain of the patient PID. More...
int32_t	m_inspiratoryValveLastAperture
	Last aperture of the blower valve. More...
int32_t	m_expiratoryValveLastAperture
	Last aperture of the blower valve. More...
int32_t	m_expiratoryPidLastError
	Error of the last computation of the PID. More...
int32_t	m_inspiratoryPidLastErrors [PC_NUMBER_OF_SAMPLE_DERIVATIVE_MOVING_MEAN]
	Last errors in inspiratory PID. More...
int32_t	m_inspiratoryPidLastErrorsIndex
	Last error index in inspiratory PID. More...
int32_t	m_expiratoryPidLastErrors [PC_NUMBER_OF_SAMPLE_DERIVATIVE_MOVING_MEAN]
	Last errors in expiratory PID. More...
int32_t	m_expiratoryPidLastErrorsIndex
	Last error index in expiratory PID. More...
int32_t	m_maxInspiratoryFlow
	Max flow during inspiration. More...

Detailed Description

Controller for the VSAI mode.

Definition at line 14 of file pc_vsai_controller.h.

Constructor & Destructor Documentation

PC_VSAI_Controller()

PC_VSAI_Controller::PC_VSAI_Controller

(

)

Default constructor.

Definition at line 28 of file pc_vsai_controller.cpp.

                                       {
    m_inspiratoryValveLastAperture = inspiratoryValve.maxAperture();
    m_expiratoryValveLastAperture = expiratoryValve.maxAperture();
    m_plateauPressureReached = false;
    m_triggerWindow =
        mainController.ticksPerInhalation()
        + (1000u / MAIN_CONTROLLER_COMPUTE_PERIOD_MS);  // Possible to trigger 1s before end
 
    m_inspiratoryPidLastErrorsIndex = 0;
    m_expiratoryPidLastErrorsIndex = 0;
 
    for (uint8_t i = 0u; i < PC_NUMBER_OF_SAMPLE_DERIVATIVE_MOVING_MEAN; i++) {
        m_inspiratoryPidLastErrors[i] = 0u;
        m_expiratoryPidLastErrors[i] = 0u;
    }
 
    m_blowerSpeed = DEFAULT_BLOWER_SPEED;
    m_reOpenInspiratoryValve = false;
    m_inspiratorySlope = 0;
    m_blowerIncrement = 0;
    m_inspiratoryPidIntegral = 0;
    m_inspiratoryPidLastError = 0;
    m_expiratoryPidFastMode = true;
    m_inspiratoryPidFastMode = true;
    m_expiratoryPidIntegral = 0;
    m_expiratoryPidLastError = 0;
    m_maxInspiratoryFlow = 0;
}

Member Function Documentation

calculateBlowerIncrement()

void PC_VSAI_Controller::calculateBlowerIncrement ( )

private

Determine the blower speed to adopt for next cycle.

Definition at line 172 of file pc_vsai_controller.cpp.

                                                  {
    int16_t peakDelta =
        mainController.peakPressureMeasure() - mainController.plateauPressureCommand();
    int16_t rebouncePeakDelta =
        mainController.rebouncePeakPressureMeasure() - mainController.plateauPressureCommand();
    DBG_DO(Serial.print("peakPressure:");)
    DBG_DO(Serial.println(mainController.peakPressureMeasure());)
    DBG_DO(Serial.print("plateauPressureCommand:");)
    DBG_DO(Serial.println(mainController.plateauPressureCommand());)
 
    // Check that pressure didn't rebounced
    // High rebounces will decrease the blower
    // Low rebounce will prevent increase (but not decrease)
    bool veryHighRebounce = (peakDelta > 60) || ((rebouncePeakDelta < -60) && (peakDelta >= 0));
    bool highRebounce = (peakDelta > 40) || ((rebouncePeakDelta < -40) && (peakDelta >= 0));
    bool lowRebounce = (peakDelta > 20) || ((rebouncePeakDelta < -15) && (peakDelta >= 0));
    bool veryLowRebounce = (peakDelta > 10) || ((rebouncePeakDelta < -10) && (peakDelta >= 0));
 
    // Update blower only if patient is plugged on the machine
    if (mainController.peakPressureMeasure() > 20) {
        // Safety condition: a too high peak (4 cmH2O) should decrease the blower
        if (veryHighRebounce) {
            m_blowerIncrement = -100;
        } else if (highRebounce) {
            m_blowerIncrement = -10;
        } else if (m_inspiratorySlope > 650) {  // We want the m_inspiratorySlope = 600 mmH2O/s
            // Only case for decreasing the blower: ramping is too fast or overshooting is too high
            if ((m_inspiratorySlope > 1000)
                || ((lowRebounce && (m_inspiratorySlope > 800)) || (peakDelta > 25))) {
                m_blowerIncrement = -100;
            } else {
                m_blowerIncrement = 0;
            }
        } else if (m_inspiratorySlope > 550) {
            m_blowerIncrement = 0;
        } else if ((m_inspiratorySlope > 450) && !veryLowRebounce) {
            m_blowerIncrement = +25;
        } else if ((m_inspiratorySlope > 350) && !veryLowRebounce) {
            m_blowerIncrement = +50;
        } else if ((m_inspiratorySlope > 250) && !veryLowRebounce) {
            m_blowerIncrement = +75;
        } else if (!lowRebounce) {
            m_blowerIncrement = +100;
        } else {
            // Do nothing
        }
    }
 
    DBG_DO(Serial.print("BLOWER"));
    DBG_DO(Serial.println(m_blowerIncrement));
    DBG_DO(Serial.print("m_inspiratorySlope:");)
    DBG_DO(Serial.println(m_inspiratorySlope);)
}

enabledAlarms()

struct Alarms PC_VSAI_Controller::enabledAlarms ( ) const

inlineoverridevirtual

List of alarms that must be enabled for this mode.

Implements VentilationController.

Definition at line 32 of file pc_vsai_controller.h.

                                                 {
        struct Alarms a = {RCM_SW_1,  RCM_SW_2,  RCM_SW_3,  RCM_SW_4,  RCM_SW_5,
                           RCM_SW_6,  RCM_SW_7,  RCM_SW_8,  RCM_SW_9,  0u,
                           RCM_SW_11, RCM_SW_12, RCM_SW_14, RCM_SW_15, RCM_SW_16,
                           RCM_SW_18, RCM_SW_19, RCM_SW_20, RCM_SW_21, RCM_SW_22,
                           RCM_SW_22};
        return a;
    }

endCycle()

void PC_VSAI_Controller::endCycle ( )

overridevirtual

End the current breathing cycle.

Implements VentilationController.

Definition at line 170 of file pc_vsai_controller.cpp.

{ calculateBlowerIncrement(); }

exhale()

void PC_VSAI_Controller::exhale ( )

overridevirtual

Control the exhalation.

Implements VentilationController.

Definition at line 139 of file pc_vsai_controller.cpp.

                                {
    // Open the expiration valve so the patient can exhale outside
    int32_t expiratoryValveOpenningValue = PCexpiratoryPID(
        mainController.pressureCommand(), mainController.pressure(), mainController.dt());
 
    (void)expiratoryValve.openLinear(expiratoryValveOpenningValue);
 
    inspiratoryValve.close();
 
    // Calculate max pressure for the last samples
    int32_t maxPressureValue = mainController.lastPressureValues()[0];
    for (uint8_t i = 0; i < MAX_PRESSURE_SAMPLES; i++) {
        if (mainController.lastPressureValues()[i] > maxPressureValue) {
            maxPressureValue = mainController.lastPressureValues()[i];
        }
    }
 
    // In case the pressure trigger mode is enabled, check if inspiratory trigger is raised
    if ((mainController.tick()
         > (mainController.ticksPerInhalation() + (500u / MAIN_CONTROLLER_COMPUTE_PERIOD_MS)))) {
        // m_peakPressure > CONST_MIN_PEAK_PRESSURE ensures that the patient is plugged on the
        // machine
        if (((mainController.pressure())
                 < (maxPressureValue - (mainController.pressureTriggerOffsetCommand()))
             && (mainController.peakPressureMeasure() > CONST_MIN_PEAK_PRESSURE))
            || mainController.pressure() < -mainController.pressureTriggerOffsetCommand()) {
            mainController.setTrigger(true);
        }
    }
}

inhale()

void PC_VSAI_Controller::inhale ( )

overridevirtual

Control the inhalation.

Implements VentilationController.

Definition at line 102 of file pc_vsai_controller.cpp.

                                {
    m_expiratoryPidFastMode = false;
 
    // Keep the inspiratory valve open using a PID
    int32_t inspiratoryValveOpenningValue = PCinspiratoryPID(
        mainController.pressureCommand(), mainController.pressure(), mainController.dt());
 
    // Normally inspiratory valve is open, but at the end of the cycle it could be closed and
    // expiratory valve will open
    (void)inspiratoryValve.openLinear(inspiratoryValveOpenningValue);
    expiratoryValve.close();
 
    m_expiratoryPidFastMode = true;
 
    // m_inspiratorySlope is used for blower regulations, -20 corresponds to open loop openning
    if ((mainController.pressure() > (mainController.plateauPressureCommand() - 20))
        && !m_plateauPressureReached) {
        m_inspiratorySlope = ((mainController.pressure() - mainController.peepMeasure()) * 100)
                             / static_cast<int32_t>(mainController.tick());  // in mmH2O/s
        m_plateauPressureReached = true;
    }
 
    int32_t tiMinInTick =
        mainController.tiMinCommand() / static_cast<int16_t>(MAIN_CONTROLLER_COMPUTE_PERIOD_MS);
 
    if (mainController.inspiratoryFlow() > m_maxInspiratoryFlow) {
        m_maxInspiratoryFlow = mainController.inspiratoryFlow();
    } else if ((mainController.inspiratoryFlow()
                < ((mainController.expiratoryTriggerFlowCommand() * m_maxInspiratoryFlow) / 100))
               && (static_cast<int64_t>(mainController.tick())
                   > static_cast<int64_t>(tiMinInTick))) {
        mainController.ticksPerInhalationSet(mainController.tick());
    } else {
        // Do nothing
    }
}

initCycle()

void PC_VSAI_Controller::initCycle ( )

overridevirtual

Begin a new breathing cycle.

Implements VentilationController.

Definition at line 59 of file pc_vsai_controller.cpp.

                                   {
    m_plateauPressureReached = false;
    m_triggerWindow =
        mainController.ticksPerInhalation()
        + (1400u / MAIN_CONTROLLER_COMPUTE_PERIOD_MS);  // Possible to trigger 1.4s before end
    m_maxInspiratoryFlow = 0;
    m_expiratoryValveLastAperture = expiratoryValve.maxAperture();
    // Reset PID values
    m_inspiratoryPidIntegral = 0;
    m_expiratoryPidIntegral = 0;
    m_inspiratoryPidLastError =
        mainController.plateauPressureCommand() - mainController.peepCommand();
    m_expiratoryPidLastError =
        mainController.peepCommand() - mainController.plateauPressureCommand();
    m_inspiratoryPidFastMode = true;
    m_expiratoryPidFastMode = true;
    for (uint8_t i = 0; i < PC_NUMBER_OF_SAMPLE_DERIVATIVE_MOVING_MEAN; i++) {
        m_inspiratoryPidLastErrors[i] = 0;
        m_expiratoryPidLastErrors[i] =
            mainController.peepCommand() - mainController.plateauPressureCommand();
    }
 
    // Apply blower ramp-up
    if (m_blowerIncrement >= 0) {
        blower.runSpeedWithRampUp(m_blowerSpeed + static_cast<uint16_t>(abs(m_blowerIncrement)));
    } else {
        // When blower increment is negative, we need to check that it is less than current speed
        // If not, it would result in an overflow
        if (static_cast<uint16_t>(abs(m_blowerIncrement)) < blower.getSpeed()) {
            blower.runSpeedWithRampUp(m_blowerSpeed
                                      - static_cast<uint16_t>(abs(m_blowerIncrement)));
        } else {
            blower.runSpeedWithRampUp(MIN_BLOWER_SPEED);
        }
    }
    m_blowerSpeed = blower.getTargetSpeed();
    m_blowerIncrement = 0;
 
    m_reOpenInspiratoryValve = false;
 
    m_inspiratorySlope = 0;
}

PCexpiratoryPID()

int32_t PC_VSAI_Controller::PCexpiratoryPID ( int32_t  targetPressure, int32_t  currentPressure, int32_t  dt  )

private

PID to control the patient valve during some specific steps of the cycle.

Parameters

targetPressure	The pressure we want (in mmH2O)
currentPressure	The pressure measured by the sensor (in mmH2O)
dt	Time since the last computation (in microsecond)

Definition at line 328 of file pc_vsai_controller.cpp.

                                                                                               {
    int32_t minAperture = expiratoryValve.minAperture();
    int32_t maxAperture = expiratoryValve.maxAperture();
    int32_t expiratoryValveAperture;
    int32_t derivative = 0;
    int32_t smoothError = 0;
    int32_t totalValues = 0;
    int32_t temporarym_expiratoryPidIntegral = 0;
    int32_t proportionnalWeight;
    int32_t derivativeWeight;
 
    int32_t coefficientP;
    int32_t coefficientI;
    int32_t coefficientD;
 
    // Compute error
    int32_t error = targetPressure + PID_PATIENT_SAFETY_PEEP_OFFSET - currentPressure;
 
    // Calculate derivative part
    // Include a moving average on error for smoothing purpose
    m_expiratoryPidLastErrors[m_expiratoryPidLastErrorsIndex] = error;
    m_expiratoryPidLastErrorsIndex++;
    if (m_expiratoryPidLastErrorsIndex
        >= static_cast<int32_t>(PC_NUMBER_OF_SAMPLE_DERIVATIVE_MOVING_MEAN)) {
        m_expiratoryPidLastErrorsIndex = 0;
    }
    for (uint8_t i = 0u; i < PC_NUMBER_OF_SAMPLE_DERIVATIVE_MOVING_MEAN; i++) {
        totalValues += m_expiratoryPidLastErrors[i];
    }
    smoothError = totalValues / static_cast<int32_t>(PC_NUMBER_OF_SAMPLE_DERIVATIVE_MOVING_MEAN);
    derivative = (dt == 0) ? 0 : (1000000 * (smoothError - m_expiratoryPidLastError)) / dt;
 
    //  Windowing (it overrides the parameter.h coefficients)
    if (error < 0) {
        coefficientI = 50;
        coefficientP = 2500;
        coefficientD = 0;
    } else {
        // For a high PEEP, a lower KI is required
        // For PEEP = 100 mmH2O, KI = 120
        // For PEEP = 50 mmH2O, KI = 250
        if (mainController.peepCommand() > 100) {
            coefficientI = 120;
        } else {
            coefficientI = ((-130 * ((int32_t)mainController.peepCommand())) / 50) + 380;
        }
        coefficientP = 2500;
        coefficientD = 0;
    }
 
    // Fast mode ends at 30 mmH20 from target
    // When changing from fast mode to PID, set the integral to the previous value
    if (error > -30) {
        if (m_expiratoryPidFastMode) {
            proportionnalWeight = (coefficientP * error) / 1000;
            derivativeWeight = (coefficientD * derivative / 1000);
            m_expiratoryPidIntegral = 1000 * ((int32_t)m_expiratoryValveLastAperture - maxAperture)
                                          / (maxAperture - minAperture)
                                      - (proportionnalWeight + derivativeWeight);
        }
        m_expiratoryPidFastMode = false;
    }
 
    // Fast mode: open loop with ramp
    if (m_expiratoryPidFastMode) {
        expiratoryValveAperture = 0;
    } else {  // If not in fast mode, the PID is used
        temporarym_expiratoryPidIntegral =
            m_expiratoryPidIntegral + ((coefficientI * error * dt) / 1000000);
        temporarym_expiratoryPidIntegral =
            max(PID_PATIENT_INTEGRAL_MIN,
                min(PID_PATIENT_INTEGRAL_MAX, temporarym_expiratoryPidIntegral));
 
        proportionnalWeight = ((coefficientP * error) / 1000);
        int32_t integralWeight = temporarym_expiratoryPidIntegral;
        derivativeWeight = coefficientD * derivative / 1000;
 
        int32_t patientCommand = proportionnalWeight + integralWeight + derivativeWeight;
 
        expiratoryValveAperture = max(
            minAperture,
            min(maxAperture, maxAperture + (maxAperture - minAperture) * patientCommand / 1000));
    }
 
    // If the valve is completely open or completely closed, don't update integral part
    if ((expiratoryValveAperture != minAperture) && (expiratoryValveAperture != maxAperture)) {
        m_expiratoryPidIntegral = temporarym_expiratoryPidIntegral;
    }
 
    m_expiratoryPidLastError = smoothError;
    m_expiratoryValveLastAperture = expiratoryValveAperture;
 
    return expiratoryValveAperture;
}

PCinspiratoryPID()

int32_t PC_VSAI_Controller::PCinspiratoryPID ( int32_t  targetPressure, int32_t  currentPressure, int32_t  dt  )

private

PID to control the blower valve during some specific steps of the cycle.

Parameters

targetPressure	The pressure we want (in mmH2O)
currentPressure	The pressure measured by the sensor (in mmH2O)
dt	Time since the last computation (in microsecond)

Definition at line 227 of file pc_vsai_controller.cpp.

                                                                                                {
    int32_t minAperture = inspiratoryValve.minAperture();
    int32_t maxAperture = inspiratoryValve.maxAperture();
    int32_t inspiratoryValveAperture;
    int32_t derivative = 0;
    int32_t smoothError = 0;
    int32_t totalValues = 0;
    int32_t proportionnalWeight;
    int32_t derivativeWeight;
 
    int32_t coefficientP;
    int32_t coefficientI;
    int32_t coefficientD;
 
    int32_t temporarym_inspiratoryPidIntegral = 0;
 
    // Compute error
    int32_t error = targetPressure - currentPressure;
 
    // Windowing (it overrides the parameter.h coefficients)
    coefficientP = 2500;
 
    coefficientD = 0;
    if (error < 0) {
        coefficientI = 200;
 
    } else {
        coefficientI = 50;
    }
 
    // Calculate derivative part
    // Include a moving average on error for smoothing purpose
    m_inspiratoryPidLastErrors[m_inspiratoryPidLastErrorsIndex] = error;
    m_inspiratoryPidLastErrorsIndex++;
    if (m_inspiratoryPidLastErrorsIndex
        >= static_cast<int32_t>(PC_NUMBER_OF_SAMPLE_DERIVATIVE_MOVING_MEAN)) {
        m_inspiratoryPidLastErrorsIndex = 0;
    }
    for (uint8_t i = 0u; i < PC_NUMBER_OF_SAMPLE_DERIVATIVE_MOVING_MEAN; i++) {
        totalValues += m_inspiratoryPidLastErrors[i];
    }
    smoothError = totalValues / static_cast<int32_t>(PC_NUMBER_OF_SAMPLE_DERIVATIVE_MOVING_MEAN);
 
    // Fast mode ends at 20 mmH20 from target
    // When changing from fast mode to PID, set the integral to the previous value
    if (error < 20) {
        if (m_inspiratoryPidFastMode) {
            proportionnalWeight = (coefficientP * error) / 1000;
            derivativeWeight = (coefficientD * derivative / 1000);
            m_inspiratoryPidIntegral = 1000
                                           * ((int32_t)m_inspiratoryValveLastAperture - maxAperture)
                                           / (minAperture - maxAperture)
                                       - (proportionnalWeight + derivativeWeight);
        }
        m_inspiratoryPidFastMode = false;
    }
 
    // In fast mode: everything is openned (open loop)
    if (m_inspiratoryPidFastMode) {
        // Ramp from 125 to 0 angle during 250 ms
        int32_t increment =
            (5 * static_cast<int32_t>(MAIN_CONTROLLER_COMPUTE_PERIOD_MICROSECONDS)) / 10000;
        if (m_inspiratoryValveLastAperture >= abs(increment)) {
            inspiratoryValveAperture =
                max(minAperture,
                    min(maxAperture,
                        (static_cast<int32_t>(m_inspiratoryValveLastAperture) - increment)));
        } else {
            inspiratoryValveAperture = 0;
        }
    } else {  // If not in fast mode, the PID is used
        derivative = ((dt == 0)) ? 0 : ((1000000 * (m_inspiratoryPidLastError - smoothError)) / dt);
 
        temporarym_inspiratoryPidIntegral =
            m_inspiratoryPidIntegral + ((coefficientI * error * dt) / 1000000);
        temporarym_inspiratoryPidIntegral =
            max(PID_BLOWER_INTEGRAL_MIN,
                min(PID_BLOWER_INTEGRAL_MAX, temporarym_inspiratoryPidIntegral));
 
        proportionnalWeight = ((coefficientP * error) / 1000);
        int32_t integralWeight = temporarym_inspiratoryPidIntegral;
        derivativeWeight = coefficientD * derivative / 1000;
 
        int32_t blowerCommand = proportionnalWeight + integralWeight + derivativeWeight;
        inspiratoryValveAperture =
            max(minAperture,
                min(maxAperture, maxAperture + (minAperture - maxAperture) * blowerCommand / 1000));
    }
 
    // If the valve is completely open or completely closed, don't update integral part
    if ((inspiratoryValveAperture != minAperture) && (inspiratoryValveAperture != maxAperture)) {
        m_inspiratoryPidIntegral = temporarym_inspiratoryPidIntegral;
    }
 
    m_inspiratoryValveLastAperture = inspiratoryValveAperture;
    m_inspiratoryPidLastError = smoothError;
 
    return inspiratoryValveAperture;
}

setup()

void PC_VSAI_Controller::setup ( )

overridevirtual

Initialize controller.

Implements VentilationController.

Definition at line 57 of file pc_vsai_controller.cpp.

{ m_blowerSpeed = DEFAULT_BLOWER_SPEED; }

Member Data Documentation

m_blowerIncrement

int32_t PC_VSAI_Controller::m_blowerIncrement

private

Current blower speed increment (to apply at the beginning of the next cycle)

Definition at line 83 of file pc_vsai_controller.h.

m_blowerSpeed

uint16_t PC_VSAI_Controller::m_blowerSpeed

private

Current blower speed.

Definition at line 73 of file pc_vsai_controller.h.

m_expiratoryPidFastMode

bool PC_VSAI_Controller::m_expiratoryPidFastMode

private

Fast mode at start of expiration.

Definition at line 92 of file pc_vsai_controller.h.

m_expiratoryPidIntegral

int32_t PC_VSAI_Controller::m_expiratoryPidIntegral

private

Integral gain of the patient PID.

Definition at line 98 of file pc_vsai_controller.h.

m_expiratoryPidLastError

int32_t PC_VSAI_Controller::m_expiratoryPidLastError

private

Error of the last computation of the PID.

Definition at line 107 of file pc_vsai_controller.h.

m_expiratoryPidLastErrors

int32_t PC_VSAI_Controller::m_expiratoryPidLastErrors[PC_NUMBER_OF_SAMPLE_DERIVATIVE_MOVING_MEAN]

private

Last errors in expiratory PID.

Definition at line 116 of file pc_vsai_controller.h.

m_expiratoryPidLastErrorsIndex

int32_t PC_VSAI_Controller::m_expiratoryPidLastErrorsIndex

private

Last error index in expiratory PID.

Definition at line 119 of file pc_vsai_controller.h.

m_expiratoryValveLastAperture

int32_t PC_VSAI_Controller::m_expiratoryValveLastAperture

private

Last aperture of the blower valve.

Definition at line 104 of file pc_vsai_controller.h.

m_inspiratoryPidFastMode

bool PC_VSAI_Controller::m_inspiratoryPidFastMode

private

Fast mode at start of inspiration.

Definition at line 95 of file pc_vsai_controller.h.

m_inspiratoryPidIntegral

int32_t PC_VSAI_Controller::m_inspiratoryPidIntegral

private

Error of the last computation of the blower PID.

Definition at line 86 of file pc_vsai_controller.h.

m_inspiratoryPidLastError

int32_t PC_VSAI_Controller::m_inspiratoryPidLastError

private

Error of the last computation of the blower PID.

Definition at line 89 of file pc_vsai_controller.h.

m_inspiratoryPidLastErrors

int32_t PC_VSAI_Controller::m_inspiratoryPidLastErrors[PC_NUMBER_OF_SAMPLE_DERIVATIVE_MOVING_MEAN]

private

Last errors in inspiratory PID.

Definition at line 110 of file pc_vsai_controller.h.

m_inspiratoryPidLastErrorsIndex

int32_t PC_VSAI_Controller::m_inspiratoryPidLastErrorsIndex

private

Last error index in inspiratory PID.

Definition at line 113 of file pc_vsai_controller.h.

m_inspiratorySlope

int32_t PC_VSAI_Controller::m_inspiratorySlope

private

Slope of the inspiration open loop (in mmH2O/s)

Definition at line 80 of file pc_vsai_controller.h.

m_inspiratoryValveLastAperture

int32_t PC_VSAI_Controller::m_inspiratoryValveLastAperture

private

Last aperture of the blower valve.

Definition at line 101 of file pc_vsai_controller.h.

m_maxInspiratoryFlow

int32_t PC_VSAI_Controller::m_maxInspiratoryFlow

private

Max flow during inspiration.

Definition at line 122 of file pc_vsai_controller.h.

m_plateauPressureReached

bool PC_VSAI_Controller::m_plateauPressureReached

private

True if plateau pressure has been reached (but not necessarily converged)

Definition at line 52 of file pc_vsai_controller.h.

m_reOpenInspiratoryValve

bool PC_VSAI_Controller::m_reOpenInspiratoryValve

private

True if we want to reopen the inspiratory valve to create a circulation flow able to detect inspiratory flow trigger.

Definition at line 77 of file pc_vsai_controller.h.

m_triggerWindow

uint16_t PC_VSAI_Controller::m_triggerWindow

private

Number of ticks from which it is possible to trigger a new inspiration.

Definition at line 49 of file pc_vsai_controller.h.

---

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

• includes/pc_vsai_controller.h
• srcs/pc_vsai_controller.cpp