Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

Ventilador pulmonar COVID-19 de código aberto

Componentes e suprimentos

Arduino UNO
Para versão com Arduino
× 1
Arduino 4 Relays Shield
Para versão com Arduino
× 1
Digital Servo MG995
Para todas as versões
× 1
LM2596S módulo
Para todas as versões
× 2
Potenciômetro linear multivoltas de 10k
Para todas as versões
× 1
Fonte de alimentação Digilent 60W PCIe 12V 5A
Para todas as versões
× 1
LED de 5 mm:Vermelho
Para todas as versões
× 1
LED de 5 mm:Verde
× 1
LCD alfanumérico, 20 x 4
Para todas as versões
× 1
botão de alternar 220v
Para todas as versões
× 1
snorke full face
× 1
Válvula solenóide de 2 vias
× 1

Ferramentas e máquinas necessárias

Impressora 3D (genérica)
A8
300-001 - Lightbox, exposição UV

Aplicativos e serviços online

Arduino IDE
Elegância PcB
Autodesk Fusion 360

Sobre este projeto


Ventilador não invasivo de código aberto É de baixo custo e fácil de construir, um respirador de emergência para combater a crise de saúde Covid19 se não houver ventiladores disponíveis e desde que o paciente não esteja sedado ou intubado.

Este projecto resultou de um desafio lançado pelo meu ex professor e amigo Serafim Pires que me contactou apresentando um projecto espanhol, dizendo que seria bom se pudesse desenvolver um projecto que ajudasse a combater esta crise mundial.

Após várias pesquisas e estudos sobre o tema Ventilação não invasiva, construí este protótipo funcional com base em 2 tecnologias existentes,

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

A ventilação não invasiva é fornecida com o uso de máscaras faciais nasais, que empurram uma determinada quantidade de ar pressurizado para os pulmões. Isso apóia o processo de respiração natural quando a doença faz com que os pulmões falhem, permitindo que o corpo lute contra infecções e melhore.

Com base em pesquisas realizadas na Itália, usei essa tecnologia em meu projeto que transforma uma máscara de snorkel Decathlon em um ventilador de emergência para pacientes que sofrem de COVID-19, para ajudar a mitigar a falta de ventiladores durante o pico da pandemia de coronavírus.

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

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

https://www.prosaude.org.br/noticias/hospital-regional-de-santarem-utiliza-mascaras-de-mergulho-no-tratamento-da-covid-19/?fbclid=IwAR36UVLXCztk0zSSJwTCBQ1lgb5iYmY1Ha_twITQ74-Q74H74

Notícias no jornal de Portugal.

Iterview em uma rádio local se tornou viral nas redes sociais em Portugal.

.

Teste de funcionamento inicial usando um pequeno volume de ar e 15 ciclos respiratórios, alterando a frequência respiratória e o peep para demonstração.




AVISO:Este protótipo ainda não foi validado por nenhum órgão oficial e declino qualquer responsabilidade por seu uso.

Além disso, será usado como último recurso e por pessoal médico treinado, este equipamento se destina a salvar vidas em situações de pico extremo.

O projeto sem fins lucrativos pode ser replicado em massa, desde que aprovado pelas autoridades competentes em Portugal.

Código

  • INOVT_COVID19_Version_2.2.ino
  • INOVT_COVID19_Version_2.2.rar
INOVT_COVID19_Version_2.2.ino Arduino
 / * Programa ventilador pulmonar INOVT COVID-19 Versio 2.2 * Autor:David Pascoal * O equipamento foi testado e comprovado, segurança com sensor de pressão, * Saída de alarme para ligar Buzer ou besouro. * / # inclui  #include  #include  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_Alarm_Relay 8 #define PIN_Safety_Valve 9 # define SENSOR_FLOW A3 # define EXPIRANDO 92 #define MÁX. =0; int valInspira =0; int valExpira =0; int valPeep =0; int aux; int x =500; int y =1000; tempo sem sinal; Servo meuServo; int frecuencia_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); lcd.write (3); atraso (x); lcd.setCursor (1, 2); lcd.write (3); atraso (x); digitalWrite (PIN_LED, HIGH); lcd.setCursor (2, 2); lcd.write (3); atraso (x); lcd.setCursor (3, 2); lcd.write (3); atraso (x); digitalWrite (PIN_LED2, HIGH); lcd.setCursor (4, 2); lcd.write (3); atraso (x); lcd.setCursor (5, 2); lcd.write (3); atraso (x); digitalWrite (PIN_LED, LOW); lcd.setCursor (6, 2); lcd.write (3); atraso (x); lcd.setCursor (7, 2); lcd.write (3); atraso (x); digitalWrite (PIN_LED2, LOW); lcd.setCursor (8, 2); lcd.write (3); atraso (x); digitalWrite (PIN_LED, HIGH); digitalWrite (PIN_LED2, HIGH); lcd.setCursor (9, 2); lcd.write (3); atraso (x); myServo.write (100); digitalWrite (PIN_LED, LOW); digitalWrite (PIN_LED2, LOW); lcd.setCursor (10, 2); lcd.write (3); atraso (x); digitalWrite (PIN_LED, HIGH); digitalWrite (PIN_LED2, HIGH); lcd.setCursor (11, 2); lcd.write (3); atraso (x); myServo.write (110); digitalWrite (PIN_LED, LOW); digitalWrite (PIN_LED2, LOW); lcd.setCursor (12, 2); lcd.write (3); atraso (x); digitalWrite (PIN_LED, HIGH); digitalWrite (PIN_LED2, HIGH); lcd.setCursor (13, 2); lcd.write (3); atraso (x); myServo.write (115); digitalWrite (PIN_LED, LOW); digitalWrite (PIN_LED2, LOW); lcd.setCursor (14, 2); lcd.write (3); atraso (x); digitalWrite (PIN_LED, HIGH); digitalWrite (PIN_LED2, HIGH); lcd.setCursor (15, 2); lcd.write (3); atraso (x); myServo.write (120); digitalWrite (PIN_LED, LOW); digitalWrite (PIN_LED2, LOW); lcd.setCursor (16, 2); lcd.write (3); atraso (x); digitalWrite (PIN_LED, HIGH); digitalWrite (PIN_LED2, HIGH); lcd.setCursor (17, 2); lcd.write (3); atraso (x); myServo.write (130); digitalWrite (PIN_LED, LOW); digitalWrite (PIN_LED2, LOW); lcd.setCursor (18, 2); lcd.write (3); atraso (x); lcd.setCursor (19, 2); lcd.write (3); atraso (x);} void maobc () {thumbdownA (); atraso (x); lcd.clear (); afirmativo(); atraso (x); thumbdownA (); atraso (x); lcd.clear (); afirmativo(); atraso (x); thumbdownA (); atraso (x); lcd.clear (); afirmativo(); atraso (x); thumbdownA (); atraso (x); lcd.clear (); afirmativo(); atraso (1000); lcd.clear ();} void thumbdownA () {byte thumb1 [8] ={B00001, B00010, B00011, B00100, B00011, B00100, B00011, B00100}; byte thumb2 [8] ={B00011, B00000, B00000, B00000, B00000, B00000, B00000, B00000}; byte thumb3 [8] ={B11110, B00001, B00000, B00000, B00000, B00000, B00000, B00000}; byte thumb4 [8] ={B00000, B11110, B01000, B10001, B10010, B10010, B01100, B00000}; byte thumb5 [8] ={B00000, B10000, B01110, B00010, B00010, B00010, B00010, B00010}; byte thumb6 [8] ={B00110, B01000, B10000, B00000, B00000, B00000, B00000, B00000}; lcd.createChar (6, thumb1); lcd.createChar (1, thumb2); lcd.createChar (2, thumb3); lcd.createChar (3, thumb4); lcd.createChar (4, thumb5); lcd.createChar (5, thumb6); lcd.setCursor (7,0); lcd.write (6); lcd.setCursor (7,1); lcd.write (1); lcd.setCursor (8,0); lcd.write (2); lcd.setCursor (8,1); lcd.write (3); lcd.setCursor (9,0); lcd.write (4); lcd.setCursor (9,1); lcd.write (5);} void thumbsup () {byte thumb1 [8] ={B00100, B00011, B00100, B00011, B00100, B00011, B00010, B00001}; byte thumb2 [8] ={B00000, B00000, B00000, B00000, B00000, B00000, B00000, B00011}; byte thumb3 [8] ={B00000, B00000, B00000, B00000, B00000, B00000, B00001, B11110}; byte thumb4 [8] ={B00000, B01100, B10010, B10010, B10001, B01000, B11110, B00000}; byte thumb5 [8] ={B00010, B00010, B00010, B00010, B00010, B01110, B10000, B00000}; byte thumb6 [8] ={B00000, B00000, B00000, B00000, B00000, B10000, B01000, B00110}; lcd.createChar (6, thumb1); lcd.createChar (1, thumb2); lcd.createChar (2, thumb3); lcd.createChar (3, thumb4); lcd.createChar (4, thumb5); lcd.createChar (5, thumb6); lcd.setCursor (7,1); lcd.write (6); lcd.setCursor (7,0); lcd.write (1); lcd.setCursor (8,1); lcd.write (2); lcd.setCursor (8,0); lcd.write (3); lcd.setCursor (9,1); lcd.write (4); lcd.setCursor (9,0); lcd.write (5);} void setServo () {if (millis ()> tempo) {if (estado ==EXPIRANDO) {// Pasar a inspirandO digitalWrite (PIN_LED2, LOW); digitalWrite (PIN_LED, HIGH); myServo.write (MIN_ANGLE); tempo =milis () + (valInspira * 100); estado =INSPIRANDO; lcd.setCursor (8, 2); lcd.print ("EXPIRANDO>"); } else if (estado ==INSPIRANDO) {// P0asar a expirando digitalWrite (PIN_LED2, HIGH); digitalWrite (PIN_LED, LOW); myServo.write (MAX_ANGLE - valPeep); tempo =milis () + (valExpira * 100); estado =EXPIRANDO; lcd.setCursor (8, 2); lcd.print ("INSPIRANDO <"); }}} void setup () {myServo.attach (PIN_SERVO); myServo.write (92); // digitalWrite (PIN_LED, LOW); pinMode (PIN_FREQ, INPUT_PULLUP); pinMode (PIN_PEEP, INPUT_PULLUP); pinMode (SENSOR_FLOW, INPUT); pinMode (PIN_LED, OUTPUT); pinMode (PIN_LED2, OUTPUT); pinMode (PIN_Alarm_Relay, OUTPUT); pinMode (PIN_Safety_Valve, OUTPUT); lcd.init (); lcd.backlight (); lcd.clear (); lcd.setCursor (0,0); logotipo(); lcd.setCursor (4,2); lcd.print ("FONTE ABERTA"); lcd.setCursor (0,3); lcd.print ("Ventilador pulmonar"); atraso (4000); lcd.clear (); lcd.print (".... Inicializando ...."); initior (); atraso (500); lcd.clear (); maobc (); lcd.clear (); if (digitalRead (SENSOR_FLOW) ==LOW) {thumbsup (); lcd.setCursor (0,0); lcd.print ("SISTEMA"); lcd.setCursor (2,1); lcd.print ("OK"); atraso (5000); lcd.clear (); } else {myServo.write (139); thumbdownA (); lcd.setCursor (0,0); lcd.print ("SISTEMA"); lcd.setCursor (1,1); lcd.print ("FALHA"); atraso (5000); lcd.clear (); Serial.begin (9600); tempo =milis (); frecuencia_ant =-1; valPeep_ant =-1; } atraso (500); estado =EXPIRANDO; } void loop () {digitalRead (SENSOR_FLOW); aux =analogRead (PIN_FREQ); frecuencia =map (aux, 0,1023, 10, 60); valInspira =((1,0 / frequência) * 600,0) * (1,0 / 3,0); valExpira =((1,0 / frequência) * 600,0) * (2,0 / 3,0); aux =analogRead (PIN_PEEP); valPeep =map (aux, 0,1023, 0, 10); if ((frecuencia_ant! =frecuencia) || (valPeep_ant! =valPeep)) {// Pode monitorar os valores de Frequência e PEEP sem exibição usando o Monitor serie do Arduino IDE. Serial.print ("Frecuencia:"); Serial.println (frecuencia); 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 (frecuencia); lcd.setCursor (1, 1); lcd.print ("PEEP:"); lcd.setCursor (13, 1); lcd.print (valPeep); // atraso (500); lcd.setCursor (0, 2); lcd.print ("ESTADO:"); lcd.setCursor (0, 3); lcd.print ("VENTILADOR D.PASCOAL"); frecuencia_ant =frecuencia; valPeep_ant =valPeep; } if (digitalRead (SENSOR_FLOW) ==HIGH) {myServo.write (139); digitalWrite (PIN_Alarm_Relay, HIGH); digitalWrite (PIN_Safety_Valve, 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 ("Verificar fluxo AR"); lcd.setCursor (12,1); lcd.print ("ALARME"); digitalWrite (PIN_LED, HIGH); digitalWrite (PIN_LED2, HIGH); atraso (500); lcd.setCursor (12,1); lcd.print (""); atraso (500); lcd.setCursor (12,1); lcd.print ("ALARME"); digitalWrite (PIN_LED, LOW); digitalWrite (PIN_LED2, LOW); atraso (1000); lcd.clear (); } else {digitalWrite (PIN_Alarm_Relay, LOW); digitalWrite (PIN_Safety_Valve, LOW); setServo (); atraso (10);}} 
INOVT_COVID19_Version_2.2.rar C / C ++
 Sem visualização (somente download). 

Peças personalizadas e gabinetes

Eles devem ser impressos em uma impressora 3D.
Requer alguma precisão. Instruções passo a passo completas para trocar a máscara de mergulho e transformá-la em uma máscara respiratória pressurizada Requer alguma precisão.
Impressora 3D de alta resolução inovt_covid19_version_2_0_david_pascoal_0mbFUa0ce1.rar

Esquemas

Diagrama da versão autônoma,
não precisa da coluna de ar do hospital. Versão 2.2.
Com guarde de segurança e saída de alarme. Versão 2.2.
Com guarde de segurança e saída de alarme.

Processo de manufatura

  1. O quadro de referência de código aberto visa a implantação rápida de ventilador médico
  2. Arduino Spybot
  3. FlickMote
  4. TV B-Gone caseiro
  5. Relógio mestre
  6. Encontre-me
  7. Arduino Power
  8. Tech-TicTacToe
  9. Arduino Quadruped
  10. Joystick Arduino