Temperatursensor für Arduino für COVID 19 - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:17

Der Temperatursensor für Arduino ist ein grundlegendes Element, wenn wir die Temperatur eines Prozessors des menschlichen Körpers messen möchten.

Der Temperatursensor mit Arduino muss in Kontakt oder in der Nähe sein, um das Wärmeniveau zu empfangen und zu messen. So funktionieren Thermometer.

Diese Geräte werden in hohem Maße verwendet, um die Körpertemperatur von kranken Menschen zu messen, da die Temperatur einer der ersten Faktoren ist, die sich im menschlichen Körper ändern, wenn eine Anomalie oder Krankheit vorliegt.

Eine der Krankheiten, die die Temperatur des menschlichen Körpers verändern, ist COVID 19. Daher stellen wir die Hauptsymptome vor:

Husten Müdigkeit Atembeschwerden (schwere Fälle) Fieber Fieber ist ein Symptom, dessen Hauptmerkmal eine Erhöhung der Körpertemperatur ist. Bei dieser Krankheit müssen wir diese Symptome ständig überwachen.

Daher werden wir ein Projekt entwickeln, um die Temperatur zu überwachen und diese Daten über einen JLCPCB-Datenlogger mit einem Temperatursensor mit Arduino auf einer Speicherkarte zu speichern.

Daher erfahren Sie in diesem Artikel:

• Wie funktioniert ein JLCPCB-Datenlogger mit einem Temperatursensor mit Arduino?
• Wie funktioniert der Temperatursensor mit Arduino.
• Wie funktioniert der DS18B20 Temperatursensor mit Arduino
• Verwenden Sie Tasten mit mehreren Funktionen.

Als nächstes zeigen wir Ihnen, wie Sie Ihren JLCPCB-Datenlogger mit dem Arduino-Temperatursensor entwickeln.

Lieferungen

Arduino UNO

JLCPCB-Leiterplatte

DS18B20 Temperatursensor

Arduino Nano R3

Jumper

LCD-Anzeige 16 x 2

Druckknopfschalter

Widerstand 1kR

SD-Kartenmodul für Arduino

Schritt 1: Aufbau des JLCPCB-Datenloggers mit Temperatursensor mit Arduino

Wie bereits erwähnt, besteht das Projekt darin, einen JLCPCB-Datenlogger mit Temperatursensor mit Arduino zu erstellen, und anhand dieser Daten können wir die Temperatur des behandelten Patienten überwachen.

Somit ist die Schaltung in der obigen Abbildung dargestellt.

Daher verfügt diese Schaltung, wie Sie sehen können, über einen DS18B20-Temperatursensor mit Arduino, der für die Messung der Temperatur des Patienten verantwortlich ist.

Darüber hinaus ist der Arduino Nano dafür verantwortlich, diese Daten zu sammeln und auf der Speicherkarte des SD-Kartenmoduls zu speichern.

Jede Information wird mit ihrer jeweiligen Uhrzeit gespeichert, die vom RTC-Modul DS1307 gelesen wird.

Damit die Daten des Temperatursensors mit Arduino gespeichert werden, muss der Benutzer den Vorgang über das Steuerungsmenü mit dem 16x2-LCD ausführen.

Schritt 2:

Jede Taste ist für die Steuerung einer Option verantwortlich, wie auf dem LCD-Bildschirm 16x2 in Abbildung 2 dargestellt.

Jede Option ist für die Ausführung einer Funktion im System verantwortlich, wie unten gezeigt.

• Option M ist für das Starten der Messung und das Aufzeichnen der Daten auf der Speicherkarte verantwortlich.
• Option H ist für die Anpassung der Systemstunden verantwortlich.
• Option O/P wird verwendet, um die Dateneingabe im System zu bestätigen oder das Schreiben von Daten auf die Speicherkarte zu unterbrechen.

Um den Systemsteuerungsprozess zu verstehen, stellen wir den folgenden Code zur Verfügung und besprechen das schrittweise Steuerungssystem des JLCPCB-Datenloggers mit Temperatursensor mit Arduino.

#include //Bibliothek mit allen Funktionen des DS18B20-Sensors

#include #include //Biblioteca I2C do LCD 16x2 #include //Biblioteca de Comunicacao I2C #include //OneWire-Bibliothek für DS18B20 Sensor #include #include LiquidCrystal_I2C lcd (0x27, 16, 2); // Configurando o endereco do LCD 16x2 para 0x27 #define ONE_WIRE_BUS 8 //Digitaler Pin zum Anschluss des DS18B20 Sensors //Define uma instancia do oneWire para comunicacao com o sensor OneWire oneWire(ONE_WIRE_BUS); DallasTemperatursensoren(&oneWire); Geräteadresse sensor1; Datei meineDatei; #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 IstMin = 0, VorherMin = 0; Byte aktuelle Stunde = 0, vorherige Stunde = 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 (Zeiten); minUpdate = DataTime[5]; aufrechtzuerhalten. aufrechtzuerhalten. 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 (Zeiten); lcd.setCursor(0, 1); lcd.print("Temperatur:"); lcd.setCursor(14, 1); sensoren.requestTemperatures(); float TempSensor = Sensoren.getTempCByIndex(0); lcd.print (TempSensor); minUpdate = DataTime[5]; aufrechtzuerhalten. aufrechtzuerhalten. Void setup () { Serial.begin (9600); DS1307.begin(); sensoren.begin(); pinMode (pinoSS, AUSGANG); // Declara pinoSS como saída Wire.begin(); //Inicializacao da Comunicacao I2C lcd.init(); // Initialisieren Sie LCD lcd.backlight (); lcd.setCursor(3, 0); lcd.print("Temp-System"); lcd.setCursor(3, 1); lcd.print("Datenlogger"); Verzögerung (2000); // Localiza e mostra enderecos dos sensores Serial.println ("Localizando sensores DS18B20…"); Serial.print ("Sensorlokalisierung erfolgreich!"); Serial.print (sensors.getDeviceCount(), DEC); Serial.println ("Sensor"); if (SD.begin ()) {// Inicializa o SD-Karte Serial.println ("SD-Karte pronto para uso."); // Imprime na tela} else {Serial.println ("Falha na inicialização do SD Card."); Rückkehr; } DS1307.getDate(DataTime); lcd.clear(); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 0); lcd.print (Zeiten); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O/P"); aufrechtzuerhalten. Void Schleife () { updateHour (); // Schaltflächenzustände lesen Measure = digitalRead (Buttonmeasure); adjusthour = digitalRead (Buttonadjusthour); ok = digitalRead (Buttonok); if(maß == 0 && messzustand == 1) { messzustand = 0; } if(Measure == 1 && measure_state == 0 && measure_process == 0) {Measure_process = 1; Messzustand = 1; if (SD.exists("temp.txt")) {Serial.println("Apagou oder 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(); } Verzögerung (500); myFile.print("Stunde: "); myFile.println("Temperatur"); DS1307.getDate(DataTime); aktuellesMin = vorherigesMin = DataTime[5]; sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.clear(); lcd.setCursor(5, 0); lcd.print (Zeiten); lcd.setCursor(0, 1); lcd.print("Temperatur:"); lcd.setCursor(14, 1); sensoren.requestTemperatures(); float TempSensor = Sensoren.getTempCByIndex(0); lcd.print (TempSensor); aufrechtzuerhalten. If (adjusthour == 0 && adjusthour_state == 1) { adjusthour_state = 0; } if(adjusthour == 1 && adjusthour_state == 0 && measure_process == 0) { adjust_process = 1; } //----------------------------------------------------------- ---Messprozess--------------------------------------------------------- -------------- if(measure_process == 1) { updateTemp(); Byte contMin = 0, contHour = 0; DS1307.getDate(DataTime); IstMin = DataTime[5]; //------------------------------------------------ ---------- Minuten zählen -------------------------------------- ------------------- if(actualMin != previousMin) { contMin++; vorherigeMin = aktuelleMin; } if(contMin == 5) { sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); sensoren.requestTemperatures(); float TempSensor = Sensoren.getTempCByIndex(0); myFile.print (Zeiten); myFile.println (TempSensor); contMin = 0; } //----------------------------------------------------------- ------------ Stunden zählen ------------------------------------ ---------------------- if(actualHour != previousHour) { contHour++; vorherigeStunde = aktuelleStunde; } if(contHour == 5) { myFile.close(); lcd.clear(); lcd.setCursor(5, 0); lcd.print("Fertig"); lcd.setCursor(5, 1); lcd.print("Prozess"); mess_prozess = 0; conStour = 0; } //----------------------------------------------Zustand um den Datenlogger zu stoppen ---------------------------------------------------------- ---- if(ok == 1) { myFile.close(); lcd.clear(); lcd.setCursor(6, 0); lcd.print("Gestoppt"); lcd.setCursor(5, 1); lcd.print("Prozess"); mess_prozess = 0; Verzögerung (2000); lcd.clear(); DS1307.getDate(DataTime); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 0); lcd.print (Zeiten); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O/P"); } } //--------------------------------------------------------- ------- Stunden anpassen ------------------------------------------ ---------------------- //Stunde anpassen if(adjust_process == 1) {lcd.clear(); DS1307.getDate(DataTime); lcd.setCursor(0, 0); lcd.print("Stunde anpassen:"); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print (Zeiten); // Stunde anpassen tun { messen = digitalRead (Buttonmeasure); adjusthour = digitalRead (Buttonadjusthour); ok = digitalRead (Buttonok); if(maß == 0 && messzustand == 1) { messzustand = 0; } if(measure == 1 && measure_state == 0) { DataTime[4]++; if(DataTime[4] > 23) { DataTime[4] = 0; } Messzustand = 1; sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print (Zeiten); DS1307.setDate(DataTime[0], DataTime[1], DataTime[2], DataTime[3], DataTime[4], DataTime[5], 00); aufrechtzuerhalten. 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 (Zeiten); DS1307.setDate(DataTime[0], DataTime[1], DataTime[2], DataTime[3], DataTime[4], DataTime[5], 00); adjusthour_state = 1; aufrechtzuerhalten. Wenn (ok == 1) {lcd.clear(); DS1307.getDate(DataTime); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(0, 0); lcd.print (Zeiten); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O"); adjust_process = 0; } } while(ok != 1); } //----------------------------------------------------------- ---------- Ende der Anpassungsstunde -------------------------------------- ------------------- }

Zuerst definieren wir alle Bibliotheken zur Steuerung der Module und zur Deklaration von Variablen, die bei der Programmierung des JLCPCB Dataloggers mit einem Temperatursensor für Arduino verwendet werden. Der Codeblock ist unten dargestellt.

Schritt 3:

#include //Bibliothek mit allen Funktionen des DS18B20-Sensors

#include #include //Biblioteca I2C do LCD 16x2 #include //Biblioteca de Comunicacao I2C #include //OneWire-Bibliothek für DS18B20 Sensor #include #include LiquidCrystal_I2C lcd (0x27, 16, 2); // Configurando oder endereco do LCD 16x2 para 0x27 #define ONE_WIRE_BUS 8 //Digitaler Pin zum Anschluss des DS18B20 Sensors //Define uma instancia do oneWire para comunicacao com o sensor OneWire oneWire(ONE_WIRE_BUS); DallasTemperatursensoren(&oneWire); Geräteadresse sensor1; Datei meineDatei; #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 IstMin = 0, VorherMin = 0; Byte aktuelle Stunde = 0, vorherige Stunde = 0; Byte minUpdate = 0; int pinoSS = 10; // Pin 53 für Mega / Pin 10 für UNO int DataTime[7];

Im Folgenden haben wir die Funktion void setup. Diese Funktion wird verwendet, um die Pins und die Geräteinitialisierung zu konfigurieren, wie unten gezeigt.

Void-Setup ()

{ Serial.begin (9600); DS1307.begin(); sensoren.begin(); pinMode (pinoSS, AUSGANG); // Declara pinoSS como saída Wire.begin(); //Inicializacao da Comunicacao I2C lcd.init(); // Initialisieren Sie LCD lcd.backlight (); lcd.setCursor(3, 0); lcd.print("Temp-System"); lcd.setCursor(3, 1); lcd.print("Datenlogger"); Verzögerung (2000); // Localiza e mostra enderecos dos sensores Serial.println ("Localizando sensores DS18B20…"); Serial.print ("Sensorlokalisierung erfolgreich!"); 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."); Rückkehr; } DS1307.getDate(DataTime); lcd.clear(); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 0); lcd.print (Zeiten); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O/P"); }

Zuerst wurde die serielle Kommunikation, die Echtzeituhr und der Temperatursensor für Arduino DS18B20 gestartet. Nach dem Initialisieren und Testen der Geräte wurde die Meldung mit den Menüoptionen auf dem 16x2 LCD-Bildschirm ausgedruckt. Dieser Bildschirm ist in Abbildung 1 dargestellt.

Schritt 4:

Danach liest das System die Stunden und aktualisiert den Wert durch Aufrufen der Funktion updateHour. Diese Funktion hat also den Zweck, den Stundenwert jede Minute anzuzeigen. Der Funktionscodeblock ist unten dargestellt.

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

Schritt 5:

Neben der Aktualisierung der Stunden kann der Benutzer eine der drei Schaltflächen auswählen, um den Patienten mit einem Temperatursensor mit Arduino zu überwachen. Die Schaltung ist in der obigen Abbildung dargestellt.

Schritt 6: JLCPCB-Datenlogger-Steuerungsmenü

Zunächst muss der Benutzer die Systemstunden überprüfen und anpassen. Dieser Vorgang wird ausgeführt, wenn die zweite Taste gedrückt wird.

Wenn die Taste gedrückt wird, sollte der folgende Bildschirm erscheinen, der in der Abbildung oben gezeigt ist.

Schritt 7:

Auf diesem Bildschirm kann der Benutzer die Stunden- und Minutenwerte über die Tasten eingeben, die mit den digitalen Pins 2 und 3 des Arduino verbunden sind. Die Schaltflächen sind in der Abbildung oben dargestellt.

Der Codeteil zur Steuerung der Stunden ist unten dargestellt.

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

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

Wenn die Stundentaste gedrückt wird und die Variable measure_process auf 0 gesetzt wird, ist die Bedingung wahr und die Variable adjust_process wird auf 1 gesetzt. Die Variable measure_process wird verwendet, um zu signalisieren, dass das System die Temperatur überwacht. Wenn der Wert 0 ist, erlaubt das System dem Benutzer, das Zeiteinstellungsmenü aufzurufen. Nachdem die Variable adjust_process einen Wert von 1 erhalten hat, tritt das System daher in die Zeitanpassungsbedingung ein. Dieser Codeblock wird unten gezeigt.

//------------------------------------------------ -----Stunden anpassen------------------------------------------------------ --------------------

//Stunde anpassen if(adjust_process == 1) {lcd.clear(); DS1307.getDate(DataTime); lcd.setCursor(0, 0); lcd.print("Stunde anpassen:"); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print (Zeiten); // Stunde anpassen tun { messen = digitalRead (Buttonmeasure); adjusthour = digitalRead (Buttonadjusthour); ok = digitalRead (Buttonok); if(maß == 0 && messzustand == 1) { messzustand = 0; } if(measure == 1 && measure_state == 0) { DataTime[4]++; if(DataTime[4] > 23) { DataTime[4] = 0; } Messzustand = 1; sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print (Zeiten); DS1307.setDate(DataTime[0], DataTime[1], DataTime[2], DataTime[3], DataTime[4], DataTime[5], 00); aufrechtzuerhalten. 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 (Zeiten); DS1307.setDate(DataTime[0], DataTime[1], DataTime[2], DataTime[3], DataTime[4], DataTime[5], 00); adjusthour_state = 1; aufrechtzuerhalten. Wenn (ok == 1) {lcd.clear(); DS1307.getDate(DataTime); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(0, 0); lcd.print (Zeiten); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O"); adjust_process = 0; } } Während (ok ! = 1); }

In diesem Zustand zeigt das System die in Abbildung 4 gezeigte Meldung an und wartet dann auf die interne Anpassung der Werte in der while-Schleife. Beim Einstellen der Stunden werden diese Tasten in ihrer Funktion geändert, dh sie sind multifunktional.

Dadurch können Sie eine Taste für mehr als eine Funktion verwenden und die Komplexität des Systems reduzieren.

Auf diese Weise passt der Benutzer den Wert der Stunden und Minuten an und speichert die Daten dann im System, wenn die Ok-Taste gedrückt wird.

Wie Sie sehen, liest das System die 3 Tasten, wie unten gezeigt.

messen = digitalRead (Buttonmeasure);

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

Beachten Sie, dass die Funktion der Messtaste (Buttonmeasure) geändert wurde. Es wird nun verwendet, um die Stundenwerte wie unten gezeigt einzustellen. Die folgenden beiden Bedingungen sind ähnlich und werden verwendet, um die Stunden und Minuten einzustellen, wie oben gezeigt.

if(Measure == 0 && Measure_state == 1)

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

Daher wird jedes Mal, wenn eine der beiden Tasten gedrückt wird, der Wert der Positionen 4 und 5 des DataTime-Vektors geändert und zweitens werden diese Werte im Speicher des DS1307 gespeichert.

Nach den Anpassungen muss der Benutzer auf die Schaltfläche Ok klicken, um den Vorgang abzuschließen. Wenn dieses Ereignis eintritt, führt das System die folgenden Codezeilen aus.

wenn(ok == 1)

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

Es tritt in die obige Bedingung ein und präsentiert dem Benutzer die Stundennachricht und das Optionsmenü.

Schließlich muss der Benutzer den Patientenüberwachungsprozess über den Temperatursensor mit Arduino JLCPCB Datalogger starten.

Dazu muss der Benutzer die Messtaste drücken, die mit dem digitalen Pin 2 verbunden ist.

Dann führt das System das Lesen mit dem Temperatursensor für Arduino durch und speichert es auf der Speicherkarte. Der Schaltungsbereich ist in der obigen Abbildung dargestellt.

Schritt 8:

Daher wird beim Drücken der Schaltfläche der folgende Codeabschnitt ausgeführt.

if(Measure == 0 && Measure_state == 1)

{ Messzustand = 0; } if(Measure == 1 && measure_state == 0 && measure_process == 0) {Measure_process = 1; Messzustand = 1; if (SD.exists("temp.txt")) {Serial.println("Apagou oder 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(); } Verzögerung (500); myFile.print("Stunde: "); myFile.println("Temperatur"); DS1307.getDate(DataTime); aktuellesMin = vorherigesMin = DataTime[5]; sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.clear(); lcd.setCursor(5, 0); lcd.print (Zeiten); lcd.setCursor(0, 1); lcd.print("Temperatur:"); lcd.setCursor(14, 1); sensoren.requestTemperatures(); float TempSensor = Sensoren.getTempCByIndex(0); lcd.print (TempSensor); }

Im obigen Codeteil weist das System der Variablen measure_process den Wert 1 zu. Er ist dafür verantwortlich, dass die Daten auf der SD-Karte gespeichert werden.

Außerdem prüft das System, ob eine Textdatei mit Datenprotokoll existiert oder nicht. Wenn eine Datei vorhanden ist, löscht das System und erstellt eine neue, um die Daten zu speichern.

Danach werden zwei Spalten erstellt: eine für die Stunden und eine für die Temperatur in der Textdatei.

Danach werden die Stunden und die Temperatur auf dem LCD-Bildschirm angezeigt, wie in der Abbildung oben gezeigt.

Danach führt der Codefluss den folgenden Programmblock aus.

if(Measure_process == 1)

{ updateTemp(); Byte contMin = 0, contHour = 0; DS1307.getDate(DataTime); IstMin = DataTime[5]; //------------------------------------------------ ---------- Minuten zählen -------------------------------------- ------------------- if(actualMin != previousMin) { contMin++; vorherigeMin = aktuelleMin; } if(contMin == 5) { sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); sensoren.requestTemperatures(); float TempSensor = Sensoren.getTempCByIndex(0); myFile.print (Zeiten); myFile.println (TempSensor); contMin = 0; } //----------------------------------------------------------- ------------ Stunden zählen ------------------------------------ ---------------------- if(actualHour != previousHour) { contHour++; vorherigeStunde = aktuelleStunde; } if(contHour == 5) { myFile.close(); lcd.clear(); lcd.setCursor(5, 0); lcd.print("Fertig"); lcd.setCursor(5, 1); lcd.print("Prozess"); mess_prozess = 0; conStour = 0; } //----------------------------------------------Zustand um den Datenlogger zu stoppen-----

Zuerst wird die Funktion updateTemp() ausgeführt. Sie ähnelt der Funktion updateHour(); es zeigt jedoch alle 1 Minute die Temperatur an.

Danach sammelt das System die Zeitdaten von der Echtzeituhr und speichert den aktuellen Minutenwert in der Variablen currentMin.

Dann wird geprüft, ob die min-Variable gemäß der unten angegebenen Bedingung geändert wurde

if(actualMin != previousMin)

{ contMin++; vorherigeMin = aktuelleMin; }

Wenn sich die aktuelle Minutenvariable vom vorherigen Wert unterscheidet, bedeutet dies, dass eine Wertänderung aufgetreten ist. Auf diese Weise ist die Bedingung wahr und der Wert der Minutenzählung wird erhöht (contMin) und der aktuelle Wert wird der Variablen previousMin zugewiesen, um ihren vorherigen Wert zu speichern.

Wenn der Wert dieser Zählung 5 beträgt, bedeutet dies, dass 5 Minuten vergangen sind und das System eine neue Temperaturmessung durchführen und den Stunden- und Temperaturwert in der Protokolldatei der SD-Karte speichern muss.

if(contMin == 5)

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

Auf diese Weise wird dieser Vorgang wiederholt, bis der Wert von 5 Stunden der Überwachung der Patiententemperatur mit dem Temperatursensor mit Arduino erreicht ist.

Der Codeteil wird unten angezeigt und ähnelt der oben vorgestellten Minutenzählung.

//------------------------------------------------ ---------- Stunden zählen -------------------------------------- ---------------------

if(actualHour != previousHour) { contHour++; vorherigeStunde = aktuelleStunde; } if(contHour == 5) { myFile.close(); lcd.clear(); lcd.setCursor(5, 0); lcd.print("Fertig"); lcd.setCursor(5, 1); lcd.print("Prozess"); mess_prozess = 0; conStour = 0; }

Nach Erreichen von 5 Stunden Überwachung schließt das System die Protokolldatei und zeigt dem Benutzer die Meldung "Abgeschlossener Prozess" an.

Außerdem kann der Benutzer die Ok/Pause-Taste drücken, um die Datenaufzeichnung zu stoppen. In diesem Fall wird der folgende Codeblock ausgeführt.

//---------------------------------------------------------- Bedingung für Stoppen Sie den Datenlogger---------------------------------------------------------- ---

if(ok == 1) { meineDatei.close(); lcd.clear(); lcd.setCursor(6, 0); lcd.print("Gestoppt"); lcd.setCursor(5, 1); lcd.print("Prozess"); mess_prozess = 0; Verzögerung (2000); lcd.clear(); DS1307.getDate(DataTime); sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 0); lcd.print (Zeiten); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O/P"); }

Schritt 9:

Dann schließt das System die Datei und zeigt die Meldung "Stoped Process" an, wie in Abbildung 8 gezeigt.

Schritt 10:

Danach druckt das System den Zeitbildschirm und die Menüoptionen, wie in Abbildung 9 gezeigt.

Schritt 11: Zugriff auf SD-Kartenmoduldaten mit Arduino

Nach der Überwachung des JLCPCB Dataloggers mit dem Temperatursensor mit Arduino ist es notwendig, die Speicherkarte zu entfernen und auf die Daten auf dem Computer zuzugreifen.

Um die Daten mit besserer Qualität anzuzeigen und zu analysieren, exportieren / kopieren Sie alle Informationen der Textdatei nach Excel. Danach können Sie Grafiken zeichnen und die erhaltenen Ergebnisse analysieren.

Schritt 12: Fazit

Der JLCPCB Datalogger mit Temperatursensor mit Arduino ermöglicht uns neben der Temperaturmessung auch Informationen über das Temperaturverhalten des Patienten über einen Zeitraum aufzuzeichnen.

Mit diesen gespeicherten Daten ist es möglich zu analysieren und zu verstehen, wie sich die Temperatur des mit COVID-19 infizierten Patienten verhält.

Darüber hinaus ist es möglich, das Temperaturniveau zu bewerten und seinen Wert mit der Anwendung bestimmter Medikamente zu verknüpfen.

Daher zielt der JLCPCB Datalogger mit Temperatursensor für Arduino durch diese Daten darauf ab, Ärzte und Pflegepersonal bei der Untersuchung des Patientenverhaltens zu unterstützen.

Schließlich danken wir der Firma JLCPCB für die Unterstützung bei der Entwicklung des Projekts und hoffen, dass Sie es nutzen können

Alle Dateien können von jedem Benutzer heruntergeladen und frei verwendet werden.