APPLICATION TEMPÉRATURE ET HUMIDITÉ THINGSPEAK UTILISANT ESP8266 : 9 étapes

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

En bricolant avec mes trucs électroniques, j'ai eu l'idée de créer une application météo basée sur le Web. Cette application Web utilise le capteur SHT31 pour obtenir les données de température et d'humidité en temps réel. Nous avons déployé notre projet sur le module WiFi ESP8266. En ligne ou hors ligne ! Ne vous inquiétez pas, que vous soyez en ligne ou hors ligne, vous obtiendrez les mises à jour météo de n'importe où et n'importe quand. Cette application Web publie des données sur le serveur Web local ainsi que sur le cloud. Pour les opérations cloud, nous utilisons l'API ThingSpeak. SHT31 utilise I2C pour obtenir les données du capteur.

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. SHT 31
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 calbackDans la tâche 3, nous publions la lecture du capteur sur l'API ThingSpeak du cloud
• 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âche 3 atteint son délai d'expiration, la tâche 1 est à nouveau activée et la tâche 3 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.

void taskI2CCallback();

void taskI2CDisable(); void taskAPCallback(); void taskAPDisable(); void taskWiFiCallback(); void taskWiFiDisable(); //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 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ébergez 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 APIPAddress 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 a démarré"); server.handleClient(); } void onHandleDataRoot(){ server.send(200, "text/html", PAGE1); } void onHandleDataFeed(){ server.send(200, "text/html", PAGE2); } void onHandleNotFound(){ String message = "Fichier introuvable\n\n"; message += "URI: "; message += serveur.uri(); message += "\nMéthode: "; message += (server.method() == HTTP_GET)?"GET":"POST"; message += "\nArguments: "; message += serveur.args(); message += "\n"; server.send(404, "text/plain", message); } void reconnectAPWiFi(){ WiFi.mode(WIFI_AP_STA); retard (100); WiFi.disconnect(); statut booléen = WiFi.softAPConfig(ap_local_IP, ap_gateway, ap_subnet); if(status ==true){ Serial.print("Setting soft-AP … "); booléen ap = WiFi.softAP(APssid, APpass); if(ap==true){ Serial.print("connecté à:\t"); //Adresse IP monIP = WiFi.softAPIP(); Serial.println(WiFi.softAPIP()); } serveur.begin();

}

Étape 6: Configuration de Thingspeak

ThingSpeak est une plateforme IoT. ThingSpeak est un service Web gratuit qui vous permet de collecter et de stocker les données des capteurs dans le cloud.

Dans cette étape, je vais vous donner une brève procédure pour configurer votre compte Thing Speak

• Inscrivez-vous pour un nouveau compte utilisateur dans ThingSpeak
• Créez une nouvelle chaîne en sélectionnant Chaînes, Mes chaînes, puis Nouvelle chaîne
• Modifier vos champs
• Ces champs contiennent les données de votre capteur
• Notez la clé d'API d'écriture et l'ID de canal
• Sur votre croquis Arduino, vous pouvez utiliser la bibliothèque ThingSpeak pour Arduino ou vous pouvez directement POST les données à l'API ThingSpeak
• l'étape suivante traite de la publication du contenu sur l'API Thing Speak

Étape 7: 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 speakCré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

id 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 8: Code général

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

Étape 9: Crédits

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