main_controller.h

Go to the documentation of this file.

 
#pragma once
 
// INCLUDES ===================================================================
 
// Internal
 
#include "../includes/alarm_controller.h"
#include "../includes/battery.h"
#include "../includes/blower.h"
#include "../includes/config.h"
#include "../includes/cycle.h"
#include "../includes/debug.h"
#include "../includes/parameters.h"
#include "../includes/pc_ac_controller.h"
#include "../includes/pc_cmv_controller.h"
#include "../includes/pc_vsai_controller.h"
#include "../includes/pressure_valve.h"
#include "../includes/telemetry.h"
#include "../includes/vc_ac_controller.h"
#include "../includes/vc_cmv_controller.h"
 
#define MAX_PRESSURE_SAMPLES 10u
 
// CLASS ======================================================================
 
// cppcheck-suppress misra-c2012-5.2 ; false positive
class MainController {
 public:
    MainController();
 
    void setup();
 
    void initRespiratoryCycle();
 
    void endRespiratoryCycle(uint32_t p_currentMillis);
 
    void updateTick(uint32_t p_tick);
 
    void updatePressure(int16_t p_currentPressure);
 
    void updateInspiratoryFlow(int32_t p_currentInspiratoryFlow);
 
    void updateExpiratoryFlow(int32_t p_currentExpiratoryFlow);
 
    void updateFakeExpiratoryFlow();
 
    void compute();
 
    void onVentilationModeSet(uint16_t p_ventilationControllerMode);
 
    void onInspiratoryTriggerFlowSet(uint16_t p_inspiratoryTriggerFlow);
 
    void onExpiratoryTriggerFlowSet(uint16_t p_expiratoryTriggerFlow);
 
    void onTiMinSet(uint16_t p_tiMin);
 
    void onTiMaxSet(uint16_t p_tiMax);
 
    void onLowInspiratoryMinuteVolumeAlarmThresholdSet(
        uint16_t p_lowInspiratoryMinuteVolumeAlarmThreshold);
 
    void onHighInspiratoryMinuteVolumeAlarmThresholdSet(
        uint16_t p_highInspiratoryMinuteVolumeAlarmThreshold);
 
    void onLowExpiratoryMinuteVolumeAlarmThresholdSet(
        uint16_t p_lowExpiratoryMinuteVolumeAlarmThreshold);
 
    void onHighExpiratoryMinuteVolumeAlarmThresholdSet(
        uint16_t p_highExpiratoryMinuteVolumeAlarmThreshold);
 
    void onlowRespiratoryRateAlarmThresholdSet(uint16_t p_lowRespiratoryRateAlarmThreshold);
 
    void onhighRespiratoryRateAlarmThresholdSet(uint16_t p_highRespiratoryRateAlarmThreshold);
 
    void onTargetTidalVolumeSet(uint16_t p_targetTidalVolume);
 
    void onLowTidalVolumeAlarmThresholdSet(uint16_t p_lowTidalVolumeAlarmThreshold);
 
    void onHighTidalVolumeAlarmThresholdSet(uint16_t p_highTidalVolumeAlarmThreshold);
 
    void onPlateauDurationSet(uint16_t p_plateauDuration);
 
    void onLeakAlarmThresholdSet(uint16_t p_leakAlarmThreshold);
 
    void onTargetInspiratoryFlow(uint16_t p_targetInspiratoryFlow);
 
    void onInspiratoryDuration(uint16_t p_inspiratoryDuration);
 
    void onCycleDecrease();
 
    void onCycleIncrease();
 
    void onCycleSet(uint16_t p_cpm);
 
    void onPeepPressureDecrease();
 
    void onPeepPressureIncrease();
 
    void onPeepSet(int16_t p_peep);
 
    void onPlateauPressureDecrease();
 
    void onPlateauPressureIncrease();
 
    void onPlateauPressureSet(int16_t p_plateauPressure);
 
    void onPeakPressureDecrease();
 
    void onPeakPressureIncrease();
 
    void onExpiratoryTermSet(uint16_t p_expiratoryTerm);
 
    void onTriggerModeEnabledSet(uint16_t p_triggerEnabled);
 
    void onTriggerOffsetSet(uint16_t p_triggerOffset);
 
    void onPatientHeight(int16_t p_patientHeight);
 
    void onPeakPressureAlarmThreshold(int16_t p_peakPressureAlarmThreshold);
 
    void onPatientGender(int16_t p_patientGender);
 
    void onPatientComputePreset();
 
    // Get the patient Height in cm
    inline int32_t patientHeight() const { return m_patientHeight; }
    // Get the desired tidalVolue
    inline int16_t tidalVolumeCommand() const { return m_tidalVolumeCommand; }
    // Get the desired plateau duration (in VC modes)
    inline int16_t plateauDurationCommand() const { return m_plateauDurationCommand; }
    inline int16_t peakPressureCommand() const { return m_peakPressureCommand; }
    inline int16_t plateauPressureCommand() const { return m_plateauPressureCommand; }
    inline int16_t peepCommand() const { return m_peepNextCommand; }
    inline uint16_t cyclesPerMinuteCommand() const { return m_cyclesPerMinuteCommand; }
    inline const int16_t pressureTriggerOffsetCommand() const {
        return m_pressureTriggerOffsetCommand;
    }
    inline const bool triggerModeEnabledCommand() { return m_triggerModeEnabledCommand; }
    inline const int16_t inspiratoryTriggerFlowCommand() const {
        return m_inspiratoryTriggerFlowCommand;
    }
    inline const int16_t expiratoryTriggerFlowCommand() const {
        return m_expiratoryTriggerFlowCommand;
    }
    inline const int16_t tiMinCommand() const { return m_tiMinCommand; }
    inline const int16_t tiMaxCommand() const { return m_tiMaxCommand; }
    inline const int32_t targetInspiratoryFlowCommand() const {
        return m_targetInspiratoryFlowCommand;
    }
    inline const int16_t inspiratoryDurationCommand() const { return m_inspiratoryDurationCommand; }
 
    inline int16_t tidalVolumeNextCommand() const { return m_tidalVolumeNextCommand; }
    // Get the desired plateau duration for the next cycle (used in VC modes)
    inline int16_t plateauDurationNextCommand() const { return m_plateauDurationNextCommand; }
    inline int16_t peakPressureNextCommand() const { return m_peakPressureNextCommand; }
    inline int16_t plateauPressureNextCommand() const { return m_plateauPressureNextCommand; }
    inline int16_t peepNextCommand() const { return m_peepNextCommand; }
    inline uint16_t cyclesPerMinuteNextCommand() const { return m_cyclesPerMinuteNextCommand; }
    inline const int16_t pressureTriggerOffsetNextCommand() const {
        return m_pressureTriggerOffsetNextCommand;
    }
    inline const bool triggerModeEnabledNextCommand() { return m_triggerModeEnabledNextCommand; }
    inline const int16_t inspiratoryTriggerFlowNextCommand() const {
        return m_inspiratoryTriggerFlowNextCommand;
    }
    inline const int16_t expiratoryTriggerFlowNextCommand() const {
        return m_expiratoryTriggerFlowNextCommand;
    }
    inline const int16_t tiMinNextCommand() const { return m_tiMinNextCommand; }
    inline const int16_t tiMaxNextCommand() const { return m_tiMaxNextCommand; }
    inline const int32_t targetInspiratoryFlowNextCommand() const {
        return m_targetInspiratoryFlowNextCommand;
    }
    inline const int16_t inspiratoryDurationNextCommand() const {
        return m_inspiratoryDurationNextCommand;
    }
    inline const VentilationController* ventilationControllerNextCommand() const {
        return m_ventilationControllerNextCommand;
    }
 
    inline int16_t peakPressureMeasure() const { return m_peakPressureMeasure; }
    inline int16_t rebouncePeakPressureMeasure() const { return m_rebouncePeakPressureMeasure; }
    inline int16_t plateauPressureMeasure() const { return m_plateauPressureMeasure; }
    inline int16_t peepMeasure() const { return m_peepMeasure; }
    inline uint16_t cyclesPerMinuteMeasure() const { return m_cyclesPerMinuteMeasure; }
    inline uint16_t tidalVolumeMeasure() const { return m_tidalVolumeMeasure; }
    inline int32_t currentDeliveredVolume() const { return m_currentDeliveredVolume; }
 
    inline uint32_t cycleNumber() const { return m_cycleNb; }
 
    inline uint16_t ticksPerCycle() const { return m_ticksPerCycle; }
 
    inline uint32_t ticksPerInhalation() const { return m_ticksPerInhalation; }
 
    inline void ticksPerInhalationSet(uint32_t p_ticksPerInhalation) {
        m_ticksPerInhalation = p_ticksPerInhalation;
    }
 
    inline int16_t pressure() const { return m_pressure; }
 
    inline int32_t inspiratoryFlow() const { return m_inspiratoryFlow; }
 
    inline int32_t expiratoryFlow() const { return m_expiratoryFlow; }
 
    inline int32_t dt() const { return m_dt; }
 
    inline uint32_t tick() const { return m_tick; }
 
    inline int32_t pressureCommand() const { return m_pressureCommand; }
 
    inline CyclePhases phase() const { return m_phase; }
 
    inline const bool triggered() const { return m_triggered; }
 
    inline const void setTrigger(bool triggerValue) { m_triggered = triggerValue; }
 
    inline const bool isPeepDetected() { return m_isPeepDetected; }
 
    inline int16_t* lastPressureValues() { return m_lastPressureValues; }
 
    inline uint16_t lastPressureValuesIndex() { return m_lastPressureValuesIndex; }
 
    void updateDt(int32_t p_dt);
 
    void updateCurrentDeliveredVolume(int32_t p_currentDeliveredVolume);
 
    // current expiratory Volume
    void updateCurrentExpiratoryVolume(int32_t p_expiratoryVolume);
 
    void reachSafetyPosition();
 
    void stop(uint32_t p_currentMillis);
 
    void sendStopMessageToUi();
 
    void sendMachineState();
 
 private:
    void updatePhase();
 
    void inhale();
 
    void exhale();
 
    void computeTickParameters();
 
    void executeCommands();
 
    void checkCycleAlarm();
 
    void calculateBlowerIncrement();
 
    void printDebugValues();
 
 private:
    uint32_t m_tick;
 
    uint16_t m_cyclesPerMinuteCommand;
    uint16_t m_cyclesPerMinuteNextCommand;
    uint32_t m_cyclesPerMinuteMeasure;
    uint32_t m_lastBreathPeriodsMs[NUMBER_OF_BREATH_PERIOD];
    uint32_t m_lastBreathPeriodsMsIndex;
    uint32_t m_lastEndOfRespirationDateMs;
 
    int16_t m_peakPressureCommand;
    int16_t m_peakPressureMeasure;
    int16_t m_rebouncePeakPressureMeasure;
    int16_t m_peakPressureNextCommand;
 
    int16_t m_plateauPressureCommand;
    int16_t m_plateauPressureNextCommand;
    int16_t m_plateauPressureMeasure;
    int16_t m_plateauPressureToDisplay;
    int64_t m_PlateauMeasureSum;
    uint16_t m_PlateauMeasureCount;
    uint32_t m_plateauDurationMs;
 
    int16_t m_peepCommand;
    int16_t m_peepNextCommand;
    int16_t m_peepMeasure;
    bool m_isPeepDetected;
 
    int16_t m_pressureTriggerOffsetCommand;
    int16_t m_pressureTriggerOffsetNextCommand;
    bool m_triggered;
 
    bool m_triggerModeEnabledCommand;
    bool m_triggerModeEnabledNextCommand;
 
    bool m_tidalVolumeAlreadyRead;
 
    uint16_t m_expiratoryTermCommand;
    uint16_t m_expiratoryTermNextCommand;
 
    int16_t m_inspiratoryTriggerFlowCommand;
    int16_t m_inspiratoryTriggerFlowNextCommand;
 
    int16_t m_expiratoryTriggerFlowCommand;
    int16_t m_expiratoryTriggerFlowNextCommand;
 
    int16_t m_tiMinCommand;
    int16_t m_tiMaxCommand;
    int16_t m_tiMinNextCommand;
    int16_t m_tiMaxNextCommand;
 
    VentilationController* m_ventilationController;
    VentilationController* m_ventilationControllerNextCommand;
 
    VentilationController* m_ventilationControllersTable[NUMBER_OF_VENTILATION_MODES + 1u];
 
    VentilationModes m_ventilationControllerMode;
 
    int16_t m_tidalVolumeMeasure;
 
    int16_t m_tidalVolumeCommand;
    int16_t m_tidalVolumeNextCommand;
 
    int16_t m_plateauDurationCommand;
    int16_t m_plateauDurationNextCommand;
 
    int32_t m_targetInspiratoryFlowCommand;
    int32_t m_targetInspiratoryFlowNextCommand;
    int16_t m_inspiratoryDurationCommand;
    int16_t m_inspiratoryDurationNextCommand;
 
    int32_t m_lowInspiratoryMinuteVolumeAlarmThresholdCommand;
    // cppcheck-suppress misra-c2012-5.2
    int32_t m_lowInspiratoryMinuteVolumeAlarmThresholdNextCommand;
 
    int32_t m_highInspiratoryMinuteVolumeAlarmThresholdCommand;
    // cppcheck-suppress misra-c2012-5.2
    int32_t m_highInspiratoryMinuteVolumeAlarmThresholdNextCommand;
 
    int32_t m_lowExpiratoryMinuteVolumeAlarmThresholdCommand;
    // cppcheck-suppress misra-c2012-5.2
    int32_t m_lowExpiratoryMinuteVolumeAlarmThresholdNextCommand;
 
    int32_t m_highExpiratoryMinuteVolumeAlarmThresholdCommand;
    // cppcheck-suppress misra-c2012-5.2
    int32_t m_highExpiratoryMinuteVolumeAlarmThresholdNextCommand;
 
    int32_t m_lowRespiratoryRateAlarmThresholdCommand;
    // cppcheck-suppress misra-c2012-5.2
    int32_t m_lowRespiratoryRateAlarmThresholdNextCommand;
 
    int32_t m_highRespiratoryRateAlarmThresholdCommand;
    // cppcheck-suppress misra-c2012-5.2
    int32_t m_highRespiratoryRateAlarmThresholdNextCommand;
 
    int32_t m_lowTidalVolumeAlarmThresholdCommand;
    int32_t m_lowTidalVolumeAlarmThresholdNextCommand;
 
    int32_t m_highTidalVolumeAlarmThresholdCommand;
    // cppcheck-suppress misra-c2012-5.2
    int32_t m_highTidalVolumeAlarmThresholdNextCommand;
 
    int32_t m_leakAlarmThresholdCommand;
    int32_t m_leakAlarmThresholdNextCommand;
 
    int16_t m_peakPressureAlarmThresholdCommand;
    int16_t m_peakPressureAlarmThresholdNextCommand;
 
    int32_t m_expiratoryVolume;
 
    uint16_t m_ticksPerCycle;
 
    uint32_t m_ticksPerInhalation;
 
    int16_t m_pressure;
 
    int32_t m_inspiratoryFlow;
 
    int32_t m_maxInspiratoryFlow;
 
    int32_t m_expiratoryFlow;
 
    int32_t m_maxExpiratoryFlow;
 
    int32_t m_lastMaxExpiratoryFlow;
 
    int32_t m_currentDeliveredVolume;
 
    int16_t m_inhalationLastPressure;
 
    uint32_t m_inspiratoryValveAngle;
 
    CyclePhases m_phase;
 
    uint32_t m_cycleNb;
 
    int32_t m_dt;
 
    int32_t m_pressureCommand;
 
    int16_t m_lastPressureValues[MAX_PRESSURE_SAMPLES];
 
    uint16_t m_lastPressureValuesIndex;
 
    uint32_t m_sumOfPressures;
 
    uint16_t m_numberOfPressures;
 
    // Height of the patient in cm
    int32_t m_patientHeight;
 
    // Gender of patient 0 = male, 1 = female
    int32_t m_patientGender;
};
 
extern MainController mainController;