Code Minimal Réseau - (4) Mes Wemos D1 Mini discutent sur Internet avec MQTT

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 ===

Difficulté

Technical Technique

Durée

2 hour(s) heure(s)

Disciplines scientifiques

Arduino, Informatique

Code_minimal_des_fonctions_r_seau_WiKi_Reseau1.png

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 :

1. Connecter le Wemos D1 Mini à internet en Wi-Fi.
2. Héberger un site web sur mon Wemos D1 Mini.
3. Mon Wemos D1 Mini récupère des données sur Internet  (format Json) .
4. 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.

Dans la même philosophie que les expériences "Code minimal des capteurs pour Arduino" et "Code minimal des actionneurs pour Arduino", nous fournirons ici uniquement le code relatif à nos besoins de connexion, sans mettre au point une quelconque application. Donc, ici, pas besoin de connecter une led ou un capteur, donc pas de schéma de montage : vous branchez simplement votre carte en USB sur votre ordinateur, et les résultats seront visibles en mode texte dans le moniteur série de l'environnement de développement Arduino.

• Matériel et outils
• Expériences pré-requises
• Fichiers

D1 mini

C'est un cousin de l'Arduino, avec du wifi !

D1 mini

Logiciel Arduino

C'est le logiciel libre développé pour accompagner et programmer la carte Arduino

Logiciel 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.).

Câble USB - micro-USB

Installer l'environnement Arduino sur votre système

Premiers pas avec Arduino

Utiliser le D1 mini avec Arduino

https://cloud.debrouillonet.org/s/netQgbkgG34RnYt

É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 :

Dans cet exemple, notre carte est à la fois émettrice (elle va envoyer des "Pings") et réceptrice sur le topic "PING_PONG". Elle va aussi répondre "Pong" sur réception d'un "Ping". En règle générale, dans les vraies applications, une carte est souvent émettrice (envoi de données d'un capteur de pollution, par exemple), et il peut y avoir une seule autre carte chargée d'exploiter les données remontées par plusieurs capteurs.

  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 :
  • TuTiempo.net
  • OpenWeather
  • Previsionsmeteo.ch
• 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.

Draft