Temperatursensor för Arduino Tillämpad för COVID 19: 12 steg (med bilder)

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:40

Temperatursensorn för Arduino är ett grundläggande element när vi vill mäta temperaturen på en processor i människokroppen.

Temperaturgivaren med Arduino måste vara i kontakt eller nära för att ta emot och mäta värmenivån. Så fungerar termometrar.

Dessa enheter används extremt för att mäta kroppstemperaturen hos sjuka människor, eftersom temperaturen är en av de första faktorerna som förändras i människokroppen när det finns en abnormitet eller sjukdom.

En av sjukdomarna som förändrar temperaturen i människokroppen är COVID 19. Därför presenterar vi de viktigaste symptomen:

Hosta Trötthet Andningssvårigheter (Svåra fall) Feber Feber är ett symptom vars främsta egenskap är en ökning av kroppstemperaturen. I denna sjukdom måste vi ständigt övervaka dessa symtom.

Således kommer vi att utveckla ett projekt för att övervaka temperaturen och lagra dessa data på ett minneskort genom en JLCPCB Datalogger med en temperatursensor med Arduino.

Därför lär du dig i den här artikeln:

• Hur fungerar en JLCPCB -datalogger med temperatursensor med Arduino?
• Hur fungerar temperaturgivaren med Arduino.
• Hur fungerar DS18B20 temperaturgivare med Arduino
• Använd knappar med flera funktioner.

Därefter visar vi dig hur du kommer att utveckla din JLCPCB Datalogger med Arduino temperatursensor.

Tillbehör

Arduino UNO

JLCPCB kretskort

DS18B20 Temperaturgivare

Arduino Nano R3

Tröjor

LCD -skärm 16 x 2

Tryckknappsbrytare

Motstånd 1kR

SD -kortmodul för Arduino

Steg 1: Konstruktion av JLCPCB -datalogger med temperatursensor med Arduino

Som tidigare nämnts består projektet av att skapa en JLCPCB -datalogger med temperatursensor med Arduino, och genom dessa data kan vi övervaka temperaturen hos patienten som behandlas.

Således visas kretsen i figuren ovan.

Därför, som du kan se, har denna krets en DS18B20 temperatursensor med Arduino, som är ansvarig för att mäta patientens temperaturavläsning.

Dessutom kommer Arduino Nano att ansvara för att samla in denna data och lagra den på SD -kortmodulens minneskort.

Varje information sparas med sin respektive tid, som kommer att läsas från RTC -modulen DS1307.

För att data från temperaturgivaren med Arduino ska sparas måste användaren utföra processen via kontrollmenyn med 16x2 LCD.

Steg 2:

Varje knapp är ansvarig för att styra ett alternativ, som visas på LCD -skärmen 16x2 i figur 2.

Varje alternativ är ansvarigt för att utföra en funktion i systemet, som visas nedan.

• Alternativ M ansvarar för att starta mätning och registrering av data på minneskortet.
• Alternativ H ansvarar för att justera systemtiden.
• Alternativ O/P används för att bekräfta datainmatning i systemet eller för att pausa att skriva data till minneskortet.

För att förstå systemkontrollprocessen kommer vi att tillhandahålla koden nedan och diskutera steg-för-steg-kontrollsystemet för JLCPCB Datalogger med temperatursensor med Arduino.

#inkludera // Bibliotek med all funktion av DS18B20 -sensorn

#include #include // Biblioteca I2C till LCD 16x2 #include // Biblioteca de Comunicacao I2C #include // OneWire Library for DS18B20 Sensor #include #include LiquidCrystal_I2C lcd (0x27, 16, 2); // Configurando o endereco do LCD 16x2 para 0x27 #define ONE_WIRE_BUS 8 // Digital Pin för att ansluta DS18B20 -sensorn // Definiera oma instancia do oneWire för comunicacao com o sensor OneWire oneWire (ONE_WIRE_BUS); DallasTemperatursensorer (& oneWire); DeviceAddress -sensor1; Arkivera minFile; #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ått_process = 0, juster_process = 0; byte actualMin = 0, previousMin = 0; byte actualHour = 0, previousHour = 0; byte minUpdate = 0; int pinoSS = 10; // Pin 53 för Mega / Pin 10 för 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 (gånger); 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 (gånger); lcd.setCursor (0, 1); lcd.print ("Temperatur:"); lcd.setCursor (14, 1); sensors.requestTemperatures (); float TempSensor = sensors.getTempCByIndex (0); lcd.print (TempSensor); minUpdate = DataTime [5]; }} void setup () {Serial.begin (9600); DS1307.begin (); sensorer.start (); 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 ("Temp System"); lcd.setCursor (3, 1); lcd.print ("Datalogger"); fördröjning (2000); // Localiza e mostra enderecos dos sensores Serial.println ("Localizando sensores DS18B20 …"); Serial.print ("Sensorlokalisering framgångsrikt!"); Serial.print (sensors.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."); lämna tillbaka; } DS1307.getDate (DataTime); lcd.clear (); sprintf (gånger, "%02d:%02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 0); lcd.print (gånger); lcd.setCursor (0, 1); lcd.print ("1-M 2-H 3-O/P"); } void loop () {updateHour (); // Läsknapptillstånd mäter = digitalRead (knappmått); adjusthour = digitalRead (Buttonadjusthour); ok = digitalRead (Buttonok); if (mått == 0 && mått_stat == 1) {mått_stat = 0; } if (mått == 1 && mått_stat == 0 && mått_process == 0) {mått_process = 1; mått_stat = 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!"); } annat {Serial.println ("Criou o arquivo!"); myFile = SD.open ("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt myFile.close (); } fördröjning (500); myFile.print ("Hour:"); myFile.println ("Temperatur"); DS1307.getDate (DataTime); actualMin = previousMin = DataTime [5]; sprintf (gånger, "%02d:%02d", DataTime [4], DataTime [5]); lcd.clear (); lcd.setCursor (5, 0); lcd.print (gånger); lcd.setCursor (0, 1); lcd.print ("Temperatur:"); 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; } // ----------------------------------------------- --- Mätprocess --------------------------------------------- -------------- if (mått_process == 1) {updateTemp (); byte contMin = 0, contHour = 0; DS1307.getDate (DataTime); actualMin = DataTime [5]; // ------------------------------------------------ --------- Räkna minuter --------------------------------------- ------------------- if (actualMin! = previousMin) {contMin ++; previousMin = actualMin; } if (contMin == 5) {sprintf (gånger, "%02d:%02d", DataTime [4], DataTime [5]); sensors.requestTemperatures (); float TempSensor = sensors.getTempCByIndex (0); myFile.print (tider); myFile.println (TempSensor); contMin = 0; } // ----------------------------------------------- ------------ Räkna timmar ------------------------------------ ---------------------- if (actualHour! = previousHour) {contHour ++; previousHour = actualHour; } if (contHour == 5) {myFile.close (); lcd.clear (); lcd.setCursor (5, 0); lcd.print ("färdig"); lcd.setCursor (5, 1); lcd.print ("Process"); mått_process = 0; contHour = 0; } //----------------------------------------------Skick för att stoppa datalogger ---------------------------------------------- ---- om (ok == 1) {myFile.close (); lcd.clear (); lcd.setCursor (6, 0); lcd.print ("Stoppad"); lcd.setCursor (5, 1); lcd.print ("Process"); mått_process = 0; fördröjning (2000); lcd.clear (); DS1307.getDate (DataTime); sprintf (gånger, "%02d:%02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 0); lcd.print (gånger); lcd.setCursor (0, 1); lcd.print ("1-M 2-H 3-O/P"); }} // ---------------------------------------------- ------- Justera timmar ----------------------------------------- ---------------------- // Justera timme om (adjust_process == 1) {lcd.clear (); DS1307.getDate (DataTime); lcd.setCursor (0, 0); lcd.print ("Justera timme:"); sprintf (gånger, "%02d:%02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (gånger); // Timjustering gör {mått = digitalRead (knappmått); adjusthour = digitalRead (Buttonadjusthour); ok = digitalRead (Buttonok); if (mått == 0 && mått_stat == 1) {mått_stat = 0; } if (mått == 1 && mått_stat == 0) {DataTime [4] ++; om (DataTime [4]> 23) {DataTime [4] = 0; } mått_stat = 1; sprintf (gånger, "%02d:%02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (gånger); 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] ++; om (DataTime [5]> 59) {DataTime [5] = 0; } sprintf (gånger, "%02d:%02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (gånger); DS1307.setDate (DataTime [0], DataTime [1], DataTime [2], DataTime [3], DataTime [4], DataTime [5], 00); adjusthour_state = 1; } om (ok == 1) {lcd.clear (); DS1307.getDate (DataTime); sprintf (gånger, "%02d:%02d", DataTime [4], DataTime [5]); lcd.setCursor (0, 0); lcd.print (gånger); lcd.setCursor (0, 1); lcd.print ("1-M 2-H 3-O"); adjust_process = 0; }} medan (ok! = 1); } // ----------------------------------------------- ------- Sluta justera timme ---------------------------------------- -------------------}

Först definierar vi alla bibliotek för att styra modulerna och deklarera variabler som används vid programmering av JLCPCB Datalogger med en temperatursensor för Arduino. Kodblocket visas nedan.

Steg 3:

#inkludera // Bibliotek med all funktion av DS18B20 -sensorn

#include #include // Biblioteca I2C till LCD 16x2 #include // Biblioteca de Comunicacao I2C #include // OneWire Library for DS18B20 Sensor #include #include LiquidCrystal_I2C lcd (0x27, 16, 2); // Configurando o endereco do LCD 16x2 para 0x27 #define ONE_WIRE_BUS 8 // Digital Pin för att ansluta DS18B20 -sensorn // Definiera oma instancia do oneWire för comunicacao com o sensor OneWire oneWire (ONE_WIRE_BUS); DallasTemperatursensorer (& oneWire); DeviceAddress -sensor1; Arkivera minFile; #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ått_process = 0, juster_process = 0; byte actualMin = 0, previousMin = 0; byte actualHour = 0, previousHour = 0; byte minUpdate = 0; int pinoSS = 10; // Pin 53 för Mega / Pin 10 för UNO int DataTime [7];

Härefter har vi funktionen för hålrumsinställning. Denna funktion används för att konfigurera stiften och enhetens initialisering, som visas nedan.

void setup ()

{Serial.begin (9600); DS1307.begin (); sensorer.start (); 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 ("Temp System"); lcd.setCursor (3, 1); lcd.print ("Datalogger"); fördröjning (2000); // Localiza e mostra enderecos dos sensores Serial.println ("Localizando sensores DS18B20 …"); Serial.print ("Sensorlokalisering framgångsrikt!"); Serial.print (sensors.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."); lämna tillbaka; } DS1307.getDate (DataTime); lcd.clear (); sprintf (gånger, "%02d:%02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 0); lcd.print (gånger); lcd.setCursor (0, 1); lcd.print ("1-M 2-H 3-O/P"); }

Först startades seriekommunikationen, realtidsklockan och temperatursensorn för Arduino DS18B20. Efter initialisering och testning av enheterna skrevs meddelandet med menyalternativen ut på 16x2 LCD-skärmen. Denna skärm visas i figur 1.

Steg 4:

Därefter läser systemet timmarna och uppdaterar värdet genom att anropa funktionen updateHour. Således har denna funktion syftet att presentera timvärdet varje minut. Funktionskodblocket visas nedan.

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

Steg 5:

Förutom att uppdatera timmarna kan användaren välja en av de tre knapparna för att övervaka patienten med en temperatursensor med Arduino. Kretsen visas i figuren ovan.

Steg 6: JLCPCB Datalogger -kontrollmeny

Först måste användaren kontrollera och justera systemtiden. Denna process utförs när du trycker på den andra knappen.

När du trycker på knappen ska följande skärm visas, vilket visas i figuren ovan.

Steg 7:

Från denna skärm kan användaren ange timme och minutvärden från knapparna som är anslutna till Arduino digitala stift 2 och 3. Knapparna visas i figuren ovan.

Koddelen för att styra timmarna visas nedan.

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

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

När timmarstangenten trycks in och måttprocessvariabeln är inställd på 0 kommer villkoret att vara sant och variabeln justeringsprocess kommer att ställas in på 1. Mätprocessvariabeln används för att signalera att systemet övervakar temperaturen. När dess värde är 0, tillåter systemet användaren att gå in i tidsinställningsmenyn. Därför kommer systemet efter att justeringsprocessvariabeln har fått ett värde 1 att ange tidsjusteringsvillkoret. Detta kodblock visas nedan.

// ------------------------------------------------ ----- Justera timmar ------------------------------------------- --------------------

// Justera timme om (adjust_process == 1) {lcd.clear (); DS1307.getDate (DataTime); lcd.setCursor (0, 0); lcd.print ("Justera timme:"); sprintf (gånger, "%02d:%02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (gånger); // Timjustering gör {mått = digitalRead (knappmått); adjusthour = digitalRead (Buttonadjusthour); ok = digitalRead (Buttonok); if (mått == 0 && mått_stat == 1) {mått_stat = 0; } if (mått == 1 && mått_stat == 0) {DataTime [4] ++; om (DataTime [4]> 23) {DataTime [4] = 0; } mått_stat = 1; sprintf (gånger, "%02d:%02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (gånger); 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] ++; om (DataTime [5]> 59) {DataTime [5] = 0; } sprintf (gånger, "%02d:%02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (gånger); DS1307.setDate (DataTime [0], DataTime [1], DataTime [2], DataTime [3], DataTime [4], DataTime [5], 00); adjusthour_state = 1; } om (ok == 1) {lcd.clear (); DS1307.getDate (DataTime); sprintf (gånger, "%02d:%02d", DataTime [4], DataTime [5]); lcd.setCursor (0, 0); lcd.print (gånger); lcd.setCursor (0, 1); lcd.print ("1-M 2-H 3-O"); adjust_process = 0; }} medan (ok! = 1); }

I detta tillstånd kommer systemet att visa meddelandet som visas i figur 4 och sedan vänta på att värdena ska justeras internt i medan loop.

Detta låter dig använda en knapp för mer än en funktion och minska systemets komplexitet.

På detta sätt kommer användaren att justera värdet på timmar och minuter och sedan spara data i systemet när Ok -knappen trycks in.

Som du kan se kommer systemet att läsa de 3 knapparna, som visas nedan.

mått = digitalRead (knappmått);

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

Observera att måttknappen (knappmått) har ändrat dess funktion. Den kommer nu att användas för att justera timvärdena, enligt nedan. Följande två villkor är likartade och används för att justera timmar och minuter, som visas ovan.

if (mått == 0 && mått_stat == 1)

{mått_stat = 0; } if (mått == 1 && mått_stat == 0) {DataTime [4] ++; om (DataTime [4]> 23) {DataTime [4] = 0; } mått_stat = 1; sprintf (gånger, "%02d:%02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (gånger); 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] ++; om (DataTime [5]> 59) {DataTime [5] = 0; } sprintf (gånger, "%02d:%02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 1); lcd.print (gånger); DS1307.setDate (DataTime [0], DataTime [1], DataTime [2], DataTime [3], DataTime [4], DataTime [5], 00); adjusthour_state = 1; }

Varje gång en av de två knapparna trycks in ändras därför värdet för positionerna 4 och 5 i datatidsvektorn och för det andra sparas dessa värden i DS1307 -minnet.

Efter justeringarna måste användaren klicka på OK -knappen för att avsluta processen. När denna händelse inträffar kommer systemet att köra följande kodrader.

om (ok == 1)

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

Det kommer att ange ovanstående villkor och presentera timmeddelandet och alternativmenyn för användaren.

Slutligen måste användaren starta patientövervakningsprocessen genom temperatursensorn med Arduino JLCPCB Datalogger.

För att göra detta måste användaren trycka på mätknappen, som är ansluten till digital stift 2.

Därefter utför systemet avläsningen med temperatursensorn för Arduino och sparar den på minneskortet. Kretsområdet visas i figuren ovan.

Steg 8:

Därför, när knappen trycks, kommer följande del av koden att köras.

if (mått == 0 && mått_stat == 1)

{mått_stat = 0; } if (mått == 1 && mått_stat == 0 && mått_process == 0) {mått_process = 1; mått_stat = 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!"); } annat {Serial.println ("Criou o arquivo!"); myFile = SD.open ("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt myFile.close (); } fördröjning (500); myFile.print ("Hour:"); myFile.println ("Temperatur"); DS1307.getDate (DataTime); actualMin = previousMin = DataTime [5]; sprintf (gånger, "%02d:%02d", DataTime [4], DataTime [5]); lcd.clear (); lcd.setCursor (5, 0); lcd.print (gånger); lcd.setCursor (0, 1); lcd.print ("Temperatur:"); lcd.setCursor (14, 1); sensors.requestTemperatures (); float TempSensor = sensors.getTempCByIndex (0); lcd.print (TempSensor); }

I koddelen ovan kommer systemet att tilldela värdet 1 till variabeln mått_process. Den ansvarar för att data kan sparas på SD -kortet.

Dessutom kommer systemet att kontrollera om det finns en textfil med en datalogg eller inte. Om det finns en fil kommer systemet att ta bort och skapa en ny för att lagra data.

Därefter kommer det att skapa två kolumner: en för timmarna och en för temperaturen inuti textfilen.

Efter det kommer det att visa timmar och temperatur på LCD -skärmen, som visas i figuren ovan.

Därefter kör kodflödet följande programblock.

om (mått_process == 1)

{updateTemp (); byte contMin = 0, contHour = 0; DS1307.getDate (DataTime); actualMin = DataTime [5]; // ------------------------------------------------ --------- Räkna minuter --------------------------------------- ------------------- if (actualMin! = previousMin) {contMin ++; previousMin = actualMin; } if (contMin == 5) {sprintf (gånger, "%02d:%02d", DataTime [4], DataTime [5]); sensors.requestTemperatures (); float TempSensor = sensors.getTempCByIndex (0); myFile.print (tider); myFile.println (TempSensor); contMin = 0; } // ----------------------------------------------- ------------ Räkna timmar ------------------------------------ ---------------------- if (actualHour! = previousHour) {contHour ++; previousHour = actualHour; } if (contHour == 5) {myFile.close (); lcd.clear (); lcd.setCursor (5, 0); lcd.print ("färdig"); lcd.setCursor (5, 1); lcd.print ("Process"); mått_process = 0; contHour = 0; } //----------------------------------------------Skick för att stoppa datalogger -----

Först körs updateTemp () -funktionen. Det liknar funktionen updateHour (); den visar dock temperaturen var 1 minut.

Därefter kommer systemet att samla in tidsdata från realtidsklockan och lagra det aktuella minutvärdet i currentMin-variabeln.

Sedan kommer den att kontrollera om min -variabeln har ändrats, enligt villkoret som presenteras nedan

om (actualMin! = previousMin)

{contMin ++; previousMin = actualMin; }

Därför, om den aktuella minutvariabeln skiljer sig från det tidigare värdet, betyder det att en förändring i värdet har inträffat. På så sätt kommer villkoret att vara sant och värdet på minuträkningen kommer att ökas (forts. Min) och det aktuella värdet kommer att tilldelas variabeln previousMin för att lagra dess tidigare värde.

Därför, när värdet för denna räkning är lika med 5, betyder det att 5 minuter har gått och systemet måste utföra en ny temperaturavläsning och spara tim- och temperaturvärdet i SD -kortets loggfil.

if (contMin == 5)

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

På detta sätt kommer denna process att upprepas tills värdet av 5 timmar övervakas patientens temperatur med temperatursensorn med Arduino.

Koddelen visas nedan och liknar minuträkningen som presenterades ovan.

// ------------------------------------------------ ----------- Räkna timmar ------------------------------------- ---------------------

if (actualHour! = previousHour) {contHour ++; previousHour = actualHour; } if (contHour == 5) {myFile.close (); lcd.clear (); lcd.setCursor (5, 0); lcd.print ("färdig"); lcd.setCursor (5, 1); lcd.print ("Process"); mått_process = 0; contHour = 0; }

Efter att ha nått 5 timmars övervakning stänger systemet loggfilen och presenterar meddelandet "Avslutad process" för användaren.

Dessutom kan användaren trycka på OK/Paus -knappen för att stoppa inspelning av data. När detta inträffar körs följande kodblock.

// ---------------------------------------------- Skick till stoppa datalogger ----------------------------------------------- ---

om (ok == 1) {myFile.close (); lcd.clear (); lcd.setCursor (6, 0); lcd.print ("Stoppad"); lcd.setCursor (5, 1); lcd.print ("Process"); mått_process = 0; fördröjning (2000); lcd.clear (); DS1307.getDate (DataTime); sprintf (gånger, "%02d:%02d", DataTime [4], DataTime [5]); lcd.setCursor (5, 0); lcd.print (gånger); lcd.setCursor (0, 1); lcd.print ("1-M 2-H 3-O/P"); }

Steg 9:

Sedan stänger systemet filen och presenterar meddelandet "Stoppad process", som visas i figur 8.

Steg 10:

Därefter kommer systemet att skriva ut tidsskärmen och menyalternativen, som visas i figur 9.

Steg 11: Få åtkomst till SD -kortmoduldata med Arduino

Efter övervakningen av JLCPCB Datalogger med temperatursensorn med Arduino är det nödvändigt att ta bort minneskortet och få åtkomst till data på datorn.

För att visa och analysera data med bättre kvalitet, exportera / kopiera all information om textfilen till Excel. Därefter kan du plotta diagram och analysera de erhållna resultaten.

Steg 12: Slutsats

JLCPCB Datalogger med temperatursensor med Arduino gör att vi, förutom att mäta temperaturen, kan registrera information om patientens temperaturbeteende under en tidsperiod.

Med dessa lagrade data är det möjligt att analysera och förstå hur temperaturen hos patienten infekterad av COVID 19 beter sig.

Dessutom är det möjligt att utvärdera temperaturnivån och associera dess värde med applicering av någon typ av medicinering.

Därför syftar JLCPCB Datalogger med temperatursensor för Arduino genom dessa data till att hjälpa läkare och sjuksköterskor i studien av patienters beteende.

Slutligen tackar vi företaget JLCPCB för att stödja utvecklingen av projektet och hoppas att du kan använda det

Alla filer kan laddas ner och användas fritt av alla användare.