Temperatuursensor voor Arduino toegepast op COVID 19: 12 stappen (met afbeeldingen)

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:15

De temperatuursensor voor Arduino is een fundamenteel element wanneer we de temperatuur van een processor van het menselijk lichaam willen meten.

De temperatuursensor met Arduino moet in contact of dichtbij zijn om het warmteniveau te ontvangen en te meten. Zo werken thermometers.

Deze apparaten worden enorm gebruikt om de lichaamstemperatuur van zieke mensen te meten, aangezien de temperatuur een van de eerste factoren is die in het menselijk lichaam veranderen bij een afwijking of ziekte.

Een van de ziekten die de temperatuur van het menselijk lichaam veranderen, is COVID 19. Daarom presenteren we de belangrijkste symptomen:

Hoesten Vermoeidheid Ademhalingsmoeilijkheden (ernstige gevallen) Koorts Koorts is een symptoom waarvan het belangrijkste kenmerk een verhoging van de lichaamstemperatuur is. Bij deze ziekte moeten we deze symptomen constant in de gaten houden.

Daarom zullen we een project ontwikkelen om de temperatuur te bewaken en deze gegevens op een geheugenkaart op te slaan via een JLCPCB-datalogger met behulp van een temperatuursensor met Arduino.

Daarom leer je in dit artikel:

• Hoe werkt een JLCPCB Datalogger met een temperatuursensor met Arduino?
• Hoe werkt de temperatuursensor met Arduino.
• Hoe werkt de DS18B20 temperatuursensor met Arduino
• Gebruik knoppen met meerdere functies.

Vervolgens laten we u zien hoe u uw JLCPCB-datalogger gaat ontwikkelen met behulp van de Arduino-temperatuursensor.

Benodigdheden

Arduino UNO

JLCPCB printplaat

DS18B20 Temperatuursensor

Arduino Nano R3

Truien

LCD-scherm 16 x 2"

Drukknopschakelaar

Weerstand 1kR

SD-kaartmodule voor Arduino

Stap 1: Bouw van de JLCPCB-datalogger met temperatuursensor met Arduino

Zoals eerder vermeld, bestaat het project uit het maken van een JLCPCB-datalogger met temperatuursensor met Arduino, en via deze gegevens kunnen we de temperatuur van de patiënt die wordt behandeld volgen.

Het circuit wordt dus getoond in de bovenstaande afbeelding.

Daarom heeft dit circuit, zoals u kunt zien, een DS18B20-temperatuursensor met Arduino, die verantwoordelijk is voor het meten van de temperatuurmeting van de patiënt.

Bovendien is de Arduino Nano verantwoordelijk voor het verzamelen van deze gegevens en het opslaan ervan op de geheugenkaart van de SD-kaartmodule.

Elke informatie wordt opgeslagen met de bijbehorende tijd, die wordt uitgelezen uit de RTC-module DS1307.

Dus om de gegevens van de temperatuursensor met Arduino op te slaan, moet de gebruiker het proces uitvoeren via het bedieningsmenu met het 16x2 LCD-scherm.

Stap 2:

Elke knop is verantwoordelijk voor het bedienen van een optie, zoals weergegeven op het LCD-scherm 16x2 in afbeelding 2.

Elke optie is verantwoordelijk voor het uitvoeren van een functie in het systeem, zoals hieronder weergegeven.

• Optie M is verantwoordelijk voor het starten van het meten en vastleggen van gegevens op de geheugenkaart.
• Optie H is verantwoordelijk voor het aanpassen van de systeemuren.
• Optie O/P wordt gebruikt om gegevensinvoer in het systeem te bevestigen of om het schrijven van gegevens naar de geheugenkaart te pauzeren.

Om het systeembesturingsproces te begrijpen, zullen we de onderstaande code geven en het stapsgewijze besturingssysteem van de JLCPCB-datalogger met temperatuursensor met Arduino bespreken.

#include //Bibliotheek met alle functies van de DS18B20-sensor

#include #include //Biblioteca I2C do LCD 16x2 #include //Biblioteca de Comunicacao I2C #include //OneWire-bibliotheek voor DS18B20-sensor #include #include LiquidCrystal_I2C lcd(0x27, 16, 2); // Configurando of endereco do LCD 16x2 para 0x27 #define ONE_WIRE_BUS 8 //Digitale pin om de DS18B20-sensor aan te sluiten //Define instancia do oneWire para comunicacao com o sensor OneWire oneWire(ONE_WIRE_BUS); DallasTemperatuursensoren (&oneWire); ApparaatAdres sensor1; Bestand mijnBestand; #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 measure_process = 0, adjust_process = 0; byte actualMin = 0, vorigeMin = 0; byte actualHour = 0, previousHour = 0; byte minUpdate = 0; int pinoSS = 10; // Pin 53 voor Mega / Pin 10 voor 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(tijden); minUpdate = DataTijd[5]; } } void updateTemp() { DS1307.getDate(DataTime); if(DataTime[5] != minUpdate) { sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.wissen(); lcd.setCursor (5, 0); lcd.print(tijden); lcd.setCursor(0, 1); lcd.print("Temperatuur: "); lcd.setCursor(14, 1); sensoren.requestTemperatures(); float TempSensor = sensoren.getTempCByIndex(0); lcd.print (TempSensor); minUpdate = DataTijd[5]; } } void setup() { Serial.begin(9600); DS1307.begin(); sensoren.begin(); pinMode (pinoSS, UITGANG); // Declara pinoSS como saída Wire.begin(); //Inicializacao da Comunicacao I2C lcd.init(); //Inicializacao doen LCD lcd.backlight(); lcd.setCursor(3, 0); lcd.print("Temp Systeem"); lcd.setCursor (3, 1); lcd.print("Datalogger"); vertraging (2000); // Localiza e mostra enderecos dos sensores Serial.println ("Localizando sensoren DS18B20…"); Serial.print("Sensorlokalisatie succesvol!"); Serial.print(sensors.getDeviceCount(), DEC); Serial.println ("Sensor"); if(SD.begin()) { // Inicializa o SD Card Serial.println ("SD-kaart pronto para uso."); // Imprime na tela } else { Serial.println ("Falha na inicialização do SD Card."); opbrengst; } DS1307.getDate(DataTime); lcd.wissen(); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor (5, 0); lcd.print(tijden); lcd.setCursor(0, 1); lcd.print ("1-M 2-H 3-O/P"); } void loop() { updateHour(); // Leesknopstatussen meten = digitalRead (Knopmaat); Adjusthour = digitalRead(Knop aanpassenuur); ok = digitalRead (Buttonok); if(measure == 0 && Measure_state == 1) { Measure_state = 0; } if(measure == 1 && Measure_state == 0 && Measure_process == 0) { Measure_process = 1; maatregel_staat = 1; if (SD.exists("temp.txt")) { Serial.println("Apagou o arquivo anterior!"); SD.remove("temp.txt"); mijnBestand = SD.open("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt Serial.println ("Criou o arquivo!"); } else { Serial.println("Criou o arquivo!"); mijnBestand = SD.open("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt myFile.close(); } vertraging (500); mijnBestand.print("Uur: "); mijnBestand.println("Temperatuur"); DS1307.getDate(DataTime); actualMin = vorigeMin = DataTijd[5]; sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.wissen(); lcd.setCursor (5, 0); lcd.print(tijden); lcd.setCursor(0, 1); lcd.print("Temperatuur: "); lcd.setCursor(14, 1); sensoren.requestTemperatures(); float TempSensor = sensoren.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; } //----------------------------------------------- --- Meetproces --------------------------------------------- -------------- if(measure_process == 1) { updateTemp(); byte contMin = 0, contHour = 0; DS1307.getDate(DataTime); actualMin = DataTijd[5]; //------------------------------------------------ ---------Tellen Minuten--------------------------------------- ------------------- if(actualMin != previousMin) { contMin++; previousMin = actueelMin; } if(contMin == 5) { sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); sensoren.requestTemperatures(); float TempSensor = sensoren.getTempCByIndex(0); mijnFile.print(tijden); mijnBestand.println(TempSensor); contMin = 0; } //----------------------------------------------- ------------Telt uren ------------------------------------ --------------------- if(actualHour != previousHour) { contHour++; previousHour = actueel uur; } if(contHour == 5) { mijnFile.close(); lcd.wissen(); lcd.setCursor (5, 0); lcd.print("Voltooid"); lcd.setCursor(5, 1); lcd.print("Proces"); maatregel_proces = 0; contHour = 0; } //----------------------------------------------Voorwaarde om de datalogger te stoppen---------------------------------------------- ---- if(ok == 1) { mijnFile.close(); lcd.wissen(); lcd.setCursor(6, 0); lcd.print("Gestopt"); lcd.setCursor(5, 1); lcd.print("Proces"); maatregel_proces = 0; vertraging (2000); lcd.wissen(); DS1307.getDate(DataTime); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor (5, 0); lcd.print(tijden); lcd.setCursor(0, 1); lcd.print ("1-M 2-H 3-O/P"); } } //---------------------------------------------- -------uren aanpassen----------------------------------------- --------------------- // Uur aanpassen if (adjust_process == 1) { lcd.clear (); DS1307.getDate(DataTime); lcd.setCursor(0, 0); lcd.print("Uur aanpassen:"); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(tijden); //Hour Adjust do { measure = digitalRead (Buttonmeasure); Adjusthour = digitalRead (Buttonadjusthour); ok = digitalRead (Buttonok); if(measure == 0 && Measure_state == 1) { Measure_state = 0; } if(measure == 1 && measure_state == 0) { DataTime[4]++; if(DataTime[4] > 23) {DataTime[4] = 0; } maatregel_staat = 1; sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(tijden); 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(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(tijden); DS1307.setDate(DataTime[0], DataTime[1], DataTime[2], DataTime[3], DataTime[4], DataTime[5], 00); aanpassingsuur_status = 1; } if(ok == 1) { lcd.clear(); DS1307.getDate(DataTime); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(0, 0); lcd.print(tijden); lcd.setCursor(0, 1); lcd.print ("1-M 2-H 3-O"); aanpassing_proces = 0; } }terwijl(ok !=1); } //----------------------------------------------- -------Einde Uur aanpassen ---------------------------------------- ------------------- }

Eerst definiëren we alle bibliotheken voor het besturen van de modules en het declareren van variabelen die worden gebruikt bij het programmeren van de JLCPCB-datalogger met een temperatuursensor voor Arduino. Het codeblok wordt hieronder getoond.

Stap 3:

#include //Bibliotheek met alle functies van de DS18B20-sensor

#include #include //Biblioteca I2C do LCD 16x2 #include //Biblioteca de Comunicacao I2C #include //OneWire-bibliotheek voor DS18B20-sensor #include #include LiquidCrystal_I2C lcd(0x27, 16, 2); // Configurando of endereco do LCD 16x2 para 0x27 #define ONE_WIRE_BUS 8 //Digitale pin om de DS18B20-sensor aan te sluiten. DallasTemperatuursensoren (&oneWire); ApparaatAdres sensor1; Bestand mijnBestand; #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 measure_process = 0, adjust_process = 0; byte actualMin = 0, vorigeMin = 0; byte actualHour = 0, previousHour = 0; byte minUpdate = 0; int pinoSS = 10; // Pin 53 voor Mega / Pin 10 voor UNO int DataTime [7];

Hierna hebben we de void setup-functie. Deze functie wordt gebruikt om de pinnen en de initialisatie van het apparaat te configureren, zoals hieronder weergegeven.

ongeldige setup()

{ Serieel.begin (9600); DS1307.begin(); sensoren.begin(); pinMode (pinoSS, UITGANG); // Declara pinoSS como saída Wire.begin(); //Inicializacao da Comunicacao I2C lcd.init(); //Inicializacao doen LCD lcd.backlight(); lcd.setCursor(3, 0); lcd.print("Temp Systeem"); lcd.setCursor (3, 1); lcd.print("Datalogger"); vertraging (2000); // Localiza e mostra enderecos dos sensores Serial.println ("Localizando sensoren DS18B20…"); Serial.print("Sensorlokalisatie succesvol!"); Serial.print(sensors.getDeviceCount(), DEC); Serial.println ("Sensor"); if(SD.begin()) { // Inicializa o SD Card Serial.println ("SD-kaart pronto para uso."); // Imprime na tela } else { Serial.println ("Falha na inicialização do SD Card."); opbrengst; } DS1307.getDate(DataTime); lcd.wissen(); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor (5, 0); lcd.print(tijden); lcd.setCursor(0, 1); lcd.print ("1-M 2-H 3-O/P"); }

Eerst werden de seriële communicatie, de real-time klok en de temperatuursensor voor Arduino DS18B20 gestart. Na het initialiseren en testen van de apparaten werd het bericht met de menu-opties afgedrukt op het 16x2 LCD-scherm. Dit scherm wordt weergegeven in figuur 1.

Stap 4:

Daarna leest het systeem de uren en werkt de waarde bij door de functie updateHour aan te roepen. Deze functie heeft dus als doel om elke minuut de uurwaarde weer te geven. Het functiecodeblok wordt hieronder weergegeven.

ongeldige 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(tijden); minUpdate = DataTijd[5]; } }

Stap 5:

Naast het updaten van de uren kan de gebruiker één van de drie knoppen selecteren om de patiënt te monitoren met een temperatuursensor met Arduino. Het circuit wordt getoond in de bovenstaande afbeelding.

Stap 6: JLCPCB Datalogger-bedieningsmenu

Eerst moet de gebruiker de systeemuren controleren en aanpassen. Dit proces wordt uitgevoerd wanneer de tweede knop wordt ingedrukt.

Wanneer de knop wordt ingedrukt, zou het volgende scherm moeten verschijnen, dat wordt weergegeven in de bovenstaande afbeelding.

Stap 7:

Vanaf dit scherm kan de gebruiker de uur- en minuutwaarden invoeren van de knoppen die zijn aangesloten op digitale pinnen 2 en 3 van de Arduino. De knoppen worden weergegeven in de bovenstaande afbeelding.

Het codegedeelte voor het regelen van de uren is hieronder weergegeven.

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

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

Wanneer de urenknop wordt ingedrukt en de meet_process-variabele is ingesteld op 0, is de voorwaarde waar en de aanpassing_process-variabele wordt ingesteld op 1. De meet_process-variabele wordt gebruikt om aan te geven dat het systeem de temperatuur bewaakt. Wanneer de waarde 0 is, zal het systeem de gebruiker toestaan om het tijdinstelmenu te openen. Daarom zal het systeem, nadat de variabele adjust_process een waarde van 1 heeft ontvangen, de tijdaanpassingsconditie invoeren. Dit codeblok wordt hieronder weergegeven.

//------------------------------------------------ -----uren aanpassen------------------------------------------- --------------------

// Uur aanpassen if (adjust_process == 1) { lcd.clear (); DS1307.getDate(DataTime); lcd.setCursor(0, 0); lcd.print("Uur aanpassen:"); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(tijden); //Hour Adjust do { measure = digitalRead (Buttonmeasure); Adjusthour = digitalRead(Knop aanpassenuur); ok = digitalRead (Buttonok); if(measure == 0 && Measure_state == 1) { Measure_state = 0; } if(measure == 1 && measure_state == 0) { DataTime[4]++; if(DataTime[4] > 23) {DataTime[4] = 0; } maatregel_staat = 1; sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(tijden); 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(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(tijden); DS1307.setDate(DataTime[0], DataTime[1], DataTime[2], DataTime[3], DataTime[4], DataTime[5], 00); aanpassingsuur_status = 1; } if(ok == 1) { lcd.clear(); DS1307.getDate(DataTime); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(0, 0); lcd.print(tijden); lcd.setCursor(0, 1); lcd.print ("1-M 2-H 3-O"); aanpassing_proces = 0; } }terwijl(ok !=1); }

In deze toestand zal het systeem het bericht weergeven dat wordt weergegeven in Afbeelding 4 en vervolgens wachten tot de waarden intern zijn aangepast in de while-lus. Bij het aanpassen van de uren hebben deze knoppen hun functie gewijzigd, dat wil zeggen dat ze multifunctioneel zijn.

Hierdoor kunt u een knop voor meer dan één functie gebruiken en de complexiteit van het systeem verminderen.

Op deze manier zal de gebruiker de waarde van de uren en minuten aanpassen en vervolgens de gegevens in het systeem opslaan wanneer op de OK-knop wordt gedrukt.

Zoals u kunt zien, leest het systeem de 3 knoppen, zoals hieronder weergegeven.

maat = digitalRead (Knopmaat);

Adjusthour = digitalRead(Knop aanpassenuur); ok = digitalRead (Buttonok);

Merk op dat de meetknop (Buttonmeasure) van functie is veranderd. Het wordt nu gebruikt om de uurwaarden aan te passen, zoals hieronder weergegeven. De volgende twee voorwaarden zijn vergelijkbaar en worden gebruikt om de uren en minuten aan te passen, zoals hierboven weergegeven.

if(meting == 0 && meetstatus == 1)

{ Measure_state = 0; } if(measure == 1 && measure_state == 0) { DataTime[4]++; if(DataTime[4] > 23) {DataTime[4] = 0; } maatregel_staat = 1; sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(tijden); 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(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(tijden); DS1307.setDate(DataTime[0], DataTime[1], DataTime[2], DataTime[3], DataTime[4], DataTime[5], 00); aanpassingsuur_status = 1; }

Daarom zal elke keer dat een van de twee knoppen wordt ingedrukt, de waarde van positie 4 en 5 van de DataTime-vector worden gewijzigd en ten tweede worden deze waarden opgeslagen in het DS1307-geheugen.

Na de aanpassingen moet de gebruiker op de knop Ok klikken om het proces te voltooien. Wanneer deze gebeurtenis zich voordoet, voert het systeem de volgende coderegels uit.

als(ok == 1)

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

Het zal de bovenstaande toestand invoeren en het uurbericht en het optiemenu aan de gebruiker presenteren.

Ten slotte moet de gebruiker het patiëntbewakingsproces starten via de temperatuursensor met Arduino JLCPCB Datalogger.

Om dit te doen, moet de gebruiker op de meetknop drukken, die is verbonden met digitale pin 2.

Vervolgens voert het systeem de meting uit met de temperatuursensor voor Arduino en slaat deze op de geheugenkaart op. Het circuitgebied wordt getoond in de bovenstaande afbeelding.

Stap 8:

Daarom, wanneer de knop wordt ingedrukt, wordt het volgende deel van de code uitgevoerd.

if(meting == 0 && meetstatus == 1)

{ Measure_state = 0; } if(measure == 1 && Measure_state == 0 && Measure_process == 0) { Measure_process = 1; maatregel_staat = 1; if (SD.exists("temp.txt")) { Serial.println("Apagou o arquivo anterior!"); SD.remove("temp.txt"); mijnBestand = SD.open("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt Serial.println ("Criou o arquivo!"); } else { Serial.println("Criou o arquivo!"); mijnBestand = SD.open("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt myFile.close(); } vertraging (500); mijnBestand.print("Uur: "); mijnBestand.println("Temperatuur"); DS1307.getDate(DataTime); actualMin = vorigeMin = DataTijd[5]; sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.wissen(); lcd.setCursor (5, 0); lcd.print(tijden); lcd.setCursor(0, 1); lcd.print("Temperatuur: "); lcd.setCursor(14, 1); sensoren.requestTemperatures(); float TempSensor = sensoren.getTempCByIndex(0); lcd.print (TempSensor); }

In het bovenstaande codegedeelte zal het systeem een waarde van 1 toewijzen aan de variabele measure_process. Het is verantwoordelijk voor het opslaan van de gegevens op de SD-kaart.

Daarnaast controleert het systeem of er een tekstbestand met een datalog bestaat of niet. Als er een bestand is, zal het systeem het verwijderen en een nieuw maken om de gegevens op te slaan.

Daarna maakt het twee kolommen: één voor de uren en één voor de temperatuur in het tekstbestand.

Daarna worden de uren en temperatuur weergegeven op het LCD-scherm, zoals weergegeven in de bovenstaande afbeelding.

Daarna zal de codestroom het volgende programmablok uitvoeren.

if(measure_process == 1)

{ updateTemp(); byte contMin = 0, contHour = 0; DS1307.getDate(DataTime); actualMin = DataTijd[5]; //------------------------------------------------ ---------Tellen Minuten--------------------------------------- ------------------- if(actualMin != previousMin) { contMin++; previousMin = actueelMin; } if(contMin == 5) { sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); sensoren.requestTemperatures(); float TempSensor = sensoren.getTempCByIndex(0); mijnFile.print(tijden); mijnBestand.println(TempSensor); contMin = 0; } //----------------------------------------------- ------------Telt uren ------------------------------------ --------------------- if(actualHour != previousHour) { contHour++; previousHour = actueel uur; } if(contHour == 5) { mijnFile.close(); lcd.wissen(); lcd.setCursor (5, 0); lcd.print("Voltooid"); lcd.setCursor(5, 1); lcd.print("Proces"); maatregel_proces = 0; contHour = 0; } //----------------------------------------------Voorwaarde om de datalogger te stoppen-----

Eerst wordt de functie updateTemp() uitgevoerd. Het is vergelijkbaar met de updateHour() functie; het geeft echter elke minuut de temperatuur weer.

Daarna verzamelt het systeem de tijdgegevens van de Real-Time Clock en slaat de huidige minuutwaarde op in de currentMin-variabele.

Vervolgens zal het controleren of de min-variabele is gewijzigd, volgens de onderstaande voorwaarde:

if(actualMin != previousMin)

{ contMin++; previousMin = actueelMin; }

Daarom, als de huidige minuutvariabele verschilt van de vorige waarde, betekent dit dat er een verandering in de waarde is opgetreden. Op deze manier is de voorwaarde waar en wordt de waarde van de minutentelling verhoogd (contMin) en de huidige waarde wordt toegewezen aan de variabele previousMin, om de vorige waarde op te slaan.

Daarom, wanneer de waarde van deze telling gelijk is aan 5, betekent dit dat er 5 minuten zijn verstreken en het systeem een nieuwe temperatuurmeting moet uitvoeren en het uur en de temperatuurwaarde moet opslaan in het logbestand van de SD-kaart.

if(contMin == 5)

{ sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); sensoren.requestTemperatures(); float TempSensor = sensoren.getTempCByIndex(0); mijnFile.print(tijden); mijnBestand.println(TempSensor); contMin = 0; }

Op deze manier wordt dit proces herhaald totdat de waarde van 5 uur monitoring van de temperatuur van de patiënt met de temperatuursensor met Arduino is bereikt.

Het codegedeelte wordt hieronder weergegeven en is vergelijkbaar met het aantal minuten dat hierboven werd weergegeven.

//------------------------------------------------ -----------Telt uren ------------------------------------- ---------------------

if(actualHour!= previousHour) { contHour++; previousHour = actueel uur; } if(contHour == 5) { mijnFile.close(); lcd.wissen(); lcd.setCursor (5, 0); lcd.print("Voltooid"); lcd.setCursor(5, 1); lcd.print("Proces"); maatregel_proces = 0; contHour = 0; }

Na het bereiken van 5 uur bewaking, sluit het systeem het logbestand en presenteert het bericht "Voltooid proces" aan de gebruiker.

Bovendien kan de gebruiker op de OK/Pauze-knop drukken om het opnemen van gegevens te stoppen. Wanneer dit gebeurt, wordt het volgende codeblok uitgevoerd.

//----------------------------------------------Voorwaarde tot stop de datalogger ----------------------------------------------- ---

if(ok == 1) { mijnFile.close(); lcd.wissen(); lcd.setCursor(6, 0); lcd.print("Gestopt"); lcd.setCursor(5, 1); lcd.print("Proces"); maatregel_proces = 0; vertraging (2000); lcd.wissen(); DS1307.getDate(DataTime); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor (5, 0); lcd.print(tijden); lcd.setCursor(0, 1); lcd.print ("1-M 2-H 3-O/P"); }

Stap 9:

Vervolgens zal het systeem het bestand sluiten en het bericht "Gestopt proces" weergeven, zoals weergegeven in afbeelding 8.

Stap 10:

Daarna zal het systeem het tijdscherm en de menu-opties afdrukken, zoals weergegeven in Afbeelding 9.

Stap 11: Toegang tot SD-kaartmodulegegevens met Arduino

Na het proces van het bewaken van de JLCPCB-datalogger met de temperatuursensor met Arduino, is het noodzakelijk om de geheugenkaart te verwijderen en toegang te krijgen tot de gegevens op de computer.

Om de gegevens met een betere kwaliteit te bekijken en te analyseren, exporteert / kopieert u alle informatie van het tekstbestand naar Excel. Daarna kunt u grafieken plotten en de verkregen resultaten analyseren.

Stap 12: Conclusie

De JLCPCB Datalogger met temperatuursensor met Arduino stelt ons in staat om, naast het meten van de temperatuur, informatie over het temperatuurgedrag van de patiënt over een bepaalde periode vast te leggen.

Met deze opgeslagen gegevens is het mogelijk om te analyseren en te begrijpen hoe de temperatuur van de door COVID 19 geïnfecteerde patiënt zich gedraagt.

Bovendien is het mogelijk om het temperatuurniveau te evalueren en de waarde ervan te associëren met de toepassing van een soort medicatie.

Daarom wil de JLCPCB Datalogger met temperatuursensor voor Arduino met deze gegevens artsen en verpleegkundigen helpen bij het bestuderen van het gedrag van patiënten.

Ten slotte bedanken we het bedrijf JLCPCB voor het ondersteunen van de ontwikkeling van het project en hopen we dat u het kunt gebruiken

Alle bestanden kunnen door elke gebruiker gratis worden gedownload en gebruikt.