LOCODUINO

Forum de discussion
Dépôt GIT Locoduino
Flux RSS

dimanche 26 juin 2022

32 visiteurs en ce moment

Éclairer le réseau (2)

Connexion au WiFi et Multi Cast DNS

. Par : Jean-Luc

DIFFICULTÉ :

Nous continuons cette série par l’infrastructure logicielle avec la connexion au WiFi et l’usage de mDNS.

Le logiciel Arduino de l’ESP32, mais c’est aussi vrai des autres cartes compatibles Arduino qui possèdent une connexion WiFi, fournit de multiples fonctions pour communiquer via le réseau. Nous allons examiner ici et dans les articles suivants :

  • La connexion WiFi ;
  • Le multi-cast DNS ;
  • l’OTA ;
  • MQTT.

Mais tout d’abord occupons nous d’installer le paquet logiciel permettant de programmer un ESP32 depuis l’IDE Arduino. Si vous avez déjà installé de nouveaux paquets de gestion de cartes, la procédure est familière. Il s’agit d’abord de se rendre dans les préférence de l’IDE Arduino et cliquer sur le bouton représentant une fenêtre ombrée (voir figure 1). Il faut ajouter l’URL suivante dans la fenêtre qui s’est ouverte en prenant soin de mettre une URL par ligne.

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
Figure 1 : Ajout d'un gestionnaire de cartes dans les préférences.
Figure 1 : Ajout d’un gestionnaire de cartes dans les préférences.

Ce n’est que la première étape. Pour installer tout le nécessaire pour programmer un ESP32, il faut se rendre ensuite dans le Outils puis Type de carte : … et sélectionner dans le sous-menu l’item Gestionnaire de cartes. Une fenêtre s’ouvre et dans la case de recherche en haut à droite, on tape « ESP32 ». Puis on clique sur le bouton Installer.

Figure 2 : Installation du paquet pour la prise en charge des ESP32.
Figure 2 : Installation du paquet pour la prise en charge des ESP32.
Dans cette capture d’écran, le nécessaire est déjà installé et le bouton Supprimer apparaît au lieu de Installer.

Enfin, il faut sélectionner la carte ESP32 que l’on souhaite programmer. Ici, il s’agit de la « MH ET LIVE ESP32MiniKit », voir figure 3 ci-dessous.

Figure 3 : sélection de la carte adéquate.
Figure 3 : sélection de la carte adéquate.

La connexion WiFi

Il y a plusieurs façons d’initialiser le WiFi mais nous n’allons ici nous préoccuper que du mode station ; c’est à dire que l’ESP32 va rejoindre le réseau WiFi de votre domicile comme un ordinateur, un téléphone ou une tablette. Le type de protection, WPA, WPA2, … est géré automatiquement. Le nom du réseau (ssid, ici polaris) et son mot de passe sont placés en dur dans le sketch. Il va sans dire que vous devez substituer à polaris le nom de votre réseau et à ************ votre mot de passe.

Le sketch minimum pour que l’ESP32 se connecte au WiFi est le suivant :

  1. #include <WiFi.h>
  2.  
  3. /* Nom du réseau WiFi */
  4. const char ssid[] = "polaris";
  5. /* Mot de passe du réseau WiFi */
  6. const char pass[] = "************";
  7.  
  8. void setup() {
  9. /* Pour le debug */
  10. Serial.begin(115200);
  11. /* Connexion au Wifi */
  12. WiFi.begin(ssid, pass);
  13. /* Boucle d'attente que la connexion soit ok */
  14. while (WiFi.status() != WL_CONNECTED) {
  15. Serial.print('.');
  16. delay(1000);
  17. }
  18. Serial.println();
  19. Serial.print("Connecté à ");
  20. Serial.println(ssid);
  21. }
  22.  
  23. void loop() {
  24. }

Ceci a l’avantage de la simplicité mais présente plusieurs défauts [1] :

  1. En cas de perte de la connexion, rien ne garantit que l’ESP32 se reconnectera de lui même ;
  2. Même en améliorant le programme pour demander une reconnexion, rien ne garantit que les couches logicielle du WiFi soient dans un état cohérent et permettent cette reconnexion ;
  3. On bloque sur la connexion WiFi sans assurer une fonction minimum. Par exemple, pour notre application d’éclairage, le minimum serait que l’éclairage se mette en route sans pour autant qu’il soit pilotable.

Pour détecter la perte de connexion, on peut utiliser à intervalles réguliers WiFi.status() qui retournera WL_CONNECTED si la connexion est fonctionnelle, pour plus de détails voir la documentation.

Pour 1, on devrait normalement utiliser WiFi.reconnect() lorsque WiFi.status() ne retourne pas WL_CONNECTED. C’est d’ailleurs ce que l’on trouve sur de nombreux sites pour reconnecter l’ESP32. Mais l’expérience menée avec mon téléphone comme borne WiFi [2], en coupant et en remettant le partage de connexion montre que l’ESP32 ne se reconnecte pas et qu’il faut en réalité repasser par la fonction WiFi.begin(...) pour avoir un fonctionnement satisfaisant. Pour 2, il est nécessaire de compter le nombre de tentatives qui échouent et, quand il dépasse un seuil, redémarrer l’ESP32. On peut également compter le nombre de déconnexions qui ont lieu trop fréquemment. Par exemple si la durée entre une déconnexion et la suivante est inférieure à un intervalle de temps, on incrémente une variable. Si cette variable dépasse un seuil, l’ESP32 est redémarré. Enfin pour 3, on va découpler la connexion au réseau WiFi et l’application qui s’exécute sur la carte.

Mais si le but de 3 est d’assurer un service minimum d’éclairage non pilotable, il est en conflit avec 2 car à chaque redémarrage les rubans de LED blanches s’éteindront une fraction de seconde [3]. Nous allons donc laisser de côté le point 2.

Voici donc une classe, Connection qui découple l’établissement et le maintien de la connexion du reste du logiciel et qui rétablit la connexion quand elle est perdue. Elle est basée sur une machine à états comprenant 3 états : OFFLINE correspondant à une connexion absente, WIFI_STBY correspondant à l’attente de l’établissement de la connexion et WIFI_OK lorsque la connexion est établie. La machine à état est montrée à la figure 4.

Figure 4 : Machine à états de gestion de la connexion WiFi
Figure 4 : Machine à états de gestion de la connexion WiFi

La déclaration de la classe est la suivante :

  1. class Connection {
  2. public:
  3. typedef enum { OFFLINE, WIFI_STBY, WIFI_OK } State;
  4.  
  5. private:
  6. static State sState;
  7. static uint32_t sLastDate;
  8. static uint32_t sPeriod;
  9. static char *sSsid;
  10. static char *sPass;
  11.  
  12. Connection() {}
  13.  
  14. static void update();
  15.  
  16. public:
  17. static void setup(const char *inSsid, const char *inPass, const uint32_t inPeriod = 1000ul);
  18. static void loop();
  19. static bool isOnline();
  20. };

On trouve la définition, sous forme d’enum, des 3 états précédemment évoqués puis 5 variables de classe permettant de :

  • Mémoriser l’état courant (sState) ;
  • Mémoriser la dernière date d’appel de update (sLastDate) ;
  • Spécifier la période d’appel de update (sPeriod) ;
  • Pointer vers le le nom et le mot de passe du réseau WiFi (sSsid et sPass) ;

Le constructeur, Connection() est déclaré privé de manière à empêcher de créer une instance de cette classe. En effet, elle n’est pas destinée à être instanciée et ne sert qu’à encapsuler les fonctions et les variables employées pour la connexion au WiFi.

update() implémente la machine d’états présentée figure 4. setup() est destiné à être appelé dans la fonction homonyme du sketch avec pour argument le nom du réseau, son mot de passe et, de manière optionnelle, la période d’appel de update() avec une valeur par défaut d’une seconde. loop() doit être appelé dans le loop() du sketch. Enfin, isOnline() sert à tester si la connexion est opérationnelle.

L’implémentation est donnée ci-dessous :

  1. Connection::State Connection::sState = OFFLINE;
  2. uint32_t Connection::sLastDate = 0ul;
  3. uint32_t Connection::sPeriod = 1000ul;
  4. char *Connection::sSsid = NULL;
  5. char *Connection::sPass = NULL;
  6.  
  7. void Connection::update()
  8. {
  9. switch (sState) {
  10. case OFFLINE:
  11. if (sSsid != NULL && sPass != NULL) {
  12. DP("Connexion à : ");
  13. WiFi.begin(sSsid, sPass);
  14. sState = WIFI_STBY;
  15. }
  16. break;
  17.  
  18. case WIFI_STBY:
  19. if (WiFi.status() == WL_CONNECTED) {
  20. DP(' ');
  21. DPLN(sSsid);
  22. sState = WIFI_OK;
  23. } else {
  24. DP('.');
  25. }
  26. break;
  27.  
  28. case WIFI_OK:
  29. if (WiFi.status() != WL_CONNECTED) {
  30. DPLN("Perte de connexion");
  31. sState = OFFLINE;
  32. }
  33. break;
  34. }
  35. }
  36.  
  37. void Connection::setup(const char *inSsid, const char *inPass, const uint32_t inPeriod)
  38. {
  39. sPeriod = inPeriod;
  40. sSsid = (char *)inSsid;
  41. sPass = (char *)inPass;
  42. }
  43.  
  44. void Connection::loop()
  45. {
  46. const uint32_t currentDate = millis();
  47. if ((currentDate - sLastDate) >= sPeriod) {
  48. update();
  49. sLastDate = currentDate;
  50. }
  51. }
  52.  
  53. bool Connection::isOnline()
  54. {
  55. return (sState == WIFI_OK);
  56. }

On notera l’usage de macros (DP et DPLN) pour « Debug Print » et « Debug PrintLN » permettant d’afficher des messages afin de débugger. Ces macros sont définies comme ceci :

  1. #define DEBUG
  2.  
  3. #ifdef DEBUG
  4. #define DSB(v) Serial.begin(v)
  5. #define DP(m) Serial.print(m)
  6. #define DPLN(m) Serial.println(m)
  7. #else
  8. #define DSB(v)
  9. #define DP(m)
  10. #define DPLN(m)
  11. #endif

Le fait de supprimer le #define DEBUG au début permettra d’enlever ces messages lorsque le programme sera terminé.

Dans cette première version ne s’occupant que d’établir et de maintenir la connexion WiFI, le sketch se réduit à ceci :

  1. void setup() {
  2. /* Pour le debug */
  3. DSB(115200);
  4. /* Connexion */
  5. Connection::setup(ssid, pass);
  6. }
  7.  
  8. void loop() {
  9. Connection::loop();
  10. }

Le Multicast DNS

Le DNS (Domain Name Server ou serveur de nom de domaine) est un service qui, sur Internet, permet de convertir un nom de machine, par exemple www.locoduino.org en adresse IP. Ainsi quand vous tapez de manière fort avisée http://www.locoduino.org dans votre navigateur, ce dernier demande au système d’exploitation de votre ordinateur de trouver l’adresse IP de Locoduino. Le système d’exploitation possède l’adresse IP d’un DNS auquel il s’adresse pour obtenir la réponse. Généralement c’est votre box qui remplit ce rôle. Elle-même s’adresse au DNS de votre fournisseur d’accès et, de proche en proche, on aboutit au DNS du domaine .org qui connait Locoduino. La réponse suit le chemin inverse et atteint votre navigateur qui peut alors ouvrir une connexion TCP avec Locoduino. Dans le processus la chaine de DNS mémorise la réponse pour un temps afin d’éviter de s’adresser au DNS de .org systématiquement.

Chez vous, par contre, c’est différent car il n’existe pas de DNS pour faire la correspondance entre un nom de machine/téléphone/tablette/imprimante/ESP32 et son adresse IP. C’est là qu’intervient le service Multicast DNS ou mDNS. Ici chaque machine connaît son nom qui va forcément se terminer par .local. Dès qu’une requête de DNS concerne un nom se terminant par .local, votre machine, au lieu de s’adresser au DNS, va envoyer sur votre réseau local une requête à toutes les machines qui s’y trouvent. Celle qui a le nom spécifié répond « C’est moi et voici mon adresse IP ».

Il s’agit donc ici de donner un petit nom à l’ESP32, ce qui sera quand même plus sympathique qu’une adresse IP et ce d’autant plus que cette dernière peut changer entre deux mises sous tension de l’ESP32 étant donné que c’est votre box internet qui attribue cette adresse.

Mettre en œuvre mDNS sur ESP32 est très simple. Il suffit d’inclure l’entête de la bibliothèque MDNS : #include <ESPmDNS.h> puis, à l’endroit approprié du code, d’appeler MDNS.begin(...); avec comme argument le nom de machine sans le .local. C’est tout.

Mais il faut l’intégrer au processus de connexion afin de lancer le mDNS après que la connexion WiFi soit établie. Cela conduit à ajouter un état à notre automate, entre WIFI_STBY et WIFI_OK tel que montré à la figure 5.

Figure 5 : Machine à états de gestion de la connexion WiFi avec service mDNS.
Figure 5 : Machine à états de gestion de la connexion WiFi avec service mDNS.

Un état est donc ajouté à l’enum :

  1. typedef enum { OFFLINE, WIFI_STBY, WIFI_OK, MDNS_OK } State;

La classe Connection reçoit une nouvelle variable membre pour disposer du nom mDNS de l’ESP :

  1. static char *sName;

Connection::setup reçoit un argument supplémentaire pour le nom :

  1. static void setup(const char *inSsid, const char *inPass, const char *inName, const uint32_t inPeriod = 1000ul);

Connection::update() est modifié pour prendre en charge ce nouvel état :

  1. void Connection::update()
  2. {
  3. switch (sState) {
  4. case OFFLINE:
  5. if (sSsid != NULL && sPass != NULL) {
  6. DP("Connexion à : ");
  7. WiFi.begin(sSsid, sPass);
  8. sState = WIFI_STBY;
  9. }
  10. break;
  11.  
  12. case WIFI_STBY:
  13. if (WiFi.status() == WL_CONNECTED) {
  14. DP(' ');
  15. DPLN(sSsid);
  16. sState = WIFI_OK;
  17. } else {
  18. DP('.');
  19. }
  20. break;
  21.  
  22. case WIFI_OK:
  23. if (WiFi.status() == WL_CONNECTED) {
  24. if (sName != NULL) {
  25. MDNS.begin(sName);
  26. DP("Demarrage de mDNS sous le nom ");
  27. DP(sName);
  28. DPLN(".local");
  29. sState = MDNS_OK;
  30. }
  31. } else {
  32. DPLN("Perte de connexion");
  33. sState = OFFLINE;
  34. }
  35. break;
  36.  
  37. case MDNS_OK:
  38. if (WiFi.status() != WL_CONNECTED) {
  39. DPLN("Perte de connexion");
  40. sState = OFFLINE;
  41. }
  42. break;
  43. }
  44. }

La ligne suivante est ajoutée à Connection::setup(...)

  1. sName = (char *)inName;

Et enfin le setup() du sketch devient :

  1. void setup() {
  2. /* Pour le debug */
  3. DSB(115200);
  4. /* Connexion */
  5. Connection::setup(ssid, pass, "Eclairage");
  6. }

Si vous utilisez un Mac ou un Linux, un tour dans le terminal vous informe que l’ESP répond bien par son petit nom sur le réseau (figure 6). Avec Windows, l’Invite de commande remplit le même rôle pourvu que vous possédiez au moins Windows 10 ≥ TH2 (1511). Si vous utilisez une version de Windows < Windows 10 TH2 (1511), il vous faudra installer une service mDNS de tierce partie (il semblerait qu’installer iTunes pour Windows fasse le job) ou bien vous résigner à utiliser l’adresse IP attribué à l’ESP32.

Figure 6 : Ping de l'ESP sur le réseau local.
Figure 6 : Ping de l’ESP sur le réseau local.

Ci dessous vous pouvez télécharger ce sketch complet. N’oubliez pas d’y mettre votre ssid et votre mot de passe avant de le compiler !

Sketch d’essai de la connexion WiFi et du mDNS

[1Je parle ici en connaissance de cause car j’ai subi quelques déboires concernant la robustesse.

[2C’est un moyen simple de mener des tests sans déclencher des hurlements chez les membres de la famille.

[3Mais pas les rubans à base de WS2811 où chacun d’entre eux possède 3 PWM autonomes.

2 Messages

Réagissez à « Éclairer le réseau (2) »

Qui êtes-vous ?
Votre message

Pour créer des paragraphes, laissez simplement des lignes vides.

Lien hypertexte

(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)

Rubrique « Projets »

Un chenillard de DEL

Enseigne de magasin

Feux tricolores

Multi-animations lumineuses

L’Arduino et le système de commande numérique DCC

Un décodeur d’accessoire DCC versatile basé sur Arduino

Un moniteur de signaux DCC

Une barrière infrarouge

Un capteur RFID

Un TCO xpressnet

Une animation sonore

L’Arduino au coeur des systèmes de pilotage analogiques ou numériques

Calcul de la vitesse d’un train miniature avec l’Arduino

La génèse d’un réseau 100% Arduino

Une horloge à échelle H0

Simulateur de soudure à arc

Un automatisme de Passage à Niveau

Automatisation du pont FLEISCHMANN 6152 (HO) avec un ESP32 (1)

Identifier et localiser vos trains avec le RFID/NFC et un bus CAN.

Etude d’un passage à niveau multivoies

La rétro-signalisation sur Arduino

Décodeur pour aiguillage à solénoïdes sur Arduino

Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO

Etude d’un passage à niveau universel

Réalisation pratique d’un système de mesure de vitesse à l’échelle N

Une Passerelle entre le bus S88 et le bus CAN pour la rétro signalisation

Un décodeur DCC pour 16 feux tricolores

Block Automatique Lumineux avec la carte shield "Arduino 4 relays"

Réalisation d’un affichage de gare ARRIVEE DEPART

Ménage à trois (Ordinateur, Arduino, réseau)

Réalisation d’un va-et-vient automatique et réaliste

Souris et centrale sans fil

Communications entre JMRI et Arduino

Annonces en gare avec la RFID

Une croix de pharmacie animée avec Arduino UNO

Réalisation d’un wagon de mesure (distance et vitesse)

Une manette simple et autonome pour LaBox

Block Automatique Lumineux à 8 cantons analogiques

JMRI pour Ma première centrale DCC

Rocrail pour Ma première centrale DCC

CDM-Rail pour Ma première centrale DCC (1)

CDM-Rail pour Ma première centrale DCC (2)

Ma première manette pour les aiguillages DCC

Mon premier décodeur pour les aiguillages DCC

Boitier 3D pour la station DCC minimale

Va-et-vient pour deux trains

Comment piloter trains et accessoires en DCC avec un Arduino (1)

Comment piloter trains et accessoires en DCC avec un Arduino (2)

Comment piloter trains et accessoires en DCC avec un Arduino (3)

Comment piloter trains et accessoires en DCC avec un Arduino (4)

SGDD : Système de Gestion DD (1)

SGDD : Système de Gestion DD (2)

SGDD : Système de Gestion DD (3)

La PWM : Qu’est-ce que c’est ? (1)

La PWM : Qu’est-ce que c’est ? (2)

La PWM : Qu’est ce que c’est ? (3)

La PWM : Qu’est ce que c’est ? (4)

Mise en oeuvre du Bus CAN entre modules Arduino (1)

Mise en oeuvre du Bus CAN entre modules Arduino (2)

Un gestionnaire en C++ pour votre réseau (1)

Un gestionnaire en C++ pour votre réseau (2)

Un gestionnaire en C++ pour votre réseau (3)

Un gestionnaire en C++ pour votre réseau (4)

Réalisation de centrales DCC avec le logiciel libre DCC++ (1)

Réalisation de centrales DCC avec le logiciel libre DCC++ (2)

Réalisation de centrales DCC avec le logiciel libre DCC++ (3)

Contrôleur à télécommande infrarouge pour centrale DCC++

Gestion d’une gare cachée (1)

Gestion d’une gare cachée (2)

Gestion d’une gare cachée (3)

La carte Satellite V1

La carte Satellite V1

La carte Satellite V1

La carte Satellite V1

La carte Satellite V1

Les derniers articles

Va-et-vient pour deux trains


msport

Boitier 3D pour la station DCC minimale


msport

Mon premier décodeur pour les aiguillages DCC


msport

Ma première manette pour les aiguillages DCC


msport

Éclairer le réseau (5)


Jean-Luc

CDM-Rail pour Ma première centrale DCC (2)


msport

Éclairer le réseau (4)


Jean-Luc

CDM-Rail pour Ma première centrale DCC (1)


msport

Rocrail pour Ma première centrale DCC


msport

Éclairer le réseau (3)


Jean-Luc

Les articles les plus lus

La PWM : Qu’est-ce que c’est ? (1)

Réalisation de centrales DCC avec le logiciel libre DCC++ (3)

Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO

Réalisation d’un affichage de gare ARRIVEE DEPART

Mise en oeuvre du Bus CAN entre modules Arduino (2)

L’Arduino au coeur des systèmes de pilotage analogiques ou numériques

Va-et-vient pour deux trains

Feux tricolores

Calcul de la vitesse d’un train miniature avec l’Arduino

La PWM : Qu’est-ce que c’est ? (2)