Ventilador Pulmonar Open-Source para COVID-19: Sistema de Suporte Respiratório Baseado em Arduino

Componentes e Materiais

Componente	Quantidade	Observações
Arduino UNO	1	Para versão com Arduino
Shield Arduino 4 Relés	1	Para versão com Arduino
Servo Digital MG995	1	Para todas as versões
Módulo LM2596S	2	Para todas as versões
Potenciômetro Linear Multivoltas 10k	1	Para todas as versões
Fonte de Alimentação 60W PCIe 12V 5A (Digilent)	1	Para todas as versões
LED 5mm Vermelho	1	Para todas as versões
LED 5mm Verde	1	Para todas as versões
LCD Alfanumérico 20x4	1	Para todas as versões
Chave Seletora 220V	1	Para todas as versões
Máscara de Snorkel Facial Completa (Decathlon)	1	Interface do paciente
Válvula Solenoide 2 Vias	1

Ferramentas e Máquinas Necessárias

• Impressora 3D (genérica) - Modelo A8
• Lightbox / Unidade de Exposição UV 300-001

Software e Serviços Online

• Arduino IDE
• PCB Elegance (design de PCB)
• Autodesk Fusion 360 (modelagem 3D)

Sobre o Projeto

Ventilador não invasivo de código aberto. Baixo custo e fácil de construir, um respirador de emergência para combater a crise de saúde da COVID-19 quando não há ventiladores disponíveis e enquanto o paciente não estiver sedado ou intubado.

Este projeto resultou de um desafio lançado pelo meu ex-professor e amigo Serafim Pires, que me contactou mostrando um projeto espanhol, sugerindo que eu desenvolvesse algo para ajudar a combater esta crise mundial.

Após várias pesquisas e estudos sobre ventilação não invasiva, construí este protótipo funcional baseado em duas tecnologias existentes.

Todos os testes foram bem-sucedidos, com teste funcional de mais de 20 dias sem qualquer problema ou interrupção.

A ventilação não invasiva é administrada usando máscaras faciais ou nasais, que empurram uma quantidade definida de ar pressurizado para os pulmões. Isso apoia o processo natural de respiração quando a doença causou falha pulmonar, permitindo que o corpo combata a infecção e se recupere.

Baseado em pesquisas conduzidas na Itália, usei esta tecnologia no meu projeto que transforma uma máscara de snorkel Decathlon em um ventilador de emergência para pacientes com COVID-19, ajudando a mitigar a falta de ventiladores durante o pico da pandemia de coronavírus.

Essas máscaras foram adaptadas e usadas em locais ao redor do mundo devido ao seu baixo custo e fácil adaptação.

Os resultados foram evidentes e, recentemente, esta tecnologia também foi utilizada em Portugal no Hospital de Santarém.

Notícia no jornal em Portugal

Entrevista em rádio local que viralizou nas redes sociais em Portugal.

Primeiro teste de operação usando pequeno volume de ar e 15 ciclos respiratórios, variando frequência respiratória e PEEP para demonstração.

AVISO: Este protótipo ainda não foi validado por nenhum órgão oficial e declino toda responsabilidade pelo seu uso. Além disso, será usado como último recurso e por pessoal médico treinado, destinado a salvar vidas em situação extrema de pico. O projeto sem fins lucrativos pode ser replicado em massa, se aprovado pelas autoridades competentes em Portugal.

Código

INOVT_COVID19_Versao_2.2.ino (Arduino)

/* Ventilador Pulmonar INOVT COVID-19 Versão 2.2
 * Autor: David Pascoal
 * Equipamento testado e comprovado, segurança com sensor de pressão,
 * Saída de alarme para ativar Buzzer ou alerta.
 */
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Servo.h>

LiquidCrystal_I2C lcd(0x27, 20, 4);

#define PIN_SERVO 6
#define PIN_FREQ A1
#define PIN_PEEP A0
#define PIN_LED 2
#define PIN_LED2 3
#define PIN_ALARME_RELE 8
#define PIN_VALVULA_SEGURANCA 9
#define SENSOR_FLUXO A3
#define EXPIRANDO 0
#define INSPIRANDO 1
#define ANGULO_MIN 92
#define ANGULO_MAX 139

int frequencia = 0;
int valInspira = 0;
int valExpira = 0;
int valPeep = 0;
int aux;
int x = 500;
int y = 1000;
unsigned long tempo;
Servo meuServo;
int frequencia_ant;
int valPeep_ant;
int estado;

void logo() {
  byte a3[8] = { B00011, B00111, B01100, B11000, B10000, B00000, B00000 };
  byte a2[8] = { B00000, B00000, B00000, B00000, B10001, B11111, B01110 };
  byte a1[8] = { B11000, B01100, B00110, B00011, B00001, B00000, B00000 };
  byte a4[9] = { B00000, B00000, B00000, B00001, B00011, B00110, B01100, B11000 };
  byte a5[9] = { B00000, B01110, B11111, B10001, B00000, B00000, B00000, B01110, B00000 };
  byte a6[8] = { B00000, B00000, B00000, B10000, B11000, B01100, B00110, B00011 };
  byte a7[10] = { B00000, B01110, B11111, B10001, B00000, B00000, B00000, B00000 };
  byte a8[8] = { B00100, B01110, B00100, B00000, B10001, B11111, B01110 };
  
  lcd.print("*COVID19*");
  lcd.setCursor(0, 1);
  lcd.print("..INOVT..");
  lcd.createChar(0, a1);
  lcd.createChar(1, a2);
  lcd.createChar(2, a3);
  lcd.createChar(7, a8);
  lcd.createChar(3, a4);
  lcd.createChar(4, a5);
  lcd.createChar(5, a6);
  lcd.createChar(6, a7);
  lcd.setCursor(10, 0);
  lcd.write(byte(3)); lcd.write(byte(4)); lcd.write(byte(5));
  lcd.write(byte(3)); lcd.write(byte(6)); lcd.write(byte(5));
  lcd.setCursor(10, 1);
  lcd.write(byte(0)); lcd.write(byte(1)); lcd.write(byte(2));
  lcd.write(byte(0)); lcd.write(byte(7)); lcd.write(byte(2));
}

void initior() {
  byte c11[8] = { B00000, B00000, B11111, B11111, B11111, B11111, B00000, B00000 };
  lcd.createChar(3, c11);
  lcd.setCursor(0, 2);
  for (int i = 0; i < 20; i++) {
    lcd.write(3);
    delay(x);
    // Efeitos visuais com LEDs e servo durante inicialização
    if (i % 2 == 0) digitalWrite(PIN_LED, HIGH); else digitalWrite(PIN_LED, LOW);
    if (i % 3 == 0) digitalWrite(PIN_LED2, HIGH); else digitalWrite(PIN_LED2, LOW);
    if (i == 9) meuServo.write(100);
    if (i == 11) meuServo.write(110);
    if (i == 13) meuServo.write(115);
    if (i == 15) meuServo.write(120);
    if (i == 17) meuServo.write(130);
  }
}

void maobc() {
  for (int i = 0; i < 4; i++) {
    thumbdownA(); delay(x); lcd.clear();
    thumbsup(); delay(x); lcd.clear();
  }
  delay(1000); lcd.clear();
}

// Funções de animação thumbdownA e thumbsup omitidas por brevidade
// (criam caracteres personalizados no LCD)

void setServo() {
  if (millis() > tempo) {
    if (estado == EXPIRANDO) {
      digitalWrite(PIN_LED2, LOW);
      digitalWrite(PIN_LED, HIGH);
      meuServo.write(ANGULO_MIN);
      tempo = millis() + (valInspira * 100);
      estado = INSPIRANDO;
      lcd.setCursor(8, 2);
      lcd.print("EXPIRANDO > ");
    } else if (estado == INSPIRANDO) {
      digitalWrite(PIN_LED2, HIGH);
      digitalWrite(PIN_LED, LOW);
      meuServo.write(ANGULO_MAX - valPeep);
      tempo = millis() + (valExpira * 100);
      estado = EXPIRANDO;
      lcd.setCursor(8, 2);
      lcd.print("INSPIRANDO < ");
    }
  }
}

void setup() {
  meuServo.attach(PIN_SERVO);
  meuServo.write(92);
  
  pinMode(PIN_FREQ, INPUT_PULLUP);
  pinMode(PIN_PEEP, INPUT_PULLUP);
  pinMode(SENSOR_FLUXO, INPUT);
  pinMode(PIN_LED, OUTPUT);
  pinMode(PIN_LED2, OUTPUT);
  pinMode(PIN_ALARME_RELE, OUTPUT);
  pinMode(PIN_VALVULA_SEGURANCA, OUTPUT);
  
  lcd.init();
  lcd.backlight();
  lcd.clear();
  lcd.setCursor(0, 0);
  logo();
  lcd.setCursor(4, 2);
  lcd.print("OPEN-SOURCE");
  lcd.setCursor(0, 3);
  lcd.print("Ventilador Pulmonar");
  delay(4000);
  lcd.clear();
  lcd.print("....Inicializando....");
  initior();
  delay(500);
  lcd.clear();
  maobc();
  lcd.clear();
  
  if (digitalRead(SENSOR_FLUXO) == LOW) {
    thumbsup();
    lcd.setCursor(0, 0);
    lcd.print("SISTEMA");
    lcd.setCursor(2, 1);
    lcd.print("OK");
    delay(5000);
    lcd.clear();
  } else {
    meuServo.write(139);
    thumbdownA();
    lcd.setCursor(0, 0);
    lcd.print("SISTEMA");
    lcd.setCursor(1, 1);
    lcd.print("FALHA");
    delay(5000);
    lcd.clear();
    Serial.begin(9600);
    tempo = millis();
    frequencia_ant = -1;
    valPeep_ant = -1;
  }
  delay(500);
  estado = EXPIRANDO;
}

void loop() {
  digitalRead(SENSOR_FLUXO);
  aux = analogRead(PIN_FREQ);
  frequencia = map(aux, 0, 1023, 10, 60);
  valInspira = ((1.0 / frequencia) * 600.0) * (1.0 / 3.0);
  valExpira = ((1.0 / frequencia) * 600.0) * (2.0 / 3.0);
  aux = analogRead(PIN_PEEP);
  valPeep = map(aux, 0, 1023, 0, 10);
  
  if ((frequencia_ant != frequencia) || (valPeep_ant != valPeep)) {
    Serial.print("Frequencia: "); Serial.println(frequencia);
    Serial.print("Inspira: "); Serial.println(valInspira);
    Serial.print("Expira: "); Serial.println(valExpira);
    Serial.print("Peep: "); Serial.println(valPeep);
    
    lcd.setCursor(1, 0); lcd.print("FREQUENCIA: "); lcd.setCursor(13, 0); lcd.print(frequencia);
    lcd.setCursor(1, 1); lcd.print("PEEP: "); lcd.setCursor(13, 1); lcd.print(valPeep);
    lcd.setCursor(0, 2); lcd.print("ESTADO: ");
    lcd.setCursor(0, 3); lcd.print("VENTILADOR D.PASCOAL ");
    
    frequencia_ant = frequencia;
    valPeep_ant = valPeep;
  }
  
  if (digitalRead(SENSOR_FLUXO) == HIGH) {
    // Falha no fluxo de ar - alarme
    meuServo.write(139);
    digitalWrite(PIN_ALARME_RELE, HIGH);
    digitalWrite(PIN_VALVULA_SEGURANCA, HIGH);
    lcd.clear();
    thumbdownA();
    lcd.setCursor(0, 0); lcd.print("SISTEMA");
    lcd.setCursor(1, 1); lcd.print("FALHA");
    lcd.setCursor(1, 2); lcd.print("******************");
    lcd.setCursor(3, 3); lcd.print("Verifique fluxo AR");
    lcd.setCursor(12, 1); lcd.print("ALARME");
    
    for (int i = 0; i < 3; i++) {
      digitalWrite(PIN_LED, HIGH); digitalWrite(PIN_LED2, HIGH);
      delay(500);
      lcd.setCursor(12, 1); lcd.print(" ");
      digitalWrite(PIN_LED, LOW); digitalWrite(PIN_LED2, LOW);
      delay(500);
      lcd.setCursor(12, 1); lcd.print("ALARME");
    }
    delay(1000);
    lcd.clear();
  } else {
    digitalWrite(PIN_ALARME_RELE, LOW);
    digitalWrite(PIN_VALVULA_SEGURANCA, LOW);
    setServo();
    delay(10);
  }
}

Arquivo compactado: INOVT_COVID19_Versao_2.2.rar (download apenas)

Peças Personalizadas e Gabinetes

Devem ser impressas em impressora 3D. Requer alguma precisão.

Instruções passo a passo completas para transformar a máscara de mergulho em máscara de respiração pressurizada.

Requer precisão. Impressora 3D de alta resolução.

inovt_covid19_version_2_0_david_pascoal_0mbFUa0ce1.rar

Esquemáticos

Diagrama da versão autônoma, não necessita coluna de ar hospitalar.

Versão 2.2. Com guarda de segurança e saída de alarme.