PC_CMV_Controller Class Reference

Controller for the CMV mode. More...

#include <pc_cmv_controller.h>

Inheritance diagram for PC_CMV_Controller:

Public Member Functions
	PC_CMV_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_plateauStartTime
	Number of ticks when plateau is reached for the first time. More...
bool	m_plateauPressureReached
	True if plateau pressure has been reached (but not necessarily converged) More...
uint16_t	m_blowerSpeed
	Current blower speed. 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...
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 expiratory 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 inspiratory PID. More...
int32_t	m_inspiratoryPidLastError
	Error of the last computation of the expiratory 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...

Detailed Description

Controller for the CMV mode.

Definition at line 14 of file pc_cmv_controller.h.

Constructor & Destructor Documentation

PC_CMV_Controller()

PC_CMV_Controller::PC_CMV_Controller

(

)

Default constructor.

Definition at line 29 of file pc_cmv_controller.cpp.

                                     {
    m_inspiratoryValveLastAperture = inspiratoryValve.maxAperture();
    m_expiratoryValveLastAperture = expiratoryValve.maxAperture();
    m_plateauPressureReached = false;
    m_plateauStartTime = mainController.ticksPerInhalation();
 
    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_blowerIncrement = 0;
    m_inspiratoryPidIntegral = 0;
    m_inspiratoryPidLastError = 0;
    m_expiratoryPidFastMode = true;
    m_inspiratoryPidFastMode = true;
    m_expiratoryPidIntegral = 0;
    m_expiratoryPidLastError = 0;
}

Member Function Documentation

calculateBlowerIncrement()

void PC_CMV_Controller::calculateBlowerIncrement ( )

private

Determine the blower speed to adopt for next cycle.

Definition at line 121 of file pc_cmv_controller.cpp.

                                                 {
    int16_t peakDelta =
        mainController.peakPressureMeasure() - mainController.plateauPressureCommand();
 
    // Number of tick for the half ramp (120 ms)
    int32_t halfRampNumberfTick =
        1000 * 120 / static_cast<int32_t>(MAIN_CONTROLLER_COMPUTE_PERIOD_MICROSECONDS);
 
    // Update blower only if patient is plugged on the machine
    if (mainController.peakPressureMeasure() > 20) {
        if (m_plateauStartTime < ((mainController.ticksPerInhalation() * 30u) / 100u)) {
            // Only case for decreasing the blower: ramping is too fast or overshooting is too high
            if ((m_plateauStartTime < static_cast<uint32_t>(abs(halfRampNumberfTick)))
                || ((peakDelta > 15)
                    && (m_plateauStartTime < ((mainController.ticksPerInhalation() * 20u) / 100u)))
                || (peakDelta > 25)) {
                m_blowerIncrement = -100;
                DBG_DO(Serial.println("BLOWER -100");)
            } else {
                m_blowerIncrement = 0;
                DBG_DO(Serial.println("BLOWER 0");)
            }
        } else if (m_plateauStartTime < ((mainController.ticksPerInhalation() * 40u) / 100u)) {
            DBG_DO(Serial.println("BLOWER +0");)
            m_blowerIncrement = 0;
        } else if (m_plateauStartTime < ((mainController.ticksPerInhalation() * 50u) / 100u)) {
            m_blowerIncrement = +25;
            DBG_DO(Serial.println("BLOWER +25"));
        } else if (m_plateauStartTime < ((mainController.ticksPerInhalation() * 60u) / 100u)) {
            m_blowerIncrement = +50;
            DBG_DO(Serial.println("BLOWER +50"));
        } else {
            m_blowerIncrement = +100;
            DBG_DO(Serial.println("BLOWER +100"));
        }
    }
 
    DBG_DO(Serial.print("Plateau Start time:");)
    DBG_DO(Serial.println(m_plateauStartTime);)
}

enabledAlarms()

struct Alarms PC_CMV_Controller::enabledAlarms ( ) const

inlineoverridevirtual

List of alarms that must be enabled for this mode.

Implements VentilationController.

Definition at line 32 of file pc_cmv_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,  0u,  0u,        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_23};
        return a;
    }

endCycle()

void PC_CMV_Controller::endCycle ( )

overridevirtual

End the current breathing cycle.

Implements VentilationController.

Definition at line 119 of file pc_cmv_controller.cpp.

{ calculateBlowerIncrement(); }

exhale()

void PC_CMV_Controller::exhale ( )

overridevirtual

Control the exhalation.

Implements VentilationController.

Definition at line 110 of file pc_cmv_controller.cpp.

                               {
    // Close the inspiratory valve
    inspiratoryValve.close();
 
    // Open the expiratos valve so the patient can exhale outside
    expiratoryValve.open(PCexpiratoryPID(mainController.pressureCommand(),
                                         mainController.pressure(), mainController.dt()));
}

inhale()

void PC_CMV_Controller::inhale ( )

overridevirtual

Control the inhalation.

Implements VentilationController.

Definition at line 94 of file pc_cmv_controller.cpp.

                               {
    // Keep the inspiratory valve open using a PID
    int32_t inspiratoryPidValue = PCinspiratoryPID(mainController.pressureCommand(),
                                                   mainController.pressure(), mainController.dt());
 
    inspiratoryValve.open(inspiratoryPidValue);
    expiratoryValve.close();
 
    // m_plateauStartTime is used for blower regulations, -5 is added to help blower convergence
    if ((mainController.pressure() > (mainController.plateauPressureCommand() - 5))
        && !m_plateauPressureReached) {
        m_plateauStartTime = mainController.tick();
        m_plateauPressureReached = true;
    }
}

initCycle()

void PC_CMV_Controller::initCycle ( )

overridevirtual

Begin a new breathing cycle.

Implements VentilationController.

Definition at line 54 of file pc_cmv_controller.cpp.

                                  {
    m_plateauPressureReached = false;
    m_plateauStartTime = mainController.ticksPerInhalation();
 
    m_inspiratoryValveLastAperture = inspiratoryValve.maxAperture();
    m_expiratoryValveLastAperture = expiratoryValve.maxAperture();
    m_inspiratoryValveLastAperture = inspiratoryValve.maxAperture();
    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)) < m_blowerSpeed) {
            blower.runSpeedWithRampUp(m_blowerSpeed
                                      - static_cast<uint16_t>(abs(m_blowerIncrement)));
        } else {
            blower.runSpeedWithRampUp(MIN_BLOWER_SPEED);
        }
    }
    m_blowerSpeed = blower.getTargetSpeed();
    m_blowerIncrement = 0;
}

PCexpiratoryPID()

int32_t PC_CMV_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 262 of file pc_cmv_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) {
        // 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_expiratoryValveLastAperture >= abs(increment)) {
            expiratoryValveAperture =
                max(minAperture, min(maxAperture, m_expiratoryValveLastAperture - increment));
        } else {
            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_CMV_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 163 of file pc_cmv_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)
    if (error < 0) {
        coefficientI = 200;
        coefficientP = 2500;
        coefficientD = 0;
    } else {
        coefficientI = 50;
        coefficientP = 2500;
        coefficientD = 0;
    }
 
    // Calculate the 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, 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 the integral part
    if ((inspiratoryValveAperture != minAperture) && (inspiratoryValveAperture != maxAperture)) {
        m_inspiratoryPidIntegral = temporarym_inspiratoryPidIntegral;
    }
 
    m_inspiratoryValveLastAperture = inspiratoryValveAperture;
    m_inspiratoryPidLastError = smoothError;
 
    return inspiratoryValveAperture;
}

setup()

void PC_CMV_Controller::setup ( )

overridevirtual

Initialize controller.

Implements VentilationController.

Definition at line 52 of file pc_cmv_controller.cpp.

{ m_blowerSpeed = DEFAULT_BLOWER_SPEED; }

Member Data Documentation

m_blowerIncrement

int32_t PC_CMV_Controller::m_blowerIncrement

private

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

Definition at line 76 of file pc_cmv_controller.h.

m_blowerSpeed

uint16_t PC_CMV_Controller::m_blowerSpeed

private

Current blower speed.

Definition at line 73 of file pc_cmv_controller.h.

m_expiratoryPidFastMode

bool PC_CMV_Controller::m_expiratoryPidFastMode

private

Fast mode at start of expiration.

Definition at line 82 of file pc_cmv_controller.h.

m_expiratoryPidIntegral

int32_t PC_CMV_Controller::m_expiratoryPidIntegral

private

Integral gain of the patient PID.

Definition at line 88 of file pc_cmv_controller.h.

m_expiratoryPidLastError

int32_t PC_CMV_Controller::m_expiratoryPidLastError

private

Error of the last computation of the expiratory PID.

Definition at line 97 of file pc_cmv_controller.h.

m_expiratoryPidLastErrors

int32_t PC_CMV_Controller::m_expiratoryPidLastErrors[PC_NUMBER_OF_SAMPLE_DERIVATIVE_MOVING_MEAN]

private

Last errors in expiratory PID.

Definition at line 99 of file pc_cmv_controller.h.

m_expiratoryPidLastErrorsIndex

int32_t PC_CMV_Controller::m_expiratoryPidLastErrorsIndex

private

Last error index in inspiratory PID.

Definition at line 101 of file pc_cmv_controller.h.

m_expiratoryValveLastAperture

int32_t PC_CMV_Controller::m_expiratoryValveLastAperture

private

Last aperture of the blower valve.

Definition at line 94 of file pc_cmv_controller.h.

m_inspiratoryPidFastMode

bool PC_CMV_Controller::m_inspiratoryPidFastMode

private

Fast mode at start of inspiration.

Definition at line 85 of file pc_cmv_controller.h.

m_inspiratoryPidIntegral

int32_t PC_CMV_Controller::m_inspiratoryPidIntegral

private

Error of the last computation of the blower PID.

Definition at line 79 of file pc_cmv_controller.h.

m_inspiratoryPidLastError

int32_t PC_CMV_Controller::m_inspiratoryPidLastError

private

Error of the last computation of the expiratory PID.

Definition at line 104 of file pc_cmv_controller.h.

m_inspiratoryPidLastErrors

int32_t PC_CMV_Controller::m_inspiratoryPidLastErrors[PC_NUMBER_OF_SAMPLE_DERIVATIVE_MOVING_MEAN]

private

Last errors in inspiratory PID.

Definition at line 106 of file pc_cmv_controller.h.

m_inspiratoryPidLastErrorsIndex

int32_t PC_CMV_Controller::m_inspiratoryPidLastErrorsIndex

private

Last error index in inspiratory PID.

Definition at line 108 of file pc_cmv_controller.h.

m_inspiratoryValveLastAperture

int32_t PC_CMV_Controller::m_inspiratoryValveLastAperture

private

Last aperture of the blower valve.

Definition at line 91 of file pc_cmv_controller.h.

m_plateauPressureReached

bool PC_CMV_Controller::m_plateauPressureReached

private

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

Definition at line 52 of file pc_cmv_controller.h.

m_plateauStartTime

uint16_t PC_CMV_Controller::m_plateauStartTime

private

Number of ticks when plateau is reached for the first time.

Definition at line 49 of file pc_cmv_controller.h.

---

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

• includes/pc_cmv_controller.h
• srcs/pc_cmv_controller.cpp