Sensor de temperatura para Arduino aplicado para COVID 19: 12 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

O sensor de temperatura do Arduino é um elemento fundamental quando queremos medir a temperatura de um processador do corpo humano.

O sensor de temperatura com Arduino deve estar em contato ou próximo para receber e medir o nível de calor. É assim que os termômetros funcionam.

Esses aparelhos são extremamente utilizados para medir a temperatura corporal de pessoas enfermas, pois a temperatura é um dos primeiros fatores que se alteram no corpo humano quando ocorre uma anomalia ou doença.

Uma das doenças que alteram a temperatura do corpo humano é a COVID 19. Portanto, apresentamos os principais sintomas:

Tosse Cansaço Dificuldade respiratória (casos graves) Febre A febre é um sintoma cuja principal característica é o aumento da temperatura corporal. Nesta doença, precisamos monitorar constantemente esses sintomas.

Assim, desenvolveremos um projeto para monitorar a temperatura e armazenar esses dados em um cartão de memória através de um Datalogger JLCPCB utilizando um sensor de temperatura com Arduino.

Portanto, neste artigo você aprenderá:

• Como funciona um Datalogger JLCPCB com sensor de temperatura com Arduino?
• Como funciona o sensor de temperatura com o Arduino.
• Como funciona o sensor de temperatura DS18B20 com Arduino
• Use botões com várias funções.

A seguir, mostraremos como você desenvolverá seu registrador de dados JLCPCB usando o sensor de temperatura Arduino.

Suprimentos

Arduino UNO

Placa de circuito impresso JLCPCB

Sensor de Temperatura DS18B20

Arduino Nano R3

Jumpers

Display LCD 16 x 2

Pressionar no interruptor

Resistor 1kR

Módulo de cartão SD para Arduino

Etapa 1: construção do registrador de dados JLCPCB com sensor de temperatura com Arduino

Conforme mencionado anteriormente, o projeto consiste na criação de um Datalogger JLCPCB com Sensor de Temperatura com Arduino, e através desses dados, podemos monitorar a temperatura do paciente em tratamento.

Assim, o circuito é mostrado na Figura acima.

Portanto, como você pode ver, este circuito possui um sensor de temperatura DS18B20 com Arduino, que é responsável por medir a leitura de temperatura do paciente.

Além disso, o Arduino Nano será responsável por coletar esses dados e armazená-los no cartão de memória do Módulo SD Card.

Cada informação será salva com seu respectivo horário, que será lido a partir do Módulo RTC DS1307.

Assim, para que os dados do sensor de temperatura com Arduino sejam salvos, o usuário deve realizar o processo através do Menu de Controle com o LCD 16x2.

Passo 2:

Cada botão é responsável por controlar uma opção, conforme mostrado na tela LCD 16x2 na Figura 2.

Cada opção é responsável por realizar uma função no sistema, conforme mostrado a seguir.

• A opção M é responsável por iniciar a medição e registro dos dados no cartão de memória.
• A opção H é responsável por ajustar as horas do sistema.
• A opção O / P é usada para confirmar a entrada de dados no sistema ou para pausar a gravação de dados no cartão de memória.

Para entender o processo de controle do sistema, forneceremos o código abaixo e discutiremos o sistema de controle passo a passo do registrador de dados JLCPCB com sensor de temperatura com Arduino.

#include // Biblioteca com todas as funções do sensor DS18B20

#include #include // Biblioteca I2C do LCD 16x2 #include // Biblioteca de Comunicacao I2C #include // Biblioteca OneWire para Sensor DS18B20 #include #include LiquidCrystal_I2C lcd (0x27, 16, 2); // Configurando o endereco do LCD 16x2 para 0x27 #define ONE_WIRE_BUS 8 // Pino digital para conectar o sensor DS18B20 // Definir uma instancia do oneWire para comunicacao com o sensor OneWire oneWire (ONE_WIRE_BUS); Sensores de temperatura Dallas (& oneWire); DeviceAddress sensor1; Arquivo meuArquivo; #define Buttonmeasure 2 #define Buttonadjusthour 3 #define Buttonok 4 bool measure = 0, adjusthour = 0, ok = 0; bool measure_state = 0, adjusthour_state = 0, ok_state = 0; bool medido_processo = 0, ajuste_processo = 0; byte actualMin = 0, previousMin = 0; byte actualHour = 0, previousHour = 0; byte minUpdate = 0; pinoSS interno = 10; // Pino 53 para Mega / Pino 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 (vezes); 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 (vezes); lcd.setCursor (0, 1); lcd.print ("Temperatura:"); lcd.setCursor (14, 1); sensores.requestTemperatures (); float TempSensor = sensores.getTempCByIndex (0); lcd.print (TempSensor); minUpdate = DataTime [5]; }} void setup () {Serial.begin (9600); DS1307.begin (); sensores.begin (); pinMode (pinoSS, OUTPUT); // 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 temporário"); lcd.setCursor (3, 1); lcd.print ("Datalogger"); atraso (2000); // Localiza e mostra enderecos dos sensores Serial.println ("Localizando sensores DS18B20…"); Serial.print ("Localização do sensor com sucesso!"); 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 cartão SD."); Retorna; } DS1307.getDate (DataTime); lcd.clear (); sprintf (vezes, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 0); lcd.print (vezes); lcd.setCursor (0, 1); lcd.print ("1-M 2-H 3-O / P"); } void loop () {updateHour (); // Lendo os estados do botão measure = digitalRead (Buttonmeasure); adjusthour = digitalRead (Buttonadjusthour); ok = digitalRead (Buttonok); if (medida == 0 && medida_estado == 1) {medida_estado = 0; } if (measure == 1 && measure_state == 0 && measure_process == 0) {measure_process = 1; medida_estado = 1; if (SD.exists ("temp.txt")) {Serial.println ("Apagou o arquivo anterior!"); SD.remove ("temp.txt"); meuArquivo = SD.open ("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt Serial.println ("Criou o arquivo!"); } else {Serial.println ("Criou o arquivo!"); meuArquivo = SD.open ("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt myFile.close (); } atraso (500); meuArquivo.print ("Hora:"); meuArquivo.println ("Temperatura"); DS1307.getDate (DataTime); actualMin = previousMin = DataTime [5]; sprintf (vezes, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.clear (); lcd.setCursor (5, 0); lcd.print (vezes); lcd.setCursor (0, 1); lcd.print ("Temperatura:"); lcd.setCursor (14, 1); sensores.requestTemperatures (); float TempSensor = sensores.getTempCByIndex (0); lcd.print (TempSensor); } if (adjusthour == 0 && adjusthour_state == 1) {adjusthour_state = 0; } if (adjusthour == 1 && adjusthour_state == 0 && measure_process == 0) {Adjust_process = 1; } // ----------------------------------------------- --- Processo de Medição --------------------------------------------- -------------- if (measure_process == 1) {updateTemp (); byte contMin = 0, contHour = 0; DS1307.getDate (DataTime); actualMin = DataTime [5]; // ------------------------------------------------ --------- Contagem de minutos --------------------------------------- ------------------- if (actualMin! = previousMin) {contMin ++; previousMin = actualMin; } if (contMin == 5) {sprintf (vezes, "% 02d:% 02d", DataTime [4], DataTime [5]); sensores.requestTemperatures (); float TempSensor = sensores.getTempCByIndex (0); meuArquivo.print (vezes); meuArquivo.println (TempSensor); contMin = 0; } // ----------------------------------------------- ------------ Contar horas ------------------------------------ ---------------------- if (actualHour! = previousHour) {contHour ++; previousHour = actualHour; } if (contHour == 5) {myFile.close (); lcd.clear (); lcd.setCursor (5, 0); lcd.print ("Concluído"); lcd.setCursor (5, 1); lcd.print ("Processo"); medida_processo = 0; contHour = 0; } //----------------------------------------------Doença para parar o datalogger ---------------------------------------------- ---- if (ok == 1) {meuArquivo.close (); lcd.clear (); lcd.setCursor (6, 0); lcd.print ("Parado"); lcd.setCursor (5, 1); lcd.print ("Processo"); medida_processo = 0; atraso (2000); lcd.clear (); DS1307.getDate (DataTime); sprintf (vezes, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 0); lcd.print (vezes); lcd.setCursor (0, 1); lcd.print ("1-M 2-H 3-O / P"); }} // ---------------------------------------------- ------- Ajustar Horário ----------------------------------------- ---------------------- // Ajustar hora se (ajustar_processo == 1) {lcd.clear (); DS1307.getDate (DataTime); lcd.setCursor (0, 0); lcd.print ("Ajustar hora:"); sprintf (vezes, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (vezes); // Ajuste de hora do {measure = digitalRead (Buttonmeasure); adjusthour = digitalRead (Buttonadjusthour); ok = digitalRead (Buttonok); if (medida == 0 && medida_estado == 1) {medida_estado = 0; } if (measure == 1 && measure_state == 0) {DataTime [4] ++; if (DataTime [4]> 23) {DataTime [4] = 0; } medida_estado = 1; sprintf (vezes, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (vezes); DS1307.setDate (DataTime [0], DataTime [1], DataTime [2], DataTime [3], DataTime [4], DataTime [5], 00); } if (adjusthour == 0 && adjusthour_state == 1) {adjusthour_state = 0; } if (adjusthour == 1 && adjusthour_state == 0) {DataTime [5] ++; if (DataTime [5]> 59) {DataTime [5] = 0; } sprintf (vezes, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (vezes); 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 (vezes, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (0, 0); lcd.print (vezes); lcd.setCursor (0, 1); lcd.print ("1-M 2-H 3-O"); ajustar_processo = 0; }} enquanto (ok! = 1); } // ----------------------------------------------- ------- Hora de ajuste final ---------------------------------------- -------------------}

Primeiro, definimos todas as bibliotecas para controlar os módulos e declarar as variáveis usadas na programação do JLCPCB Datalogger com um sensor de temperatura para Arduino. O bloco de código é mostrado abaixo.

Etapa 3:

#include // Biblioteca com todas as funções do sensor DS18B20

#include #include // Biblioteca I2C do LCD 16x2 #include // Biblioteca de Comunicacao I2C #include // Biblioteca OneWire para Sensor DS18B20 #include #include LiquidCrystal_I2C lcd (0x27, 16, 2); // Configurando o endereco do LCD 16x2 para 0x27 #define ONE_WIRE_BUS 8 // Pino digital para conectar o sensor DS18B20 // Definir uma instancia do oneWire para comunicacao com o sensor OneWire oneWire (ONE_WIRE_BUS); Sensores de temperatura Dallas (& oneWire); DeviceAddress sensor1; Arquivo meuArquivo; #define Buttonmeasure 2 #define Buttonadjusthour 3 #define Buttonok 4 bool measure = 0, adjusthour = 0, ok = 0; bool measure_state = 0, adjusthour_state = 0, ok_state = 0; bool medido_processo = 0, ajuste_processo = 0; byte actualMin = 0, previousMin = 0; byte actualHour = 0, previousHour = 0; byte minUpdate = 0; pinoSS int = 10; // Pino 53 para Mega / Pino 10 para UNO int DataTime [7];

Doravante, temos a função de configuração de vazio. Esta função é usada para configurar os pinos e a inicialização do dispositivo, conforme mostrado abaixo.

void setup ()

{Serial.begin (9600); DS1307.begin (); sensores.begin (); pinMode (pinoSS, OUTPUT); // 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 temporário"); lcd.setCursor (3, 1); lcd.print ("Datalogger"); atraso (2000); // Localiza e mostra enderecos dos sensores Serial.println ("Localizando sensores DS18B20…"); Serial.print ("Localização do sensor com sucesso!"); 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 cartão SD."); Retorna; } DS1307.getDate (DataTime); lcd.clear (); sprintf (vezes, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 0); lcd.print (vezes); lcd.setCursor (0, 1); lcd.print ("1-M 2-H 3-O / P"); }

Primeiramente, foi iniciada a comunicação serial, o relógio em tempo real e o sensor de temperatura do Arduino DS18B20. Após inicializar e testar os dispositivos, a mensagem com as opções do menu foi impressa na tela LCD 16x2. Esta tela é mostrada na Figura 1.

Passo 4:

Depois disso, o sistema lê as horas e atualiza o valor chamando a função updateHour. Assim, esta função tem por objetivo apresentar o valor horário a cada minuto. O bloco de código de função é mostrado abaixo.

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 (vezes); minUpdate = DataTime [5]; }}

Etapa 5:

Além de atualizar o horário, o usuário pode selecionar um dos três botões para monitorar o paciente com sensor de temperatura com Arduino. O circuito é mostrado na Figura acima.

Etapa 6: Menu de controle do registrador de dados JLCPCB

Primeiro, o usuário deve verificar e ajustar as horas do sistema. Este processo é executado quando o segundo botão é pressionado.

Quando o botão é pressionado, a seguinte tela deve aparecer, que é mostrada na Figura acima.

Etapa 7:

Nessa tela, o usuário poderá inserir os valores de hora e minuto a partir dos botões conectados aos pinos digitais 2 e 3 do Arduino. Os botões são mostrados na Figura acima.

A parte do código para controlar as horas é mostrada abaixo.

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

{adjusthour_state = 0; } if (adjusthour == 1 && adjusthour_state == 0 && measure_process == 0) {Adjust_process = 1; }

Quando o botão de horas é pressionado e a variável measure_process é definida como 0, a condição será verdadeira e a variável optimize_process será definida como 1. A variável measure_process é usada para sinalizar que o sistema está monitorando a temperatura. Quando seu valor for 0, o sistema permitirá que o usuário entre no menu de configuração de tempo. Portanto, após a variável ajustar_processo receber o valor 1, o sistema entrará na condição de ajuste de tempo. Este bloco de código é mostrado abaixo.

// ------------------------------------------------ ----- Ajustar Horário ------------------------------------------- --------------------

// Ajustar hora if (ajustar_processo == 1) {lcd.clear (); DS1307.getDate (DataTime); lcd.setCursor (0, 0); lcd.print ("Ajustar hora:"); sprintf (vezes, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (vezes); // Ajuste de hora do {measure = digitalRead (Buttonmeasure); adjusthour = digitalRead (Buttonadjusthour); ok = digitalRead (Buttonok); if (medida == 0 && medida_estado == 1) {medida_estado = 0; } if (measure == 1 && measure_state == 0) {DataTime [4] ++; if (DataTime [4]> 23) {DataTime [4] = 0; } medida_estado = 1; sprintf (vezes, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (vezes); DS1307.setDate (DataTime [0], DataTime [1], DataTime [2], DataTime [3], DataTime [4], DataTime [5], 00); } if (adjusthour == 0 && adjusthour_state == 1) {adjusthour_state = 0; } if (adjusthour == 1 && adjusthour_state == 0) {DataTime [5] ++; if (DataTime [5]> 59) {DataTime [5] = 0; } sprintf (vezes, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (vezes); 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 (vezes, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (0, 0); lcd.print (vezes); lcd.setCursor (0, 1); lcd.print ("1-M 2-H 3-O"); ajustar_processo = 0; }} enquanto (ok! = 1); }

Nessa condição, o sistema exibirá a mensagem mostrada na Figura 4 e, em seguida, aguardará que os valores se ajustem internamente no loop while. Ao acertar as horas, esses botões têm suas funções alteradas, ou seja, são multifuncionais.

Isso permite que você use um botão para mais de uma função e reduz a complexidade do sistema.

Desta forma, o usuário irá ajustar o valor das horas e minutos e depois salvar os dados no sistema quando o botão Ok for pressionado.

Como você pode ver, o sistema irá ler os 3 botões, conforme mostrado abaixo.

medida = digitalRead (Buttonmeasure);

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

Observe que o botão de medição (Buttonmeasure) mudou sua função. Ele agora será usado para ajustar os valores das horas, conforme mostrado abaixo. As duas condições a seguir são semelhantes e são usadas para ajustar as horas e os minutos, conforme mostrado acima.

if (medida == 0 && medida_estado == 1)

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

Portanto, cada vez que um dos dois botões for pressionado, o valor das posições 4 e 5 do vetor DataTime será alterado e, em seguida, esses valores serão salvos na memória do DS1307.

Após os ajustes, o usuário deve clicar no botão Ok, para finalizar o processo. Quando esse evento ocorrer, o sistema executará as seguintes linhas de código.

if (ok == 1)

{lcd.clear (); DS1307.getDate (DataTime); sprintf (vezes, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (0, 0); lcd.print (vezes); lcd.setCursor (0, 1); lcd.print ("1-M 2-H 3-O"); ajustar_processo = 0; }

Ele entrará na condição acima e apresentará a mensagem de hora e o Menu de Opções ao usuário.

Finalmente, o usuário deve iniciar o processo de monitoramento do paciente através do sensor de temperatura com Arduino JLCPCB Datalogger.

Para fazer isso, o usuário deve pressionar o botão de medição, que está conectado ao pino digital 2.

Em seguida, o sistema fará a leitura com o sensor de temperatura do Arduino e salvará no cartão de memória. A região do circuito é mostrada na Figura acima.

Etapa 8:

Portanto, quando o botão é pressionado, a seguinte parte do código será executada.

if (medida == 0 && medida_estado == 1)

{medida_estado = 0; } if (measure == 1 && measure_state == 0 && measure_process == 0) {measure_process = 1; medida_estado = 1; if (SD.exists ("temp.txt")) {Serial.println ("Apagou o arquivo anterior!"); SD.remove ("temp.txt"); meuArquivo = SD.open ("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt Serial.println ("Criou o arquivo!"); } else {Serial.println ("Criou o arquivo!"); meuArquivo = SD.open ("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt myFile.close (); } atraso (500); meuArquivo.print ("Hora:"); meuArquivo.println ("Temperatura"); DS1307.getDate (DataTime); actualMin = previousMin = DataTime [5]; sprintf (vezes, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.clear (); lcd.setCursor (5, 0); lcd.print (vezes); lcd.setCursor (0, 1); lcd.print ("Temperatura:"); lcd.setCursor (14, 1); sensores.requestTemperatures (); float TempSensor = sensores.getTempCByIndex (0); lcd.print (TempSensor); }

Na parte do código acima, o sistema atribuirá um valor de 1 à variável measure_process. É responsável por permitir que os dados sejam salvos no cartão SD.

Além disso, o sistema verificará se existe ou não um arquivo de texto com registro de dados. Se houver um arquivo, o sistema apagará e criará um novo para armazenar os dados.

Depois disso, serão criadas duas colunas: uma para as horas e outra para a temperatura dentro do arquivo de texto.

Depois disso, ele irá mostrar as horas e a temperatura na tela LCD, conforme mostrado na Figura acima.

Depois disso, o fluxo de código executará o seguinte bloco de programa.

if (measure_process == 1)

{updateTemp (); byte contMin = 0, contHour = 0; DS1307.getDate (DataTime); actualMin = DataTime [5]; // ------------------------------------------------ --------- Contagem de minutos --------------------------------------- ------------------- if (actualMin! = previousMin) {contMin ++; previousMin = actualMin; } if (contMin == 5) {sprintf (vezes, "% 02d:% 02d", DataTime [4], DataTime [5]); sensores.requestTemperatures (); float TempSensor = sensores.getTempCByIndex (0); meuArquivo.print (vezes); meuArquivo.println (TempSensor); contMin = 0; } // ----------------------------------------------- ------------ Contar horas ------------------------------------ ---------------------- if (actualHour! = previousHour) {contHour ++; previousHour = actualHour; } if (contHour == 5) {myFile.close (); lcd.clear (); lcd.setCursor (5, 0); lcd.print ("Concluído"); lcd.setCursor (5, 1); lcd.print ("Processo"); medida_processo = 0; contHour = 0; } //----------------------------------------------Doença para parar o datalogger -----

Primeiro, a função updateTemp () será executada. É semelhante à função updateHour (); no entanto, ele exibe a temperatura a cada 1 minuto.

Depois disso, o sistema irá coletar os dados de tempo do Relógio em Tempo Real e armazenar o valor do minuto atual na variável currentMin.

Em seguida, irá verificar se a variável min foi alterada, conforme condição apresentada a seguir

if (actualMin! = previousMin)

{contMin ++; previousMin = actualMin; }

Portanto, se a variável do minuto atual for diferente do valor anterior, significa que ocorreu uma alteração no valor. Dessa forma, a condição será verdadeira e o valor da contagem dos minutos aumentará (contMin) e o valor atual será atribuído à variável previousMin, para armazenar seu valor anterior.

Portanto, quando o valor dessa contagem for igual a 5, significa que 5 minutos se passaram e o sistema deve realizar uma nova leitura de temperatura e salvar o valor da hora e da temperatura no arquivo de log do cartão SD.

if (contMin == 5)

{sprintf (vezes, "% 02d:% 02d", DataTime [4], DataTime [5]); sensores.requestTemperatures (); float TempSensor = sensores.getTempCByIndex (0); meuArquivo.print (vezes); meuArquivo.println (TempSensor); contMin = 0; }

Desta forma, este processo será repetido até atingir o valor de 5 horas de monitoramento da temperatura do paciente com o sensor de temperatura com Arduino.

A parte do código é mostrada abaixo e é semelhante à contagem de minutos apresentada acima.

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

if (actualHour! = previousHour) {contHour ++; previousHour = actualHour; } if (contHour == 5) {myFile.close (); lcd.clear (); lcd.setCursor (5, 0); lcd.print ("Concluído"); lcd.setCursor (5, 1); lcd.print ("Processo"); medida_processo = 0; contHour = 0; }

Após atingir 5 horas de monitoramento, o sistema fechará o arquivo de log e apresentará a mensagem “Processo Finalizado” ao usuário.

Além disso, o usuário pode pressionar o botão Ok / Pausa para interromper a gravação de dados. Quando isso ocorrer, o seguinte bloco de código será executado.

// ---------------------------------------------- Condição para pare o datalogger ----------------------------------------------- ---

if (ok == 1) {meuArquivo.close (); lcd.clear (); lcd.setCursor (6, 0); lcd.print ("Parado"); lcd.setCursor (5, 1); lcd.print ("Processo"); medida_processo = 0; atraso (2000); lcd.clear (); DS1307.getDate (DataTime); sprintf (vezes, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 0); lcd.print (vezes); lcd.setCursor (0, 1); lcd.print ("1-M 2-H 3-O / P"); }

Etapa 9:

Em seguida, o sistema fechará o arquivo e apresentará a mensagem "Processo Parado", conforme mostrado na Figura 8.

Etapa 10:

Depois disso, o sistema imprimirá a tela de horário e as opções de menu, conforme mostrado na Figura 9.

Etapa 11: Acesso aos dados do módulo do cartão SD com Arduino

Após o processo de monitoramento do Datalogger JLCPCB com o sensor de temperatura com Arduino, é necessário retirar o cartão de memória e acessar os dados no computador.

Para visualizar e analisar os dados com melhor qualidade, exporte / copie todas as informações do arquivo texto para o Excel. Depois disso, você pode plotar gráficos e analisar os resultados obtidos.

Etapa 12: Conclusão

O Datalogger JLCPCB com sensor de temperatura com Arduino nos permite, além de medir a temperatura, registrar informações sobre o comportamento da temperatura do paciente ao longo de um período de tempo.

Com esses dados armazenados, é possível analisar e compreender como se comporta a temperatura do paciente infectado pelo COVID 19.

Além disso, é possível avaliar o nível de temperatura e associar seu valor à aplicação de algum tipo de medicamento.

Portanto, por meio desses dados, o JLCPCB Datalogger com sensor de temperatura para Arduino visa auxiliar médicos e enfermeiros no estudo do comportamento de pacientes.

Por fim, agradecemos a empresa JLCPCB pelo apoio no desenvolvimento do projeto e esperamos que você possa utilizá-lo

Todos os arquivos podem ser baixados e usados livremente por qualquer usuário.