Utilisation des fonction réseau des cartes compatibles Arduino, possédant une puce Wi-Fi
=== Episode n° 4 : Mes Wemos D1 Mini discutent sur Internet avec MQTT ===
=== Episode n° 4 : Mes Wemos D1 Mini discutent sur Internet avec MQTT ===
Difficulté
Technique
Durée
2 heure(s)
Disciplines scientifiques
Arduino, Informatique
Introduction
Cette expérience fait partie d'une série de 4 épisodes, présentant différentes façons de bénéficier des capacités de communication des cartes compatibles Arduino possédant une puce Wi-Fi (Wemos D1 mini, ESP32, ...). On suppose (Cf. "Expériences ré-requises" ci-après) que vous avez déjà manipulé une carte Arduino et son environnement de développement. Ces 4 épisodes sont les suivants :
- Connecter le Wemos D1 Mini à internet en Wi-Fi.
- Héberger un site web sur mon Wemos D1 Mini.
- Mon Wemos D1 Mini récupère des données sur Internet (format Json) .
- Mes Wemos D1 Mini discutent sur Internet avec MQTT --- cette page.
Il est nécessaire de commencer par l'épisode 1, par contre les épisodes suivants peuvent être consultés dans n'importe quel ordre.
- Matériel et outils
- Expériences pré-requises
- Fichiers
D1 mini 
C'est un cousin de l'Arduino, avec du wifi !
Logiciel Arduino 
C'est le logiciel libre développé pour accompagner et programmer la carte Arduino
Câble USB - micro-USB 
Le terme anglais Universal Serial Bus ou USB (en français bus universel en série) est une norme relative à un bus informatique en série qui sert à connecter des périphériques informatiques à un ordinateur ou à tout type d'appareil prévu à cet effet (tablette, smartphone, etc.).
Étape 1 - MQTT ? qu'est-ce que c'est ?
MQTT (Message Queuing Telemetry Transport) permet l'envoi et la réception de messages de petite taille. MQTT s'appuie sur un "broker MQTT", serveur externe, qui va recevoir les données d'un système, et les redistribuer à d'autres systèmes.
MQTT est souvent utilisé pour collecter des données en provenance de petits capteurs (par exemple, capteurs de température dans un système domotique, capteurs de pollution au niveau d'une région voire d'un pays), car il a aussi comme avantage d'être peu consommateur de ressources.
MQTT est basé sur un principe d'abonnement : le système émetteur doit préciser à quel sujet ("topic") se rattache son message, et tous les systèmes qui s'étaient préalablement abonnés à ce "topic" recevront alors le message. Principe proche de Twitter ou Instagram et leurs "hashtags", donc.
On peut implémenter son propre broker MQTT (le code est libre d'usage), ou s'appuyer sur des brokers gérés par des associations ou des entreprises. Dans l'exemple ci-après, on utilise le broker des Petits Débrouillards, à utiliser avec modération.
Mais ce n'est pas l'objet du tutoriel, nous nous intéressons ici uniquement à la partie "client", c'est à dire ce qu'il faut mettre en œuvre sur nos cartes D1 mini ou ESP.
Étape 2 - Mise en œuvre sur nos petites cartes
Il existe plusieurs bibliothèques Arduino permettent de gérer des messages MQTT. Pour notre part, on utilise celle-ci (à aller chercher dans le gestionnaire de bibliothèque) :
| Gestion du MQTT | ||
| Avant le Setup | Importation de la bibliothèque | #include <MQTT.h> |
| Création de l’objet | MQTTClient myMQTTClient; | |
| Dans le Setup (ou le loop) | Initialisation | myMQTTClient.begin(@IP Broker, Port Broker, Client Wifi) ; |
| Se préparer à la réception de messages | myMQTTClient.onMessage(référence de la fonction à appeler sur réception d'un message) ; | |
| Connexion au broker MQTT | myMQTTClient.connect(ID unique) | |
| Souscrire à un "topic" particulier | myMQTTClient.subscribe(topic) ; | |
| Publier un message | myMQTTClient.publish(topic, message) ; | |
| Dans le Loop | Activation régulière | obligatoire : myMQTTClient.loop() ; |
Pour connaître toutes les autres possibilités de cette bibliothèque, voir sa référence, ici.
Code minimal :
1 /* =========================================================================================================
2 *
3 * CODE MINIMAL RESEAU - ETAPE 6 : Messages MQTT
4 *
5 * ---------------------------------------------------------------------------------------------------------
6 * Les petits Débrouillards - décembre 2022 - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
7 * ========================================================================================================= */
8
9 // Bibliothèques requises
10 // ATTENTION AUX MAJUSCULES & MINUSCULES ! Sinon d'autres bibliothèques, plus ou moins valides, seraient utilisées.
11
12 #include <WiFiManager.h> // Gestion de la connexion Wi-Fi (recherche de points d'accès)
13 #include <WiFiClientSecure.h> // Gestion de la connexion à un serveur de données
14 #include <MQTT.h> // Gestion des requêtes MQTT
15
16
17 // Variables globales
18
19 WiFiManager myWiFiManager; // Manager Wi-Fi
20 WiFiClient myWiFiClient ; // Client WiFi
21 const char* mySSID = "AP_PetitDeb" ; // Nom de la carte en mode Point d'Accès.
22 const char* mySecKey = "PSWD1234" ; // Mot de passe associé, 8 caractères au minimum.
23
24
25 #define MQTT_BROKER_IP "debrouillards.ddns.net" // Serveur sur lequel est installé le Broker MQTT.
26 #define MQTT_BROKER_PORT 1883 // Port sur lequel écoute le broker MQTT
27
28 char MY_MQTT_ID[20] ; // Id unique de notre objet, basé sur ESP.getChipId()
29 const char MY_MQTT_TOPIC[] = "PING_PONG" ; // Nom de notre topic (sujet) MQTT
30
31 MQTTClient myMQTTClient; // Client MQTT
32
33 bool IHaveToAnswer = false ; // Passe à 'true' si on doit répondre.
34
35 #define TEN_SECONDS 10000 // On enverra un message au broker toutes les 10000 ms = 10 secondes.
36 unsigned long myWakeUp ; // Timer mis en place pour limiter le nombre d'envois au broker.
37
38 /* --------------------------------------------------------------------------------------------------------------
39 * MQTT_Received : réception d'un message MQTT
40 * ------------------------------------------------------------------------------------------------------------- */
41 void MQTT_Received(String &topic, String &payload) {
42
43 char myTrace[80] ;
44
45 sprintf(myTrace, "Réception sur le topic \"%s\" du message MQTT \"%s\".", topic, payload) ;
46 Serial.println(myTrace) ;
47
48 // Comme indiqué dans la documentation, il ne faut pas renvoyer de messages dans cette fonction,
49 // ça risque de mal se passer (blocages, ...). Si on souhaite répondre au message reçu, il vaut
50 // mieux mettre à jour une variable globale, qui sera vérifiée dans la partie loop().
51
52 if (payload == String("Ping")) {
53 IHaveToAnswer = true ;
54 }
55
56 }
57
58 /* --------------------------------------------------------------------------------------------------------------
59 * MQTT_Connect : Connexion - ou reconnexion - au broker MQTT.
60 * ------------------------------------------------------------------------------------------------------------- */
61 void MQTT_Connect() {
62
63 // Vérification WiFi OK.
64
65 int nbTries = 0 ;
66 while (WiFi.status() != WL_CONNECTED) {
67 if (nbTries++ > 10) {
68 Serial.println("Connexion WiFi KO :-(") ;
69 return ;
70 }
71 delay(500);
72 }
73
74 // Connexion au broker.
75
76 Serial.println("--- Connexion MQTT, Id unique \"" + String(MY_MQTT_ID) + "\" ") ;
77 nbTries = 0 ;
78 while (!myMQTTClient.connect(MY_MQTT_ID)) {
79 Serial.print(".") ;
80 if (nbTries++ > 10) {
81 Serial.println(" KO :-(") ;
82 return ;
83 }
84 delay(500);
85 }
86
87 // Abonnement au topic.
88
89 Serial.println("--- Abonnement au sujet \"" + String(MY_MQTT_TOPIC) + "\"") ;
90 myMQTTClient.subscribe(MY_MQTT_TOPIC);
91
92 }
93 /* --------------------------------------------------------------------------------------------------------
94 * SETUP : Initialisation
95 * -------------------------------------------------------------------------------------------------------- */
96 void setup() {
97
98 // Initialisation de la liaison série, affichage 1er message
99
100 Serial.begin(115200);
101 delay(100) ;
102 Serial.println();
103 Serial.println("---------------------") ;
104 Serial.println("Exemple messages MQTT") ;
105 Serial.println("---------------------") ;
106
107 // Tentative de connexion au Wi-Fi. Si la carte n'a pas réussi se connecter au dernier Point d'Accès connu,
108 // alors elle va se positionner en mode Point d'Accès, demandera sur l'adresse 192.168.4.1 quel nouveau
109 // Point d'Accès choisir. Par défaut, on restera bloqué tant que l'utilisateur n'aura pas fait de choix.
110
111 Serial.println("Connexion au Wi-Fi ...");
112 if (myWiFiManager.autoConnect(mySSID, mySecKey)) {
113 Serial.println(); Serial.print("Connecté ! Adresse IP : ");
114 Serial.println(WiFi.localIP());
115 }
116 else {
117 Serial.println("Connexion Wi-Fi KO :-(");
118 }
119
120 // Initialisation du MQTT
121
122 Serial.println("Initialisation MQTT ...");
123 myMQTTClient.begin(MQTT_BROKER_IP, MQTT_BROKER_PORT, myWiFiClient); // lancement du client MQTT ...
124 myMQTTClient.onMessage(MQTT_Received); // ... qui appelera la fonction MQTT_Received si un message est reçu.
125
126 strncpy(MY_MQTT_ID, String(ESP.getChipId()).c_str(),sizeof(MY_MQTT_ID)) ; // Fabrication de mon ID unique, sur la base du n° de puce
127 MY_MQTT_ID[sizeof(MY_MQTT_ID)-1] = '\0' ;
128
129 // Connexion au broker
130
131 MQTT_Connect() ;
132
133 // Initialisation du timer qui sera testé dans loop() - pour faire appel au serveur seulement toutes les 10 secondes
134 // millis() est une fonction système donnant le nombre de ms depuis le lancement ou la réinitialisation de la carte.
135
136 unsigned long myWakeUp = millis() + TEN_SECONDS ;
137
138 }
139
140 /* --------------------------------------------------------------------------------------------------------------
141 * LOOP : fonction appelée régulièrement par le système
142 * ------------------------------------------------------------------------------------------------------------- */
143 void loop() {
144
145 // Réactivation du client MQTT
146
147 myMQTTClient.loop() ;
148 delay(10) ; // Problèmes de stabilité Wi-Fi ? (Cf. doc MQTT)
149
150 // Reconnexion au broker MQTT si nécessaire ...
151
152 if (!myMQTTClient.connected()) {
153 MQTT_Connect();
154 }
155
156 // Si on a précédemment reçu un 'Ping', on va répondre 'Pong'
157
158 if (IHaveToAnswer) {
159 IHaveToAnswer = false ;
160 Serial.println("Envoi de la réponse \"Pong\" sur le topic \"" + String(MY_MQTT_TOPIC) + "\".") ;
161 myMQTTClient.publish(MY_MQTT_TOPIC, "Pong") ;
162 }
163
164 // Envoi d'un message toutes les 10 secondew.
165
166 unsigned long myNow = millis() ;
167 if (myNow >= myWakeUp) {
168 Serial.println("Wake Up ! envoi du message \"Ping\" sur le topic \"" + String(MY_MQTT_TOPIC) + "\".") ;
169 myMQTTClient.publish(MY_MQTT_TOPIC, "Ping") ;
170 myWakeUp = myNow + TEN_SECONDS ;
171 }
172
173
174 }
Étape 3 - La suite, la suite ... à vous de jouer !
... Si vous avez suivi tous les épisodes ... :-)
Les exemples de code "minimal" fournis peuvent servir de base pour vos futures réalisations, ou pour gagner un temps précieux pendant un hackathon. Tous les codes sont regroupés dans un dossier compressé, accessible dans la rubrique "Fichiers" en début de cette page.
Pour aller plus loin, n'hésitez pas à copier ces programmes minimaux, et à les modifier en douceur pour obtenir autre chose que des traces dans le moniteur série Arduino. Juste quelques idées ...
- Sur la base du code de l'étape 4 (serveur web), et d'un servomoteur, fabriquer un coffre secret qui ne s'ouvre que lorsque son/sa propriétaire tape un code sur son téléphone ;
- Sur la base du code de l'étape 5 (JSON) et d'un ruban de leds, faire un thermomètre affichant la température de votre ville préférée. Il y a de nombreux sites web proposant gratuitement (si on n'abuse pas) des informations météo en mode JSONs, par exemple :
- Sur la base du code de l'étape 6 (MQTT), et d'un capteur de température et d'humidité, ... ah, on me glisse dans l’oreillette que ça existe déjà sur le Wikidébrouillard ! (avec une autre bibliothèque MQTT). ... Ou bien alors, avec deux D1 Mini, deux boutons poussoirs et deux rubans de leds, faire une version "jeu à distance" du célèbre D1-Pong !
Dernière modification 1/02/2023 par user:Philby.
Published