main_state_machine.cpp File Reference

Auto test for end of line unit test. More...

#include "../includes/parameters.h"
#include "Arduino.h"
#include <IWatchdog.h>
#include "../includes/activation.h"
#include "../includes/battery.h"
#include "../includes/buzzer_control.h"
#include "../includes/debug.h"
#include "../includes/keyboard.h"
#include "../includes/main_controller.h"
#include "../includes/main_state_machine.h"
#include "../includes/mass_flow_meter.h"
#include "../includes/pressure.h"
#include "../includes/rpi_watchdog.h"
#include "../includes/screen.h"
#include "../includes/serial_control.h"
#include "../includes/telemetry.h"

Go to the source code of this file.

Enumerations
enum	Step {   SETUP , STOPPED , INIT_CYCLE , BREATH ,   TRIGGER_RAISED , END_CYCLE }

Functions
void	millisecondTimerMSM (HardwareTimer *)

Variables
MainStateMachine	mainStateMachine = MainStateMachine()
uint32_t	clockMsmTimer = 0
uint32_t	lastMillis = 0
uint32_t	lastMainControllerCall = 0
HardwareTimer *	msmTimer
uint32_t	lastMicro = 0
uint32_t	tick = 0
Step	msmstep = SETUP
Step	previousmsmstep = SETUP

Detailed Description

Auto test for end of line unit test.

Author

Makers For Life

Copyright

Copyright (c) 2020 Makers For Life

Definition in file main_state_machine.cpp.

Enumeration Type Documentation

Step

enum Step

Enumerator
SETUP
STOPPED
INIT_CYCLE
BREATH
TRIGGER_RAISED
END_CYCLE

Definition at line 42 of file main_state_machine.cpp.

{ SETUP, STOPPED, INIT_CYCLE, BREATH, TRIGGER_RAISED, END_CYCLE };

Function Documentation

millisecondTimerMSM()

void millisecondTimerMSM

(

HardwareTimer *

)

Definition at line 68 of file main_state_machine.cpp.

{
    IWatchdog.reload();
    clockMsmTimer++;
    int32_t pressure = inspiratoryPressureSensor.read();
    mainController.updatePressure(pressure);
 
    if ((clockMsmTimer % 10u) == 0u) {
        // Check if some buttons have been pushed
        keyboardLoop();
        // Check if battery state has changed
        batteryLoop(mainController.cycleNumber());
        // Check serial input
        serialControlLoop();
 
        if (isBatteryDeepDischarged()) {
            // Delay will trigger the watchdog and the machine will restart with a message
            // on screen
            delay(10000);
        }
        alarmController.runAlarmEffects(tick);
    }
 
    // Because this kind of LCD screen is not reliable, we need to reset it every 5 min or
    // so
    if ((clockMsmTimer % 300000u) == 0u) {
        DBG_DO(Serial.println("resetting LCD screen");)
        resetScreen();
        clearAlarmDisplayCache();
    }
 
    // Refresh screen every 300 ms, no more
    if ((clockMsmTimer % 300u) == 0u) {
        mainStateMachine.ScreenUpdate();
    }
 
    // Check that the UI software on the Raspberry PI has sent a heartbeat in the last 60s
    // Otherwise restart the power
    if ((clockMsmTimer % 1000u) == 0u) {
        rpiWatchdog.update();
    }
 
    if (msmstep == SETUP) {
        mainController.setup();
        mainStateMachine.ScreenUpdate();
        displayMachineStopped();
        msmstep = STOPPED;
    } else if (msmstep == STOPPED) {
        // Executed just after booting, until the first start
        if ((clockMsmTimer % 100u) == 0u) {
            mainController.stop(millis());
            displayMachineStopped();
        }
 
        if ((clockMsmTimer % 10u) == 0u) {
            tick++;  // Also increase ticks during stop, for alarm controller
        }
 
        activationController.refreshState();
        if (activationController.isRunning()) {
            msmstep = INIT_CYCLE;
            // set patient height to default value
            if (mainController.patientHeight() == 0) {
                mainController.onPatientHeight(DEFAULT_PATIENT_HEIGHT);
            }
        }
 
    } else if (msmstep == INIT_CYCLE) {
        mainController.initRespiratoryCycle();
        lastMillis = millis();
        lastMainControllerCall = millis();
        tick = 0;
        msmstep = BREATH;
#ifdef MASS_FLOW_METER_ENABLED
        (void)MFM_read_milliliters(true);  // Reset volume integral
#endif
#ifdef MASS_FLOW_METER_ENABLED&& MASS_FLOW_METER_SENSOR_EXPI
        (void)MFM_expi_read_milliliters(true);  // Reset volume integral
#endif
 
    } else if (msmstep == BREATH) {
        // If breathing
        uint32_t currentMillis = millis();
        tick = (currentMillis - lastMillis) / MAIN_CONTROLLER_COMPUTE_PERIOD_MS;
 
        if ((currentMillis - lastMainControllerCall) > MAIN_CONTROLLER_COMPUTE_PERIOD_MS) {
            if (tick >= mainController.ticksPerCycle()) {
                msmstep = END_CYCLE;
            } else {
                uint32_t currentMicro = micros();
                int32_t inspiratoryflow = 0;
                int32_t expiratoryflow = 0;
#ifdef MASS_FLOW_METER_ENABLED
                inspiratoryflow = MFM_read_airflow();
                mainController.updateCurrentDeliveredVolume(MFM_read_milliliters(false));
#endif
                mainController.updateInspiratoryFlow(inspiratoryflow);
 
#ifdef MASS_FLOW_METER_ENABLED&& MASS_FLOW_METER_SENSOR_EXPI
                expiratoryflow = MFM_expi_read_airflow();
                mainController.updateExpiratoryFlow(expiratoryflow);
                mainController.updateCurrentExpiratoryVolume(MFM_expi_read_milliliters(false));
#else
                mainController.updateFakeExpiratoryFlow();
#endif
                mainController.updateDt(currentMicro - lastMicro);
                lastMicro = currentMicro;
                mainController.updateTick(tick);
                mainController.compute();
                lastMainControllerCall = currentMillis;
                tick++;
            }
        }
 
        if (mainController.triggered()) {
            msmstep = TRIGGER_RAISED;
        }
 
        // Check if machine has been paused
        activationController.refreshState();
        if (!activationController.isRunning()) {
            msmstep = SETUP;
        }
    } else if (msmstep == TRIGGER_RAISED) {
        if (activationController.isRunning()) {
            msmstep = END_CYCLE;
        } else {
            msmstep = SETUP;
        }
    } else if (msmstep == END_CYCLE) {
        mainController.endRespiratoryCycle(millis());
        displayCurrentInformation(mainController.peakPressureMeasure(),
                                  mainController.plateauPressureMeasure(),
                                  mainController.peepMeasure());
        if (activationController.isRunning()) {
            msmstep = INIT_CYCLE;
        } else {
            msmstep = SETUP;
        }
    } else {
        // Do nothing
    }
 
    previousmsmstep = msmstep;
}

Variable Documentation

clockMsmTimer

uint32_t clockMsmTimer = 0

Definition at line 34 of file main_state_machine.cpp.

lastMainControllerCall

uint32_t lastMainControllerCall = 0

Definition at line 36 of file main_state_machine.cpp.

lastMicro

uint32_t lastMicro = 0

Definition at line 38 of file main_state_machine.cpp.

lastMillis

uint32_t lastMillis = 0

Definition at line 35 of file main_state_machine.cpp.

mainStateMachine

MainStateMachine mainStateMachine = MainStateMachine()

Definition at line 32 of file main_state_machine.cpp.

msmstep

Step msmstep = SETUP

Definition at line 44 of file main_state_machine.cpp.

msmTimer

HardwareTimer* msmTimer

Definition at line 37 of file main_state_machine.cpp.

previousmsmstep

Step previousmsmstep = SETUP

Definition at line 45 of file main_state_machine.cpp.

tick

uint32_t tick = 0

Definition at line 39 of file main_state_machine.cpp.