VC_CMV_Controller Class Reference

Controller for the Volume Controled mode. More...

#include <vc_cmv_controller.h>

Inheritance diagram for VC_CMV_Controller:

Public Member Functions
	VC_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	calculateBlower ()
	Determine the blower speed to adopt for next 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
bool	m_duringPlateau = true
uint16_t	m_blowerSpeed
	Current blower speed. More...
int32_t	m_targetFlowMultiplyBy1000
bool	m_expiratoryPidFastMode
	Fast mode at start of expiration. More...
int32_t	m_expiratoryPidIntegral
	Integral gain of the expiratory PID. More...
int32_t	m_inspiratoryPidIntegral
	Integral gain of the inspiratory PID. More...
int32_t	m_inspiratoryValveLastAperture
	Last aperture of the inspiratory 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_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_inspiratoryFlowLastValues [NUMBER_OF_SAMPLE_LAST_VALUES]
	Last flow values. More...
int32_t	m_inspiratoryFlowLastValuesIndex
	Last flow index. More...
int32_t	m_maxInspiratoryFlow
	Max flow during inspiration. More...
int32_t	m_blowerTicks
	Blower ticks. More...

Detailed Description

Controller for the Volume Controled mode.

Definition at line 14 of file vc_cmv_controller.h.

Constructor & Destructor Documentation

VC_CMV_Controller()

VC_CMV_Controller::VC_CMV_Controller

(

)

Default constructor.

Definition at line 28 of file vc_cmv_controller.cpp.

                                     {
    m_inspiratoryValveLastAperture = inspiratoryValve.maxAperture();
    m_expiratoryValveLastAperture = expiratoryValve.maxAperture();
 
    m_inspiratoryFlowLastValuesIndex = 0;
    m_expiratoryPidLastErrorsIndex = 0;
    for (uint8_t i = 0u; i < NUMBER_OF_SAMPLE_LAST_VALUES; i++) {
        m_inspiratoryFlowLastValues[i] = 0u;
    }
    for (uint8_t i = 0u; i < PC_NUMBER_OF_SAMPLE_DERIVATIVE_MOVING_MEAN; i++) {
        m_expiratoryPidLastErrors[i] = 0u;
    }
 
    m_blowerSpeed = DEFAULT_BLOWER_SPEED;
    m_blowerTicks = 0;
    m_expiratoryPidFastMode = true;
    m_expiratoryPidIntegral = 0;
    m_inspiratoryPidIntegral = 0;
    m_expiratoryPidLastError = 0;
    m_maxInspiratoryFlow = 0;
    m_targetFlowMultiplyBy1000 = 0;
}

Member Function Documentation

calculateBlower()

void VC_CMV_Controller::calculateBlower ( )

private

Determine the blower speed to adopt for next cycle.

Definition at line 164 of file vc_cmv_controller.cpp.

                                        {
    // Compute target flow for inspiration
    int32_t inspirationDurationMs =
        ((mainController.ticksPerInhalation() * MAIN_CONTROLLER_COMPUTE_PERIOD_MS)
         - static_cast<uint16_t>(mainController.plateauDurationCommand()));  // in ms
    m_targetFlowMultiplyBy1000 = (inspirationDurationMs == 0)
                                     ? 0
                                     : (60 * 1000 * mainController.tidalVolumeCommand())
                                           / inspirationDurationMs;  // in mL/min
 
    // Blower always run at full speed
    m_blowerSpeed = 1800;
}

enabledAlarms()

struct Alarms VC_CMV_Controller::enabledAlarms ( ) const

inlineoverridevirtual

List of alarms that must be enabled for this mode.

Implements VentilationController.

Definition at line 32 of file vc_cmv_controller.h.

                                                 {
        struct Alarms a = {0u, RCM_SW_2,  RCM_SW_3,  0u,        0u,        0u,
                           0u, 0u,        0u,        RCM_SW_10, RCM_SW_11, RCM_SW_12,
                           0u, RCM_SW_15, RCM_SW_16, RCM_SW_18, RCM_SW_19, 0u,
                           0u, RCM_SW_22, RCM_SW_23};
        return a;
    }

endCycle()

void VC_CMV_Controller::endCycle ( )

overridevirtual

End the current breathing cycle.

Implements VentilationController.

Definition at line 162 of file vc_cmv_controller.cpp.

{}

exhale()

void VC_CMV_Controller::exhale ( )

overridevirtual

Control the exhalation.

Implements VentilationController.

Definition at line 151 of file vc_cmv_controller.cpp.

                               {
    // Open the expiration valve using PID so the patient can exhale outside
    int32_t expiratoryValveOpenningValue = PCexpiratoryPID(
        mainController.pressureCommand(), mainController.pressure(), mainController.dt());
 
    (void)expiratoryValve.openLinear(expiratoryValveOpenningValue);
 
    inspiratoryValve.close();
    // m_inspiratoryValveLastAperture = inspiratoryValveOpenningValue;
}

inhale()

void VC_CMV_Controller::inhale ( )

overridevirtual

Control the inhalation.

Implements VentilationController.

Definition at line 81 of file vc_cmv_controller.cpp.

                               {
    m_inspiratoryValveLastAperture = inspiratoryValve.maxAperture();
 
    expiratoryValve.close();
 
    int32_t inspirationRemainingDurationMs =
        static_cast<int32_t>((mainController.ticksPerInhalation() - mainController.tick())
                             * MAIN_CONTROLLER_COMPUTE_PERIOD_MS)
        - mainController.plateauDurationCommand();  // in ms
 
    if (inspirationRemainingDurationMs > 20) {
        // m_targetFlowMultiplyBy1000 =
        //     (60 * 1000
        //      * (mainController.tidalVolumeCommand() - mainController.currentDeliveredVolume()))
        //     / inspirationRemainingDurationMs;  // in mL/min
        // m_targetFlowMultiplyBy1000 = max(int32_t(0), m_targetFlowMultiplyBy1000);
        m_targetFlowMultiplyBy1000 = mainController.targetInspiratoryFlowCommand();
    }
 
    // The safety volume is the volume that will be delivered during the closing of the valve.
    // Taking is into account allows better accuracy on volume delivery
    int32_t safetyVolume = mainController.inspiratoryFlow() * VALVE_RESPONSE_TIME_MS / 60000;
    if (!m_duringPlateau
        && mainController.currentDeliveredVolume()
               > mainController.tidalVolumeCommand() - safetyVolume) {
        mainController.ticksPerInhalationSet(
            mainController.tick()
            + static_cast<uint16_t>(mainController.plateauDurationCommand())
                  / MAIN_CONTROLLER_COMPUTE_PERIOD_MS);
        m_duringPlateau = true;
    }
    // If before plateau
    if (mainController.tick() < mainController.ticksPerInhalation()
                                    - static_cast<uint16_t>(mainController.plateauDurationCommand())
                                          / MAIN_CONTROLLER_COMPUTE_PERIOD_MS) {
        int32_t flow = mainController.inspiratoryFlow();
        int32_t blowerPressure = blower.getBlowerPressure(flow);
        int32_t patientPressure = mainController.pressure();
 
        // Use Venturi equation to find the sectionToOpen in order to get the target flow.
        // https://en.wikipedia.org/wiki/Venturi_effect
        int32_t A1MultiplyBy100 = 3318;
        int32_t rhoMultiplyBy100 = 120;
        int32_t twoA1SquareDotDeltaPressureMultiplyBy100 =
            100 * 2 * (A1MultiplyBy100 * A1MultiplyBy100 / 10000)
            * (98 * (blowerPressure - patientPressure) / 10);
        int32_t divider = (rhoMultiplyBy100 * (m_targetFlowMultiplyBy1000 / 60)
                           * (m_targetFlowMultiplyBy1000 / 60) / 100);
        int32_t tempRatio =
            (divider == 0) ? 0 : (twoA1SquareDotDeltaPressureMultiplyBy100 / divider);
        int32_t sectionToOpen;
        if (m_targetFlowMultiplyBy1000 == 0) {
            sectionToOpen = 0;
        } else {
            int32_t divider2 = ((tempRatio + 100) < 0) ? 0 : sqrt(tempRatio + 100);
            sectionToOpen = (divider2 == 0) ? 0 : (A1MultiplyBy100 * 10 / divider2);
        }
 
        // Open the valve to a specific section (in mm^2 multiplied by 100)
        inspiratoryValve.openSection(sectionToOpen);
    } else {  // else : during plateau, valves are closed
        inspiratoryValve.close();
    }
 
    // Compute max inspiratory flow
    if (mainController.inspiratoryFlow() > m_maxInspiratoryFlow) {
        m_maxInspiratoryFlow = mainController.inspiratoryFlow();
    }
}

initCycle()

void VC_CMV_Controller::initCycle ( )

overridevirtual

Begin a new breathing cycle.

Implements VentilationController.

Definition at line 55 of file vc_cmv_controller.cpp.

                                  {
    m_maxInspiratoryFlow = 0;
    m_expiratoryValveLastAperture = expiratoryValve.maxAperture();
    // Reset PID values
    m_expiratoryPidIntegral = 0;
    m_inspiratoryPidIntegral = 0;
    m_expiratoryPidLastError =
        mainController.peepCommand() - mainController.plateauPressureCommand();
    m_expiratoryPidFastMode = true;
    for (uint8_t i = 0; i < PC_NUMBER_OF_SAMPLE_DERIVATIVE_MOVING_MEAN; i++) {
        m_expiratoryPidLastErrors[i] =
            mainController.peepCommand() - mainController.plateauPressureCommand();
    }
 
    for (uint8_t i = 0u; i < NUMBER_OF_SAMPLE_LAST_VALUES; i++) {
        m_inspiratoryFlowLastValues[i] = 0u;
    }
    m_inspiratoryFlowLastValuesIndex = 0;
 
    calculateBlower();
    blower.runSpeedWithRampUp(m_blowerSpeed);
    m_blowerSpeed = blower.getTargetSpeed();
    mainController.ticksPerInhalationSet(mainController.ticksPerInhalation() + 50u);
    m_duringPlateau = false;
}

PCexpiratoryPID()

int32_t VC_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 179 of file vc_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 temporaryExpiratoryPidIntegral = 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
        temporaryExpiratoryPidIntegral =
            m_expiratoryPidIntegral + ((coefficientI * error * dt) / 1000000);
        temporaryExpiratoryPidIntegral =
            max(PID_PATIENT_INTEGRAL_MIN,
                min(PID_PATIENT_INTEGRAL_MAX, temporaryExpiratoryPidIntegral));
 
        proportionnalWeight = ((coefficientP * error) / 1000);
        int32_t integralWeight = temporaryExpiratoryPidIntegral;
        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 = temporaryExpiratoryPidIntegral;
    }
 
    m_expiratoryPidLastError = smoothError;
    m_expiratoryValveLastAperture = expiratoryValveAperture;
 
    return expiratoryValveAperture;
}

setup()

void VC_CMV_Controller::setup ( )

overridevirtual

Initialize controller.

Implements VentilationController.

Definition at line 51 of file vc_cmv_controller.cpp.

                              {
    // No specific setup code
}

Member Data Documentation

m_blowerSpeed

uint16_t VC_CMV_Controller::m_blowerSpeed

private

Current blower speed.

Definition at line 59 of file vc_cmv_controller.h.

m_blowerTicks

int32_t VC_CMV_Controller::m_blowerTicks

private

Blower ticks.

Definition at line 97 of file vc_cmv_controller.h.

m_duringPlateau

bool VC_CMV_Controller::m_duringPlateau = true

private

Definition at line 56 of file vc_cmv_controller.h.

m_expiratoryPidFastMode

bool VC_CMV_Controller::m_expiratoryPidFastMode

private

Fast mode at start of expiration.

Definition at line 64 of file vc_cmv_controller.h.

m_expiratoryPidIntegral

int32_t VC_CMV_Controller::m_expiratoryPidIntegral

private

Integral gain of the expiratory PID.

Definition at line 67 of file vc_cmv_controller.h.

m_expiratoryPidLastError

int32_t VC_CMV_Controller::m_expiratoryPidLastError

private

Error of the last computation of the PID.

Definition at line 79 of file vc_cmv_controller.h.

m_expiratoryPidLastErrors

int32_t VC_CMV_Controller::m_expiratoryPidLastErrors[PC_NUMBER_OF_SAMPLE_DERIVATIVE_MOVING_MEAN]

private

Last errors in expiratory PID.

Definition at line 82 of file vc_cmv_controller.h.

m_expiratoryPidLastErrorsIndex

int32_t VC_CMV_Controller::m_expiratoryPidLastErrorsIndex

private

Last error index in expiratory PID.

Definition at line 85 of file vc_cmv_controller.h.

m_expiratoryValveLastAperture

int32_t VC_CMV_Controller::m_expiratoryValveLastAperture

private

Last aperture of the blower valve.

Definition at line 76 of file vc_cmv_controller.h.

m_inspiratoryFlowLastValues

int32_t VC_CMV_Controller::m_inspiratoryFlowLastValues[NUMBER_OF_SAMPLE_LAST_VALUES]

private

Last flow values.

Definition at line 88 of file vc_cmv_controller.h.

m_inspiratoryFlowLastValuesIndex

int32_t VC_CMV_Controller::m_inspiratoryFlowLastValuesIndex

private

Last flow index.

Definition at line 91 of file vc_cmv_controller.h.

m_inspiratoryPidIntegral

int32_t VC_CMV_Controller::m_inspiratoryPidIntegral

private

Integral gain of the inspiratory PID.

Definition at line 70 of file vc_cmv_controller.h.

m_inspiratoryValveLastAperture

int32_t VC_CMV_Controller::m_inspiratoryValveLastAperture

private

Last aperture of the inspiratory valve.

Definition at line 73 of file vc_cmv_controller.h.

m_maxInspiratoryFlow

int32_t VC_CMV_Controller::m_maxInspiratoryFlow

private

Max flow during inspiration.

Definition at line 94 of file vc_cmv_controller.h.

m_targetFlowMultiplyBy1000

int32_t VC_CMV_Controller::m_targetFlowMultiplyBy1000

private

Definition at line 61 of file vc_cmv_controller.h.

---

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

• includes/vc_cmv_controller.h
• srcs/vc_cmv_controller.cpp