- Matériaux nécessaires:
- Comment les choses fonctionnent?
- Programmation de l'ESP8266-01:
- Connexion de l'ESP8266-01 à Arduino:
- Programme Arduino et fonctionnement:
L'ESP8266-01 a été un excellent module pour étancher toutes nos soifs de projets IOT. Depuis sa sortie, il a développé une communauté forte et a évolué vers un module Wi-Fi facile à utiliser, bon marché et puissant. Une autre plate-forme open-source beaucoup plus populaire est l'Arduino, elle a déjà des tonnes de projets construits autour d'elle. La combinaison de ces deux plates-formes ouvrira des portes à de nombreux projets innovants.Dans ce tutoriel, nous allons donc apprendre à interfacer le module ESP8266-01 avec Arduino. De cette façon, nous pourrons envoyer ou recevoir des données entre l'Arduino et Internet.
Pour les besoins de ce tutoriel, nous lirons l'heure, la date, la température et l'humidité sur Internet à l' aide d'une API avec l'ESP8266-01. Envoyez ensuite ces valeurs à une carte Arduino et affichez-les sur l'écran LCD 16 * 2. Ça a l'air cool! Alors, commençons.
Matériaux nécessaires:
- Carte Arduino (toute version)
- ESP8266-01
- Carte de programmation FTDI avec option 3,3 V
- Écran LCD 16x2
- Potentiomètre
- Bouton poussoir
- Fils de connexion
- Planche à pain
Comment les choses fonctionnent?
Avant de plonger, il est important de savoir comment cette chose va fonctionner. En gros, nous devons commencer par le module ESP8266-01. Nous utiliserons l' IDE Arduino pour programmer l'ESP8266 et le code sera écrit pour utiliser une API pour lire un fichier JSON via une requête http. Ensuite, nous allons formuler ce fichier JSON pour extraire uniquement les informations requises du fichier JSON complet.
Une fois les informations formulées, nous les imprimerons en utilisant la communication série. Ces lignes série seront ensuite connectées à l'Arduino, afin que l'Arduino puisse lire les informations envoyées depuis l'ESP8266. Une fois les informations lues et traitées, nous les afficherons sur l'écran LCD.
Ce n'est pas grave, si vous ne l'avez pas complètement compris, car nous apprendrons la même chose dans le reste de ce tutoriel.
Programmation de l'ESP8266-01:
Ce didacticiel suppose que vous avez une certaine expérience avec le module ESP8266. Sinon, il est recommandé de lire les trois tutoriels suivants pour bien comprendre.
- Premiers pas avec ESP8266-01
- Programmation de l'ESP8266-01 à l'aide des commandes AT
- Programmation de l'ESP8266-01 à l'aide de l'IDE Arduino et flash de sa mémoire
Vous pouvez également consulter tous nos projets ESP8266 ici.
Ici, nous allons programmer le module ESP8266-01 en utilisant l'IDE Arduino. Pour le matériel, nous utilisons la carte FTDI avec 3,3 V pour programmer ESP8266, car cela rendra le matériel beaucoup plus simple. Le schéma de circuit pour connecter votre ESP8266 avec la carte FTDI est illustré ci-dessous.
Assurez-vous que les conditions suivantes sont remplies
1. L'ESP8266-01 ne tolère que 3,3 V, n'utilisez pas de 5 V. Donc, réglez FTDI uniquement en mode 3.3V.
2. GPIO_0 doit être mis à la terre pour le mode de programmation
3. La broche de réinitialisation doit être connectée via un bouton à la broche de terre. Ce bouton doit être pressé juste avant de télécharger le code. Chaque fois que vous appuyez sur le bouton, la LED bleue du module ESP8266-01 devient élevée pour indiquer que le module est réinitialisé.
Une fois les connexions effectuées, ouvrez l'IDE Arduino et vérifiez si vous pouvez télécharger un exemple de programme avec succès. Si vous ne savez pas comment utiliser l'IDE Arduino pour télécharger le programme sur ESP8266, suivez la programmation ESP8266 avec Arduino pour l'apprendre. À ce stade, je suppose que vous avez téléchargé avec succès le programme blink.
. Le programme complet est donné à la fin de cette page plus loin ci-dessous, je les explique sous forme de petits extraits. Le programme nécessite également la compilation de la bibliothèque Arduino JSON, donc si vous n'avez pas déjà ajouté la bibliothèque à votre IDE Arduino, ajoutez-la en la téléchargeant à partir de la bibliothèque Arduino JSON de Github.
L'ESP8266 doit se connecter à Internet pour obtenir les données sur la date, l'heure, la température et l'humidité. Vous devez donc lui permettre de se connecter à votre Wi-Fi en prouvant le SSID et le mot de passe dans les lignes ci-dessous
const char * ssid = "JIO-Fi"; // Entrez votre SSID Wi-Fi const char * password = "Pas123"; // Entrez votre mot de passe Wi-Fi
Dans la fonction setup () , nous vérifions si l'ESP est capable de se connecter au Wi-Fi, sinon il y attendra pour toujours en imprimant simplement «Connexion..» sur le moniteur série.
while (WiFi.status ()! = WL_CONNECTED) {// Attendre que le Wi-Fi soit connecté delay (1000); Serial.print ("Connexion.."); // Impression de la connexion… jusqu'à ce que la connexion soit établie }
La prochaine étape est l'étape très importante. Si la connexion Wi-Fi réussit, nous devons invoquer une requête http get pour lire le fichier JSON depuis Internet. Dans ce tutoriel, j'utilise l'API fournie par wunderground.com. Donc, si vous prévoyez d'utiliser la même chose, vous pouvez créer un lien et vous inscrire à la clé API gratuite ou utiliser n'importe quelle API de votre choix. Une fois que vous avez finalisé avec votre API, vous vous retrouverez avec un lien comme celui-ci ci-dessous
Remarque: j'ai changé la clé API de ce lien afin que cela ne fonctionne pas. Gardez votre clé API sécurisée et ne la partagez pas.
Mon API ici est utilisée pour obtenir les données météorologiques de Chennai. Vous pouvez utiliser n'importe quelle API. Mais lorsque vous chargez l'API dans n'importe quel navigateur, elle doit renvoyer un fichier JSON. Par exemple, mon API renvoie le fichier JSON suivant
Le vôtre peut renvoyer un fichier avec des données différentes. Nous pouvons vérifier si ce fichier JSON est également reçu par notre ESP8266 en le lisant et en imprimant JSON sur notre moniteur série en utilisant les lignes suivantes
int httpCode = http.GET (); // Passer une requête get if (httpCode> 0) {// Vérifier le code de retour // payload = http.getString (); // Stocke la valeur sur varibale Payload pour le débogage // Serial.println (payload); // Affiche la charge utile pour le débogage sinon commente les deux lignes
J'ai commenté ces lignes, car elles ne sont nécessaires que pour les tests. Une fois que vous vous êtes assuré que ESP8266 est en mesure d'obtenir les données JSON, il est temps de formuler les données. Comme vous pouvez le voir, ces données sont énormes et la plupart des valeurs sont inutiles, sauf celles qui nous sont nécessaires comme la date, l'heure, la température et l'humidité.
Nous utilisons donc la bibliothèque JSON Arduino pour séparer les valeurs requises pour nous et les stocker dans une variable. Cela est possible car les valeurs du fichier JSON sont affectées sous forme de paires de valeurs de nom. Donc, ce nom est une chaîne qui contiendra la valeur requise pour nous.
Pour ce faire, nous devons passer à un site Web qui analysera le fichier JSON et nous donnera le code Arduino. Oui, c'est aussi simple que ça. Accédez à https://arduinojson.org/assistant/ et collez le fichier JSON que nous avons chargé dans notre navigateur et appuyez sur Entrée. Une fois terminé, le mien ressemblait à ceci ci-dessous
Faites défiler un peu pour voir le programme de phrasé qui est créé automatiquement
Tout ce que vous avez à faire est de sélectionner la variable que vous voulez, de les copier et de la coller sur votre IDE Arduino, comme je l'ai fait ici
/ * Phrasing Data à l'aide de la librarey JSON * / // Utilisez https://arduinojson.org/assistant/ pour obtenir les valeurs de phrasé pour votre chaîne JSON const size_t bufferSize = JSON_OBJECT_SIZE (0) + JSON_OBJECT_SIZE (1) + JSON_OBJECT_SIZE (2) + 2 * JSON_OBJECT_SIZE (3) + JSON_OBJECT_SIZE (8) + JSON_OBJECT_SIZE (12) + JSON_OBJECT_SIZE (56) + 2160; DynamicJsonBuffer jsonBuffer (bufferSize); JsonObject & root = jsonBuffer.parseObject (http.getString ()); / * Fin des données de formulation * / // Adresser la valeur sin aux variables souhaitées JsonObject & current_observation = root; // sous current_observation JsonObject & current_observation_observation_location = current_observation; // sous observation_location const char * current_observation_station_id = current_observation; // "ICHENNAI1" // obtenir les détails de l'emplacement const char * current_observation_local_time_rfc822 = current_observation; // Heure locale // récupère l'heure locale const char * current_observation_temperature_string = current_observation; // "90,7 F (32,6 C)" // obtenir la valeur de température const char * current_observation_relative_humidity = current_observation; // "73%" // récupère la valeur d'humidité
Je viens de copier les variables current_observation_station_id, current_observation_local_time_rfc822, current_observation_temperature_string et current_observation_relative_humidity . Puisque nous prévoyons d'afficher uniquement ces quatre données sur notre écran LCD.
Enfin, nous avons obtenu les données dont nous avons besoin sur Internet et les avons sauvegardées en tant que variable que nous pouvons utiliser confortablement. Pour envoyer ces données à Arduino, il suffit de les écrire en série via le moniteur série. Les lignes suivantes feront exactement la même chose
// Imprimer les variables via le moniteur série Serial.print (current_observation_station_id); // envoyer les détails de l'emplacement à Arduino delay (100); // délai de stabilité Serial.print (current_observation_local_time_rfc822); // envoyer les détails de l'heure locale à Arduino delay (100); // délai de stabilité Serial.print (current_observation_temperature_string); // envoyer les détails de la température à Arduino delay (100); // délai de stabilité Serial.print (current_observation_relative_humidity); // envoyer les détails d'humidité à Arduino delay (100); // délai de stabilité
Notez que j'ai utilisé Serial.print () et non Serial.println () puisque la commande Serial.println () ajoutera un / n et / r avec les données qui ne sont pas nécessaires pour nous. Nous avons également ajouté un délai de 10 secondes pour que l'ESP envoie ces valeurs uniquement à un intervalle de 10 secondes à Arduino.
Connexion de l'ESP8266-01 à Arduino:
Jusqu'à présent, nous avons programmé notre ESP8266-01 pour lire les données requises sur Internet à un intervalle de 10 secondes et les envoyer en série. Nous devons maintenant interfacer l'ESP avec Arduino pour pouvoir lire ces données série. Nous devons également ajouter un écran LCD 16 * 2 à Arduino afin que nous puissions afficher les données reçues du module ESP8266. Le schéma de circuit pour interfacer le module ESP8266 avec Arduino est illustré ci-dessous
Assurez-vous que la broche GPIO_0 est laissée libre, alimentez le module uniquement avec la broche 3.3V d'Arduino et appuyez sur le bouton poussoir pour mettre le module ESP dans le module d'exploitation. Maintenant, le programme que nous avons téléchargé sur ESP devrait avoir commencé à fonctionner et le module devrait envoyer les données via une broche série à Arduino. Ces broches série sont connectées aux broches numéro 6 et 7 sur l'Arduino. Nous pouvons donc utiliser l'option série logicielle sur Arduino pour lire ces données série à partir des broches.
Programme Arduino et fonctionnement:
Le programme Arduino complet est également donné avec le code ESP à la fin de cette page. Vous pouvez faire défiler vers le bas pour afficher le programme ou lire plus loin si vous souhaitez comprendre le programme.
Le programme d'interfaçage est assez simple, il suffit d'utiliser la bibliothèque série logicielle pour lire les données des broches 6 et 7 et les afficher sur l'écran LCD. Étant donné que les données reçues sont au format chaîne, nous devons utiliser l'option de sous-chaîne pour diviser la charge utile selon nos besoins ou même la convertir en entier si nécessaire. Nous commençons donc par définir les broches auxquelles le LCD est connecté.
const int rs = 8, en = 9, d4 = 10, d5 = 11, d6 = 12, d7 = 13; // Broches auxquelles l'écran LCD est connecté LiquidCrystal lcd (rs, en, d4, d5, d6, d7);
Depuis que nous avons connecté les broches Rx et Tx de l'ESP8266 avec les 6 et 7 e broches d'Arduino, nous devons initialiser le logiciel série pour ces broches afin que nous puissions recevoir les données série d'eux. nommez-les comme vous le souhaitez
SoftwareSerial ESP_Serial (6,7); // Tx, Rx
Dans la fonction setup () , nous initialisons la communication série pour le moniteur série et également pour le logiciel série. Si vous vous souvenez bien, nous avons fait en sorte que le programme ESP communique à un débit de 9600 bauds, nous devons donc utiliser le même débit en bauds pour le port série du logiciel. Nous affichons également un petit message d'introduction sur l'écran LCD pendant 2 secondes.
void setup () {lcd.begin (16, 2); // Nous utilisons un écran LCD 16 * 2 lcd.print ("Arduino & ESP"); // Afficher un message d'introduction Serial.begin (115200); ESP_Serial.begin (9600); retard (2000); lcd.clear (); }
Dans la fonction principale loop () , nous devons vérifier si l'ESP8266 envoie quelque chose. Si c'est le cas, nous lisons la chaîne depuis ESP8266 et la sauvegardons dans une variable appelée payload. La charge utile variable est de type String et contient les informations complètes envoyées par le module ESP8266.
while (ESP_Serial.available ()> 0) {payload = ESP_Serial.readString ();
Nous devons maintenant diviser cette chaîne en petits morceaux afin de pouvoir les utiliser à nos propres fins, dans ce cas, nous devons les diviser pour les afficher sur l'écran LCD. Cela peut être fait facilement en utilisant la fonction de sous - chaîne dans Arduino. Vous devez connaître la position de chaque caractère pour utiliser cette fonction de sous - chaîne . Vous pouvez imprimer la charge utile sur le moniteur série pour connaître la position des caractères et les utiliser pour classer les sous-chaînes comme indiqué ci-dessous
local_date = payload.substring (14, 20); local_time = payload.substring (26, 31); température = charge utile.substring (48, 54); Humidité = charge utile.substring (55, 60);
Maintenant, je peux continuer et utiliser ces variables pour les imprimer sur un moniteur série ou simplement les imprimer sur l'écran LCD. Cependant, les imprimer sur le moniteur série nous aidera à vérifier si les sous-chaînes sont correctement divisées. Ensuite, nous les imprimons simplement sur l'écran LCD en utilisant les lignes suivantes
lcd.clear (); lcd.setCursor (1, 0); lcd.print (date_locale); lcd.setCursor (8, 0); lcd.print (heure_locale); lcd.setCursor (1, 1); lcd.print (température); lcd.setCursor (10, 1); lcd.print (humidité);
Téléchargez le programme sur Arduino et assurez-vous que les connexions sont comme indiqué dans le schéma de circuit ci-dessus. Ajustez le contraste de l'écran LCD jusqu'à ce que vous voyiez clairement les choses. Vous devriez voir le message d'introduction sur l'écran LCD, puis après quelques secondes, les détails tels que la date, l'heure, la température et l'humidité doivent être affichés sur l'écran LCD comme indiqué ci-dessous.
Vous pouvez également remarquer que le voyant bleu de l'ESP8266 clignote à chaque fois que les données arrivent. Si vous ne voyez pas cela, cela signifie que l'ESP n'est pas en mode de programmation, essayez d'appuyer sur le bouton de réinitialisation et vérifiez également les connexions.
De même, vous pouvez utiliser n'importe quelle API pour obtenir toutes les données requises sur Internet et les alimenter à l'Arduino et au processus de votre travail avec Arduino. Il existe des tonnes d'API disponibles sur Internet et avec toutes celles-ci, vous pouvez réaliser un nombre illimité de projets. J'espère que vous avez compris le projet et que vous avez apprécié sa construction. Si vous avez rencontré un problème, postez-les dans la section commentaires ci-dessous ou sur nos forums.
Vous pouvez trouver tous nos projets liés à l'ESP8266 ici.