Sensor de temperatura para Arduino aplicado para COVID 19:12 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:41

El sensor de temperatura para Arduino es un elemento fundamental cuando queremos medir la temperatura de un procesador del cuerpo humano.

El sensor de temperatura con Arduino debe estar en contacto o cerca para recibir y medir el nivel de calor. Así funcionan los termómetros.

Estos dispositivos son extremadamente utilizados para medir la temperatura corporal de personas enfermas, ya que la temperatura es uno de los primeros factores que cambian en el cuerpo humano cuando existe una anomalía o enfermedad.

Una de las enfermedades que alteran la temperatura del cuerpo humano es COVID 19. Por ello, presentamos los principales síntomas:

Tos Cansancio Dificultad para respirar (Casos severos) Fiebre La fiebre es un síntoma cuya principal característica es el aumento de la temperatura corporal. En esta enfermedad, necesitamos monitorear constantemente estos síntomas.

Así, desarrollaremos un proyecto para monitorear la temperatura y almacenar estos datos en una tarjeta de memoria a través de un Datalogger JLCPCB utilizando un sensor de temperatura con Arduino.

Por tanto, en este artículo aprenderás:

• ¿Cómo funciona un registrador de datos JLCPCB con un sensor de temperatura con Arduino?
• Cómo funciona el sensor de temperatura con Arduino.
• Cómo funciona el sensor de temperatura DS18B20 con Arduino
• Utilice botones con múltiples funciones.

A continuación, le mostraremos cómo desarrollará su registrador de datos JLCPCB utilizando el sensor de temperatura Arduino.

Suministros

Arduino UNO

Placa de circuito impreso JLCPCB

Sensor de temperatura DS18B20

Arduino Nano R3

Jerséis

Pantalla LCD 16 x 2

Interruptor de botón

Resistencia 1kR

Módulo de tarjeta SD para Arduino

Paso 1: Construcción del registrador de datos JLCPCB con sensor de temperatura con Arduino

Como se mencionó anteriormente, el proyecto consiste en crear un Datalogger JLCPCB con Sensor de Temperatura con Arduino, y a través de estos datos podemos monitorear la temperatura del paciente en tratamiento.

Por lo tanto, el circuito se muestra en la Figura anterior.

Por tanto, como puedes ver, este circuito cuenta con un sensor de temperatura DS18B20 con Arduino, que se encarga de medir la lectura de temperatura del paciente.

Además, el Arduino Nano se encargará de recopilar estos datos y almacenarlos en la tarjeta de memoria del Módulo de Tarjeta SD.

Cada información se guardará con su hora respectiva, que se leerá desde el Módulo RTC DS1307.

Así, para que se guarden los datos del sensor de temperatura con Arduino, el usuario debe realizar el proceso a través del Menú de Control con el LCD 16x2.

Paso 2:

Cada botón es responsable de controlar una opción, como se muestra en la pantalla LCD 16x2 en la Figura 2.

Cada opción es responsable de realizar una función en el sistema, como se muestra a continuación.

• La opción M es responsable de iniciar la medición y el registro de datos en la tarjeta de memoria.
• La opción H es responsable de ajustar las horas del sistema.
• La opción O / P se utiliza para confirmar la entrada de datos en el sistema o para pausar la escritura de datos en la tarjeta de memoria.

Para comprender el proceso de control del sistema, proporcionaremos el código a continuación y discutiremos el sistema de control paso a paso del registrador de datos JLCPCB con sensor de temperatura con Arduino.

#include // Biblioteca con todas las funciones del sensor DS18B20

#include #include // Biblioteca I2C do LCD 16x2 #include // Biblioteca de Comunicacao I2C #include // Biblioteca OneWire para el sensor DS18B20 #include #include LiquidCrystal_I2C lcd (0x27, 16, 2); // Configurando o endereco do LCD 16x2 para 0x27 #define ONE_WIRE_BUS 8 // Pin digital para conectar el sensor DS18B20 // Definir uma instancia do oneWire para comunicacao com o sensor OneWire oneWire (ONE_WIRE_BUS); Sensores de temperatura de Dallas (y oneWire); DeviceAddress sensor1; Archivo myFile; #define Buttonmeasure 2 #define Buttonadjusthour 3 #define Buttonok 4 bool meter = 0, adjusthour = 0, ok = 0; bool estado_medida = 0, estado_ajuste = 0, estado_correcto = 0; bool medida_proceso = 0, ajuste_proceso = 0; byte actualMin = 0, previousMin = 0; byte hora actual = 0, hora anterior = 0; byte minUpdate = 0; int pinoSS = 10; // Pin 53 para Mega / Pin 10 para UNO int DataTime [7]; void updateHour () {DS1307.getDate (DataTime); if (DataTime [5]! = minUpdate) {sprintf (times, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (0, 0); lcd.print (""); lcd.setCursor (5, 0); lcd.print (veces); minUpdate = DataTime [5]; }} void updateTemp () {DS1307.getDate (DataTime); if (DataTime [5]! = minUpdate) {sprintf (times, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.clear (); lcd.setCursor (5, 0); lcd.print (veces); lcd.setCursor (0, 1); lcd.print ("Temperatura:"); lcd.setCursor (14, 1); sensores.requestTemperaturas (); Float TempSensor = sensores.getTempCByIndex (0); lcd.print (TempSensor); minUpdate = DataTime [5]; }} void setup () {Serial.begin (9600); DS1307.begin (); sensores.begin (); pinMode (pinoSS, SALIDA); // Declara pinoSS como saída Wire.begin (); // Inicializacao da Comunicacao I2C lcd.init (); // Inicializacao do LCD lcd.backlight (); lcd.setCursor (3, 0); lcd.print ("Sistema de temperatura"); lcd.setCursor (3, 1); lcd.print ("Registrador de datos"); retraso (2000); // Localiza e mostra enderecos dos sensores Serial.println ("Localizando sensores DS18B20…"); Serial.print ("¡Localización del sensor con éxito!"); Serial.print (sensores.getDeviceCount (), DEC); Serial.println ("Sensor"); if (SD.begin ()) {// Inicializa o SD Card Serial.println ("SD Card pronto para uso."); // Imprime na tela} else {Serial.println ("Falha na inicialização do SD Card."); regreso; } DS1307.getDate (DataTime); lcd.clear (); sprintf (tiempos, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 0); lcd.print (veces); lcd.setCursor (0, 1); impresión lcd ("1-M 2-H 3-O / P"); } bucle vacío () {updateHour (); // Leyendo los estados del botón medir = digitalRead (Buttonmeasure); adjusthour = digitalRead (Buttonadjusthour); ok = digitalRead (Buttonok); if (medida == 0 && estado_medida == 1) {estado_medida = 0; } if (medida == 1 && estado_medida == 0 && proceso_medida == 0) {proceso_medida = 1; estado_medida = 1; if (SD.exists ("temp.txt")) {Serial.println ("Apagou o arquivo anterior!"); SD.remove ("temp.txt"); myFile = SD.open ("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt Serial.println ("¡Criou o arquivo!"); } else {Serial.println ("¡Criou o arquivo!"); myFile = SD.open ("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt myFile.close (); } retraso (500); myFile.print ("Hora:"); myFile.println ("Temperatura"); DS1307.getDate (DataTime); actualMin = previousMin = DataTime [5]; sprintf (tiempos, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.clear (); lcd.setCursor (5, 0); lcd.print (veces); lcd.setCursor (0, 1); lcd.print ("Temperatura:"); lcd.setCursor (14, 1); sensores.requestTemperaturas (); Float TempSensor = sensores.getTempCByIndex (0); lcd.print (TempSensor); } si (adjusthour == 0 && adjusthour_state == 1) {adjusthour_state = 0; } if (adjusthour == 1 && adjusthour_state == 0 && medir_proceso == 0) {ajustar_proceso = 1; } // ----------------------------------------------- --- Proceso de medición --------------------------------------------- -------------- if (medida_proceso == 1) {updateTemp (); byte contMin = 0, contHour = 0; DS1307.getDate (DataTime); actualMin = DataTime [5]; // ------------------------------------------------ --------- Contar minutos --------------------------------------- ------------------- if (actualMin! = previousMin) {contMin ++; previousMin = actualMin; } if (contMin == 5) {sprintf (veces, "% 02d:% 02d", DataTime [4], DataTime [5]); sensores.requestTemperaturas (); Float TempSensor = sensores.getTempCByIndex (0); myFile.print (veces); myFile.println (TempSensor); contMin = 0; } // ----------------------------------------------- ------------ Contar horas ------------------------------------ ---------------------- if (hora actual! = hora anterior) {contHour ++; previousHour = actualHour; } if (contHour == 5) {myFile.close (); lcd.clear (); lcd.setCursor (5, 0); lcd.print ("Finalizado"); lcd.setCursor (5, 1); lcd.print ("Proceso"); medir_proceso = 0; contHour = 0; } // ---------------------------------------------- Condición para detener el registrador de datos ---------------------------------------------- ---- if (ok == 1) {myFile.close (); lcd.clear (); lcd.setCursor (6, 0); lcd.print ("Detenido"); lcd.setCursor (5, 1); lcd.print ("Proceso"); medir_proceso = 0; retraso (2000); lcd.clear (); DS1307.getDate (DataTime); sprintf (tiempos, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 0); lcd.print (veces); lcd.setCursor (0, 1); impresión lcd ("1-M 2-H 3-O / P"); }} // ---------------------------------------------- ------- Ajustar horas ----------------------------------------- ---------------------- // Ajustar la hora if (Adjust_process == 1) {lcd.clear (); DS1307.getDate (DataTime); lcd.setCursor (0, 0); lcd.print ("Ajustar hora:"); sprintf (tiempos, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (veces); // Ajuste de la hora do {medir = digitalRead (Buttonmeasure); adjusthour = digitalRead (Buttonadjusthour); ok = digitalRead (Buttonok); if (medida == 0 && estado_medida == 1) {estado_medida = 0; } if (medida == 1 && estado_medida == 0) {DataTime [4] ++; si (DataTime [4]> 23) {DataTime [4] = 0; } estado_medida = 1; sprintf (tiempos, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (veces); DS1307.setDate (DataTime [0], DataTime [1], DataTime [2], DataTime [3], DataTime [4], DataTime [5], 00); } si (adjusthour == 0 && adjusthour_state == 1) {adjusthour_state = 0; } if (adjusthour == 1 && adjusthour_state == 0) {DataTime [5] ++; si (DataTime [5]> 59) {DataTime [5] = 0; } sprintf (tiempos, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (veces); DS1307.setDate (DataTime [0], DataTime [1], DataTime [2], DataTime [3], DataTime [4], DataTime [5], 00); adjusthour_state = 1; } if (ok == 1) {lcd.clear (); DS1307.getDate (DataTime); sprintf (tiempos, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (0, 0); lcd.print (veces); lcd.setCursor (0, 1); impresión en lcd ("1-M 2-H 3-O"); ajustar_proceso = 0; }} while (ok! = 1); } // ----------------------------------------------- ------- Hora de fin de ajuste ---------------------------------------- -------------------}

Primero, definimos todas las librerías para controlar los módulos y declarar las variables utilizadas al programar el Datalogger JLCPCB con un sensor de temperatura para Arduino. El bloque de código se muestra a continuación.

Paso 3:

#include // Biblioteca con todas las funciones del sensor DS18B20

#include #include // Biblioteca I2C do LCD 16x2 #include // Biblioteca de Comunicacao I2C #include // Biblioteca OneWire para el sensor DS18B20 #include #include LiquidCrystal_I2C lcd (0x27, 16, 2); // Configurando o endereco do LCD 16x2 para 0x27 #define ONE_WIRE_BUS 8 // Pin digital para conectar el sensor DS18B20 // Definir uma instancia do oneWire para comunicacao com o sensor OneWire oneWire (ONE_WIRE_BUS); Sensores de temperatura de Dallas (y oneWire); DeviceAddress sensor1; Archivo myFile; #define Buttonmeasure 2 #define Buttonadjusthour 3 #define Buttonok 4 bool meter = 0, adjusthour = 0, ok = 0; bool estado_medida = 0, estado_ajuste = 0, estado_correcto = 0; bool proceso_medida = 0, proceso_ajuste = 0; byte actualMin = 0, previousMin = 0; byte hora actual = 0, hora anterior = 0; byte minUpdate = 0; int pinoSS = 10; // Pin 53 para Mega / Pin 10 para UNO int DataTime [7];

De ahora en adelante, tenemos la función de configuración vacía. Esta función se utiliza para configurar los pines y la inicialización del dispositivo, como se muestra a continuación.

configuración vacía ()

{Serial.begin (9600); DS1307.begin (); sensores.begin (); pinMode (pinoSS, SALIDA); // Declara pinoSS como saída Wire.begin (); // Inicializacao da Comunicacao I2C lcd.init (); // Inicializacao do LCD lcd.backlight (); lcd.setCursor (3, 0); lcd.print ("Sistema de temperatura"); lcd.setCursor (3, 1); lcd.print ("Registrador de datos"); retraso (2000); // Localiza e mostra enderecos dos sensores Serial.println ("Localizando sensores DS18B20…"); Serial.print ("¡Localización del sensor con éxito!"); Serial.print (sensores.getDeviceCount (), DEC); Serial.println ("Sensor"); if (SD.begin ()) {// Inicializa o SD Card Serial.println ("SD Card pronto para uso."); // Imprime na tela} else {Serial.println ("Falha na inicialização do SD Card."); regreso; } DS1307.getDate (DataTime); lcd.clear (); sprintf (tiempos, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 0); lcd.print (veces); lcd.setCursor (0, 1); impresión en lcd ("1-M 2-H 3-O / P"); }

Primero se inició la comunicación serial, el reloj en tiempo real y el sensor de temperatura para Arduino DS18B20, luego de inicializar y probar los dispositivos, se imprimió el mensaje con las opciones del menú en la pantalla LCD 16x2. Esta pantalla se muestra en la Figura 1.

Paso 4:

Después de eso, el sistema lee las horas y actualiza el valor llamando a la función updateHour. Por tanto, esta función tiene como finalidad presentar el valor horario cada minuto. El bloque de código de función se muestra a continuación.

void updateHour ()

{DS1307.getDate (DataTime); if (DataTime [5]! = minUpdate) {sprintf (times, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (0, 0); lcd.print (""); lcd.setCursor (5, 0); lcd.print (veces); minUpdate = DataTime [5]; }}

Paso 5:

Además de actualizar las horas, el usuario puede seleccionar uno de los tres botones para monitorear al paciente con un sensor de temperatura con Arduino. El circuito se muestra en la Figura anterior.

Paso 6: Menú de control del registrador de datos JLCPCB

Primero, el usuario debe verificar y ajustar las horas del sistema. Este proceso se realiza cuando se presiona el segundo botón.

Cuando se presiona el botón, debería aparecer la siguiente pantalla, que se muestra en la Figura anterior.

Paso 7:

Desde esta pantalla, el usuario podrá ingresar los valores de horas y minutos desde los botones conectados a los pines digitales 2 y 3 del Arduino. Los botones se muestran en la Figura anterior.

La parte del código para controlar las horas se muestra a continuación.

si (adjusthour == 0 && adjusthour_state == 1)

{adjusthour_state = 0; } if (adjusthour == 1 && adjusthour_state == 0 && medir_proceso == 0) {ajustar_proceso = 1; }

Cuando se presiona el botón de horas y la variable medir_proceso se establece en 0, la condición será verdadera y la variable ajustar_proceso se establecerá en 1. La variable medir_proceso se usa para señalar que el sistema está monitoreando la temperatura. Cuando su valor es 0, el sistema permitirá al usuario ingresar al menú de configuración de la hora. Por lo tanto, después de que la variable adjust_process reciba un valor de 1, el sistema ingresará la condición de ajuste de tiempo. Este bloque de código se muestra a continuación.

// ------------------------------------------------ ----- Ajustar horas ------------------------------------------- --------------------

// Ajustar la hora if (ajustar_proceso == 1) {lcd.clear (); DS1307.getDate (DataTime); lcd.setCursor (0, 0); lcd.print ("Ajustar hora:"); sprintf (tiempos, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (veces); // Ajuste de la hora do {medir = digitalRead (Buttonmeasure); adjusthour = digitalRead (Buttonadjusthour); ok = digitalRead (Buttonok); if (medida == 0 && estado_medida == 1) {estado_medida = 0; } if (medida == 1 && estado_medida == 0) {DataTime [4] ++; si (DataTime [4]> 23) {DataTime [4] = 0; } estado_medida = 1; sprintf (tiempos, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (veces); DS1307.setDate (DataTime [0], DataTime [1], DataTime [2], DataTime [3], DataTime [4], DataTime [5], 00); } si (adjusthour == 0 && adjusthour_state == 1) {adjusthour_state = 0; } if (adjusthour == 1 && adjusthour_state == 0) {DataTime [5] ++; si (DataTime [5]> 59) {DataTime [5] = 0; } sprintf (tiempos, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (veces); DS1307.setDate (DataTime [0], DataTime [1], DataTime [2], DataTime [3], DataTime [4], DataTime [5], 00); adjusthour_state = 1; } if (ok == 1) {lcd.clear (); DS1307.getDate (DataTime); sprintf (tiempos, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (0, 0); lcd.print (veces); lcd.setCursor (0, 1); impresión en lcd ("1-M 2-H 3-O"); ajustar_proceso = 0; }} while (ok! = 1); }

En esta condición, el sistema mostrará el mensaje que se muestra en la Figura 4 y luego esperará a que los valores se ajusten internamente en el bucle while. Al ajustar las horas, estos botones tienen sus funciones cambiadas, es decir, son multifunción.

Esto le permite utilizar un botón para más de una función y reducir la complejidad del sistema.

De esta forma, el usuario ajustará el valor de las horas y minutos y luego guardará los datos en el sistema cuando se presione el botón Ok.

Como puede ver, el sistema leerá los 3 botones, como se muestra a continuación.

medir = digitalRead (Buttonmeasure);

adjusthour = digitalRead (Buttonadjusthour); ok = digitalRead (Buttonok);

Tenga en cuenta que el botón de medición (Buttonmeasure) ha cambiado de función. Ahora se utilizará para ajustar los valores de las horas, como se muestra a continuación. Las siguientes dos condiciones son similares y se utilizan para ajustar las horas y los minutos, como se muestra arriba.

si (medida == 0 && estado_medida == 1)

{estado_medida = 0; } if (medida == 1 && estado_medida == 0) {DataTime [4] ++; si (DataTime [4]> 23) {DataTime [4] = 0; } estado_medida = 1; sprintf (tiempos, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (veces); DS1307.setDate (DataTime [0], DataTime [1], DataTime [2], DataTime [3], DataTime [4], DataTime [5], 00); } si (adjusthour == 0 && adjusthour_state == 1) {adjusthour_state = 0; } if (adjusthour == 1 && adjusthour_state == 0) {DataTime [5] ++; si (DataTime [5]> 59) {DataTime [5] = 0; } sprintf (tiempos, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (veces); DS1307.setDate (DataTime [0], DataTime [1], DataTime [2], DataTime [3], DataTime [4], DataTime [5], 00); adjusthour_state = 1; }

Por lo tanto, cada vez que se presione uno de los dos botones, se cambiará el valor de las posiciones 4 y 5 del vector DataTime y, en segundo lugar, estos valores se guardarán en la memoria del DS1307.

Después de los ajustes, el usuario debe hacer clic en el botón Aceptar para finalizar el proceso. Cuando ocurre este evento, el sistema ejecutará las siguientes líneas de código.

si (ok == 1)

{lcd.clear (); DS1307.getDate (DataTime); sprintf (tiempos, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (0, 0); lcd.print (veces); lcd.setCursor (0, 1); impresión en lcd ("1-M 2-H 3-O"); ajustar_proceso = 0; }

Ingresará a la condición anterior y presentará el mensaje de la hora y el menú de opciones al usuario.

Finalmente, el usuario debe iniciar el proceso de monitoreo del paciente a través del sensor de temperatura con Arduino JLCPCB Datalogger.

Para hacer esto, el usuario debe presionar el botón de medición, que está conectado al pin digital 2.

Luego, el sistema realizará la lectura con el sensor de temperatura para Arduino y la guardará en la tarjeta de memoria. La región del circuito se muestra en la Figura anterior.

Paso 8:

Por lo tanto, cuando se presiona el botón, se ejecutará la siguiente parte del código.

si (medida == 0 && estado_medida == 1)

{estado_medida = 0; } if (medida == 1 && estado_medida == 0 && proceso_medida == 0) {proceso_medida = 1; estado_medida = 1; if (SD.exists ("temp.txt")) {Serial.println ("Apagou o arquivo anterior!"); SD.remove ("temp.txt"); myFile = SD.open ("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt Serial.println ("¡Criou o arquivo!"); } else {Serial.println ("¡Criou o arquivo!"); myFile = SD.open ("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt myFile.close (); } retraso (500); myFile.print ("Hora:"); myFile.println ("Temperatura"); DS1307.getDate (DataTime); actualMin = previousMin = DataTime [5]; sprintf (tiempos, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.clear (); lcd.setCursor (5, 0); lcd.print (veces); lcd.setCursor (0, 1); lcd.print ("Temperatura:"); lcd.setCursor (14, 1); sensores.requestTemperaturas (); Float TempSensor = sensores.getTempCByIndex (0); lcd.print (TempSensor); }

En la parte de código anterior, el sistema asignará un valor de 1 a la variable medida_proceso. Es responsable de permitir que los datos se guarden en la tarjeta SD.

Además, el sistema comprobará si existe o no un archivo de texto con un registro de datos. Si hay un archivo, el sistema lo eliminará y creará uno nuevo para almacenar los datos.

Después de eso, creará dos columnas: una para las horas y otra para la temperatura dentro del archivo de texto.

Después de eso, mostrará las horas y la temperatura en la pantalla LCD, como se muestra en la Figura anterior.

Después de eso, el flujo de código ejecutará el siguiente bloque de programa.

si (medida_proceso == 1)

{updateTemp (); byte contMin = 0, contHour = 0; DS1307.getDate (DataTime); actualMin = DataTime [5]; // ------------------------------------------------ --------- Contar minutos --------------------------------------- ------------------- if (actualMin! = previousMin) {contMin ++; previousMin = actualMin; } if (contMin == 5) {sprintf (veces, "% 02d:% 02d", DataTime [4], DataTime [5]); sensores.requestTemperaturas (); Float TempSensor = sensores.getTempCByIndex (0); myFile.print (veces); myFile.println (TempSensor); contMin = 0; } // ----------------------------------------------- ------------ Contar horas ------------------------------------ ---------------------- if (hora actual! = hora anterior) {contHour ++; previousHour = actualHour; } if (contHour == 5) {myFile.close (); lcd.clear (); lcd.setCursor (5, 0); lcd.print ("Finalizado"); lcd.setCursor (5, 1); lcd.print ("Proceso"); medir_proceso = 0; contHour = 0; } // ---------------------------------------------- Condición para detener el registrador de datos -----

Primero, se ejecutará la función updateTemp (). Es similar a la función updateHour (); sin embargo, muestra la temperatura cada 1 minuto.

Después de eso, el sistema recopilará los datos de tiempo del reloj en tiempo real y almacenará el valor de los minutos actuales en la variable currentMin.

Luego, verificará si se ha cambiado la variable mínima, de acuerdo con la condición que se presenta a continuación

si (actualMin! = previousMin)

{contMin ++; previousMin = actualMin; }

Por lo tanto, si la variable de minutos actual es diferente al valor anterior, significa que se ha producido un cambio en el valor, de esta manera la condición será verdadera y se incrementará el valor de la cuenta de minutos (contMin) y el valor actual será asignado a la variable previousMin, para almacenar su valor anterior.

Por lo tanto, cuando el valor de este recuento es igual a 5, significa que han pasado 5 minutos y el sistema debe realizar una nueva lectura de temperatura y guardar el valor de hora y temperatura en el archivo de registro de la tarjeta SD.

si (contMin == 5)

{sprintf (tiempos, "% 02d:% 02d", DataTime [4], DataTime [5]); sensores.requestTemperaturas (); Float TempSensor = sensores.getTempCByIndex (0); myFile.print (veces); myFile.println (TempSensor); contMin = 0; }

De esta forma, este proceso se repetirá hasta alcanzar el valor de 5 horas de monitorización de la temperatura del paciente con el sensor de temperatura con Arduino.

La parte del código se muestra a continuación y es similar al recuento de minutos, que se presentó arriba.

// ------------------------------------------------ ----------- Contar horas ------------------------------------- ---------------------

if (hora actual! = hora anterior) {contHour ++; previousHour = actualHour; } if (contHour == 5) {myFile.close (); lcd.clear (); lcd.setCursor (5, 0); lcd.print ("Finalizado"); lcd.setCursor (5, 1); lcd.print ("Proceso"); medir_proceso = 0; contHour = 0; }

Después de alcanzar las 5 horas de monitoreo, el sistema cerrará el archivo de registro y presentará el mensaje "Proceso terminado" al usuario.

Además, el usuario puede presionar el botón Ok / Pause para detener la grabación de datos. Cuando esto ocurre, se ejecutará el siguiente bloque de código.

// ---------------------------------------------- Condición para detener el registrador de datos ----------------------------------------------- ---

if (ok == 1) {myFile.close (); lcd.clear (); lcd.setCursor (6, 0); lcd.print ("Detenido"); lcd.setCursor (5, 1); lcd.print ("Proceso"); medir_proceso = 0; retraso (2000); lcd.clear (); DS1307.getDate (DataTime); sprintf (tiempos, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 0); lcd.print (veces); lcd.setCursor (0, 1); impresión en lcd ("1-M 2-H 3-O / P"); }

Paso 9:

Luego, el sistema cerrará el archivo y presentará el mensaje "Proceso detenido", como se muestra en la Figura 8.

Paso 10:

Después de eso, el sistema imprimirá la pantalla de tiempo y las opciones del menú, como se muestra en la Figura 9.

Paso 11: Acceder a los datos del módulo de la tarjeta SD con Arduino

Luego del proceso de monitoreo del Datalogger JLCPCB con el sensor de temperatura con Arduino, es necesario retirar la tarjeta de memoria y acceder a los datos en la computadora.

Para visualizar y analizar los datos con mejor calidad, exporta / copia toda la información del archivo de texto a Excel, luego puedes trazar gráficos y analizar los resultados obtenidos.

Paso 12: Conclusión

El Datalogger JLCPCB con sensor de temperatura con Arduino nos permite, además de medir la temperatura, registrar información sobre el comportamiento de la temperatura del paciente durante un período de tiempo.

Con estos datos almacenados, es posible analizar y comprender cómo se comporta la temperatura del paciente infectado por COVID 19.

Además, es posible evaluar el nivel de temperatura y asociar su valor con la aplicación de algún tipo de medicación.

Por tanto, a través de estos datos, el Datalogger JLCPCB con sensor de temperatura para Arduino tiene como objetivo ayudar a los médicos y enfermeras en el estudio del comportamiento de los pacientes.

Finalmente, agradecemos a la empresa JLCPCB por apoyar el desarrollo del proyecto y esperamos que puedas utilizarlo

Todos los archivos pueden ser descargados y utilizados libremente por cualquier usuario.