L'IoT en toute simplicité : capture de données météorologiques à distance : UV et température et humidité de l'air : 7 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-02-01 14:40

Sur ce tutoriel, nous allons capturer des données à distance sous forme d'UV (rayonnement ultra-violet), de température et d'humidité de l'air. Ces données seront très importantes et seront utilisées dans une future station météo complète.

Le schéma fonctionnel montre ce que nous obtiendrons à la fin.

Étape 1: BoM - Nomenclature

NodeMCU (ESP8266-12E) - 9,00 USD

Capteur d'humidité et de température (DHT22) - USD10.00

Capteur UV - 4,00 USD

OLED 12,00 USD

Planche à pain - 1,00 USD

Étape 2: Le capteur UV analogique

Ce capteur UV génère une sortie analogique proportionnelle au rayonnement ultraviolet trouvé sur le spectre de détection de la lumière. Il utilise une photodiode UV (à base de nitrure de gallium), qui peut détecter la gamme de lumière 240-370 nm (qui couvre les UVB et la plupart du spectre UVA). Le niveau de signal de la photodiode est très faible, au niveau du nano-ampère, le module a donc intégré un amplificateur opérationnel pour amplifier le signal à un niveau de volt plus lisible (0 à 1 V).

Le capteur et l'amplificateur opérationnel peuvent être alimentés en connectant VCC à 3,3 VCC (ou 5 VCC) et GND à la terre. Le signal analogique peut être obtenu à partir de la broche OUT.

Sa sortie sera en millivolts et sera lue par l'entrée analogique de notre NodeMCU. Une fois lu, nous devrions le « convertir » (ou « mapper ») pour que les valeurs soient mieux gérées par le code. Nous pouvons le faire avec la fonction readSensorUV():

/* Lire le capteur UV en mV et appeler le calcul de l'indice UV */

void readSensorUV() { octet numOfReadings = 5; dataSensorUV = 0; for (int i=0; i< numOfReadings; i++) { dataSensorUV += analogRead(sensorUVPin); retard (200); } dataSensorUV /= numOfReadings; dataSensorUV = (dataSensorUV * (3,3 / 1023,0))*1000; Serial.println(dataSensorUV); indexCalculer(); }

Une fois que nous avons les données UV, nous pouvons facilement calculer l'indice UV tel que défini dans le tableau ci-dessus. La fonction indexCalculate() le fera pour nous:

/* Calcul de l'indice UV */

void indexCalculate() { if (dataSensorUV < 227) indexUV = 0; sinon si (227 <= dataSensorUV && dataSensorUV < 318) indexUV = 1; else if (318 <= dataSensorUV && dataSensorUV < 408) indexUV = 2; else if (408 <= dataSensorUV && dataSensorUV < 503) indexUV = 3; sinon si (503 <= dataSensorUV && dataSensorUV < 606) indexUV = 4; sinon si (606 <= dataSensorUV && dataSensorUV < 696) indexUV = 5; else if (696 <= dataSensorUV && dataSensorUV < 795) indexUV = 6; sinon si (795 <= dataSensorUV && dataSensorUV < 881) indexUV = 7; else if (881 <= dataSensorUV && dataSensorUV < 976) indexUV = 8; else if (976 <= dataSensorUV && dataSensorUV < 1079) indexUV = 9; else if (1079 <= dataSensorUV && dataSensorUV < 1170) indexUV = 10; sinon indiceUV = 11; }

Étape 3: Installation d'un écran: OLED

À des fins de test, nous inclurons un OLED sur notre compteur UV (cette étape est totalement facultative).

C'est OK pendant les tests, d'utiliser le Serial Monitor, mais que se passe-t-il lorsque vous utilisez vos prototypes loin de votre PC en mode autonome ? Pour cela, installons un écran OLED, le SSD1306, dont les principales caractéristiques sont:

• Taille de l'écran: 0.96"
• Série I2C IIC SPI
• 128X64
• LED blanche OLED LCD

Suivez le schéma électrique et connectez les 4 broches de notre OLED:

• VCC passe à 3.3V
• GND va à la terre
• SCL va à NodeMCU (GPIO 2) ==>D4
• SDA va à NodeMCU (GPIO 0) ==>D3

Une fois l'écran connecté, téléchargeons et installons sa bibliothèque sur notre IDE Arduino: le "ESP8266 OLED Driver for SSD1306 display" développé par Daniel Eichhorn (assurez-vous d'utiliser la version 3.0.0 ou supérieure !).

Installez la bibliothèque sur votre IDE Arduino, qui se trouve sur SSD1306Wire.h

Une fois que vous avez redémarré l'IDE, la bibliothèque devrait déjà être installée.

La bibliothèque prend en charge le protocole I2C pour accéder à l'écran OLED à l'aide de la bibliothèque Wire.h intégrée:

/* OLED */

#include "SSD1306Wire.h" #include "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; const int SDA_PIN = 0; const int SCL_PIN = 2; Affichage SSD1306Wire (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN);

Listons quelques API importantes qui seront utilisées avec notre écran OLED. La liste complète peut être trouvée sur le GITHub fourni ci-dessus.

A. Contrôle d'affichage:

void init(); // Initialisation de l'affichage

void displayOn(void); // Activer l'affichage void displayOff(void); // Désactive l'affichage void clear(void); // Efface le tampon de pixels local void flipScreenVertically(); // Retourne l'écran à l'envers

B. Opérations de texte:

void drawString(int16_t x, int16_t y, String text); // (xpos, ypos, "Texte")

void setFont(const char* fontData); // Définit la police actuelle.

Polices par défaut disponibles:

• ArialMT_Plain_10,

• ArialMT_Plain_16,

• ArialMT_Plain_24

Une fois que l'OLED lui-même et sa bibliothèque sont installés, écrivons un programme simple pour le tester. Entrez avec le code ci-dessous sur votre IDE, le résultat devrait être un affichage comme indiqué sur la photo ci-dessus:

*OLED*/

#include "SSD1306Wire.h" #include "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; const int SDA_PIN = 0; const int SCL_PIN = 2; SSD1306Wire display(I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN); void setup () { Serial.begin (115200); configuration de l'affichage(); } void loop() { } /* Initier et afficher les données de configuration sur OLED */ void displaySetup() { display.init(); // initialise l'affichage display.clear(); // Effacer l'affichage display.flipScreenVertically(); // Retourne l'affichage display.display(); // Mettre les données à l'écran Serial.println("Initiating Display Test"); display.setFont(ArialMT_Plain_24); display.drawString(30, 0, "OLED"); // (xpos, ypos, "Texte") display.setFont(ArialMT_Plain_16); display.drawString(18, 29, "Test lancé"); display.setFont(ArialMT_Plain_10); display.drawString(10, 52, "Serial BaudRate:"); display.drawString(90, 52, String (11500)); display.display(); // Mettre les données sur le délai d'affichage (3000); }

Le programme ci-dessus peut être téléchargé depuis mon GitHub:

NodeMCU_OLED_Test

Étape 4: Un UV-mètre local

Maintenant, avec l'écran OLED installé, nous pouvons connecter une batterie et faire des tests à distance à l'aide de notre "UV Meter"

#define SW_VERSION "UV_Sensor_V.1"

/* Capteur UV */ #define sensorUVPin A0 int dataSensorUV = 0; indice intUV = 0; /* OLED */ #include "SSD1306Wire.h" #include "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; const int SDA_PIN = 0; const int SCL_PIN = 2; SSD1306Wire display(I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN); void setup() { Serial.begin(115200); configuration de l'affichage(); } boucle vide() { readSensorUV(); afficherUV(); retard (1000); } /* Lancer et afficher les données de configuration sur OLED */ void displaySetup() { display.init(); // initialise l'affichage display.clear(); // Effacer l'affichage display.flipScreenVertically(); // Retourne l'affichage display.display(); // Affiche les données Serial.println("Initiating UV Sensor Test"); display.setFont(ArialMT_Plain_24); display.drawString (10, 0, "MJRoBot"); display.setFont(ArialMT_Plain_16); display.drawString(0, 29, "Test du capteur UV"); display.setFont(ArialMT_Plain_10); display.drawString(0, 52, "SW Ver.:"); display.drawString(45, 52, SW_VERSION); display.display(); retard (3000); } /* Lire le capteur UV en mV et appeler le calcul de l'indice UV */ void readSensorUV() { byte numOfReadings = 5; dataSensorUV = 0; for (int i=0; i< numOfReadings; i++) { dataSensorUV += analogRead(sensorUVPin); retard (200); } dataSensorUV /= numOfReadings; dataSensorUV = (dataSensorUV * (3,3 / 1023,0))*1000; Serial.println(dataSensorUV); indexCalculer(); } /* Calcul de l'indice UV */ void indexCalculate() { if (dataSensorUV < 227) indexUV = 0; sinon si (227 <= dataSensorUV && dataSensorUV < 318) indexUV = 1; else if (318 <= dataSensorUV && dataSensorUV < 408) indexUV = 2; else if (408 <= dataSensorUV && dataSensorUV < 503) indexUV = 3; sinon si (503 <= dataSensorUV && dataSensorUV < 606) indexUV = 4; sinon si (606 <= dataSensorUV && dataSensorUV < 696) indexUV = 5; else if (696 <= dataSensorUV && dataSensorUV < 795) indexUV = 6; sinon si (795 <= dataSensorUV && dataSensorUV < 881) indexUV = 7; sinon si (881 <= dataSensorUV && dataSensorUV < 976) indexUV = 8; else if (976 <= dataSensorUV && dataSensorUV < 1079) indexUV = 9; else if (1079 <= dataSensorUV && dataSensorUV < 1170) indexUV = 10; sinon indiceUV = 11; } /* Afficher les valeurs UV sur l'OLED local*/ void displayUV() { display.clear(); display.setFont(ArialMT_Plain_16); display.drawString (20, 0, "Capteur UV"); display.drawString(0, 23, "UV (mV):"); display.drawString(80, 23, String(dataSensorUV)); display.drawString(0, 48, "Index UV:"); display.setFont(ArialMT_Plain_24); display.drawString(82, 42, String(indexUV)); display.display(); }

Le code ci-dessus peut être téléchargé depuis mon GitHun: NodeMCU_UV_Sensor_OLED.ino

Étape 5: Installation d'un DHT22 pour les mesures de température et d'humidité de l'air

L'un des capteurs les plus utilisés pour capturer les données météorologiques est le DHT22 (ou son frère DHT11), un capteur numérique d'humidité relative et de température. Il utilise un capteur d'humidité capacitif et une thermistance pour mesurer l'air ambiant et crache un signal numérique sur la broche de données (aucune broche d'entrée analogique n'est nécessaire).

Le capteur doit être alimenté entre 3,3V et 5V et fonctionnera de -40oC à +80oC avec une précision de +/- 0,5oC pour la température et de +/-2% pour l'humidité relative. Il est également important de garder à l'esprit que sa période de détection est en moyenne de 2 secondes (temps minimum entre les lectures). Le site d'Adafruit fournit de nombreuses informations sur le DHT22 et son frère DHT11. Pour plus de détails, veuillez visiter la page du didacticiel DHT22/11.

Le DHT22 possède 4 broches (face au capteur, la broche 1 est la plus à gauche):

1. VCC (nous allons nous connecter à 3,3 V à partir de NodeMCU);
2. Sortie de données;
3. Non connecté et
4. Sol.

Une fois que vous utiliserez habituellement le capteur sur des distances inférieures à 20 m, une résistance de 10K doit être connectée entre les broches Data et VCC. La broche de sortie sera connectée à la broche NodeMCU D3 (voir le schéma ci-dessus). Une fois le capteur installé sur notre module, téléchargez la bibliothèque DHT depuis le référentiel Adafruit GitHub et installez-la dans le fichier de votre bibliothèque Arduino. Une fois que vous rechargez votre IDE Arduino, la "bibliothèque de capteurs DHT" doit être installée.

Au début du code, nous devons inclure les lignes:

/* DHT22*/

#include "DHT.h" #define DHTPIN D2 #define DHTTYPE DHT22 DHT dht(DHTPIN, DHTTYPE); bourdonnement flottant = 0; température flottante = 0;

Une nouvelle fonction sera créée pour lire le capteur:

/* Récupère les données DHT */

void getDhtData(void) { float tempIni = temp; flotteur humIni = hum; temp = dht.readTemperature(); hum = dht.readHumidity(); if (isnan(hum) || isnan(temp)) // Vérifiez si des lectures ont échoué et quittez plus tôt (pour réessayer). { Serial.println("Impossible de lire à partir du capteur DHT !"); temp = tempIni; hum = humIni; revenir; } }

Le code complet comprenant les capteurs UV et DHT peut être téléchargé depuis mon GitHub: NodeMCU_UV_DHT_Sensor_OLED

Étape 6: Envoi de données à ThingSpeak.com

Jusqu'à présent, nous n'avons utilisé le NodeMCU ESP12-E que comme carte Arduino ordinaire et ordinaire. Bien sûr, nous n'avons qu'« gratté » le réel potentiel de cette petite puce spectaculaire et il est maintenant temps de décoller vers le ciel ! Ou mieux aux étoiles ! Ehr… vers le cloud !;-)

Commençons!

1. Tout d'abord, vous devez avoir un compte sur ThinkSpeak.com
2. Suivez les instructions pour créer une chaîne et prenez note de votre identifiant de chaîne et de votre clé API d'écriture
3. Mettez à jour le code ci-dessous avec votre réseau WiFi et vos identifiants Thinkspeak
4. Exécuter le programme sur IDE

Commentons les parties les plus importantes du code:

Tout d'abord, appelons la bibliothèque ESP8266, définissons le client WiFi et définissons votre routeur local et les informations d'identification Thinkspeak:

/* ESP12-E & Thinkspeak*/

#inclure le client WiFiClient; const char* MY_SSID = "VOTRE ID SSD ICI"; const char* MY_PWD = "VOTRE MOT DE PASSE ICI"; const char* TS_SERVER = "api.thingspeak.com"; String TS_API_KEY =" VOTRE CLÉ API D'ÉCRITURE DE CANAL";

Deuxièmement, incluons une bibliothèque très importante pour les projets IoT: SimpleTimer.h:

/* MINUTERIE */

#include la minuterie SimpleTimer;

Troisièmement, pendant setup(), nous initierons la communication série, appellerons la fonction connectWiFi() et définirons les temporisateurs. Notez que la ligne de code: timer.setInterval(60000L, sendDataTS); appellera la fonction sendDataTS() toutes les 60 secondes, afin de télécharger des données sur le canal ThinkSpeak.

void setup()

{ … Serial.begin(115200); retard(10); … connectWifi(); timer.setInterval (60000L, sendDataTS); … }

Enfin, lors de la boucle(), la seule commande nécessaire est de lancer le timer et c'est tout !

boucle vide()

{ … timer.run(); // Lance SimpleTimer }

Ci-dessous, vous pouvez voir les deux fonctions importantes utilisées pour gérer la communication Thinkspeak:

Connexion ESP12-E avec votre réseau WiFi:

/***************************************************

* Connexion WiFi ************************************************* ***/ void connectWifi() { Serial.print("Connexion à "+ *MY_SSID); WiFi.begin(MY_SSID, MY_PWD); while (WiFi.status() != WL_CONNECTED) { delay(1000); Serial.print("."); } Serial.println(""); Serial.println("WiFi Connecté"); Serial.println(""); }

ESP12-E envoie des données à ThinkSpeak:

/***************************************************

* Envoi de données à Thinkspeak Channel ******************************************** ******/ void sendDataTS(void) { if (client.connect(TS_SERVER, 80)) { String postStr = TS_API_KEY; postStr += "&field1="; postStr += String(dataSensorUV); postStr += "&field2="; postStr += String(indexUV); postStr += "&field3="; postStr += String(temp); postStr += "&field4="; postStr += String(hum); postStr += "\r\n\r\n"; client.print("POST /mise à jour HTTP/1.1\n"); client.print("Hôte: api.thingspeak.com\n"); client.print("Connexion: fermer\n"); client.print("X-THINGSPEAKAPIKEY: " + TS_API_KEY + "\n"); client.print("Type de contenu: application/x-www-form-urlencoded\n"); client.print("Content-Length: "); client.print(postStr.length()); client.print("\n\n"); client.print(postStr); retard(1000); } envoyé++; client.stop(); }

Le code complet se trouve sur mon GitHub: NodeMCU_UV_DHT_Sensor_OLED_TS_EXT

Une fois que vous avez téléchargé le code sur votre NodeMCU. Connectons une batterie externe et faisons quelques mesures sous le soleil. Je place la station distante sur le toit et commence à capturer des données sur ThingSpeak.com comme indiqué sur les photos ci-dessus.

Étape 7: Conclusion

Comme toujours, j'espère que ce projet pourra aider d'autres personnes à trouver leur chemin dans le monde passionnant de l'électronique !

Pour plus de détails et le code final, veuillez visiter mon dépôt GitHub: RPi-NodeMCU-Weather-Station

Pour plus de projets, veuillez visiter mon blog: MJRoBot.org

Restez à l'écoute! Dans le prochain tutoriel, nous enverrons les données d'une station météo distante à une station centrale, basée sur un serveur Web Raspberry Pi:

Salutations du sud du monde !

Rendez-vous dans mon prochain instructable !

Merci, Marcelo