Embedded Files
DIAGRAMA DE CIRCUITO (en construccion)
FIRMWARE v1.5 (06/04/2020)
// Name : - PVP v1.5 "beta ARDUINO" - (Pandemic Ventilator Projet)
// Author : prof.martintorres@educ.ar - Alejandro Martin Torres
// Notes : En esta version de firmware, se opta trabajar con el sistema ARDUINO todo lo trabajado anteriormente con los microcontroladores PIC Microchip.
//Como mencionamos anteriormente, para el control de tiempo de Inhalacion y Exhalacion; Es importante controlar los perdiodos para mantener una frecuencia respiratoria estable,
//es por ello que en esta version ARDUINO sumamos un set pre-configurado con tres MODOS: NEO - INFANTES - ADULTOS. En paralelo estamos trabajando en sumar la funcion de tiempos
//programables manualmente, al igual que la version con microcontroladores PIC Microchip, y un control en 2do plano de las electrovalvulas de la version con las otras
//plataformas para tener multiple opcion de control.
// En el modo de operación NEO,se observa que a mayor frecuencia se consigue mayor presión al igual que mayor flujo de aire que se suministra al paciente. El comportamiento
//de frecuencia presenta mayor estabilidad y el desempeño esperado; al contrario del volumen corriente el cual no muestra una disminución estable de sus valores.
//Los valores de volumen corriente obtenidos al utilizar la batería DC como fuente de energía presentan mayor estabilidad en la tendencia de disminución de flujo al
//incrementar la frecuencia de ventilación, esto se debe a que la potencia suministrada por la batería es mayor a la que provee la fuente y por lo tanto se consigue un
//torque más fuerte y estable que produce la deformación de la bolsa emitiendo mayor volumen de aire. Como consecuencia de la mínima deformación ocasionada por la leva y
//considerando que la bolsa de resucitación utilizada está destinada para adultos se puede justificar el comportamiento observado para el modo neonato. El volumen corriente
//obtenido en este modo de operación está dentro del rango médico aceptado.
// En el modo de operación INFANTES se presenta mayor estabilidad, con comportamiento de volumen corriente y frecuencia esperados. Al igual que en el modo de operación
//neonatos el equipo presenta un rendimiento más estable al ser energizado con corriente continua debido a que la fuente de corriente continua (batería) puede proveer mayor
//potencia y no existen fluctuaciones en la entrada de energía al sistema. Adicionalmente, se espera que se muestre mayores valores de presión al tener menor volumen corriente,
//comportamiento que concuerda con la relación de la Ley de Gases ideal. Esta ley muestra que al incrementar la presión de un gas este presenta menor volumen.
// El modo de operación de adultos presenta menor estabilidad al ser comparado con las demás formas de operación. El volumen obtenido es bastante bajo llegando a tener un
//máximo de 64,8 [ml/ciclo] en tanto que para adultos se requiere un volumen corriente entre 500 a 800 [ml/ciclo]. A pesar de que el recorrido de la leva para este modo de
//operación esté establecido con mayor ángulo comparado con las demás formas de operación, la potencia proporcionada al motor no es suficiente para vencer la resistencia de la
//bolsa y completar el recorrido establecido. Mediante un análisis dinámico se obtuvo un torque necesario para el motor de 6[kg-cm],menor al torque requerido aplicado que fue
//de 6 [kg-cm]. A pesar de tener un motor con un torque mayor no se consiguió completar la máxima deformación de la bolsa debido a que no se contaba con los valores exactos de
//las propiedades mecánicas del material. Como consecuencia, debido a la alta fuerza de restitución del material la lev realiza un recorrido más corto el cual no es suficiente
//para presionar completamente la cámara de aire y permitir que se expulse mayor cantidad de aire hacia el paciente. Asimismo, la presión medida en este modo es pequeña
//llegando a un valor mínimo de 0.02 [cm de H2O], valor insuficiente para realizar una inspiración normal. Al igual que los demás modos de operación, presenta mayor volumen
//corriente y estabilidad al ser energizado con la batería.
#include <Servo.h> //Librería de Revo motor.
#include <LiquidCrystal.h>//Librería de pantalla.
Servo myservo; // varible que corresponde a servo motor.
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
int EV1_AMBU =10;
int EV2_INHALACION =0;
int EV3_EXHALACION =1;
int buttonState = 0;// variable que lee el estado del pulsador(botón).
//variables para volumen, frecuencia, posición motor y presión//
int velocidad;
int frec=0;
int vol=0;
int volumen;
int pos = 0; // variable de almacenamiento de posición del servo.
//Variables de presión:
float Papp, voltaje, lectura, Pfinal,Pfin ;
int alarmapin=13;
void setup()
{
// Inicialización de pulsadores:
pinMode(EV1_AMBU, OUTPUT);
pinMode(EV2_INHALACION, OUTPUT);
pinMode(EV3_EXHALACION, OUTPUT);
pinMode(6, INPUT_PULLUP);//PULLUP resistencia interna y no una resistencia extra en el circuito de cada pulsador.
pinMode(7, INPUT_PULLUP);
pinMode(8, INPUT_PULLUP);
// configurar la impresion del mensaje en la pantalla//
lcd.begin(16, 2);//Establecer # de filas y columnas//
lcd.print(" - PVP v1.5 - "); // Impresón en pantalla de modo de operación.
lcd.setCursor(0,1);//Ubicación del cursor para nueva impresión de mensaje.
lcd.print("ETI-TORRES IO&Se"); // Imprimir un mensaje a la pantalla LCD.
delay(1500);
lcd.clear(); // Limpia la impresión en pantalla.
lcd.print("MENU:"); // Imprimir un mensaje a la pantalla LCD.
lcd.setCursor(0,1);//Ubicación del cursor para nueva impresión de mensaje.
lcd.print("Neo Infan Adult");//Imprimir mensaje a la pantalla LCD
Serial.begin(9600);//Encendido impreisón de monitor serial.
myservo.attach(9); // attaches the servo on pin 9 to the servo object
myservo.write(180);//Inicialización de posición servo motor.
pinMode(alarmapin,OUTPUT);//Inicialización alarma.
digitalWrite(EV1_AMBU,LOW);
digitalWrite(EV2_INHALACION,LOW);
digitalWrite(EV3_EXHALACION,LOW);
}
void loop()
{
///////Lee qué entrada está activada/////
if(!digitalRead(6))buttonState=1;//"!" [NO]
else if(!digitalRead(7))buttonState=2;
else if(!digitalRead(8))buttonState=3;
else buttonState=buttonState;
Serial.println(buttonState); //Imprime en el monitor el estado del botón, si es 1, 2 o 3.
////////////////////////////////////////////////////////////////////
/////////////////BOTON 1_ MODO NEONATOS/////////////////////////////
////////////////////////////////////////////////////////////////////
if (buttonState == 3)//Estado del boton 3
{
velocidad=map(analogRead(5),0,1023,16,22); // Lee valores potenciometro de frecuencia.
volumen=map(analogRead(0),0,1023,140,180); // Lee valores potenciometro de volumen (desplazamiento angular de leva).
frec=(-1.7857*velocidad)+ 74.357; // Regresión lineal que representa respiraciones por minuto en función de velocidad de leva.
vol=(-11.634*frec)+ 718.63; // Regresión lineal que representa flujo de aire en función de recorrido angular de leva.
lcd.clear(); // Limpia la impresión en pantalla.
lcd.print("Modo NEONATO"); // Impresón en pantalla de modo de operación.
lectura=analogRead(2); // Lee puerto analogo 2 conectado a sensor de presión.
voltaje=((lectura*5)/1024); // Lee presión, transforma valores de voltaje entre 0 y 1024 a valores entre 0 y 5.
Papp=voltaje-2.5; // Valor de presión medidos en [in H2O]
Pfin=Papp*2.5; // Valor de presión medido en [cm H2O]
if (Papp >= 2) //Condición para encender alarma cuando presión alcanza 2 [in H2O]
{
digitalWrite(alarmapin,HIGH);
digitalWrite(EV1_AMBU,LOW);
digitalWrite(EV2_INHALACION,LOW);
digitalWrite(EV3_EXHALACION,LOW);
}
else
if (Papp <=2)//Condición para mantener apagada la alarma cuando la presión es menor a 2 [in H2O]
{
digitalWrite(alarmapin,LOW);
}
if (pos = 140) /////////////FUNCION PARA JUGAR CON EL CONTROL DE LAS ELECTROVALVULAS
{
digitalWrite(EV3_EXHALACION,LOW);
digitalWrite(EV2_INHALACION,HIGH);
}
if (pos = 180) /////////////FUNCION PARA JUGAR CON EL CONTROL DE LAS ELECTROVALVULAS
{
digitalWrite(EV2_INHALACION,LOW);
digitalWrite(EV3_EXHALACION,HIGH);
}
//Movimiento angular de leva controlada por movimiento angular de servo motor
for(pos = 140; pos < volumen; pos += 1) // Servo se mueve de 140 a 180 grados en pasos de 1 grado.
{
myservo.write(pos); // Enviar a servo a la posión guardada en la variable "pos"
if (pos=140);digitalWrite(EV2_INHALACION,HIGH); ///////////////////////////////////////////////////////////////////VER ANGULO
if (pos=180);digitalWrite(EV2_INHALACION,LOW); ///////////////////////////////////////////////////////////////////VER ANGULO
delay(velocidad); // Tiempo movimiento de servo de 140 a 180 grados
lcd.setCursor(0,1); //Asignar una posición para imprimir.
lcd.print(frec); //Imprimir valor de variable "frec"
lcd.setCursor(4,1); //Asignar una posición para imprimir.
lcd.print(Pfin); //Imprimir valor de variable "Pfin"
lcd.setCursor(9,1); //Asignar una posición para imprimir.
lcd.print(vol); //Imprimir valor de variable "vol"
}
for(pos = volumen; pos>=140; pos-=1) //Servo se mueve de 180 a 140 grados en pasos de 1 grado.
{
myservo.write(pos); // Enviar a servo a la posión guardada en la variable "pos"
delay(velocidad); // Tiempo movimiento de servo de 140 a 180 grados
}
}
///////////////////////////////////////////////////////////////////
/////////////////BOTON 2_MODO INFANTES/////////////////////////////
//////////////////////////////////////////////////////////////////
if (buttonState == 2)
{
velocidad=map(analogRead(5),0,1023,18,24);
volumen=map(analogRead(0),0,1023,125,180);
frec=(-1.3214*velocidad) + 55.607;
vol=(-6.5413*frec) + 551.65;
lcd.clear();
lcd.print("INFANTE");
lectura=analogRead(2);
voltaje=((lectura*5)/1024);
Papp=voltaje-2.5;
Pfin=Papp*2.5;
if (Papp >= 2)
{
digitalWrite(alarmapin,HIGH);
digitalWrite(EV1_AMBU,LOW);
digitalWrite(EV2_INHALACION,LOW);
digitalWrite(EV3_EXHALACION,LOW);
}
else
if (Papp <=2)
{
digitalWrite(alarmapin,LOW);
}
if (pos = 125) /////////////FUNCION PARA JUGAR CON EL CONTROL DE LAS ELECTROVALVULAS
{
digitalWrite(EV3_EXHALACION,LOW);
digitalWrite(EV2_INHALACION,HIGH);
}
if (pos = 180) /////////////FUNCION PARA JUGAR CON EL CONTROL DE LAS ELECTROVALVULAS
{
digitalWrite(EV2_INHALACION,LOW);
digitalWrite(EV3_EXHALACION,HIGH);
}
for(pos = 125; pos < volumen; pos += 1)
{
myservo.write(pos);
delay(velocidad);
lcd.setCursor(0,1);
lcd.print(frec);
lcd.setCursor(4,1);
lcd.print(Pfin);
lcd.setCursor(9,1);
lcd.print(vol);
}
for(pos = volumen; pos>=125; pos-=1)
{
myservo.write(pos);
delay(velocidad);
}
}
//////////////////////////////////////////////////////////////////
/////////////////BOTON 3_MODO ADULTOS/////////////////////////////
//////////////////////////////////////////////////////////////////
if (buttonState == 1) {
velocidad=map(analogRead(5),0,1023,18,24);
volumen=map(analogRead(0),0,1023,100,180);
frec=(-0.7857*velocidad) + 34.929;
vol=(-1.217*frec) + 80.9;
lcd.clear();
lcd.print("ADULTO");
lectura=analogRead(2);
voltaje=((lectura*5)/1024);
Papp=voltaje-2.5;
Pfin=Papp*2.5;
if (Papp >= 2)
{
digitalWrite(alarmapin,HIGH);
digitalWrite(EV1_AMBU,LOW);
digitalWrite(EV2_INHALACION,LOW);
digitalWrite(EV3_EXHALACION,LOW);
}
else
if (Papp <=2)
{
digitalWrite(alarmapin,LOW);
}
for(pos = 100; pos < volumen; pos += 1)
if (pos = 100) /////////////FUNCION PARA JUGAR CON EL CONTROL DE LAS ELECTROVALVULAS
{
digitalWrite(EV3_EXHALACION,LOW);
digitalWrite(EV2_INHALACION,HIGH);
}
if (pos = 180) /////////////FUNCION PARA JUGAR CON EL CONTROL DE LAS ELECTROVALVULAS
{
digitalWrite(EV2_INHALACION,LOW);
digitalWrite(EV3_EXHALACION,HIGH);
}
{
myservo.write(pos);
delay(velocidad);
lcd.setCursor(0,1);
lcd.print(frec);
lcd.setCursor(4,1);
lcd.print(Pfin);
lcd.setCursor(9,1);
lcd.print(vol);
}
for(pos = volumen; pos>=100; pos-=1)
if (pos = 100) /////////////FUNCION PARA JUGAR CON EL CONTROL DE LAS ELECTROVALVULAS
{
digitalWrite(EV3_EXHALACION,LOW);
digitalWrite(EV2_INHALACION,HIGH);
}
if (pos = 180) /////////////FUNCION PARA JUGAR CON EL CONTROL DE LAS ELECTROVALVULAS
{
digitalWrite(EV2_INHALACION,LOW);
digitalWrite(EV3_EXHALACION,HIGH);
}
{
myservo.write(pos);
delay(velocidad);
}
}
}
Page updated
Report abuse