Capteur de température pour Arduino appliqué pour COVID 19 : 12 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Le capteur de température pour Arduino est un élément fondamental lorsque l'on veut mesurer la température d'un processeur du corps humain.

Le capteur de température avec Arduino doit être en contact ou proche pour recevoir et mesurer le niveau de chaleur. C'est ainsi que fonctionnent les thermomètres.

Ces appareils sont extrêmement utilisés pour mesurer la température corporelle des personnes malades, car la température est l'un des premiers facteurs qui changent dans le corps humain lorsqu'il y a une anomalie ou une maladie.

L'une des maladies qui modifient la température du corps humain est le COVID 19. Par conséquent, nous présentons les principaux symptômes:

Toux Fatigue Difficulté à respirer (Cas graves) Fièvre La fièvre est un symptôme dont la caractéristique principale est une augmentation de la température corporelle. Dans cette maladie, nous devons surveiller constamment ces symptômes.

Ainsi, nous développerons un projet pour surveiller la température et stocker ces données sur une carte mémoire via un Datalogger JLCPCB utilisant un capteur de température avec Arduino.

Par conséquent, dans cet article, vous apprendrez:

• Comment fonctionne un enregistreur de données JLCPCB avec un capteur de température avec Arduino ?
• Comment fonctionne le capteur de température avec Arduino.
• Comment fonctionne le capteur de température DS18B20 avec Arduino
• Utilisez des boutons avec plusieurs fonctions.

Ensuite, nous vous montrerons comment développer votre enregistreur de données JLCPCB à l'aide du capteur de température Arduino.

Fournitures

Arduino UNO

Circuit imprimé JLCPCB

Capteur de température DS18B20

Arduino Nano R3

Pulls

Écran LCD 16x2

Interrupteur à bouton-poussoir

Résistance 1kR

Module de carte SD pour Arduino

Étape 1: Construction de l'enregistreur de données JLCPCB avec capteur de température avec Arduino

Comme mentionné précédemment, le projet consiste à créer un enregistreur de données JLCPCB avec capteur de température avec Arduino, et grâce à ces données, nous pouvons surveiller la température du patient traité.

Ainsi, le circuit est représenté sur la figure ci-dessus.

Par conséquent, comme vous pouvez le voir, ce circuit dispose d'un capteur de température DS18B20 avec Arduino, qui est chargé de mesurer la lecture de la température du patient.

De plus, l'Arduino Nano sera chargé de collecter ces données et de les stocker sur la carte mémoire du module de carte SD.

Chaque information sera enregistrée avec son heure respective, qui sera lue à partir du module RTC DS1307.

Ainsi, pour que les données du capteur de température avec Arduino soient enregistrées, l'utilisateur doit effectuer le processus via le menu de contrôle avec l'écran LCD 16x2.

Étape 2:

Chaque bouton est chargé de contrôler une option, comme indiqué sur l'écran LCD 16x2 de la figure 2.

Chaque option est responsable de l'exécution d'une fonction dans le système, comme indiqué ci-dessous.

• L'option M est responsable du démarrage de la mesure et de l'enregistrement des données sur la carte mémoire.
• L'option H est responsable de l'ajustement des heures du système.
• L'option O/P est utilisée pour confirmer la saisie des données dans le système ou pour suspendre l'écriture des données sur la carte mémoire.

Pour comprendre le processus de contrôle du système, nous fournirons le code ci-dessous et discuterons du système de contrôle étape par étape de l'enregistreur de données JLCPCB avec capteur de température avec Arduino.

#include //Bibliothèque avec toutes les fonctions du capteur DS18B20

#include #include //Biblioteca I2C do LCD 16x2 #include //Biblioteca de Comunicacao I2C #include //Bibliothèque OneWire pour capteur DS18B20 #include #include LiquidCrystal_I2C lcd (0x27, 16, 2); // Configurando o endereco do LCD 16x2 para 0x27 #define ONE_WIRE_BUS 8 //Broche numérique pour connecter le capteur DS18B20 //Définir uma instancia do oneWire para comunicacao com o sensor OneWire oneWire(ONE_WIRE_BUS); DallasCapteurs de température (&oneWire); DeviceAddress sensor1; Fichier monFichier; #define Buttonmeasure 2 #define Buttonadjusthour 3 #define Buttonok 4 bool mesure = 0, Adjusthour = 0, ok = 0; bool measure_state = 0, Adjusthour_state = 0, ok_state = 0; bool mesure_process = 0, ajustement_process = 0; octet actualMin = 0, previousMin = 0; octet actualHour = 0, previousHour = 0; octet minUpdate = 0; int pinoSS = 10; // Pin 53 pour Mega / Pin 10 pour 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(fois); 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(fois); lcd.setCursor(0, 1); lcd.print("Température: "); lcd.setCursor(14, 1); capteurs.requestTemperatures(); float TempSensor = capteurs.getTempCByIndex(0); lcd.print(TempSensor); minUpdate = DataTime[5]; } } void setup() { Serial.begin(9600); DS1307.begin(); capteurs.begin(); pinMode(pinoSS, SORTIE); // Déclare pinoSS avec Wire.begin(); //Inicializacao da Comunicacao I2C lcd.init(); //Inicializacao do LCD lcd.backlight(); lcd.setCursor(3, 0); lcd.print("Système Temp"); lcd.setCursor(3, 1); lcd.print("Enregistreur de données"); retard (2000); // Localiza e mostra enderecos dos sensores Serial.println("Localizando sensores DS18B20…"); Serial.print("La localisation du capteur a réussi !"); Serial.print(sensors.getDeviceCount(), DEC); Serial.println(" Capteur"); if(SD.begin()) { // Initializa o SD Card Serial.println("SD Card pronto para uso."); // Imprime na tela } else { Serial.println("Falha na inicialização do SD Card."); revenir; } DS1307.getDate(DataTime); lcd.clear(); sprintf(fois, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 0); lcd.print(fois); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O/P"); } boucle vide() { updateHour(); //Lecture des états du bouton measure = digitalRead(Buttonmeasure); Adjusthour = digitalRead (Buttonadjusthour); ok = digitalRead(Buttonok); if(mesure == 0 && mesure_état == 1) { mesure_état = 0; } if(mesure == 1 && mesure_état == 0 && mesure_process == 0) { mesure_process = 1; mesure_état = 1; if (SD.exists("temp.txt")) { Serial.println("Apagou o arquivo anterior!"); SD.remove("temp.txt"); monFichier = SD.open("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt Serial.println("Criou o arquivo!"); } else { Serial.println("Criou o arquivo!"); monFichier = SD.open("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt monFichier.close(); } délai (500); monFichier.print("Heure: "); monFichier.println("Température"); DS1307.getDate(DataTime); actualMin = previousMin = DataTime[5]; sprintf(fois, "%02d:%02d", DataTime[4], DataTime[5]); lcd.clear(); lcd.setCursor(5, 0); lcd.print(fois); lcd.setCursor(0, 1); lcd.print("Température: "); lcd.setCursor(14, 1); capteurs.requestTemperatures(); float TempSensor = capteurs.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; } //------------------------------------------------------------- ---Processus de mesure--------------------------------------------- -------------- if(measure_process == 1) { updateTemp(); octet contMin = 0, contHour = 0; DS1307.getDate(DataTime); actualMin = DataTime[5]; //------------------------------------------------ --------- Compter les minutes---------------------------------------- ------------------- if(actualMin != previousMin) { contMin++; précédenteMin = actuelleMin; } if(contMin == 5) { sprintf(times, "%02d:%02d ", DataTime[4], DataTime[5]); capteurs.requestTemperatures(); float TempSensor = capteurs.getTempCByIndex(0); monFichier.print(fois); monFichier.println(TempSensor); ContMin = 0; } //------------------------------------------------------------- ------------ Compter les heures------------------------------------- ---------------------- if(actualHour != previousHour) { contHour++; heure précédente = heure actuelle; } if(contHour == 5) { monFichier.close(); lcd.clear(); lcd.setCursor(5, 0); lcd.print("Terminé"); lcd.setCursor(5, 1); lcd.print("Traiter"); mesure_processus = 0; ContHeure = 0; } //----------------------------------------------État pour arrêter l'enregistreur de données ------------------------------------ ---- if(ok == 1) { monFichier.close(); lcd.clear(); lcd.setCursor (6, 0); lcd.print("Arrêté"); lcd.setCursor(5, 1); lcd.print("Traiter"); mesure_processus = 0; retard (2000); lcd.clear(); DS1307.getDate(DataTime); sprintf(fois, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 0); lcd.print(fois); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O/P"); } } //------------------------------------------------------------ -------Ajuster les heures------------------------------------------ ---------------------- //Ajuster l'heure if(adjust_process == 1) { lcd.clear(); DS1307.getDate(DataTime); lcd.setCursor(0, 0); lcd.print("Ajuster l'heure:"); sprintf(fois, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(fois); //Hour Adjust do { measure = digitalRead (Buttonmeasure); Adjusthour = digitalRead(Buttonadjusthour); ok = digitalRead(Buttonok); if(mesure == 0 && mesure_état == 1) { mesure_état = 0; } if(mesure == 1 && measure_state == 0) { DataTime[4]++; if(DataTime[4] > 23) { DataTime[4] = 0; } état_mesure = 1; sprintf(fois, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(fois); 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(fois, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(fois); DS1307.setDate(DataTime[0], DataTime[1], DataTime[2], DataTime[3], DataTime[4], DataTime[5], 00); ajuster l'état_heure = 1; } if(ok == 1) { lcd.clear(); DS1307.getDate(DataTime); sprintf(fois, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(0, 0); lcd.print(fois); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O"); ajuster_process = 0; } } while(ok != 1); } //------------------------------------------------------------ ------- Fin de réglage de l'heure---------------------------------------- ------------------- }

Tout d'abord, nous définissons toutes les bibliothèques pour contrôler les modules et déclarer les variables utilisées lors de la programmation du JLCPCB Datalogger avec un capteur de température pour Arduino. Le bloc de code est illustré ci-dessous.

Étape 3:

#include //Bibliothèque avec toutes les fonctions du capteur DS18B20

#include #include //Biblioteca I2C do LCD 16x2 #include //Biblioteca de Comunicacao I2C #include //Bibliothèque OneWire pour capteur DS18B20 #include #include LiquidCrystal_I2C lcd (0x27, 16, 2); // Configurando o endereco do LCD 16x2 para 0x27 #define ONE_WIRE_BUS 8 //Broche numérique pour connecter le capteur DS18B20 //Définir uma instancia do oneWire para comunicacao com o sensor OneWire oneWire(ONE_WIRE_BUS); DallasCapteurs de température (&oneWire); DeviceAddress sensor1; Fichier monFichier; #define Buttonmeasure 2 #define Buttonadjusthour 3 #define Buttonok 4 bool mesure = 0, Adjusthour = 0, ok = 0; bool measure_state = 0, Adjusthour_state = 0, ok_state = 0; bool mesure_process = 0, ajustement_process = 0; octet actualMin = 0, previousMin = 0; octet actualHour = 0, previousHour = 0; octet minUpdate = 0; int pinoSS = 10; // Pin 53 pour Mega / Pin 10 pour UNO int DataTime[7];

Ci-après, nous avons la fonction de configuration void. Cette fonction est utilisée pour configurer les broches et l'initialisation de l'appareil, comme indiqué ci-dessous.

void setup()

{ Serial.begin(9600); DS1307.begin(); capteurs.begin(); pinMode(pinoSS, SORTIE); // Déclare pinoSS avec Wire.begin(); //Inicializacao da Comunicacao I2C lcd.init(); //Inicializacao do LCD lcd.backlight(); lcd.setCursor(3, 0); lcd.print("Système Temp"); lcd.setCursor(3, 1); lcd.print("Enregistreur de données"); retard (2000); // Localiza e mostra enderecos dos sensores Serial.println("Localizando sensores DS18B20…"); Serial.print("La localisation du capteur a réussi !"); Serial.print(sensors.getDeviceCount(), DEC); Serial.println(" Capteur"); if(SD.begin()) { // Initializa o SD Card Serial.println("SD Card pronto para uso."); // Imprime na tela } else { Serial.println("Falha na inicialização do SD Card."); revenir; } DS1307.getDate(DataTime); lcd.clear(); sprintf(fois, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 0); lcd.print(fois); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O/P"); }

Tout d'abord, la communication série, l'horloge en temps réel et le capteur de température pour Arduino DS18B20 ont été démarrés. Après avoir initialisé et testé les appareils, le message avec les options de menu a été imprimé sur l'écran LCD 16x2. Cet écran est illustré à la figure 1.

Étape 4:

Après cela, le système lit les heures et met à jour la valeur en appelant la fonction updateHour. Ainsi, cette fonction a pour but de présenter la valeur horaire toutes les minutes. Le bloc de code de fonction est illustré ci-dessous.

annuler l'heure de mise à jour()

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

Étape 5:

En plus de mettre à jour les heures, l'utilisateur peut sélectionner l'un des trois boutons pour surveiller le patient avec un capteur de température avec Arduino. Le circuit est représenté sur la figure ci-dessus.

Étape 6: Menu de contrôle de l'enregistreur de données JLCPCB

Tout d'abord, l'utilisateur doit vérifier et ajuster les heures du système. Ce processus est effectué lorsque le deuxième bouton est enfoncé.

Lorsque vous appuyez sur le bouton, l'écran suivant devrait apparaître, illustré dans la figure ci-dessus.

Étape 7:

À partir de cet écran, l'utilisateur pourra saisir les valeurs des heures et des minutes à partir des boutons connectés aux broches numériques 2 et 3 de l'Arduino. Les boutons sont illustrés dans la figure ci-dessus.

La partie du code pour contrôler les heures est indiquée ci-dessous.

if(ajuster l'heure == 0 && ajuster l'état_heure == 1)

{ ajuster l'état_heure = 0; } if(adjusthour == 1 && Adjusthour_state == 0 && measure_process == 0) { Adjust_process = 1; }

Lorsque le bouton des heures est enfoncé et que la variable measure_process est définie sur 0, la condition sera vraie et la variable Adjust_process sera définie sur 1. La variable measure_process est utilisée pour signaler que le système surveille la température. Lorsque sa valeur est 0, le système permettra à l'utilisateur d'entrer dans le menu de réglage de l'heure. Par conséquent, une fois que la variable Adjust_process reçoit une valeur de 1, le système entrera dans la condition d'ajustement de temps. Ce bloc de code est illustré ci-dessous.

//------------------------------------------------ -----Ajuster les heures-------------------------------------------- --------------------

//Ajuster l'heure if(adjust_process == 1) { lcd.clear(); DS1307.getDate(DataTime); lcd.setCursor(0, 0); lcd.print("Ajuster l'heure:"); sprintf(fois, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(fois); //Hour Adjust do { measure = digitalRead (Buttonmeasure); Adjusthour = digitalRead (Buttonadjusthour); ok = digitalRead(Buttonok); if(mesure == 0 && mesure_état == 1) { mesure_état = 0; } if(measure == 1 && measure_state == 0) { DataTime[4]++; if(DataTime[4] > 23) { DataTime[4] = 0; } état_mesure = 1; sprintf(fois, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(fois); 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(fois, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(fois); DS1307.setDate(DataTime[0], DataTime[1], DataTime[2], DataTime[3], DataTime[4], DataTime[5], 00); ajuster l'état_heure = 1; } if(ok == 1) { lcd.clear(); DS1307.getDate(DataTime); sprintf(fois, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(0, 0); lcd.print(fois); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O"); ajuster_process = 0; } } while(ok != 1); }

Dans cette condition, le système affichera le message illustré à la figure 4, puis attendra que les valeurs s'ajustent en interne dans la boucle while. Lors du réglage des heures, ces boutons ont leurs fonctions modifiées, c'est-à-dire qu'ils sont multifonctions.

Cela vous permet d'utiliser un bouton pour plus d'une fonction et de réduire la complexité du système.

De cette façon, l'utilisateur ajustera la valeur des heures et des minutes, puis enregistrera les données dans le système lorsque le bouton Ok est enfoncé.

Comme vous pouvez le voir, le système lira les 3 boutons, comme indiqué ci-dessous.

mesure = digitalRead(Boutonmesure);

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

Notez que le bouton de mesure (Buttonmeasure) a changé de fonction. Il sera maintenant utilisé pour ajuster les valeurs des heures, comme indiqué ci-dessous. Les deux conditions suivantes sont similaires et sont utilisées pour ajuster les heures et les minutes, comme indiqué ci-dessus.

if(mesure == 0 && mesure_état == 1)

{ mesure_état = 0; } if(measure == 1 && measure_state == 0) { DataTime[4]++; if(DataTime[4] > 23) { DataTime[4] = 0; } état_mesure = 1; sprintf(fois, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(fois); 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(fois, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 1); lcd.print(fois); DS1307.setDate(DataTime[0], DataTime[1], DataTime[2], DataTime[3], DataTime[4], DataTime[5], 00); ajuster l'état_heure = 1; }

Ainsi, à chaque appui sur l'un des deux boutons, la valeur des positions 4 et 5 du vecteur DataTime sera modifiée et d'autre part, ces valeurs seront enregistrées dans la mémoire du DS1307.

Après les ajustements, l'utilisateur doit cliquer sur le bouton Ok, pour terminer le processus. Lorsque cet événement se produit, le système exécute les lignes de code suivantes.

si(d'accord == 1)

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

Il entrera dans la condition ci-dessus et présentera le message de l'heure et le menu Options à l'utilisateur.

Enfin, l'utilisateur doit démarrer le processus de surveillance du patient via le capteur de température avec l'enregistreur de données Arduino JLCPCB.

Pour ce faire, l'utilisateur doit appuyer sur le bouton de mesure, qui est connecté à la broche numérique 2.

Ensuite, le système effectuera la lecture avec le capteur de température pour Arduino et l'enregistrera sur la carte mémoire. La région du circuit est illustrée dans la figure ci-dessus.

Étape 8:

Par conséquent, lorsque le bouton est enfoncé, la partie suivante du code sera exécutée.

if(mesure == 0 && mesure_état == 1)

{ mesure_état = 0; } if(mesure == 1 && mesure_état == 0 && mesure_process == 0) { mesure_process = 1; mesure_état = 1; if (SD.exists("temp.txt")) { Serial.println("Apagou o arquivo anterior!"); SD.remove("temp.txt"); monFichier = SD.open("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt Serial.println("Criou o arquivo!"); } else { Serial.println("Criou o arquivo!"); monFichier = SD.open("temp.txt", FILE_WRITE); // Cria / Abre arquivo.txt monFichier.close(); } délai (500); monFichier.print("Heure: "); monFichier.println("Température"); DS1307.getDate(DataTime); actualMin = previousMin = DataTime[5]; sprintf(fois, "%02d:%02d", DataTime[4], DataTime[5]); lcd.clear(); lcd.setCursor(5, 0); lcd.print(fois); lcd.setCursor(0, 1); lcd.print("Température: "); lcd.setCursor(14, 1); capteurs.requestTemperatures(); float TempSensor = capteurs.getTempCByIndex(0); lcd.print(TempSensor); }

Dans la partie de code ci-dessus, le système attribuera une valeur de 1 à la variable measure_process. Il est responsable de permettre la sauvegarde des données sur la carte SD.

De plus, le système vérifiera si un fichier texte avec un journal de données existe ou non. S'il y a un fichier, le système le supprimera et en créera un nouveau pour stocker les données.

Après cela, il créera deux colonnes: une pour les heures et une pour la température à l'intérieur du fichier texte.

Après cela, il affichera les heures et la température sur l'écran LCD, comme le montre la figure ci-dessus.

Après cela, le flux de code exécutera le bloc de programme suivant.

if(mesure_processus == 1)

{ updateTemp(); octet contMin = 0, contHour = 0; DS1307.getDate(DataTime); actualMin = DataTime[5]; //------------------------------------------------ --------- Compter les minutes---------------------------------------- ------------------- if(actualMin != previousMin) { contMin++; précédenteMin = actuelleMin; } if(contMin == 5) { sprintf(times, "%02d:%02d ", DataTime[4], DataTime[5]); capteurs.requestTemperatures(); float TempSensor = capteurs.getTempCByIndex(0); monFichier.print(fois); monFichier.println(TempSensor); ContMin = 0; } //------------------------------------------------------------- ------------ Compter les heures------------------------------------- ---------------------- if(actualHour != previousHour) { contHour++; heure précédente = heure actuelle; } if(contHour == 5) { monFichier.close(); lcd.clear(); lcd.setCursor(5, 0); lcd.print("Terminé"); lcd.setCursor(5, 1); lcd.print("Traiter"); mesure_processus = 0; ContHeure = 0; } //----------------------------------------------État pour arrêter l'enregistreur de données -----

Tout d'abord, la fonction updateTemp() sera exécutée. Elle est similaire à la fonction updateHour(); cependant, il affiche la température toutes les 1 minute.

Après cela, le système collectera les données temporelles de l'horloge en temps réel et stockera la valeur de la minute actuelle dans la variable currentMin.

Ensuite, il vérifiera si la variable min a été modifiée, selon la condition présentée ci-dessous

if(actualMin != previousMin)

{ ContMin++; précédenteMin = actuelleMin; }

Par conséquent, si la variable minute actuelle est différente de la valeur précédente, cela signifie qu'un changement dans la valeur s'est produit. De cette façon, la condition sera vraie et la valeur du nombre de minutes sera augmentée (contMin) et la valeur actuelle sera affecté à la variable previousMin, pour stocker sa valeur précédente.

Par conséquent, lorsque la valeur de ce compte est égale à 5, cela signifie que 5 minutes se sont écoulées et que le système doit effectuer une nouvelle lecture de température et enregistrer la valeur de l'heure et de la température dans le fichier journal de la carte SD.

si(contMin == 5)

{ sprintf(fois, "%02d:%02d ", DataTime[4], DataTime[5]); capteurs.requestTemperatures(); float TempSensor = capteurs.getTempCByIndex(0); monFichier.print(fois); monFichier.println(TempSensor); ContMin = 0; }

De cette façon, ce processus sera répété jusqu'à atteindre la valeur de 5 heures de surveillance de la température du patient avec le capteur de température avec Arduino.

La partie du code est illustrée ci-dessous et est similaire au nombre de minutes, qui a été présenté ci-dessus.

//------------------------------------------------ ----------- Compter les heures-------------------------------------- ---------------------

if(actualHour != previousHour) { contHour++; heure précédente = heure actuelle; } if(contHour == 5) { monFichier.close(); lcd.clear(); lcd.setCursor(5, 0); lcd.print("Terminé"); lcd.setCursor(5, 1); lcd.print("Traiter"); mesure_processus = 0; ContHeure = 0; }

Après avoir atteint 5 heures de surveillance, le système fermera le fichier journal et présentera le message « Processus terminé » à l'utilisateur.

De plus, l'utilisateur peut appuyer sur le bouton Ok/Pause pour arrêter l'enregistrement des données. Lorsque cela se produit, le bloc de code suivant sera exécuté.

//-----------------------------------------------Condition de arrêter l'enregistreur de données ------------------------------------- ---

if(ok == 1) { monFichier.close(); lcd.clear(); lcd.setCursor (6, 0); lcd.print("Arrêté"); lcd.setCursor(5, 1); lcd.print("Traiter"); mesure_processus = 0; retard (2000); lcd.clear(); DS1307.getDate(DataTime); sprintf(fois, "%02d:%02d", DataTime[4], DataTime[5]); lcd.setCursor(5, 0); lcd.print(fois); lcd.setCursor(0, 1); lcd.print("1-M 2-H 3-O/P"); }

Étape 9:

Ensuite, le système fermera le fichier et présentera le message « Processus arrêté », comme le montre la figure 8.

Étape 10:

Après cela, le système imprimera l'écran de l'heure et les options du menu, comme illustré à la Figure 9.

Étape 11: Accéder aux données du module de carte SD avec Arduino

Après le processus de surveillance du Datalogger JLCPCB avec le capteur de température avec Arduino, il est nécessaire de retirer la carte mémoire et d'accéder aux données sur l'ordinateur.

Pour afficher et analyser les données avec une meilleure qualité, exportez / copiez toutes les informations du fichier texte vers Excel. Après cela, vous pouvez tracer des graphiques et analyser les résultats obtenus.

Étape 12: Conclusion

L'enregistreur de données JLCPCB avec un capteur de température avec Arduino nous permet, en plus de mesurer la température, d'enregistrer des informations sur le comportement thermique du patient sur une période de temps.

Avec ces données stockées, il est possible d'analyser et de comprendre comment se comporte la température du patient infecté par COVID 19.

De plus, il est possible d'évaluer le niveau de température et d'associer sa valeur à l'application d'un certain type de médicament.

Par conséquent, à travers ces données, le Datalogger JLCPCB avec capteur de température pour Arduino vise à assister les médecins et les infirmières dans l'étude du comportement des patients.

Enfin, nous remercions la société JLCPCB d'avoir soutenu le développement du projet et espérons que vous pourrez l'utiliser

Tous les fichiers peuvent être téléchargés et utilisés librement par n'importe quel utilisateur.