Czujnik temperatury dla Arduino Applied for COVID 19: 12 kroków (ze zdjęciami)

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:28

Czujnik temperatury dla Arduino jest podstawowym elementem, gdy chcemy zmierzyć temperaturę procesora ludzkiego ciała.

Czujnik temperatury z Arduino musi być w kontakcie lub blisko, aby odbierać i mierzyć poziom ciepła. Tak działają termometry.

Urządzenia te są niezwykle wykorzystywane do pomiaru temperatury ciała chorych, ponieważ temperatura jest jednym z pierwszych czynników, które zmieniają się w ludzkim ciele w przypadku wystąpienia nieprawidłowości lub choroby.

Jedną z chorób zmieniających temperaturę ludzkiego ciała jest COVID 19. Dlatego przedstawiamy główne objawy:

Kaszel Zmęczenie Trudności w oddychaniu (Ciężkie przypadki) Gorączka Gorączka jest objawem, którego główną cechą jest wzrost temperatury ciała. W tej chorobie musimy stale monitorować te objawy.

W związku z tym opracujemy projekt monitorowania temperatury i przechowywania tych danych na karcie pamięci poprzez Datalogger JLCPCB z wykorzystaniem czujnika temperatury z Arduino.

Dlatego w tym artykule dowiesz się:

• Jak działa Datalogger JLCPCB z czujnikiem temperatury z Arduino?
• Jak działa czujnik temperatury z Arduino.
• Jak działa czujnik temperatury DS18B20 z Arduino?
• Użyj przycisków z wieloma funkcjami.

Następnie pokażemy, jak rozwijać swój rejestrator danych JLCPCB przy użyciu czujnika temperatury Arduino.

Kieszonkowe dzieci

Arduino UNO

Płytka drukowana JLCPCB

Czujnik temperatury DS18B20

Arduino Nano R3

Zworki

Wyświetlacz LCD 16x2

Wciśnij przycisk przełącznika

Rezystor 1kR

Moduł karty SD dla Arduino

Krok 1: Budowa rejestratora danych JLCPCB z czujnikiem temperatury z Arduino

Jak wcześniej wspomniano, projekt polega na stworzeniu rejestratora danych JLCPCB z czujnikiem temperatury z Arduino, a dzięki tym danym możemy monitorować temperaturę leczonego pacjenta.

Tak więc obwód pokazano na powyższym rysunku.

Dlatego jak widać układ ten posiada czujnik temperatury DS18B20 z Arduino, który odpowiada za pomiar odczytu temperatury pacjenta.

Dodatkowo Arduino Nano będzie odpowiedzialne za zbieranie tych danych i przechowywanie ich na karcie pamięci modułu SD Card.

Każda informacja zostanie zapisana z odpowiednim czasem, który zostanie odczytany z modułu RTC DS1307.

W związku z tym, aby dane czujnika temperatury z Arduino zostały zapisane, użytkownik musi wykonać proces poprzez Menu Sterowania z wyświetlaczem LCD 16x2.

Krok 2:

Każdy przycisk odpowiada za sterowanie opcją, jak pokazano na ekranie LCD 16x2 na rysunku 2.

Każda opcja odpowiada za realizację funkcji w systemie, jak pokazano poniżej.

• Opcja M odpowiada za uruchomienie pomiaru i rejestrację danych na Karcie Pamięci.
• Opcja H odpowiada za dostosowanie godzin pracy systemu.
• Opcja O/P służy do potwierdzenia wprowadzenia danych do systemu lub wstrzymania zapisu danych na kartę pamięci.

Aby zrozumieć proces sterowania systemem, udostępnimy poniższy kod i omówimy krok po kroku system sterowania rejestratora danych JLCPCB z czujnikiem temperatury z Arduino.

#Include //Biblioteka ze wszystkimi funkcjami czujnika DS18B20

#include #include //Biblioteka I2C do LCD 16x2 #include //Biblioteka Komunikacji I2C #include //Biblioteka OneWire dla czujnika DS18B20 #include #include LiquidCrystal_I2C lcd(0x27, 16, 2); // Konfiguracja endereco do LCD 16x2 dla 0x27 #define ONE_WIRE_BUS 8 //Cyfrowy pin do podłączenia czujnika DS18B20 //Define instancia do oneWire dla komunikacji z czujnikiem OneWire oneWire(ONE_WIRE_BUS); DallasCzujniki temperatury(&oneWire); Czujnik adresu urządzenia1; Plik mójPlik; #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; bajt aktualnyMin = 0, poprzedniMin = 0; bajt rzeczywista godzina = 0, poprzednia godzina = 0; bajt minAktualizacja = 0; int pinoSS = 10; // Pin 53 dla Mega / Pin 10 dla 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(razy); minAktualizacja = DataCzas[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(razy); lcd.setCursor(0, 1); lcd.print("Temperatura: "); lcd.setCursor(14, 1); sensory.żądanieTemperatury(); float TempSensor = sensors.getTempCByIndex(0); lcd.print(TempSensor); minAktualizacja = DataCzas[5]; } } void setup() { Serial.begin(9600); DS1307.początek(); czujniki.początek(); pinMode(pinoSS, WYJŚCIE); // Deklaracja pinoSS como saída Wire.begin(); //Zapoczątkowanie przez Comunicacao I2C lcd.init(); //Zapoczątkuj LCD lcd.backlight(); lcd.setCursor(3, 0); lcd.print("System Temp"); lcd.setCursor(3, 1); lcd.print("Datalogger"); opóźnienie (2000); // Localiza e mostra enderecos dos sensores Serial.println("Localizando sensores DS18B20…"); Serial.print("Lokalizacja czujnika pomyślnie!"); Serial.print(czujniki.getDeviceCount(), DEC); Serial.println("Czujnik"); if(SD.begin()) { // Zainicjuj kartę SD Serial.println("Karta SD od razu do użycia."); // Imprime na tela } else { Serial.println("Falha inicialização do SD Card."); powrót; } DS1307.getDate(DataCzas); lcd.clear(); sprintf(razy, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 0); lcd.print(razy); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O/P"); } void loop() { godzina aktualizacji(); //Odczyt stanów przycisków Measure = digitalRead(Buttonmeasure); dostosujgodzinę = digitalRead(Przyciskdostosujgodzinę); ok = digitalRead (Przyciskok); if(measure == 0 && Measure_state == 1) { Measure_state = 0; } if(miara == 1 && stan_miary == 0 && proces_miary == 0) { proces_miary = 1; stan_miary = 1; if (SD.exists("temp.txt")) { Serial.println("Apagou o arquivo anterior!"); SD.remove("temp.txt"); mójPlik = SD.open("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt Serial.println("Criou o arquivo!"); } else { Serial.println("Criou o arquivo!"); mójPlik = SD.open("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt myFile.close(); } opóźnienie(500); myFile.print("Godzina: "); myFile.println("Temperatura"); DS1307.getDate(DataCzas); rzeczywista Min = poprzednia Min = DataCzas[5]; sprintf(razy, "%02d:%02d", DataTime[4], DataTime[5]); lcd.clear(); lcd.setCursor(5, 0); lcd.print(razy); lcd.setCursor(0, 1); lcd.print("Temperatura: "); lcd.setCursor(14, 1); sensory.żądanieTemperatury(); float TempSensor = sensors.getTempCByIndex(0); lcd.print(TempSensor); } if(dostosujhour == 0 && dostosujhour_state == 1) { dostosujhour_state = 0; } if(dostosujgodzinę == 1 && dostosujgodzina_stan == 0 && pomiar_procesu == 0) { dostosuj_proces = 1; } //--------------------------------------------------------------- ---Proces pomiarowy--------------------------------------------- -------------- if(measure_process == 1) { updateTemp(); bajt contMin = 0, contHour = 0; DS1307.getDate(DataCzas); rzeczywista min = czas danych[5]; //------------------------------------------------ ---------Policz minuty--------------------------------------- ------------------- if(rzeczywistyMin != poprzedniMin) { contMin++; poprzednia min = rzeczywista min; } if(contMin == 5) { sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); sensory.żądanieTemperatury(); float TempSensor = sensory.getTempCByIndex(0); mójPlik.print(razy); myFile.println(TempSensor); contMin = 0; } //--------------------------------------------------------------- ------------Liczba godzin ------------------------------------ ---------------------- if(rzeczywistaGodzina != poprzedniaGodzina) { contGodzina++; poprzednia godzina = aktualna godzina; } if(contHour == 5) { myFile.close(); lcd.clear(); lcd.setCursor(5, 0); lcd.print("Zakończono"); lcd.setCursor(5, 1); lcd.print("Proces"); proces_miara = 0; kontGodzina = 0; } //----------------------------------------------Stan: schorzenie aby zatrzymać rejestrator danych -------------------------------------------------------------- ---- if(ok == 1) { mójPlik.zamknij(); lcd.clear(); lcd.setCursor(6, 0); lcd.print("Zatrzymany"); lcd.setCursor(5, 1); lcd.print("Proces"); proces_miara = 0; opóźnienie (2000); lcd.clear(); DS1307.getDate(DataCzas); sprintf(razy, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 0); lcd.print(razy); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O/P"); } } //-------------------------------------------------------------- ------- Dostosuj godziny ----------------------------------------- ---------------------- //Dostosuj godzinę if(adjust_process == 1) { lcd.clear(); DS1307.getDate(DataCzas); lcd.setCursor(0, 0); lcd.print("Dostosuj godzinę:"); sprintf(razy, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(razy); //Dostosuj godzinę do { Measure = digitalRead(Buttonmeasure); dostosujgodzinę = digitalRead(Przyciskdostosujgodzinę); ok = digitalRead (Przyciskok); if(measure == 0 && Measure_state == 1) { Measure_state = 0; } if(measure == 1 && Measure_state == 0) { DataTime[4]++; if(CzasDanych[4] > 23) {CzasDanych[4] = 0; } stan_miara = 1; sprintf(razy, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(razy); DS1307.setDate(CzasDanych[0],CzasDanych[1],CzasDanych[2],CzasDanych[3],CzasDanych[4],CzasDanych[5], 00); } if(dostosujhour == 0 && dostosujhour_state == 1) { dostosujhour_state = 0; } if(adjusthour == 1 && adjusthour_state == 0) { DataTime[5]++; if(CzasDanych[5] > 59) {CzasDanych[5] = 0; } sprintf(razy, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(razy); DS1307.setDate(CzasDanych[0],CzasDanych[1],CzasDanych[2],CzasDanych[3],CzasDanych[4],CzasDanych[5], 00); dostosuj stan_godziny = 1; } if(ok == 1) { lcd.clear(); DS1307.getDate(DataCzas); sprintf(razy, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(0, 0); lcd.print(razy); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O"); proces_dostosowania = 0; } } while(ok !=1); } //--------------------------------------------------------------- -------Zakończ godzinę regulacji---------------------------------------- ------------------- }

Najpierw definiujemy wszystkie biblioteki do sterowania modułami i deklarowania zmiennych wykorzystywanych podczas programowania JLCPCB Datalogger z czujnikiem temperatury dla Arduino. Blok kodu pokazano poniżej.

Krok 3:

#Include //Biblioteka ze wszystkimi funkcjami czujnika DS18B20

#include #include //Biblioteka I2C do LCD 16x2 #include //Biblioteka Komunikacji I2C #include //Biblioteka OneWire dla czujnika DS18B20 #include #include LiquidCrystal_I2C lcd(0x27, 16, 2); // Konfiguracja endereco do LCD 16x2 dla 0x27 #define ONE_WIRE_BUS 8 //Cyfrowy pin do podłączenia czujnika DS18B20 //Define instancia do oneWire dla komunikacji z czujnikiem OneWire oneWire(ONE_WIRE_BUS); DallasCzujniki temperatury(&oneWire); Czujnik adresu urządzenia1; Plik mójPlik; #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; bajt aktualnyMin = 0, poprzedniMin = 0; bajt rzeczywista godzina = 0, poprzednia godzina = 0; bajt minAktualizacja = 0; int pinoSS = 10; // Pin 53 dla Mega / Pin 10 dla UNO int DataTime[7];

Odtąd mamy funkcję void setup. Ta funkcja służy do konfiguracji pinów i inicjalizacji urządzenia, jak pokazano poniżej.

pusta konfiguracja()

{ Szeregowy.początek(9600); DS1307.początek(); czujniki.początek(); pinMode(pinoSS, WYJŚCIE); // Deklaracja pinoSS como saída Wire.begin(); //Zapoczątkowanie przez Comunicacao I2C lcd.init(); //Zapoczątkuj LCD lcd.backlight(); lcd.setCursor(3, 0); lcd.print("System Temp"); lcd.setCursor(3, 1); lcd.print("Datalogger"); opóźnienie (2000); // Localiza e mostra enderecos dos sensores Serial.println("Localizando sensores DS18B20…"); Serial.print("Lokalizacja czujnika pomyślnie!"); Serial.print(czujniki.getDeviceCount(), DEC); Serial.println("Czujnik"); if(SD.begin()) { // Zainicjuj kartę SD Serial.println("Karta SD od razu do użycia."); // Imprime na tela } else { Serial.println("Falha inicialização do SD Card."); powrót; } DS1307.getDate(DataCzas); lcd.clear(); sprintf(razy, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 0); lcd.print(razy); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O/P"); }

W pierwszej kolejności uruchomiono komunikację szeregową, zegar czasu rzeczywistego oraz czujnik temperatury dla Arduino DS18B20. Po zainicjowaniu i przetestowaniu urządzeń komunikat z opcjami menu został wydrukowany na ekranie LCD 16x2. Ten ekran pokazano na rysunku 1.

Krok 4:

Następnie system odczytuje godziny i aktualizuje wartość, wywołując funkcję updateHour. Funkcja ta ma więc na celu prezentację wartości godzinowej co minutę. Blok kodu funkcji pokazano poniżej.

nieważna godzina aktualizacji()

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

Krok 5:

Oprócz aktualizacji godzin użytkownik może wybrać jeden z trzech przycisków do monitorowania pacjenta czujnikiem temperatury z Arduino. Obwód pokazano na powyższym rysunku.

Krok 6: Menu sterowania rejestratorem danych JLCPCB

Najpierw użytkownik musi sprawdzić i dostosować godziny pracy systemu. Ten proces jest wykonywany po naciśnięciu drugiego przycisku.

Po naciśnięciu przycisku powinien pojawić się następujący ekran, który pokazano na powyższym rysunku.

Krok 7:

Z tego ekranu użytkownik będzie mógł wprowadzić wartości godzin i minut za pomocą przycisków podłączonych do cyfrowych pinów 2 i 3 Arduino. Przyciski pokazano na powyższym rysunku.

Część kodu do kontrolowania godzin jest pokazana poniżej.

if(dostosujgodzinę == 0 && dostosujgodzinę_stan == 1)

{ dostosuj stan_godziny = 0; } if(dostosujgodzinę == 1 && dostosujgodzina_stan == 0 && pomiar_procesu == 0) { dostosuj_proces = 1; }

Gdy naciśnięty zostanie przycisk godzin, a zmienna pomiar_procesu jest ustawiona na 0, warunek będzie prawdziwy, a zmienna korekta_procesu zostanie ustawiona na 1. Zmienna pomiar_procesu jest używana do sygnalizowania, że system monitoruje temperaturę. Gdy jego wartość wynosi 0, system pozwoli użytkownikowi wejść do menu ustawiania czasu. Dlatego po tym, jak zmienna adjust_process otrzyma wartość 1, system wejdzie w warunek korekty czasu. Ten blok kodu jest pokazany poniżej.

//------------------------------------------------ -----Dostosuj godziny----------------------------------------------- --------------------

//Dostosuj godzinę if(adjust_process == 1) { lcd.clear(); DS1307.getDate(DataCzas); lcd.setCursor(0, 0); lcd.print("Dostosuj godzinę:"); sprintf(razy, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(razy); //Dostosuj godzinę do { Measure = digitalRead(Buttonmeasure); dostosujgodzinę = digitalRead(Przyciskdostosujgodzinę); ok = digitalRead (Przyciskok); if(measure == 0 && Measure_state == 1) { Measure_state = 0; } if(measure == 1 && Measure_state == 0) { DataTime[4]++; if(CzasDanych[4] > 23) {CzasDanych[4] = 0; } stan_miara = 1; sprintf(razy, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(razy); DS1307.setDate(CzasDanych[0],CzasDanych[1],CzasDanych[2],CzasDanych[3],CzasDanych[4],CzasDanych[5], 00); } if(dostosujhour == 0 && dostosujhour_state == 1) { dostosujhour_state = 0; } if(adjusthour == 1 && adjusthour_state == 0) { DataTime[5]++; if(CzasDanych[5] > 59) {CzasDanych[5] = 0; } sprintf(razy, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(razy); DS1307.setDate(CzasDanych[0],CzasDanych[1],CzasDanych[2],CzasDanych[3],CzasDanych[4],CzasDanych[5], 00); dostosuj stan_godziny = 1; } if(ok == 1) { lcd.clear(); DS1307.getDate(DataCzas); sprintf(razy, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(0, 0); lcd.print(razy); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O"); proces_dostosowania = 0; } } while(ok !=1); }

W tym stanie system wyświetli komunikat pokazany na rysunku 4, a następnie poczeka na wewnętrzne dostosowanie wartości w pętli while. Podczas ustawiania godzin przyciski te mają zmienione funkcje, czyli są wielofunkcyjne.

Pozwala to na użycie przycisku dla więcej niż jednej funkcji i zmniejszenie złożoności systemu.

W ten sposób użytkownik dostosuje wartość godzin i minut, a następnie po naciśnięciu przycisku OK zapisze dane w systemie.

Jak widać, system odczyta 3 przyciski, jak pokazano poniżej.

miara = digitalRead (przycisk miara);

dostosujgodzinę = digitalRead(Przyciskdostosujgodzinę); ok = digitalRead (Przyciskok);

Zauważ, że przycisk pomiaru (Buttonmeasure) zmienił swoją funkcję. Będzie on teraz używany do regulacji wartości godzin, jak pokazano poniżej. Poniższe dwa warunki są podobne i służą do regulacji godzin i minut, jak pokazano powyżej.

if(miara == 0 && stan_miara == 1)

{ stan_miara = 0; } if(measure == 1 && Measure_state == 0) { DataTime[4]++; if(CzasDanych[4] > 23) {CzasDanych[4] = 0; } stan_miara = 1; sprintf(razy, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(razy); DS1307.setDate(CzasDanych[0],CzasDanych[1],CzasDanych[2],CzasDanych[3],CzasDanych[4],CzasDanych[5], 00); } if(dostosujhour == 0 && dostosujhour_state == 1) { dostosujhour_state = 0; } if(adjusthour == 1 && adjusthour_state == 0) { DataTime[5]++; if(CzasDanych[5] > 59) {CzasDanych[5] = 0; } sprintf(razy, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(razy); DS1307.setDate(CzasDanych[0],CzasDanych[1],CzasDanych[2],CzasDanych[3],CzasDanych[4],CzasDanych[5], 00); dostosuj stan_godziny = 1; }

Dlatego każdorazowe naciśnięcie jednego z dwóch przycisków powoduje zmianę wartości pozycji 4 i 5 wektora DataTime, a po drugie wartości te zostaną zapisane w pamięci DS1307.

Po dostosowaniu użytkownik musi kliknąć przycisk OK, aby zakończyć proces. Po wystąpieniu tego zdarzenia system wykona następujące wiersze kodu.

jeśli(ok == 1)

{ lcd.wyczyść(); DS1307.getDate(DataCzas); sprintf(razy, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(0, 0); lcd.print(razy); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O"); proces_dostosowania = 0; }

Wejdzie w powyższy warunek i zaprezentuje użytkownikowi komunikat godzinowy oraz Menu Opcji.

Na koniec użytkownik musi rozpocząć proces monitorowania pacjenta za pomocą czujnika temperatury z rejestratorem danych Arduino JLCPCB.

W tym celu użytkownik musi nacisnąć przycisk pomiaru, który jest podłączony do cyfrowego pinu 2.

Następnie system wykona odczyt z czujnika temperatury dla Arduino i zapisze go na karcie pamięci. Region obwodu pokazano na powyższym rysunku.

Krok 8:

Dlatego po naciśnięciu przycisku zostanie wykonana następna część kodu.

if(miara == 0 && stan_miara == 1)

{ stan_miara = 0; } if(miara == 1 && stan_miary == 0 && proces_miary == 0) { proces_miary = 1; stan_miary = 1; if (SD.exists("temp.txt")) { Serial.println("Apagou o arquivo anterior!"); SD.remove("temp.txt"); mójPlik = SD.open("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt Serial.println("Criou o arquivo!"); } else { Serial.println("Criou o arquivo!"); mójPlik = SD.open("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt myFile.close(); } opóźnienie(500); myFile.print("Godzina: "); myFile.println("Temperatura"); DS1307.getDate(DataCzas); rzeczywista Min = poprzednia Min = DataCzas[5]; sprintf(razy, "%02d:%02d", DataTime[4], DataTime[5]); lcd.clear(); lcd.setCursor(5, 0); lcd.print(razy); lcd.setCursor(0, 1); lcd.print("Temperatura: "); lcd.setCursor(14, 1); sensory.żądanieTemperatury(); float TempSensor = sensory.getTempCByIndex(0); lcd.print(TempSensor); }

W powyższej części kodu system przypisze wartość 1 do zmiennej Measure_process. Odpowiada za umożliwienie zapisu danych na karcie SD.

Dodatkowo system sprawdzi, czy istnieje plik tekstowy z logiem danych, czy nie. Jeśli istnieje plik, system usunie i utworzy nowy do przechowywania danych.

Następnie utworzy dwie kolumny: jedną z godzinami, a drugą z temperaturą w pliku tekstowym.

Następnie wyświetli godziny i temperaturę na ekranie LCD, jak pokazano na powyższym rysunku.

Następnie przepływ kodu wykona następujący blok programu.

if(proces_miara == 1)

{ aktualizacjaTemp(); bajt contMin = 0, contHour = 0; DS1307.getDate(DataCzas); rzeczywista min = czas danych[5]; //------------------------------------------------ ---------Policz minuty--------------------------------------- ------------------- if(rzeczywistyMin != poprzedniMin) { contMin++; poprzednia min = rzeczywista min; } if(contMin == 5) { sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); sensory.żądanieTemperatury(); float TempSensor = sensory.getTempCByIndex(0); mójPlik.print(razy); myFile.println(TempSensor); contMin = 0; } //--------------------------------------------------------------- ------------Liczba godzin ------------------------------------ ---------------------- if(rzeczywistaGodzina != poprzedniaGodzina) { contGodzina++; poprzednia godzina = aktualna godzina; } if(contHour == 5) { myFile.close(); lcd.clear(); lcd.setCursor(5, 0); lcd.print("Zakończono"); lcd.setCursor(5, 1); lcd.print("Proces"); proces_miara = 0; kontGodzina = 0; } //----------------------------------------------Stan: schorzenie zatrzymać rejestrator danych -----

Najpierw zostanie wykonana funkcja updateTemp(). Jest podobny do funkcji updateHour(); jednak wyświetla temperaturę co 1 minutę.

Następnie system zbierze dane czasowe z Zegara Czasu Rzeczywistego i zapisze aktualną wartość minut w zmiennej currentMin.

Następnie sprawdzi, czy zmienna min została zmieniona, zgodnie z przedstawionym poniżej warunkiem

if(rzeczywista min != poprzednia min)

{ kontyn. Min++; poprzednia min = rzeczywista min; }

W związku z tym, jeżeli aktualna zmienna minutowa jest inna od poprzedniej wartości, oznacza to, że nastąpiła zmiana wartości. W ten sposób warunek będzie spełniony i zostanie zwiększona wartość licznika minut (contMin) i wartość aktualna zostanie przypisana do zmiennej previousMin, aby zachować jej poprzednią wartość.

Dlatego, gdy wartość tego licznika jest równa 5, oznacza to, że minęło 5 minut i system musi wykonać nowy odczyt temperatury i zapisać wartość godziny i temperatury w pliku logu karty SD.

if(contMin == 5)

{ sprintf(times, "%02d:%02d", DataTime[4], DataTime[5]); sensory.żądanieTemperatury(); float TempSensor = sensory.getTempCByIndex(0); mójPlik.print(razy); myFile.println(TempSensor); contMin = 0; }

W ten sposób proces ten będzie powtarzany aż do osiągnięcia wartości 5 godzin monitorowania temperatury pacjenta czujnikiem temperatury z Arduino.

Część kodu pokazana jest poniżej i jest zbliżona do licznika minut, który został przedstawiony powyżej.

//------------------------------------------------ -----------Liczba godzin -------------------------- ---------------------

if(rzeczywistaGodzina != poprzedniaGodzina) { contGodzina++; poprzednia godzina = aktualna godzina; } if(contHour == 5) { myFile.close(); lcd.clear(); lcd.setCursor(5, 0); lcd.print("Zakończono"); lcd.setCursor(5, 1); lcd.print("Proces"); proces_miara = 0; kontGodzina = 0; }

Po osiągnięciu 5 godzin monitorowania system zamknie plik dziennika i wyświetli użytkownikowi komunikat „Proces zakończony”.

Dodatkowo użytkownik może nacisnąć przycisk Ok/Pause w celu zatrzymania zapisu danych. W takim przypadku zostanie wykonany następujący blok kodu.

//-----------------------------------------------Warunek do zatrzymaj rejestrator danych---------------------------------------------------------- ---

if(ok == 1) { mójPlik.zamknij(); lcd.clear(); lcd.setCursor(6, 0); lcd.print("Zatrzymany"); lcd.setCursor(5, 1); lcd.print("Proces"); proces_miara = 0; opóźnienie (2000); lcd.clear(); DS1307.getDate(DataCzas); sprintf(razy, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 0); lcd.print(razy); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O/P"); }

Krok 9:

Następnie system zamknie plik i wyświetli komunikat „Stoped Process”, jak pokazano na rysunku 8.

Krok 10:

Następnie system wydrukuje ekran czasu i opcje menu, jak pokazano na rysunku 9.

Krok 11: Dostęp do danych modułu karty SD za pomocą Arduino

Po zakończeniu procesu monitorowania JLCPCB Datalogger czujnikiem temperatury z Arduino konieczne jest wyjęcie karty pamięci i dostęp do danych na komputerze.

Aby przeglądać i analizować dane w lepszej jakości, wyeksportuj / skopiuj wszystkie informacje z pliku tekstowego do programu Excel. Następnie możesz wykreślić wykresy i przeanalizować uzyskane wyniki.

Krok 12: Wniosek

JLCPCB Datalogger z czujnikiem temperatury z Arduino pozwala nam, poza pomiarem temperatury, rejestrować informacje o zachowaniu temperatury pacjenta przez pewien okres czasu.

Dzięki tym przechowywanym danym można przeanalizować i zrozumieć, jak zachowuje się temperatura pacjenta zarażonego COVID 19.

Dodatkowo możliwa jest ocena poziomu temperatury i powiązanie jej wartości z zastosowaniem jakiegoś rodzaju leku.

Dlatego za pomocą tych danych JLCPCB Datalogger z czujnikiem temperatury dla Arduino ma na celu pomóc lekarzom i pielęgniarkom w badaniu zachowania pacjentów.

Na koniec dziękujemy firmie JLCPCB za wsparcie rozwoju projektu i mamy nadzieję, że możesz z niego skorzystać

Wszystkie pliki mogą być pobierane i używane swobodnie przez każdego użytkownika.