calibration.cpp File Reference

Calibration of the ventilator. More...

#include "../includes/config.h"
#include "../includes/blower.h"
#include "../includes/buzzer.h"
#include "../includes/calibration.h"
#include "../includes/keyboard.h"
#include "../includes/mass_flow_meter.h"
#include "../includes/pressure.h"
#include "../includes/pressure_valve.h"
#include "../includes/screen.h"
#include "../includes/telemetry.h"
#include "Arduino.h"

Go to the source code of this file.

Macros
#define	RESTART_READ_KEYBOARD_DELAY   100

Functions
void	Calibration_Init ()
	Initialization of calibration process. More...
void	Calibration_Wait_Measure_Pressure (uint16_t ms)
	Block execution for a given duration. More...
void	Calibration_Read_Keyboard_Delayed ()
	Read keyboard duing calibration process (delayed) More...
void	Calibration_Restart ()
	Restart calibration process. More...
bool	Calibration_Started ()
	Check if calibration mode is started. More...

Variables
int32_t	pressureOffsetSum
uint32_t	pressureOffsetCount
int32_t	minOffsetValue = 0
int32_t	maxOffsetValue = 0
uint32_t	restartWaitTimer = 0
bool	startButtonPressed = false
bool	calibationStarted = false
bool	calibrationValid = false

Detailed Description

Calibration of the ventilator.

Author

Makers For Life

Copyright

Copyright (c) 2020 Makers For Life

Definition in file calibration.cpp.

Macro Definition Documentation

RESTART_READ_KEYBOARD_DELAY

#define RESTART_READ_KEYBOARD_DELAY   100

Definition at line 38 of file calibration.cpp.

Function Documentation

Calibration_Init()

void Calibration_Init

(

void

)

Initialization of calibration process.

Definition at line 40 of file calibration.cpp.

                        {
    // Restart calibration process when invalid
    while (calibrationValid == false) {
        delay(1000);
        resetScreen();
        calibationStarted = true;
        // RCM-SW-17 (Christmas tree at startup)
        Buzzer_Boot_Start();
        digitalWrite(PIN_LED_START, LED_START_ACTIVE);
        digitalWrite(PIN_LED_GREEN, LED_GREEN_ACTIVE);
        digitalWrite(PIN_LED_RED, LED_RED_ACTIVE);
        digitalWrite(PIN_LED_YELLOW, LED_YELLOW_ACTIVE);
        Calibration_Wait_Measure_Pressure(1000);
        digitalWrite(PIN_LED_START, LED_START_INACTIVE);
        digitalWrite(PIN_LED_GREEN, LED_GREEN_INACTIVE);
        digitalWrite(PIN_LED_RED, LED_RED_INACTIVE);
        digitalWrite(PIN_LED_YELLOW, LED_YELLOW_INACTIVE);
        Calibration_Wait_Measure_Pressure(1000);
 
        displayPatientMustBeUnplugged();
        Calibration_Wait_Measure_Pressure(2000);
 
        int32_t inspiratoryPressureSensorOffset = 0;
        resetScreen();
        if (pressureOffsetCount != 0u) {
            inspiratoryPressureSensorOffset =
                pressureOffsetSum / static_cast<int32_t>(pressureOffsetCount);
        } else {
            inspiratoryPressureSensorOffset = 0;
        }
 
        // Happens when patient is plugged at startup
        if (((maxOffsetValue - minOffsetValue) >= 10)
            || (inspiratoryPressureSensorOffset >= MAX_PRESSURE_OFFSET)) {
            // Invalid calibration
            calibrationValid = false;
            displayPressureOffsetUnstable(minOffsetValue, maxOffsetValue);
            Buzzer_High_Prio_Start();
 
            // Wait for user to press start to restart calibration
            restartWaitTimer = 0;
 
            while (startButtonPressed == false) {
                restartWaitTimer += (uint32_t)RESTART_READ_KEYBOARD_DELAY;
 
                // Heartbeat fatal error periodically
                if ((restartWaitTimer % 1000u) == 0u) {
                    sendInconsistentPressureFatalError(maxOffsetValue - minOffsetValue);
                }
 
                Calibration_Read_Keyboard_Delayed();
            }
        } else {
            calibrationValid = true;
            inspiratoryPressureSensor.setPressureSensorOffset(inspiratoryPressureSensorOffset);
        }
 
        if (calibrationValid) {
#ifdef MASS_FLOW_METER_ENABLED
            int32_t flowMeterFlowAtStarting = MFM_read_airflow();
            (void)MFM_calibrateZero();
#else
            int32_t flowMeterFlowAtStarting = 0;
#endif
            inspiratoryValve.open();
            inspiratoryValve.execute();
            expiratoryValve.open();
            expiratoryValve.execute();
            delay(500);
            blower.runSpeed(DEFAULT_BLOWER_SPEED);
            delay(1000);
#ifdef MASS_FLOW_METER_ENABLED
            int32_t flowMeterFlowWithBlowerOn = MFM_read_airflow();
#else
            int32_t flowMeterFlowWithBlowerOn = 30000;
#endif
 
            blower.stop();
 
            // Happens when flow meter fails
            bool isMassFlowMeterOutOfRange = ((flowMeterFlowAtStarting < -1000)
                                              || (flowMeterFlowAtStarting > 1000));
 
            if ((isMassFlowMeterOutOfRange == true)
                || ((flowMeterFlowWithBlowerOn < 20000) || (flowMeterFlowWithBlowerOn > 100000))) {
                // Invalid calibration
                calibrationValid = false;
                displayFlowMeterFail(flowMeterFlowAtStarting, flowMeterFlowWithBlowerOn);
 
                Buzzer_High_Prio_Start();
 
                // Wait for user to press start to restart calibration
                restartWaitTimer = 0;
 
                while (startButtonPressed == false) {
                    restartWaitTimer += (uint32_t)RESTART_READ_KEYBOARD_DELAY;
 
                    // Heartbeat fatal error periodically
                    if ((restartWaitTimer % 1000u) == 0u) {
                        // MFM reports an out-of-range value, it might not be connected
                        if (isMassFlowMeterOutOfRange == true) {
                            // MFM failure (eg. not connected)
                            sendMassFlowMeterFatalError();
                        } else {
                            // Other calibration errors
                            sendCalibrationFatalError(inspiratoryPressureSensorOffset,
                                                      minOffsetValue, maxOffsetValue,
                                                      flowMeterFlowAtStarting,
                                                      flowMeterFlowWithBlowerOn);
                        }
                    }
 
                    Calibration_Read_Keyboard_Delayed();
                }
            } else {
                calibrationValid = true;
            }
 
            displayPressureOffset(inspiratoryPressureSensorOffset);
            delay(1000);
#ifdef MASS_FLOW_METER_ENABLED
            displayFlowMeterOffset(MFM_getOffset());
            delay(1000);
#endif
        }
        // Reset values to default state
        calibationStarted = false;
        startButtonPressed = false;
    }
}

Calibration_Read_Keyboard_Delayed()

void Calibration_Read_Keyboard_Delayed

(

void

)

Read keyboard duing calibration process (delayed)

Definition at line 197 of file calibration.cpp.

                                         {
    keyboardLoop();
    delay(RESTART_READ_KEYBOARD_DELAY);
}

Calibration_Restart()

void Calibration_Restart

(

void

)

Restart calibration process.

Definition at line 202 of file calibration.cpp.

{ startButtonPressed = true; }

Calibration_Started()

bool Calibration_Started

(

void

)

Check if calibration mode is started.

Returns

True if calibration mode is started

Definition at line 204 of file calibration.cpp.

{ return calibationStarted; }

Calibration_Wait_Measure_Pressure()

void Calibration_Wait_Measure_Pressure

(

uint16_t

ms

)

Block execution for a given duration.

Parameters

ms	Duration of the blocking in millisecond

Definition at line 171 of file calibration.cpp.

                                                    {
    uint16_t start = millis();
    minOffsetValue = inspiratoryPressureSensor.read();
    maxOffsetValue = inspiratoryPressureSensor.read();
    pressureOffsetSum = 0;
    pressureOffsetCount = 0;
 
    // Open valves
    inspiratoryValve.close();
    inspiratoryValve.execute();
    expiratoryValve.open();
    expiratoryValve.execute();
 
    while ((millis() - start) < ms) {
        // Measure 1 pressure per ms we wait
        if ((millis() - start) > pressureOffsetCount) {
            int32_t pressureValue = inspiratoryPressureSensor.read();
            pressureOffsetSum += pressureValue;
            minOffsetValue = min(pressureValue, minOffsetValue);
            maxOffsetValue = max(pressureValue, maxOffsetValue);
            pressureOffsetCount++;
        }
        continue;
    }
}

Variable Documentation

calibationStarted

bool calibationStarted = false

Definition at line 36 of file calibration.cpp.

calibrationValid

bool calibrationValid = false

Definition at line 37 of file calibration.cpp.

maxOffsetValue

int32_t maxOffsetValue = 0

Definition at line 33 of file calibration.cpp.

minOffsetValue

int32_t minOffsetValue = 0

Definition at line 32 of file calibration.cpp.

pressureOffsetCount

uint32_t pressureOffsetCount

Definition at line 31 of file calibration.cpp.

pressureOffsetSum

int32_t pressureOffsetSum

Definition at line 30 of file calibration.cpp.

restartWaitTimer

uint32_t restartWaitTimer = 0

Definition at line 34 of file calibration.cpp.

startButtonPressed

bool startButtonPressed = false

Definition at line 35 of file calibration.cpp.