Application Web Météo utilisant Esp8266 : 7 étapes

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

SHT 31 est un capteur de température et d'humidité fabriqué par Sensirion. Le SHT31 offre un haut niveau de précision autour de ±2 % HR. Sa plage d'humidité est comprise entre 0 et 100 % et sa plage de température est comprise entre -40 et 125 °C. Il est beaucoup plus fiable et rapide avec 8 secondes de temps de réponse du capteur. Ses fonctionnalités incluent un traitement de signal amélioré et une compatibilité I2C. Il possède différents modes de fonctionnement, ce qui le rend économe en énergie.

Dans ce tutoriel, nous avons interfacé SHT 31 avec la carte Adafruit Huzzah. Pour lire les valeurs de température et d'humidité, nous avons utilisé le blindage ESP8266 I2C. Cet adaptateur rend toutes les broches accessibles à l'utilisateur et offre un environnement I2C convivial.

Étape 1: Matériel requis

Matériel utilisé pour effectuer cette tâche:

1. SHT31

2. Adafruit Huzzah ESP8266

3. Adaptateur ESP8266 I2C

4. Câble I2C

Étape 2: Connexions matérielles

Cette étape comprend le guide de raccordement du matériel. Cette section explique essentiellement les connexions de câblage requises entre le capteur et l'ESP8266. Les connexions sont les suivantes.

1. Le SHT31 fonctionne sur I2C. L'image ci-dessus montre la connexion entre l'ESP8266 et le module SHT31. Nous utilisons un câble I2C pour cela ou nous pouvons utiliser 4 fils de cavalier F à F.
2. un fil est utilisé pour Vcc, le deuxième fil pour GND et deux autres pour SDA et SCL respectivement.
3. Selon l'adaptateur I2C, la broche 2 et la broche 14 d'une carte ESP8266 sont utilisées respectivement comme SDA et SCL

Étape 3: Code pour la planification des tâches

Dans ce tutoriel, nous effectuons trois opérations

• Lire les données de SHT11 en utilisant le protocole I2C
• héberger le serveur Web et publier la lecture du capteur sur la page Web
• publier les lectures des capteurs sur l'API ThingSpeak

Pour ce faire, nous utilisons la bibliothèque TaskScheduler. Nous avons programmé trois tâches différentes faisant référence à trois opérations de contrôle différentes. Cela se fait comme suit

• La tâche 1 sert à lire la valeur du capteur, cette tâche s'exécute pendant 1 seconde jusqu'à ce qu'elle atteigne un délai d'attente de 10 secondes.
• Lorsque la tâche 1 atteint son délai d'expiration, la tâche 2 est activée et la tâche 1 est désactivée.
• Nous nous connectons à AP dans ce rappel, deux variables booléennes sont prises en charge pour la commutation entre STA et AP
• Dans la tâche 2, nous hébergeons un serveur Web à 192.168.1.4. Cette tâche s'exécute toutes les 5 secondes jusqu'à ce qu'elle atteigne son délai d'expiration qui est de 50 secondes
• Lorsque la tâche 2 atteint le délai d'expiration, la tâche 3 est activée et la tâche 2 est désactivée.
• Nous nous connectons à STA (IP locale) dans ce rappel
• Dans la tâche 3, nous publions la lecture du capteur sur l'API cloud ThingSpeak
• La tâche 3 s'exécute toutes les cinq secondes jusqu'à ce qu'elle atteigne son délai d'attente, c'est-à-dire 50 secondes
• Lorsque la Tâche3 atteint son délai d'expiration, la Tâche 1 est à nouveau activée et la Tâche3 est désactivée.
• Lorsqu'aucun rappel n'est appelé ou que l'appareil est inactif, il passe en veille légère, économisant ainsi de l'énergie.

Planificateur ts;

//Tâches pour i2c, hébergement de serveur Web et publication sur Thingspeak

Tâche tI2C(1 * TASK_SECOND, TASK_FOREVER, &taskI2CCallback, &ts, false, NULL, &taskI2CDisable); Tâche tAP(5*TASK_SECOND, TASK_FOREVER, &taskAPCallback, &ts, false, NULL, &taskAPDisable); Tâche tWiFi(5* TASK_SECOND, TASK_FOREVER, &taskWiFiCallback, &ts, false, NULL, &taskWiFiDisable); //timeout pour les tâches tI2C.setTimeout(10 * TASK_SECOND); tAP.setTimeout(50 * TASK_SECOND); tWiFi.setTimeout(50 * TASK_SECOND); //activer la tâche I2C tI2C.enable();

Étape 4: Code de lecture des valeurs de température et d'humidité

Nous utilisons la bibliothèque Wire.h pour lire les valeurs de température et d'humidité. Cette bibliothèque facilite la communication i2c entre le capteur et l'appareil maître. 0x44 est l'adresse I2C pour SHT31.

SHT31 fonctionne dans un mode de fonctionnement différent. Vous pouvez vous référer à la fiche technique pour cela.

Nous utilisons 0x2C et 0x06 comme MSB et LSB respectivement pour le fonctionnement à un seul coup.

// Rappel de tâche I2C void taskI2CCallback()

{ Serial.println("taskI2CStarted"); racine int non signée[6]; //commencer la transmission à partir de 0x44; Wire.beginTransmission(Adr); //pour une transmission en un coup avec une répétabilité élevée, nous utilisons 0x2C(MSB) et 0x06(LSB) Wire.write(0x2C); Wire.write(0x06); //fin de la transmission Wire.endTransmission(); //demande des octets à partir de 0x44 Wire.beginTransmission(Addr); Wire.endTransmission(); Wire.requestFrom(Adr, 6); if(Wire.available() == 6){ //data[0] et data[1] contiennent 16 bits de température. root[0] = Wire.read(); root[1] =Wire.read(); //data[2] contient 8 bits de CRC root[2] = Wire.read(); //data[3] et data[4] contiennent 16 bits d'humidité root[3] = Wire.read(); root[4] = Wire.read(); //data[5] se compose de 8 bits CRC root[5] = Wire.read(); } int temp = (root[0] * 256) + root[1]; //décaler le MSB de 8 bits ajouter LSB float cTemp = -45,0 + (175,0 * temp / 65535,0); float fTemp = (cTemp * 1,8) + 32,0; //décalez le MSB de 8 bits, ajoutez-y du LSB en pleine résolution et *100 pour le pourcentage d'humidité flottante = (100.0 * ((root[3] * 256.0) + root[4])) / 65535.0;

tempC = cTemp;

tempF = fTemp; humide = humidité; Serial.print("Température dans C:\t"); Serial.println(String(cTemp, 1)); Serial.print("Température dans F:\t"); Serial.println(String(fTemp, 1)); Serial.print("Humidité:\t "); Serial.println(String(humidité, 1)); }

Étape 5: Code pour héberger un serveur Web

Nous avons hébergé un serveur Web à partir de notre appareil sur une adresse IP statique.

• La bibliothèque ESP8266WebServer est utilisée pour héberger le serveur Web
• Nous devons d'abord déclarer l'adresse IP, la passerelle et le masque de sous-réseau pour créer notre IP statique
• Déclarez maintenant le ssid et le mot de passe de votre point d'accès.
• connectez-vous au point d'accès à partir de n'importe quel appareil STA
• héberger le serveur sur le port 80 qui est un port par défaut pour le protocole de communication Internet, Hypertext Transfer Protocol (HTTP)
• entrez 192.168.1.4 sur votre navigateur Web pour la page Web d'introduction et 192.168.1.4/Value pour la page Web de lecture du capteur

// IP statique pour AP

IPAddress ap_local_IP (192, 168, 1, 4);

IPAddress ap_gateway (192, 168, 1, 254);

IPAddress ap_subnet (255, 255, 255, 0); // ssid et AP pour le WiFi local en mode STA

const char WiFissid = "*********";

const char WiFipass = "*********";

//ssid et passe pour AP

const char APssid = "********";

const char APpass = "********";

Serveur ESP8266WebServer (80);

void setup{

server.on("/", onHandleDataRoot);

server.on("/Value", onHandleDataFeed);

server.onNotFound(onHandleNotFound);

}

void taskAPCallback(){

Serial.println("taskAP démarré");

server.handleClient();

}

void onHandleDataRoot(){ server.send(200, "text/html", PAGE1); }

void onHandleDataFeed(){

server.send(200, "text/html", PAGE2); }

void onHandleNotFound(){

Message de chaîne = "Fichier introuvable\n\n";

message += "URI: ";

message += serveur.uri();

message += "\nMéthode: ";

message += (server.method() ==

message += "\nArguments: ";

message += serveur.args();

message += "\n";

server.send(404, "text/plain", message);}

annuler la reconnexionAPWiFi(){

WiFi.mode(WIFI_AP_STA);

retard (100);

WiFi.disconnect();

statut booléen = WiFi.softAPConfig(ap_local_IP, ap_gateway, ap_subnet);

if(statut ==true){

Serial.print("Réglage soft-AP … ");

booléen ap = WiFi.softAP(APssid, APpass);

si(ap==vrai){

Serial.print("connecté à:\t");

//Adresse IP monIP = WiFi.softAPIP();

Serial.println(WiFi.softAPIP());

}

serveur.begin();

}

}

Étape 6: Code pour publier des données sur Thing Speak

Ici, nous publions les lectures des capteurs sur Thing Speak. les étapes suivantes sont nécessaires pour accomplir cette tâche-

• Créez votre compte dans thing talk
• Créez des canaux et des champs pour stocker les données de vos capteurs
• nous pouvons obtenir et publier les données d'ESP vers thingSpeak et vice-versa en utilisant les requêtes GET et POST à l'api.
• nous pouvons publier nos données sur ThingSpeak comme suit

void taskWiFiCallback(){

WiFiClient wifiClient; if(wifiClient.connect(hostId, 80)){ String postStr = apiKey; postStr +="&field1="; postStr += String(humide); postStr +="&field2="; postStr += String(tempC); postStr +="&field3="; postStr += String(tempF); postStr += "\r\n\r\n"; wifiClient.print("POST /mise à jour HTTP/1.1\n"); wifiClient.print("Hôte: api.thingspeak.com\n"); wifiClient.print("Connexion: fermer\n"); wifiClient.print("X-THINGSPEAKAPIKEY: "+apiKey+"\n"); wifiClient.print("Type de contenu: application/x-www-form-urlencoded\n"); wifiClient.print("Contenu-Longueur: "); wifiClient.print(postStr.length()); wifiClient.print("\n\n"); wifiClient.print(postStr); } wifiClient.stop(); }

Étape 7: Code général

Le code global est disponible dans mon dépôt github

Crédits:

• Arduino JSON: ArduinoJson
• Serveur Web ESP826
• Planificateur de tâches
• SHT 31
• Analyse I2C
• HIH6130 tutoriel instructables
• Fil Arduino
• NCD.io