Senzor de temperatură pentru Arduino Aplicat pentru COVID 19: 12 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:42

Senzorul de temperatură pentru Arduino este un element fundamental atunci când vrem să măsurăm temperatura unui procesor al corpului uman.

Senzorul de temperatură cu Arduino trebuie să fie în contact sau aproape pentru a primi și măsura nivelul de căldură. Așa funcționează termometrele.

Aceste dispozitive sunt extrem de utilizate pentru a măsura temperatura corpului persoanelor bolnave, deoarece temperatura este unul dintre primii factori care se schimbă în corpul uman atunci când există o anomalie sau o boală.

Una dintre bolile care modifică temperatura corpului uman este COVID 19. Prin urmare, prezentăm principalele simptome:

Tuse Oboseală Dificultăți de respirație (cazuri severe) Febra Febra este un simptom a cărui caracteristică principală este creșterea temperaturii corpului. În această boală, trebuie să monitorizăm constant aceste simptome.

Astfel, vom dezvolta un proiect pentru monitorizarea temperaturii și stocarea acestor date pe o cartelă de memorie printr-un JLCPCB Datalogger folosind un senzor de temperatură cu Arduino.

Prin urmare, în acest articol veți afla:

• Cum funcționează un JLCPCB Datalogger cu un senzor de temperatură cu Arduino?
• Cum funcționează senzorul de temperatură cu Arduino.
• Cum funcționează senzorul de temperatură DS18B20 cu Arduino
• Utilizați butoane cu funcții multiple.

Apoi, vă vom arăta cum veți dezvolta JLCPCB Datalogger utilizând senzorul de temperatură Arduino.

Provizii

Arduino UNO

Placă de circuit imprimat JLCPCB

Senzor de temperatură DS18B20

Arduino Nano R3

Jumpers

Afișaj LCD 16 x 2

Apasă întrerupătorul

Rezistor 1kR

Modul card SD pentru Arduino

Pasul 1: Construcția JLCPCB Datalogger cu senzor de temperatură cu Arduino

După cum sa menționat anterior, proiectul constă în crearea unui JLCPCB Datalogger cu senzor de temperatură cu Arduino și, prin aceste date, putem monitoriza temperatura pacientului care este tratat.

Astfel, circuitul este prezentat în figura de mai sus.

Prin urmare, după cum puteți vedea, acest circuit are un senzor de temperatură DS18B20 cu Arduino, care este responsabil pentru măsurarea citirii temperaturii pacientului.

În plus, Arduino Nano va fi responsabil pentru colectarea acestor date și stocarea acestora pe cardul de memorie al modulului Card SD.

Fiecare informație va fi salvată cu ora respectivă, care va fi citită din modulul RTC DS1307.

Astfel, pentru ca datele senzorului de temperatură cu Arduino să fie salvate, utilizatorul trebuie să efectueze procesul prin meniul de control cu ecranul LCD 16x2.

Pasul 2:

Fiecare buton este responsabil pentru controlul unei opțiuni, așa cum se arată pe ecranul LCD 16x2 din Figura 2.

Fiecare opțiune este responsabilă pentru îndeplinirea unei funcții în sistem, așa cum se arată mai jos.

• Opțiunea M este responsabilă pentru începerea măsurării și înregistrării datelor pe cardul de memorie.
• Opțiunea H este responsabilă pentru ajustarea orelor sistemului.
• Opțiunea O / P este utilizată pentru a confirma introducerea datelor în sistem sau pentru a întrerupe scrierea datelor pe cardul de memorie.

Pentru a înțelege procesul de control al sistemului, vom furniza codul de mai jos și vom discuta despre sistemul de control pas cu pas al JLCPCB Datalogger cu senzor de temperatură cu Arduino.

#include // Biblioteca cu toate funcțiile senzorului DS18B20

#include #include // Biblioteca I2C do LCD 16x2 #include // Biblioteca de Comunicacao I2C #include // OneWire Library for DS18B20 Sensor #include #include LiquidCrystal_I2C lcd (0x27, 16, 2); // Configurarea endereco do LCD 16x2 para 0x27 #define ONE_WIRE_BUS 8 // Pin digital pentru conectarea senzorului DS18B20 // Definiți uma instancia do oneWire pentru comunicarea cu senzorul OneWire oneWire (ONE_WIRE_BUS); Senzori de temperatură Dallas (& oneWire); DeviceAddress sensor1; Înregistrează fișierul meu; #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 măsură_proces = 0, ajustare_proces = 0; octet actualMin = 0, precedentMin = 0; octet ora actuală = 0, ora precedentă = 0; octet minUpdate = 0; int pinoSS = 10; // Pinul 53 pentru Mega / Pinul 10 pentru UNO int DataTime [7]; void updateHour () {DS1307.getDate (DataTime); if (DataTime [5]! = minUpdate) {sprintf (ori, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (0, 0); lcd.print (""); lcd.setCursor (5, 0); lcd.print (ori); minUpdate = DataTime [5]; }} void updateTemp () {DS1307.getDate (DataTime); if (DataTime [5]! = minUpdate) {sprintf (ori, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.clear (); lcd.setCursor (5, 0); lcd.print (ori); lcd.setCursor (0, 1); lcd.print ("Temperatura:"); lcd.setCursor (14, 1); sensors.requestTemperatures (); float TempSensor = sensors.getTempCByIndex (0); lcd.print (TempSensor); minUpdate = DataTime [5]; }} void setup () {Serial.begin (9600); DS1307.begin (); sensors.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 ("Sistem Temp"); lcd.setCursor (3, 1); lcd.print ("Datalogger"); întârziere (2000); // Localiza e mostra enderecos dos sensores Serial.println ("Localizando sensores DS18B20 …"); Serial.print („Localizarea senzorului cu succes!”); Serial.print (sensors.getDeviceCount (), DEC); Serial.println („Senzor”); if (SD.begin ()) {// Inicializa o SD Card Serial.println ("SD Card pronto para uso."); // Imprime na tela} else {Serial.println ("Falha na initialização do SD Card."); întoarcere; } DS1307.getDate (DataTime); lcd.clear (); sprintf (ori, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 0); lcd.print (ori); lcd.setCursor (0, 1); imprimare lcd ("1-M 2-H 3-O / P"); } void loop () {updateHour (); // Citirea stărilor butoanelor măsură = digitalRead (Buttonmeasure); adjusthour = digitalRead (Buttonadjusthour); ok = digitalRead (Buttonok); if (măsură == 0 && măsură_stat == 1) {măsură_stat = 0; } if (măsură == 1 && măsură_stat == 0 && măsură_proces == 0) {măsură_proces = 1; stat_măsură = 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 (); } întârziere (500); myFile.print ("Ora:"); myFile.println ("Temperatura"); DS1307.getDate (DataTime); actualMin = previousMin = DataTime [5]; sprintf (ori, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.clear (); lcd.setCursor (5, 0); lcd.print (ori); lcd.setCursor (0, 1); lcd.print ("Temperatura:"); lcd.setCursor (14, 1); sensors.requestTemperatures (); float TempSensor = sensors.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; } // ----------------------------------------------- --- Proces de măsurare --------------------------------------------- -------------- if (măsură_proces == 1) {updateTemp (); octet contMin = 0, contHour = 0; DS1307.getDate (DataTime); actualMin = DataTime [5]; // ------------------------------------------------ --------- Număr de minute --------------------------------------- ------------------- if (actualMin! = previousMin) {contMin ++; previousMin = actualMin; } if (contMin == 5) {sprintf (times, "% 02d:% 02d", DataTime [4], DataTime [5]); sensors.requestTemperatures (); float TempSensor = sensors.getTempCByIndex (0); myFile.print (ori); myFile.println (TempSensor); contMin = 0; } // ----------------------------------------------- ------------ Număr de ore ------------------------------------ ---------------------- if (ActualHour! = previousHour) {contHour ++; Ora precedentă = Ora reală; } if (contHour == 5) {MyFile.close (); lcd.clear (); lcd.setCursor (5, 0); lcd.print („Finalizat”); lcd.setCursor (5, 1); lcd.print („Proces”); măsură_proces = 0; contHour = 0; } //----------------------------------------------Condiție pentru a opri registrul de date ---------------------------------------------- ---- if (ok == 1) {MyFile.close (); lcd.clear (); lcd.setCursor (6, 0); lcd.print („Oprit”); lcd.setCursor (5, 1); lcd.print („Proces”); măsură_proces = 0; întârziere (2000); lcd.clear (); DS1307.getDate (DataTime); sprintf (ori, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 0); lcd.print (ori); lcd.setCursor (0, 1); imprimare lcd ("1-M 2-H 3-O / P"); }} // ---------------------------------------------- ------- Ajustează orele ----------------------------------------- ---------------------- // Ajustează ora dacă (adjust_process == 1) {lcd.clear (); DS1307.getDate (DataTime); lcd.setCursor (0, 0); lcd.print ("Ajustează ora:"); sprintf (ori, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (ori); // Ajustare oră nu {măsură = digitalRead (Buttonmeasure); adjusthour = digitalRead (Buttonadjusthour); ok = digitalRead (Buttonok); if (măsură == 0 && măsură_stat == 1) {măsură_stat = 0; } if (măsură == 1 && măsură_stat == 0) {DataTime [4] ++; if (DataTime [4]> 23) {DataTime [4] = 0; } stat_măsură = 1; sprintf (ori, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (ori); 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 (ori, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (ori); 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 (ori, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (0, 0); lcd.print (ori); lcd.setCursor (0, 1); imprimare lcd ("1-M 2-H 3-O"); adjust_process = 0; }} while (ok! = 1); } // ----------------------------------------------- ------- Terminați ajustarea orei ---------------------------------------- -------------------}

În primul rând, definim toate bibliotecile pentru controlul modulelor și declararea variabilelor utilizate la programarea JLCPCB Datalogger cu un senzor de temperatură pentru Arduino. Blocul de cod este prezentat mai jos.

Pasul 3:

#include // Biblioteca cu toate funcțiile senzorului DS18B20

#include #include // Biblioteca I2C do LCD 16x2 #include // Biblioteca de Comunicacao I2C #include // OneWire Library for DS18B20 Sensor #include #include LiquidCrystal_I2C lcd (0x27, 16, 2); // Configurarea endereco do LCD 16x2 para 0x27 #define ONE_WIRE_BUS 8 // Pin digital pentru conectarea senzorului DS18B20 // Definiți uma instancia do oneWire pentru comunicarea cu senzorul OneWire oneWire (ONE_WIRE_BUS); Senzori de temperatură Dallas (& oneWire); DeviceAddress sensor1; Înregistrează fișierul meu; #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 măsură_proces = 0, ajustare_proces = 0; octet actualMin = 0, precedentMin = 0; octet ora actuală = 0, ora precedentă = 0; octet minUpdate = 0; int pinoSS = 10; // Pinul 53 pentru Mega / Pinul 10 pentru UNO int DataTime [7];

În continuare, avem funcția de configurare nulă. Această funcție este utilizată pentru a configura pinii și inițializarea dispozitivului, așa cum se arată mai jos.

configurare nulă ()

{Serial.begin (9600); DS1307.begin (); sensors.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 ("Sistem Temp"); lcd.setCursor (3, 1); lcd.print („Datalogger”); întârziere (2000); // Localiza e mostra enderecos dos sensores Serial.println ("Localizando sensores DS18B20 …"); Serial.print ("Localizarea senzorului cu succes!"); Serial.print (sensors.getDeviceCount (), DEC); Serial.println („Senzor”); if (SD.begin ()) {// Inicializa o SD Card Serial.println ("SD Card pronto para uso."); // Imprime na tela} else {Serial.println ("Falha na initialização do SD Card."); întoarcere; } DS1307.getDate (DataTime); lcd.clear (); sprintf (ori, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 0); lcd.print (ori); lcd.setCursor (0, 1); imprimare lcd ("1-M 2-H 3-O / P"); }

În primul rând, au început comunicarea serială, ceasul în timp real și senzorul de temperatură pentru Arduino DS18B20. După inițializarea și testarea dispozitivelor, mesajul cu opțiunile de meniu a fost tipărit pe ecranul LCD 16x2. Acest ecran este prezentat în Figura 1.

Pasul 4:

După aceea, sistemul citește orele și actualizează valoarea apelând funcția updateHour. Astfel, această funcție are scopul de a prezenta valoarea orară în fiecare minut. Blocul de cod funcțional este prezentat mai jos.

void updateHour ()

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

Pasul 5:

Pe lângă actualizarea orelor, utilizatorul poate selecta unul dintre cele trei butoane pentru a monitoriza pacientul cu un senzor de temperatură cu Arduino. Circuitul este prezentat în figura de mai sus.

Pasul 6: Meniul de control JLCPCB Datalogger

În primul rând, utilizatorul trebuie să verifice și să regleze orele sistemului. Acest proces se efectuează când este apăsat al doilea buton.

Când butonul este apăsat, ar trebui să apară următorul ecran, care este prezentat în figura de mai sus.

Pasul 7:

Din acest ecran, utilizatorul va putea introduce valorile orei și minutelor din butoanele conectate la pinii 2 și 3 ai Arduino. Butoanele sunt prezentate în figura de mai sus.

Porțiunea de cod pentru controlul orelor este prezentată mai jos.

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

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

Când butonul orelor este apăsat și variabila măsură_proces este setată la 0, condiția va fi adevărată și variabila ajustare_proces va fi setată la 1. Variabila măsură_proces este utilizată pentru a semnaliza că sistemul monitorizează temperatura. Când valoarea sa este 0, sistemul îi va permite utilizatorului să intre în meniul de setare a orei. Prin urmare, după ce variabila adjust_process primește o valoare de 1, sistemul va intra în condiția de ajustare a timpului. Acest bloc de cod este prezentat mai jos.

// ------------------------------------------------ ----- Reglarea orelor ------------------------------------------- --------------------

// Ajustează ora dacă (adjust_process == 1) {lcd.clear (); DS1307.getDate (DataTime); lcd.setCursor (0, 0); lcd.print ("Ajustează ora:"); sprintf (ori, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (ori); // Ajustare oră nu {măsură = digitalRead (Buttonmeasure); adjusthour = digitalRead (Buttonadjusthour); ok = citire digitală (Buttonok); if (măsură == 0 && măsură_stat == 1) {măsură_stat = 0; } if (măsură == 1 && măsură_stat == 0) {DataTime [4] ++; if (DataTime [4]> 23) {DataTime [4] = 0; } stat_măsură = 1; sprintf (ori, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (ori); 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 (ori, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (ori); 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 (ori, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (0, 0); lcd.print (ori); lcd.setCursor (0, 1); imprimare lcd ("1-M 2-H 3-O"); adjust_process = 0; }} while (ok! = 1); }

În această condiție, sistemul va afișa mesajul prezentat în Figura 4 și apoi va aștepta ca valorile să se regleze intern în bucla while. La ajustarea orelor, aceste butoane au funcțiile modificate, adică sunt multifuncționale.

Acest lucru vă permite să utilizați un buton pentru mai multe funcții și să reduceți complexitatea sistemului.

În acest fel, utilizatorul va ajusta valoarea orelor și minutelor și apoi va salva datele în sistem atunci când este apăsat butonul Ok.

După cum puteți vedea, sistemul va citi cele 3 butoane, așa cum se arată mai jos.

măsură = digitalRead (Buttonmeasure);

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

Rețineți că butonul de măsurare (Buttonmeasure) și-a schimbat funcția. Acum va fi folosit pentru a regla valorile orelor, după cum se arată mai jos. Următoarele două condiții sunt similare și sunt utilizate pentru a regla orele și minutele, așa cum se arată mai sus.

if (măsură == 0 && măsură_stat == 1)

{state_măsură = 0; } if (măsură == 1 && măsură_stat == 0) {DataTime [4] ++; if (DataTime [4]> 23) {DataTime [4] = 0; } stat_măsură = 1; sprintf (ori, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (ori); 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 (ori, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (ori); DS1307.setDate (DataTime [0], DataTime [1], DataTime [2], DataTime [3], DataTime [4], DataTime [5], 00); adjusthour_state = 1; }

Prin urmare, de fiecare dată când este apăsat unul dintre cele două butoane, valoarea pozițiilor 4 și 5 ale vectorului DataTime va fi modificată și, în al doilea rând, aceste valori vor fi salvate în memoria DS1307.

După ajustări, utilizatorul trebuie să facă clic pe butonul Ok, pentru a finaliza procesul. Când apare acest eveniment, sistemul va executa următoarele linii de cod.

if (ok == 1)

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

Acesta va introduce condiția de mai sus și va prezenta utilizatorului mesajul orar și meniul Opțiuni.

În cele din urmă, utilizatorul trebuie să înceapă procesul de monitorizare a pacientului prin senzorul de temperatură cu Arduino JLCPCB Datalogger.

Pentru a face acest lucru, utilizatorul trebuie să apese butonul de măsurare, care este conectat la pinul digital 2.

Apoi, sistemul va efectua citirea cu senzorul de temperatură pentru Arduino și îl va salva pe cardul de memorie. Regiunea circuitului este prezentată în figura de mai sus.

Pasul 8:

Prin urmare, atunci când butonul este apăsat, următoarea porțiune de cod va fi executată.

if (măsură == 0 && măsură_stat == 1)

{stat_măsură = 0; } if (măsură == 1 && măsură_stat == 0 && măsură_proces == 0) {măsură_proces = 1; stat_măsură = 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 (); } întârziere (500); myFile.print ("Ora:"); myFile.println ("Temperatura"); DS1307.getDate (DataTime); actualMin = previousMin = DataTime [5]; sprintf (ori, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.clear (); lcd.setCursor (5, 0); lcd.print (ori); lcd.setCursor (0, 1); lcd.print ("Temperatura:"); lcd.setCursor (14, 1); sensors.requestTemperatures (); float TempSensor = sensors.getTempCByIndex (0); lcd.print (TempSensor); }

În porțiunea de cod de mai sus, sistemul va atribui o valoare de 1 variabilei măsură_proces. Este responsabil pentru a permite salvarea datelor pe cardul SD.

În plus, sistemul va verifica dacă există sau nu un fișier text cu jurnal de date. Dacă există un fișier, sistemul va șterge și va crea unul nou pentru a stoca datele.

După aceea, va crea două coloane: una pentru ore și una pentru temperatura din fișierul text.

După aceea, va afișa orele și temperatura pe ecranul LCD, așa cum se arată în figura de mai sus.

După aceea, fluxul de cod va executa următorul bloc de program.

if (măsură_proces == 1)

{updateTemp (); octet contMin = 0, contHour = 0; DS1307.getDate (DataTime); actualMin = DataTime [5]; // ------------------------------------------------ --------- Număr de minute --------------------------------------- ------------------- if (actualMin! = previousMin) {contMin ++; previousMin = actualMin; } if (contMin == 5) {sprintf (times, "% 02d:% 02d", DataTime [4], DataTime [5]); sensors.requestTemperatures (); float TempSensor = sensors.getTempCByIndex (0); myFile.print (ori); myFile.println (TempSensor); contMin = 0; } // ----------------------------------------------- ------------ Număr de ore ------------------------------------ ---------------------- if (ActualHour! = previousHour) {contHour ++; Ora precedentă = Ora reală; } if (contHour == 5) {MyFile.close (); lcd.clear (); lcd.setCursor (5, 0); lcd.print („Finalizat”); lcd.setCursor (5, 1); lcd.print („Proces”); măsură_proces = 0; contHour = 0; } //----------------------------------------------Condiție pentru a opri registrul de date -----

În primul rând, funcția updateTemp () va fi executată. Este similar cu funcția updateHour (); cu toate acestea, afișează temperatura la fiecare 1 minut.

După aceea, sistemul va colecta datele de timp de la ceasul în timp real și va stoca valoarea curentă a minutului în variabila currentMin.

Apoi, va verifica dacă variabila min a fost modificată, în conformitate cu condiția prezentată mai jos

if (actualMin! = previousMin)

{contMin ++; previousMin = actualMin; }

Prin urmare, dacă variabila de minute curentă este diferită de valoarea anterioară, înseamnă că s-a produs o modificare a valorii. va fi atribuită variabilei previousMin, pentru a stoca valoarea sa anterioară.

Prin urmare, atunci când valoarea acestui număr este egală cu 5, înseamnă că au trecut 5 minute și sistemul trebuie să efectueze o nouă citire a temperaturii și să salveze ora și valoarea temperaturii în fișierul jurnal al cardului SD.

if (contMin == 5)

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

În acest fel, acest proces se va repeta până la atingerea valorii de 5 ore de monitorizare a temperaturii pacientului cu senzorul de temperatură cu Arduino.

Porțiunea de cod este prezentată mai jos și este similară cu numărul de minute, prezentat mai sus.

// ------------------------------------------------ ----------- Numărul de ore ------------------------------------- ---------------------

if (ActualHour! = previousHour) {contHour ++; Ora precedentă = Ora reală; } if (contHour == 5) {MyFile.close (); lcd.clear (); lcd.setCursor (5, 0); lcd.print („Finalizat”); lcd.setCursor (5, 1); lcd.print („Proces”); măsură_proces = 0; contHour = 0; }

După ce a atins 5 ore de monitorizare, sistemul va închide fișierul jurnal și va prezenta mesajul „Proces finalizat” utilizatorului.

În plus, utilizatorul poate apăsa butonul Ok / Pauză pentru a opri înregistrarea datelor. Când se întâmplă acest lucru, următorul bloc de cod va fi executat.

// ---------------------------------------------- Condiția pentru opriți registrul de date ----------------------------------------------- ---

if (ok == 1) {MyFile.close (); lcd.clear (); lcd.setCursor (6, 0); lcd.print („Oprit”); lcd.setCursor (5, 1); lcd.print („Proces”); măsură_proces = 0; întârziere (2000); lcd.clear (); DS1307.getDate (DataTime); sprintf (ori, "% 02d:% 02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 0); lcd.print (ori); lcd.setCursor (0, 1); imprimare lcd ("1-M 2-H 3-O / P"); }

Pasul 9:

Apoi, sistemul va închide fișierul și va prezenta mesajul „Proces oprit”, așa cum se arată în Figura 8.

Pasul 10:

După aceea, sistemul va imprima ecranul de timp și opțiunile meniului, așa cum se arată în Figura 9.

Pasul 11: Accesarea datelor modulului cardului SD cu Arduino

După procesul de monitorizare a JLCPCB Datalogger cu senzorul de temperatură cu Arduino, este necesar să scoateți cardul de memorie și să accesați datele de pe computer.

Pentru a vizualiza și analiza datele cu o calitate mai bună, exportați / copiați toate informațiile fișierului text în Excel. După aceea, puteți trasa grafice și analiza rezultatele obținute.

Pasul 12: Concluzie

JLCPCB Datalogger cu senzor de temperatură cu Arduino ne permite, pe lângă măsurarea temperaturii, să înregistrăm informații despre comportamentul pacientului la temperatură pe o perioadă de timp.

Cu aceste date stocate, este posibil să se analizeze și să se înțeleagă modul în care se comportă temperatura pacientului infectat cu COVID 19.

În plus, este posibilă evaluarea nivelului de temperatură și asocierea valorii acestuia cu aplicarea unui anumit tip de medicament.

Prin urmare, prin aceste date, JLCPCB Datalogger cu senzor de temperatură pentru Arduino își propune să ajute medicii și asistentele medicale în studiul comportamentului pacienților.

În cele din urmă, mulțumim companiei JLCPCB pentru sprijinirea dezvoltării proiectului și sperăm că îl puteți folosi

Toate fișierele pot fi descărcate și utilizate în mod liber de către orice utilizator.