Sensore di temperatura per Arduino applicato per COVID 19: 12 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01

Il sensore di temperatura per Arduino è un elemento fondamentale quando si vuole misurare la temperatura di un processore del corpo umano.

Il sensore di temperatura con Arduino deve essere a contatto o vicino per ricevere e misurare il livello di calore. È così che funzionano i termometri.

Questi dispositivi sono estremamente utilizzati per misurare la temperatura corporea delle persone malate, poiché la temperatura è uno dei primi fattori che cambiano nel corpo umano quando si verifica un'anomalia o una malattia.

Una delle malattie che alterano la temperatura del corpo umano è il COVID 19. Pertanto, presentiamo i sintomi principali:

Tosse Stanchezza Difficoltà respiratorie (Casi gravi) Febbre La febbre è un sintomo la cui caratteristica principale è l'aumento della temperatura corporea. In questa malattia, dobbiamo monitorare costantemente questi sintomi.

Pertanto, svilupperemo un progetto per monitorare la temperatura e archiviare questi dati su una scheda di memoria tramite un Datalogger JLCPCB utilizzando un sensore di temperatura con Arduino.

Pertanto, in questo articolo imparerai:

• Come funziona un Datalogger JLCPCB con un sensore di temperatura con Arduino?
• Come funziona il sensore di temperatura con Arduino.
• Come funziona il sensore di temperatura DS18B20 con Arduino?
• Utilizzare pulsanti con più funzioni.

Successivamente, ti mostreremo come svilupperai il tuo Datalogger JLCPCB utilizzando il sensore di temperatura Arduino.

Forniture

Arduino UNO

Circuito stampato JLCPCB

Sensore di temperatura DS18B20

Arduino Nano R3

ponticelli

Display LCD 16 x 2

Interruttore a pulsante

Resistenza 1kR

Modulo scheda SD per Arduino

Fase 1: Costruzione del Datalogger JLCPCB con sensore di temperatura con Arduino

Come accennato in precedenza, il progetto consiste nel creare un Datalogger JLCPCB con Sensore di Temperatura con Arduino, e attraverso questi dati, possiamo monitorare la temperatura del paziente in cura.

Pertanto, il circuito è mostrato nella figura sopra.

Pertanto, come puoi vedere, questo circuito ha un sensore di temperatura DS18B20 con Arduino, che è responsabile della misurazione della lettura della temperatura del paziente.

Inoltre, Arduino Nano sarà responsabile della raccolta di questi dati e dell'archiviazione sulla scheda di memoria del modulo SD Card.

Ciascuna informazione verrà salvata con la rispettiva ora, che verrà letta dal Modulo RTC DS1307.

Pertanto, per salvare i dati del sensore di temperatura con Arduino, l'utente deve eseguire il processo tramite il menu di controllo con il display LCD 16x2.

Passo 2:

Ciascun pulsante è responsabile del controllo di un'opzione, come mostrato sullo schermo LCD 16x2 in Figura 2.

Ogni opzione è responsabile dell'esecuzione di una funzione nel sistema, come mostrato di seguito.

• L'opzione M è responsabile dell'avvio della misurazione e della registrazione dei dati sulla Memory Card.
• L'opzione H è responsabile della regolazione delle ore di sistema.
• L'opzione O/P viene utilizzata per confermare l'immissione dei dati nel sistema o per sospendere la scrittura dei dati sulla scheda di memoria.

Per comprendere il processo di controllo del sistema, forniremo il codice di seguito e discuteremo il sistema di controllo passo passo del Datalogger JLCPCB con sensore di temperatura con Arduino.

#include //Libreria con tutte le funzioni del sensore DS18B20

#include #include //Biblioteca I2C do LCD 16x2 #include //Biblioteca de Comunicacao I2C #include //Libreria OneWire per sensore DS18B20 #include #include LiquidCrystal_I2C lcd(0x27, 16, 2); // Configurando o endereco do LCD 16x2 para 0x27 #define ONE_WIRE_BUS 8 //Digital Pin per connettere il sensore DS18B20 //Definisci un'istanza do oneWire per comunicacao com o sensor OneWire oneWire(ONE_WIRE_BUS); DallasSensori di temperatura(&oneWire); DeviceAddress sensore1; File mioFile; #define Buttonmeasure 2 #define Buttonadjusthour 3 #define Buttonok 4 bool misura = 0, aggiustaora = 0, ok = 0; bool stato_misura = 0, stato_orario = 0, stato_ok = 0; bool processo_misura = 0, processo_regolabile = 0; byte Min attuale = 0, Min precedente = 0; byte ora attuale = 0, ora precedente = 0; byte minUpdate = 0; int pinoSS = 10; // Pin 53 per Mega / Pin 10 per 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(tempi); 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(tempi); lcd.setCursor(0, 1); lcd.print("Temperatura: "); lcd.setCursor(14, 1); sensori.requestTemperatures(); float TempSensor = sensor.getTempCByIndex(0); lcd.print(SensoreTemp); minUpdate = DataTime[5]; } } void setup() { Serial.begin(9600); DS1307.begin(); sensori.begin(); pinMode(pinoSS, OUTPUT); // Dichiara pinoSS come saída Wire.begin(); //Inicializacao da Comunicacao I2C lcd.init(); //Inicializacao do LCD lcd.backlight(); lcd.setCursor(3, 0); lcd.print("Sistema temporaneo"); lcd.setCursor(3, 1); lcd.print("Registratore dati"); ritardo (2000); // Localizza e mostra i sensori dei sensori Serial.println("Localizza i sensori DS18B20…"); Serial.print("Localizzazione sensore riuscita!"); Serial.print(sensors.getDeviceCount(), DEC); Serial.println("Sensore"); if(SD.begin()) { // Inicializa o SD Card Serial.println("SD Card pronto per l'uso."); // Stampa su tela } else { Serial.println("Falha na inicialização do SD Card."); Restituzione; } DS1307.getDate(DataTime); lcd.clear(); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 0); lcd.print(tempi); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O/P"); } void loop() { updateHour(); //Lettura degli stati del pulsante measure = digitalRead(Buttonmeasure); Adjusthour = digitalRead(Buttonadjusthour); ok = digitalRead(Buttonok); if(misura == 0 && stato_misura == 1) { stato_misura = 0; } if(misura == 1 && stato_misura == 0 && processo_misura == 0) { processo_misura = 1; stato_misura = 1; if (SD.exists("temp.txt")) { Serial.println("Apagou o arquivo anterior!"); SD.remove("temp.txt"); mioFile = SD.open("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt Serial.println("Criou o arquivo!"); } else { Serial.println("Criou o arquivo!"); mioFile = SD.open("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt myFile.close(); } ritardo(500); mioFile.print("Ora: "); myFile.println("Temperatura"); DS1307.getDate(DataTime); effettivoMin = precedenteMin = DataTime[5]; sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.clear(); lcd.setCursor(5, 0); lcd.print(tempi); lcd.setCursor(0, 1); lcd.print("Temperatura: "); lcd.setCursor(14, 1); sensori.requestTemperatures(); float TempSensor = sensor.getTempCByIndex(0); lcd.print(SensoreTemp); } if(regolazioneora == 0 &&regolazione_stato_ora == 1) {regolazione_stato_ora = 0; } if(regolazione ora == 1 && regolazione_stato_ora == 0 && misura_processo == 0) { regolazione_processo = 1; } //------------------- ---Processo di misurazione ---------------------------------------------- -------------- if(measure_process == 1) { updateTemp(); byte contMin = 0, contHour = 0; DS1307.getDate(DataTime); effettivoMin = DataTime[5]; //------------------------------------------------ ---------Conta minuti--------------------------------------- ------------------- if(actualMin != previousMin) { contMin++; precedenteMin = effettivoMin; } if(contMin == 5) { sprintf(times, "%02d:%02d ", DataTime[4], DataTime[5]); sensori.requestTemperatures(); float TempSensor = sensor.getTempCByIndex(0); mioFile.print(tempi); mioFile.println(SensoreTemp); contMin = 0; } //------------------- ------------Conteggio ore---------------------- ---------------------- if(actualHour != precedenteora) { contHour++; oraprecedente = oraeffettivo; } if(contHour == 5) { mioFile.close(); lcd.clear(); lcd.setCursor(5, 0); lcd.print("Finito"); lcd.setCursor(5, 1); lcd.print("Processo"); misura_processo = 0; contHour = 0; } //----------------------------------------------Condizione per fermare il datalogger --------------------------------- ---- if(ok == 1) { mioFile.close(); lcd.clear(); lcd.setCursor(6, 0); lcd.print("Interrotto"); lcd.setCursor(5, 1); lcd.print("Processo"); misura_processo = 0; ritardo (2000); lcd.clear(); DS1307.getDate(DataTime); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 0); lcd.print(tempi); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O/P"); } } //---------------------------------------------- -------Regola Orari----------------------------------------- ---------------------- //Regola ora if(adjust_process == 1) { lcd.clear(); DS1307.getDate(DataTime); lcd.setCursor(0, 0); lcd.print("Regola ora:"); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(tempi); //Regola ora do { misura = digitalRead(Buttonmeasure); Adjusthour = digitalRead(Buttonadjusthour); ok = digitalRead(Buttonok); if(misura == 0 && stato_misura == 1) { stato_misura = 0; } if(misura == 1 && stato_misura == 0) { DataTime[4]++; if(DataTime[4] > 23) { DataTime[4] = 0; } stato_misura = 1; sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(tempi); DS1307.setDate(DataTime[0], DataTime[1], DataTime[2], DataTime[3], DataTime[4], DataTime[5], 00); } if(regolazioneora == 0 &&regolazione_stato_ora == 1) {regolazione_stato_ora = 0; } if(regolazione ora == 1 && regolazione ora_stato == 0) { DataTime[5]++; if(DataTime[5] > 59) { DataTime[5] = 0; } sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(tempi); DS1307.setDate(DataTime[0], DataTime[1], DataTime[2], DataTime[3], DataTime[4], DataTime[5], 00); stato_orario = 1; } if(ok == 1) { lcd.clear(); DS1307.getDate(DataTime); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(0, 0); lcd.print(tempi); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O"); regolazione_processo = 0; } }while(ok != 1); } //------------------- -------Fine Regolazione Ora---------------------------------------- ------------------- }

Innanzitutto, definiamo tutte le librerie per controllare i moduli e dichiarare le variabili utilizzate durante la programmazione del Datalogger JLCPCB con un sensore di temperatura per Arduino. Il blocco di codice è mostrato di seguito.

Passaggio 3:

#include //Libreria con tutte le funzioni del sensore DS18B20

#include #include //Biblioteca I2C do LCD 16x2 #include //Biblioteca de Comunicacao I2C #include //Libreria OneWire per sensore DS18B20 #include #include LiquidCrystal_I2C lcd(0x27, 16, 2); // Configurando o endereco do LCD 16x2 para 0x27 #define ONE_WIRE_BUS 8 //Digital Pin per connettere il sensore DS18B20 //Definisci un'istanza do oneWire per comunicacao com o sensor OneWire oneWire(ONE_WIRE_BUS); DallasSensori di temperatura(&oneWire); DeviceAddress sensore1; File mioFile; #define Buttonmeasure 2 #define Buttonadjusthour 3 #define Buttonok 4 bool misura = 0, aggiustaora = 0, ok = 0; bool stato_misura = 0, stato_orario = 0, stato_ok = 0; bool misura_processo = 0, aggiustamento_processo = 0; byte Min attuale = 0, Min precedente = 0; byte ora attuale = 0, ora precedente = 0; byte minUpdate = 0; int pinoSS = 10; // Pin 53 per Mega / Pin 10 per UNO int DataTime[7];

Di seguito, abbiamo la funzione di configurazione del vuoto. Questa funzione viene utilizzata per configurare i pin e l'inizializzazione del dispositivo, come mostrato di seguito.

configurazione nulla()

{ Serial.begin(9600); DS1307.begin(); sensori.begin(); pinMode(pinoSS, OUTPUT); // Dichiara pinoSS come saída Wire.begin(); //Inicializacao da Comunicacao I2C lcd.init(); //Inicializacao do LCD lcd.backlight(); lcd.setCursor(3, 0); lcd.print("Sistema temporaneo"); lcd.setCursor(3, 1); lcd.print("Registratore dati"); ritardo (2000); // Localizza e mostra i sensori dei sensori Serial.println("Localizza i sensori DS18B20…"); Serial.print("Localizzazione sensore riuscita!"); Serial.print(sensors.getDeviceCount(), DEC); Serial.println("Sensore"); if(SD.begin()) { // Inicializa o SD Card Serial.println("SD Card pronto per l'uso."); // Stampa su tela } else { Serial.println("Falha na inicialização do SD Card."); Restituzione; } DS1307.getDate(DataTime); lcd.clear(); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 0); lcd.print(tempi); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O/P"); }

Per prima cosa sono state avviate la comunicazione seriale, l'orologio in tempo reale e il sensore di temperatura per Arduino DS18B20. Dopo aver inizializzato e testato i dispositivi, il messaggio con le opzioni del menu è stato stampato sullo schermo LCD 16x2. Questa schermata è mostrata in Figura 1.

Passaggio 4:

Successivamente, il sistema legge le ore e aggiorna il valore chiamando la funzione updateHour. Questa funzione ha quindi lo scopo di presentare il valore orario ogni minuto. Il blocco del codice funzione è mostrato di seguito.

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

Passaggio 5:

Oltre ad aggiornare le ore, l'utente può selezionare uno dei tre pulsanti per monitorare il paziente con un sensore di temperatura con Arduino. Il circuito è mostrato nella figura sopra.

Passaggio 6: menu di controllo del registratore di dati JLCPCB

Innanzitutto, l'utente deve controllare e regolare le ore del sistema. Questo processo viene eseguito quando viene premuto il secondo pulsante.

Quando si preme il pulsante, dovrebbe apparire la seguente schermata, mostrata nella figura sopra.

Passaggio 7:

Da questa schermata l'utente potrà inserire i valori delle ore e dei minuti dai pulsanti collegati ai pin digitali 2 e 3 di Arduino. I pulsanti sono mostrati nella figura sopra.

La porzione di codice per il controllo delle ore è mostrata di seguito.

if(regolazione ora == 0 && regolazione ora_stato == 1)

{regolare_stato_ora = 0; } if(regolazione ora == 1 && regolazione_stato_ora == 0 && misura_processo == 0) { regolazione_processo = 1; }

Quando viene premuto il pulsante delle ore e la variabile measure_process è impostata su 0, la condizione sarà vera e la variabile Adjust_process sarà impostata su 1. La variabile measure_process viene utilizzata per segnalare che il sistema sta monitorando la temperatura. Quando il suo valore è 0, il sistema consentirà all'utente di accedere al menu di impostazione dell'ora. Pertanto, dopo che la variabile Adjust_process riceve il valore 1, il sistema entrerà nella condizione di regolazione dell'ora. Questo blocco di codice è mostrato di seguito.

//------------------------------------------------ -----Regolare l'orario----------------------------- --------------------

//Regola ora if(adjust_process == 1) { lcd.clear(); DS1307.getDate(DataTime); lcd.setCursor(0, 0); lcd.print("Regola ora:"); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(tempi); //Regola ora do { misura = digitalRead(Buttonmeasure); Adjusthour = digitalRead(Buttonadjusthour); ok = digitalRead(Buttonok); if(misura == 0 && stato_misura == 1) { stato_misura = 0; } if(misura == 1 && stato_misura == 0) { DataTime[4]++; if(DataTime[4] > 23) { DataTime[4] = 0; } stato_misura = 1; sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(tempi); DS1307.setDate(DataTime[0], DataTime[1], DataTime[2], DataTime[3], DataTime[4], DataTime[5], 00); } if(regolazioneora == 0 &&regolazione_stato_ora == 1) {regolazione_stato_ora = 0; } if(regolazione ora == 1 && regolazione ora_stato == 0) { DataTime[5]++; if(DataTime[5] > 59) { DataTime[5] = 0; } sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(tempi); DS1307.setDate(DataTime[0], DataTime[1], DataTime[2], DataTime[3], DataTime[4], DataTime[5], 00); stato_ora_aggiusta = 1; } if(ok == 1) { lcd.clear(); DS1307.getDate(DataTime); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(0, 0); lcd.print(tempi); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O"); regolazione_processo = 0; } }while(ok != 1); }

In questa condizione il sistema visualizzerà il messaggio mostrato in Figura 4 e quindi attenderà che i valori si regolino internamente nel ciclo while. Durante la regolazione delle ore, questi pulsanti hanno le loro funzioni modificate, cioè sono multifunzione.

Ciò consente di utilizzare un pulsante per più di una funzione e ridurre la complessità del sistema.

In questo modo l'utente regolerà il valore delle ore e dei minuti per poi salvare i dati nel sistema alla pressione del tasto Ok.

Come puoi vedere, il sistema leggerà i 3 pulsanti, come mostrato di seguito.

misura = digitalRead(Buttonmeasure);

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

Notare che il pulsante di misurazione (Buttonmeasure) ha cambiato la sua funzione. Verrà ora utilizzato per regolare i valori delle ore, come mostrato di seguito. Le due condizioni seguenti sono simili e vengono utilizzate per regolare le ore ei minuti, come mostrato sopra.

if(misura == 0 && stato_misura == 1)

{ stato_misura = 0; } if(misura == 1 && stato_misura == 0) { DataTime[4]++; if(DataTime[4] > 23) { DataTime[4] = 0; } stato_misura = 1; sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(tempi); DS1307.setDate(DataTime[0], DataTime[1], DataTime[2], DataTime[3], DataTime[4], DataTime[5], 00); } if(regolazioneora == 0 &&regolazione_stato_ora == 1) {regolazione_stato_ora = 0; } if(regolazione ora == 1 && regolazione ora_stato == 0) { DataTime[5]++; if(DataTime[5] > 59) { DataTime[5] = 0; } sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(tempi); DS1307.setDate(DataTime[0], DataTime[1], DataTime[2], DataTime[3], DataTime[4], DataTime[5], 00); stato_ora_aggiusta = 1; }

Pertanto, ogni volta che si preme uno dei due pulsanti, il valore delle posizioni 4 e 5 del vettore DataTime verrà modificato e, in secondo luogo, tali valori verranno salvati nella memoria del DS1307.

Dopo le regolazioni, l'utente deve fare clic sul pulsante Ok per terminare il processo. Quando si verifica questo evento, il sistema eseguirà le seguenti righe di codice.

se(ok == 1)

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

Entrerà nella condizione di cui sopra e presenterà il messaggio dell'ora e il menu delle opzioni all'utente.

Infine, l'utente deve avviare il processo di monitoraggio del paziente tramite il sensore di temperatura con Arduino JLCPCB Datalogger.

Per fare ciò, l'utente deve premere il pulsante di misurazione, che è collegato al pin digitale 2.

Quindi, il sistema eseguirà la lettura con il sensore di temperatura per Arduino e la salverà sulla scheda di memoria. La regione del circuito è mostrata nella figura sopra.

Passaggio 8:

Pertanto, quando viene premuto il pulsante, verrà eseguita la seguente porzione di codice.

if(misura == 0 && stato_misura == 1)

{ stato_misura = 0; } if(misura == 1 && stato_misura == 0 && processo_misura == 0) { processo_misura = 1; stato_misura = 1; if (SD.exists("temp.txt")) { Serial.println("Apagou o arquivo anterior!"); SD.remove("temp.txt"); mioFile = SD.open("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt Serial.println("Criou o arquivo!"); } else { Serial.println("Criou o arquivo!"); mioFile = SD.open("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt myFile.close(); } ritardo(500); mioFile.print("Ora: "); myFile.println("Temperatura"); DS1307.getDate(DataTime); effettivoMin = precedenteMin = DataTime[5]; sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.clear(); lcd.setCursor(5, 0); lcd.print(tempi); lcd.setCursor(0, 1); lcd.print("Temperatura: "); lcd.setCursor(14, 1); sensori.requestTemperatures(); float TempSensor = sensor.getTempCByIndex(0); lcd.print(SensoreTemp); }

Nella parte di codice sopra, il sistema assegnerà un valore 1 alla variabile measure_process. È responsabile del salvataggio dei dati sulla scheda SD.

Inoltre, il sistema verificherà se esiste o meno un file di testo con un registro dati. Se è presente un file, il sistema eliminerà e ne creerà uno nuovo per memorizzare i dati.

Successivamente, creerà due colonne: una per le ore e una per la temperatura all'interno del file di testo.

Successivamente, visualizzerà le ore e la temperatura sullo schermo LCD, come mostrato nella figura sopra.

Successivamente, il flusso di codice eseguirà il seguente blocco di programma.

if(misura_processo == 1)

{ updateTemp(); byte contMin = 0, contHour = 0; DS1307.getDate(DataTime); effettivoMin = DataTime[5]; //------------------------------------------------ ---------Conta minuti--------------------------------------- ------------------- if(actualMin != previousMin) { contMin++; precedenteMin = effettivoMin; } if(contMin == 5) { sprintf(times, "%02d:%02d ", DataTime[4], DataTime[5]); sensori.requestTemperatures(); float TempSensor = sensor.getTempCByIndex(0); mioFile.print(tempi); mioFile.println(SensoreTemp); contMin = 0; } //------------------- ------------Conteggio ore---------------------- ---------------------- if(actualHour != precedenteora) { contHour++; oraprecedente = oraeffettivo; } if(contHour == 5) { mioFile.close(); lcd.clear(); lcd.setCursor(5, 0); lcd.print("Finito"); lcd.setCursor(5, 1); lcd.print("Processo"); misura_processo = 0; contHour = 0; } //----------------------------------------------Condizione per fermare il datalogger-----

Innanzitutto, verrà eseguita la funzione updateTemp(). È simile alla funzione updateHour(); tuttavia, visualizza la temperatura ogni 1 minuto.

Successivamente, il sistema raccoglierà i dati dell'ora dall'orologio in tempo reale e memorizzerà il valore dei minuti correnti nella variabile currentMin.

Quindi, controllerà se la variabile min è stata modificata, in base alla condizione presentata di seguito

if(actMin != precedenteMin)

{contMin++; precedenteMin = effettivoMin; }

Pertanto, se la variabile dei minuti correnti è diversa dal valore precedente, significa che è avvenuta una variazione del valore. In questo modo la condizione sarà vera e il valore del conteggio dei minuti verrà incrementato (contMin) e il valore corrente verrà assegnato alla variabile previousMin, per memorizzare il suo valore precedente.

Pertanto, quando il valore di questo conteggio è pari a 5, significa che sono trascorsi 5 minuti e il sistema deve eseguire una nuova lettura della temperatura e salvare l'ora e il valore della temperatura nel file di registro della SD Card.

if(contMin == 5)

{ sprintf(times, "%02d:%02d ", DataTime[4], DataTime[5]); sensori.requestTemperatures(); float TempSensor = sensor.getTempCByIndex(0); mioFile.print(tempi); mioFile.println(SensoreTemp); contMin = 0; }

In questo modo si ripeterà questo processo fino al raggiungimento del valore di 5 ore di monitoraggio della temperatura del paziente con il sensore di temperatura con Arduino.

La porzione di codice è mostrata di seguito ed è simile al conteggio dei minuti, che è stato presentato sopra.

//------------------------------------------------ -----------Conteggio ore----------------------- ---------------------

if(actualHour != precedenteora) { contHour++; oraprecedente = oraeffettivo; } if(contHour == 5) { mioFile.close(); lcd.clear(); lcd.setCursor(5, 0); lcd.print("Finito"); lcd.setCursor(5, 1); lcd.print("Processo"); misura_processo = 0; contHour = 0; }

Dopo aver raggiunto le 5 ore di monitoraggio, il sistema chiuderà il file di registro e presenterà all'utente il messaggio "Processo terminato".

Inoltre, l'utente può premere il pulsante Ok/Pausa per interrompere la registrazione dei dati. Quando ciò si verifica, verrà eseguito il seguente blocco di codice.

//-----------------Condizione per arrestare il datalogger ------------------------------------------------ ---

if(ok == 1) { mioFile.close(); lcd.clear(); lcd.setCursor(6, 0); lcd.print("Interrotto"); lcd.setCursor(5, 1); lcd.print("Processo"); misura_processo = 0; ritardo (2000); lcd.clear(); DS1307.getDate(DataTime); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 0); lcd.print(tempi); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O/P"); }

Passaggio 9:

Quindi, il sistema chiuderà il file e presenterà il messaggio "Processo interrotto", come mostrato nella Figura 8.

Passaggio 10:

Successivamente, il sistema stamperà la schermata dell'ora e le opzioni di menu, come mostrato nella Figura 9.

Passaggio 11: accesso ai dati del modulo della scheda SD con Arduino

Dopo il processo di monitoraggio del Datalogger JLCPCB con il sensore di temperatura con Arduino, è necessario rimuovere la scheda di memoria e accedere ai dati sul computer.

Per visualizzare e analizzare i dati con una qualità migliore, esporta/copia tutte le informazioni del file di testo in Excel. Successivamente, puoi tracciare grafici e analizzare i risultati ottenuti.

Passaggio 12: Conclusione

Il Datalogger JLCPCB con sensore di temperatura con Arduino ci permette, oltre a misurare la temperatura, di registrare informazioni sull'andamento della temperatura del paziente nel tempo.

Con questi dati memorizzati è possibile analizzare e comprendere come si comporta la temperatura del paziente contagiato da COVID 19.

Inoltre è possibile valutare il livello di temperatura e associare il suo valore all'applicazione di qualche tipo di farmaco.

Attraverso questi dati, quindi, il Datalogger JLCPCB con sensore di temperatura per Arduino si propone di assistere medici e infermieri nello studio del comportamento dei pazienti.

Infine, ringraziamo la società JLCPCB per aver supportato lo sviluppo del progetto e speriamo che possiate utilizzarlo

Tutti i file possono essere scaricati e utilizzati liberamente da qualsiasi utente.