Rapport météo à l'aide des applets ThingSpeak MQTT et IFTTT : 8 étapes

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

introduction

Une application météo basée sur le cloud fournissant des rapports météorologiques quotidiens sous forme de notification par e-mail. Cette application Web mesure la température et l'humidité à l'aide de SHT25 et d'Adafruit Huzzah ESP8266. Il nous fournit des données de température et d'humidité en temps réel et des analyses horaires. Les données sont envoyées à l'aide de l'API ThingSpeak MQTT et plus tard, nous envoyons une notification par e-mail à l'utilisateur chaque fois que la température atteint le seuil assigné à l'aide du protocole IFTTT. SHT25 est un capteur de température et d'humidité fabriqué par Sensirion. Le SHT25 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.

Caractéristiques

• Vous fournit des analyses et des statistiques en temps réel à l'aide de l'API Thing Speak MQTT
• Une notification par e-mail est fournie à l'utilisateur à un moment donné à l'aide d'IFTTT
• Le planificateur de tâches est utilisé pour planifier la tâche, comme récupérer les données des capteurs, publier les lectures des capteurs, s'abonner à la rubrique MQTT
• Il utilise le protocole I2C pour récupérer la lecture du capteur qui est plus précise, extensible et évolutive
• mode veille lorsque l'appareil est inactif ou qu'aucun rappel de tâche n'est appelé.
• une planification efficace des tâches permet une utilisation sans tracas
• Une page Web distincte est hébergée où l'utilisateur doit fournir ses informations d'identification pour éviter de faire clignoter votre appareil à chaque fois lorsqu'il est à la portée d'autres réseaux wifi

• SPIFFS est utilisé pour stocker notre page Web pour rendre notre code lisible et moins maladroit

Étape 1: Spécification matérielle et logicielle

Spécification matérielle

• Planche Adafruit esp8266 Huzzah
• Bouclier de planche Huzzah
• Module capteur SHT25
• Câble I2C

Spécification du logiciel

• IDE Arduino
• IFTTT Chose Parler
• API MQTT

Étape 2: Stockage des informations d'identification de l'utilisateur

Ici, nous utilisons le capteur SHT25 I2C pour lire la valeur en temps réel de la température et de l'humidité relative et publier ces valeurs dans le cloud. Pour obtenir la valeur du capteur mise à jour de temps en temps et pour publier ces mises à jour simultanément, nous utilisons la bibliothèque du planificateur de tâches d'Arduino. Pour les opérations cloud, nous utilisons l'API ThingSpeak MQTT. Plus tard, nous fournissons un rapport météo en temps réel à l'utilisateur à l'aide d'applets IFTTT. Vous pouvez suivre ces étapes pour créer votre propre station météo. Alors, bricolage.

Avant d'aller plus loin. Nous devons enregistrer les informations d'identification de l'utilisateur. A cet effet, nous hébergeons un serveur web au 192.169.1.4. Nous avons stocké notre formulaire Web dans SPIFFS. Une fois que l'appareil démarre, il héberge un serveur Web pendant 60 secondes. L'utilisateur doit suivre ces étapes.

• Connectez-vous à l'utilisateur AP ESP, cela est répertorié dans votre liste de réseaux wifi disponibles. Connectez-vous à cet AP et entrez le mot de passe "*******"
• Une fois connecté, accédez à votre navigateur, entrez l'adresse IP 192.168.1.4.
• Entrez le SSID et le mot de passe de votre WiFi local dans les champs de saisie et entrez SOUMETTRE
• Ces informations d'identification seront enregistrées dans l'EEPROM
• Après 60 secondes, l'appareil se déconnectera automatiquement du point d'accès
• La prochaine fois que vous allumez l'appareil, l'utilisateur n'a pas à suivre cette procédure, l'appareil récupérera automatiquement les informations d'identification de l'utilisateur à partir de l'EEPROM et continuera à obtenir les lectures du capteur de l'interface I2C et à les publier dans le cloud

//--------- Configuration AP ------------// Adresse IP ap_local_IP (192, 168, 1, 4); IPAddress ap_gateway (192, 168, 1, 254); IPAddress ap_subnet (255, 255, 255, 0);

Serial.print("Configuration du point d'accès…");

WiFi.softAPConfig(ap_local_IP, ap_gateway, ap_subnet);

Serial.print("Configuration des informations d'identification de l'utilisateur");

WiFi.softAP(ssidAP, passAP);

server.on("/", handleRoot);

server.onNotFound(onHandleNotFound);

serveur.begin();

APTimer = millis();

while(millis()-APTimer <APInterval){

server.handleClient();

}

//****************************** RACINE DE POIGNÉE****************** ********* // void handleRoot() {

if (server.hasArg("ssid")&& server.hasArg("mot de passe"))

{

//Si tous les champs du formulaire contiennent des données, appel

handelEnvoyer()

handleSubmit(); }

autre {

//Réafficher le formulaire

//lire le fichier contenu dans les spiffs

Fichier fichier =SPIFFS.open("/webform.html", "r");

server.streamFile(fichier, "text/html");

//n'oubliez pas de fermer le fichier

fichier.close();

}}

// Vérifiez le statut qu'il a les arguments ssid et mot de passe

//Ensuite, écrivez les informations d'identification dans la ROM

ROMwrite(String(server.arg("ssid")), String(server.arg("password")))

Étape 3: Configuration de votre formulaire Web dans SPIFFS

SPIFFS

Serial Peripheral Interface Flash File System, ou SPIFFS en abrégé. C'est un système de fichiers léger pour les microcontrôleurs avec une puce flash SPI. La puce flash intégrée de l'ESP8266 a beaucoup d'espace pour vos pages Web, surtout si vous avez la version 1 Mo, 2 Mo ou 4 Mo. Nous avons également stocké notre page Web dans Flash System. Il y a quelques étapes que nous devons suivre pour télécharger des données vers des spiffs

1. Téléchargez l'outil:
2. Dans votre répertoire de carnet de croquis Arduino, créez un répertoire d'outils s'il n'existe pas encore
3. Décompressez l'outil dans le répertoire tools (le chemin ressemblera à /Arduino/tools/ESP8266FS/tool/esp8266fs.jar)
4. Redémarrer l'IDE Arduino
5. Ouvrez un croquis (ou créez-en un nouveau et enregistrez-le)
6. Accédez au répertoire d'esquisse (choisissez Esquisse> Afficher le dossier d'esquisse)
7. Créez un répertoire nommé data et tous les fichiers que vous voulez dans le système de fichiers. Nous avons téléchargé notre page HTML avec le nom webform.html
8. Assurez-vous d'avoir sélectionné une carte, un port et un moniteur série fermé
9. Sélectionnez Outils > ESP8266 Téléchargement de données d'esquisse. Cela devrait commencer à télécharger les fichiers dans le système de fichiers flash ESP8266. Une fois terminé, la barre d'état IDE affichera le message SPIFFS Image Uploaded.

Fichier fichier =SPIFFS.open("/webform.html", "r");

server.streamFile(fichier, "text/html");

//n'oubliez pas de fermer le fichier

fichier.close();

Étape 4: Planification des tâches

Dans ce tutoriel, nous effectuons deux opérations:

• Lire les données de SHT25 en utilisant le protocole I2C
• Publiez les données mises à jour dans le cloud à l'aide de l'API ThingSpeak MQTT

Pour ce faire, nous utilisons la bibliothèque TaskScheduler. Nous avons programmé deux tâches différentes faisant référence à deux 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âche1 atteint son délai d'expiration, nous nous connectons au courtier Wifi et MQTT local.
• Maintenant, la tâche 2 est activée et nous désactivons la tâche 1 La tâche 2 sert à publier les données du capteur sur le courtier Thing Speak MQTT, cette tâche s'exécute pendant 20 secondes jusqu'à ce qu'elle atteigne un délai d'attente de 20 secondes.
• Lorsque la tâche 2 atteint son délai d'expiration, la tâche 1 est à nouveau activée et la tâche 2 est désactivée. ici encore, nous obtenons la valeur mise à jour et le processus continue
• lorsqu'aucun rappel n'est appelé ou que l'appareil est inactif, il passe en veille légère, économisant ainsi de l'énergie.

//---------prototype pour le rappel de tâche------------//

void taskI2CCallback();

void taskI2CDisable();

void taskWiFiCallback();

void taskWiFiDisable();

//---------Tâches------------//

Tâche tI2C(2 * TASK_SECOND, TASK_FOREVER, &taskI2CCallback, &ts, false, NULL, &taskI2CDisable);

Tâche tWiFi(20* TASK_SECOND, TASK_FOREVER, &taskWiFiCallback, &ts, false, NULL, &taskWiFiDisable);

//activer tI2C tI2C.enable();

Étape 5: Lecture des valeurs de température et d'humidité de SHT25

I2C est une interface à deux fils qui n'utilise que deux fils pour communiquer avec l'appareil maître. L'un est SCL (Serial Clock) et l'autre est SDA (Serial Data). Chaque appareil esclave a une adresse unique. SHT 25 a également une adresse 8 bits et est accessible par une adresse 0x44. il a une adresse de 8 bits où 7 bits sont l'adresse réelle et tandis que le bit 0 de LSB le plus à droite est utilisé pour signaler la lecture ou l'écriture sur le périphérique. Si le bit 0 est défini sur 1, le périphérique maître lira à partir du périphérique I2C esclave. I2C est beaucoup plus fiable, évolutif et rapide et même il a de nombreux modes de fonctionnement qui le rendent beaucoup plus économe en énergie

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 SHT25. SHT25 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 en une seule fois

Étape 6: Publication de valeurs dans ThingSpeak à l'aide de l'API ThingSpeak MQTT

Pour publier nos valeurs de température et d'humidité dans le cloud, nous utilisons l'API ThingSpeak MQTT. 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. MQTT est un protocole courant utilisé dans les systèmes IoT pour connecter des appareils et des capteurs de bas niveau. MQTT est utilisé pour transmettre des messages courts vers et depuis un courtier. ThingSpeak a récemment ajouté un courtier MQTT afin que les appareils puissent envoyer des messages à ThingSpeak. Vous pouvez suivre la procédure pour configurer ThingSpeak Channel à partir de ce post

ThingSpeak MQTT

MQTT est une architecture de publication/abonnement développée principalement pour connecter des périphériques à bande passante et à puissance limitée sur des réseaux sans fil. C'est un protocole simple et léger qui s'exécute sur des sockets TCP/IP ou des WebSockets. MQTT sur WebSockets peut être sécurisé avec SSL. L'architecture de publication/abonnement permet aux messages d'être transmis aux appareils clients sans que l'appareil ait besoin d'interroger en permanence le serveur. Un client est tout appareil qui se connecte au courtier et peut publier ou s'abonner à des rubriques pour accéder aux informations. Une rubrique contient les informations de routage pour le courtier. Chaque client qui souhaite envoyer des messages les publie dans un certain sujet, et chaque client qui souhaite recevoir des messages s'abonne à un certain sujet

Publiez et abonnez-vous à l'aide de ThingSpeak MQTT

• Publication sur les canaux de flux de chaîne /publier/
• Publication dans un domaine particulier canaux /publish/fields/field/
• Abonnez-vous au champ channel channel /subscribe//
• Abonnez-vous aux canaux de flux de la chaîne privée //subscribe/fields/field/
• Abonnez-vous à tous les champs d'une chaîne. canaux// s'abonner/champs/champ/

tâche videWiFiCallback()

{

Serial.println("taskWiFiCallbackStarted");

Serial.print("timeout pour cette tâche: \t");

Serial.println(tWiFi.getTimeout());

if(!mqttCli.connected())

{

Serial.println("Client non connecté");

reconnecterMQTT();

}

String topicString ="channels/"+String(channelID)+"/publish/"+String(writeAPIKey);

int topicLength = topicString.length()+1;

char topicBuffer[topicLength];

topicString.toCharArray(topicBuffer, topicLength+1);

Serial.println(topicBuffer);

String dataString = String("field1="+ String(tempC, 1) + "&field2=" + String(tempF, 1) + "&field3=" + String(humide, 1));

int dataLength = dataString.length()+1;

octet dataBuffer[dataLength];

dataString.getBytes(dataBuffer, dataLength);

mqttCli.beginPublish(topicBuffer, dataLength, false);

Serial.println(mqttCli.write(dataBuffer, dataLength) ? "published": "published failed");

mqttCli.endPublish();

//mqttCli.loop();

}

Étape 7: Notification par e-mail de rapport météo

Nous utilisons des applets IFTTT pour envoyer une notification par e-mail en temps réel à l'utilisateur. Nous l'avons donc implémenté via ThingSpeak. Nous faisons la moyenne des valeurs de température et d'humidité de 5 fay. Chaque fois que la valeur de la dernière entrée est supérieure à la valeur moyenne. Cela déclenchera une notification par e-mail "il fait chaud". et lorsqu'elle est inférieure à la valeur moyenne. Cela déclenchera une notification par e-mail "Quelle belle journée". Chaque jour vers 10h00 (IST), nous recevrons une notification par e-mail

ID de canal = ******;

iftttURL='https://maker.ifttt.com/******************';

humiditéData=thingSpeakRead(channelID, 'Champs', 3, 'NumDays', 5); tempData = choseSpeakRead(channelID, 'Champs', 1, 'NumDays', 5);

perHumid=max(humiditéDonnées)-min(humiditéDonnées);

humidValue=0.1*perHumid+min(humiditéData);

perTemp=max(tempData)-min(tempData);

tempValue=0.1*perTemp+min(tempData);

urlTemp=strcat('https://api.thingspeak.com/channels/', string(channelID), '/fields/1/last.txt');

urlHumid = strcat('https://api.thingspeak.com/channels/', string(channelID), '/fields/3/last.txt'); lastTempValue=str2num(webread(urlTemp)); lastHumidValue = str2num(webread(urlHumid));

if (lastTempValue

if (lastTempValue>tempValue || lastHumidValue>humidValue)

plantMessage=' C'est une journée chaude.'; webwrite(iftttURL, 'value1', plantMessage, 'value2', lastTempValue, 'value3', lastHumidValue); finir

Étape 8: Code général

Code général

Le code global est disponible dans ce référentiel GitHub

Limites

• Il y a quelques problèmes avec la publication des données à l'aide de publier une méthode pour le gros des données. Pour résoudre ce problème, nous utilisons la fonction write ()
• SPIFFS doit être formaté avant de télécharger les nouvelles données vers SPIFFS.
• Vous ne devez pas utiliser la fonction delay(). delay() gêne l'opération en arrière-plan. Au lieu de cela, créez des délais en utilisant millis() uniquement si cela est nécessaire

Crédits

• Serveur Web ESP826
• Planificateur de tâches
• SHT 25
• API ThingSpeak MQTT
• IFTTT
• PubSubClient