Code minimal des fonctions réseau

Nous allons résumer ici les différentes façons d'utiliser les fonction réseau des cartes compatibles Arduino possédant une puce Wi-Fi (Wemos D1 mini, ESP32, ...). Ces fonctions vont permettre à ces cartes de discuter entre elles, d'accéder à un site web, ou même de se comporter elles-même comme un (mini) site web.

Difficulté

Technical Technique

Durée

10 hour(s) heure(s)

Disciplines scientifiques

Arduino, Informatique

Wi-Fi, HTTP, MQTT, JSON Code_minimal_des_fonctions_r_seau_WiKi_Reseau.png

Introduction

Cette expérience regroupe différentes manières de bénéficier des capacités de communication des cartes compatibles Arduino possédant une puce Wi-Fi. 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. Toutes les étapes décrites ici sont en fait indépendantes :

• Les deux premières étapes permettent à notre carte de se connecter au Wi-Fi, de façon basique (étape 1) ou un peu plus évoluée, et souple (étape 2) ;
• L'étape 3 permet à la carte d'être dans un mode particulier, dit "AP"(Access Point") et se comporter comme une borne Wi-Fi.
• Les étapes suivantes correspondent à des besoins différents :
  • étape 4 : visualiser et/ou modifier des paramètres de notre carte via une interface web ;
  • étape 5 : permettre à notre carte d'accéder à des données d'un site externe, utilisant le format standardisé JSON ⁽¹⁾
  • étape 6 : permettre à notre carte d'envoyer et de recevoir des messages courts, via le protocole standardisé MQTT ⁽¹⁾

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.

Il existe bien sûr déjà un tas de tutoriels avec des exemples similaires, sans compter bien sûr les exemples fournis avec les bibliothèques que l'on va utiliser ⁽²⁾. La modeste contribution de de cette page est de tenter de regrouper les cas de figures les plus importants. S'il en manque, n'hésitez pas à mettre un commentaire, voire à ajouter une étape !

(1) Pas d'inquiétude sur les "JSON "et autre "MQTT", on explique tout dans les étapes correspondantes

(2) On donnera d'ailleurs les liens vers les bibliothèques et leurs exemples à chaque étape.

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

D1 mini

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

D1 mini

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

Logiciel Arduino

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

Logiciel Arduino

Installer l'environnement Arduino sur votre système

Premiers pas avec Arduino

Utiliser le D1 mini avec Arduino

Étape 1 - Connexion Wi-Fi en environnement stable

Cette première étape permet à un Wemos D1 mini (ou autre carte compatible Arduino avec puce Wi-Fi) de se connecter au Wi-Fi dans un environnement connu, et qui ne change pas ; C'est-à-dire que l'on à accès à une borne Wi-Fi, on connait son mot de passe - aka "clé de sécurité réseau", et a priori la carte va rester dans cet environnement.

Ces bibliothèques sont pré-chargées dans l'environnement Arduino, il n'est pas nécessaire d'aller les chercher dans le gestionnaire de bibliothèques.

		Connexion Wi-Fi de base
Avant le Setup	Importation de la bibliothèque	#include <ESP8266WiFi.h> // Pour le Wemos D1 Mini, ou ... #include <WiFi.h> // Pour l'ESP32
	Création de l’objet
Dans le Setup	Démarrage de la connexion	WiFi.begin(SSID, SecKey) ; // Où SSID est le nom du point d'accès Wi-Fi, et SecKey son mot de passe
	Test de la connexion	if (WiFi.Status() == WL_CONNECTED) { (...) }
	Récupération de l'adresse IP	WiFi.localIP() ;
Dans le Loop	Utilisation	Le test de la connexion, et la récupération de l'adresse IP peuvent aussi être utilisés dans le loop().

Pour connaître toutes les autres possibilités de ces bibliothèques, voir leurs références, respectivement ici (D1 Mini) et ici (ESP32).

 1 /* =========================================================================================================
 2  * 
 3  *                         CODE MINIMAL RESEAU - ETAPE 1 : connexion basique au Wi-Fi
 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 WiFi : UNE SEULE EST NECESSAIRE, choisir celle correspondant à votre matériel. 
10 // ATTENTION AUX MAJUSCULES & MINUSCULES ! Sinon d'autres bibliothèques, plus ou moins valides, seraient utilisées.
11 
12 #include <ESP8266WiFi.h>          // A utiliser pour le D1 Mini 
13 //#include <WiFi.h>               // A utiliser pour l'ESP32
14 
15 // Définition du point d'accès Wi-Fi et de son mot de passe ("clé de sécurité")
16 // A REMPLACER PAR LES VERITABLES VALEURS CORRESPONDANT A VOTRE EMPLACEMENT
17         
18 const char* mySSID   = "MA_BOX_INTERNET";
19 const char* mySecKey = "MA_CLE_DE_SECURITE";
20 
21 /* --------------------------------------------------------------------------------------------------------
22  *  SETUP : Initialisation
23  *  -------------------------------------------------------------------------------------------------------- */
24 void setup() {
25 
26     // Initialisation de la liaison série, affichage 1er message
27 
28     Serial.begin(115200);
29     delay(100) ;
30     Serial.println(); 
31     Serial.println("----------------------------------") ;
32     Serial.println("Exemple de connexion Wi-Fi basique") ;
33     Serial.println("----------------------------------") ;
34 
35     // Démarrage de la tentative de connexion, avec le nom du point d'accès Wi-Fi et son mot de passe
36 
37     WiFi.begin(mySSID, mySecKey) ;
38 
39     // Attente de la connexion pendant 10 secondes (20 x 500 ms)
40 
41     Serial.print("Connexion à "); Serial.print(mySSID) ; Serial.print(" ") ;
42     int tryNumber = 1 ;
43     while (WiFi.status() != WL_CONNECTED)
44     {
45         delay(500);
46         Serial.print(".");
47         if (++tryNumber > 20) {
48             Serial.println() ; Serial.println("Pas de connexion, abandon") ;
49             return ;
50         }
51     } 
52 
53     // La connexion a réussi ! On affiche l'adresse IP obtenue.
54     
55     Serial.println(); Serial.print("Connecté ! Adresse IP : ");
56     Serial.println(WiFi.localIP());
57     
58 }
59 
60 /* --------------------------------------------------------------------------------------------------------------
61  *  LOOP : fonction appelée régulièrement par le système
62  *  ------------------------------------------------------------------------------------------------------------- */
63 void loop() { 
64   /* On ne fait rien de particulier sur cet exemple */
65 }

Étape 2 - Oui, mais si je dois changer de borne Wi-Fi ?

Dans l'étape précédente on supposait que le Wi-Fi était permanent (cas où les cartes ne quittent pas notre labo, par exemple). Mais si on souhaite faire voyager nos cartes (démos dans des écoles, etc ...), on a trois possibilités :

• On vient avec son environnement de développement Arduino, on met à jour le code Arduino avec les nouvelles informations Wi-Fi, et on téléverse le code sur toutes nos cartes ... un peu laborieux, n'est-il pas ?
• ou bien, on dispose en permanence d'un téléphone mobile avec forfait données (4G ou +), et on utilise systématiquement celui-ci en mode "Point d'accès mobile". C'est donc ce téléphone qui sera vu en permanence comme le point d'accès Wi-Fi préféré de votre carte (D1 mini ou ESP32), quelque soit l'endroit où vous vous trouvez. Pas toujours possible ...
• et sinon, on utilise la bibliothèque "WiFiManager", qui nous simplifie grandement la tâche !

En effet, cette bibliothèque permet d'enregistrer de façon pérenne (même si on débranche la carte) le dernier Point d'Accès Wi-Fi sur lequel la carte a réussi à se connecter. La bibliothèque va d'abord chercher à se connecter sur ce Point d'Accès "connu". Et si ça ne fonctionne pas (on a changé de lieu, par exemple), alors elle va se positionner elle-même en mode "Point d'Accès", et va proposer sur l'adresse 192.168.4.1 une interface web permettant d'afficher les Points d'Accès Wi-Fi environnants, et d'en sélectionner un. Le nouveau Point d'Accès choisi sera sauvegardé pour les fois suivantes.

Pour plus de détails, et présentation de l'interface utilisateur proposée par la bibliothèque, voir le chapitre "Explications" en bas de cette page.

La bibliothèque doit être rajoutée à l'environnement Arduino dans le gestionnaire de Bibliothèques (voir ici pour le mode d'emploi) :

		Wifimanager
Avant le Setup	Importation de la bibliothèque	#include <WiFiManager.h>
	Création de l’objet	WiFiManager myWiFiManager;
Dans le Setup	Déclaration du mode bloquant	myWiFiManager.setConfigPortalBlocking(true); // ... ou rien (mode par défaut)
	Déclaration du mode non bloquant	myWiFiManager.setConfigPortalBlocking(false);
	Tentative de connexion à un PA Wi-Fi	if (myWiFiManager.autoConnect(Nom_AP, MotDePasse_AP)) { (... connexion OK !) }
Dans le Loop	Activation régulière pour le mode non bloquant	myWiFiManager.process() ; // Obligatoire en mode non bloquant

Pour connaître toutes les autres possibilités de cette bibliothèque, voir sa référence, ici.

Code minimal  : mode bloquant (par défaut)

 1 /* =========================================================================================================
 2  * 
 3  *          CODE MINIMAL RESEAU - ETAPE 2 : Connexion à un point d'accès choisi par l'utilisateur
 4  *          
 5  *          CAS A : MODE BLOQUANT - On attend tant que l'utilisateur n'a pas choisi son Point d'Accès Wi-Fi
 6  * 
 7  * ---------------------------------------------------------------------------------------------------------
 8  * Les petits Débrouillards - décembre 2022 - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
 9  * ========================================================================================================= */
10 
11 // Bibliothèque WiFiManager. Un seule bibibliothèque suffit ici, quelque soit la carte (ESP32 ou Wemos D1 Mini)
12 
13 #include <WiFiManager.h>          // Gestion de la connexion Wi-Fi (recherche de points d'accès)  
14 WiFiManager myWiFiManager;        // Création de mon instance de WiFiManager.
15 
16 // Définition de la carte lorsqu'elle se positionne en mode "Point d'Accès".
17         
18 const char* mySSID   = "AP_PetitDeb" ;      // Nom du point d'accès
19 const char* mySecKey = "PSWD1234" ;         // Mot de passe, 8 caractères au minimum
20 
21 /* --------------------------------------------------------------------------------------------------------
22  *  SETUP : Initialisation
23  *  -------------------------------------------------------------------------------------------------------- */
24 void setup() {
25 
26     // Initialisation de la liaison série, affichage 1er message
27 
28     Serial.begin(115200);
29     delay(100) ;
30     Serial.println(); 
31     Serial.println("----------------------------------") ;
32     Serial.println("Exemple de connexion Wi-Fi évoluée") ;
33     Serial.println("----------------------------------") ;
34 
35     // Tentative de connexion au Wi-Fi. Si la carte n'a pas réussi  se connecter au dernier Point d'Accès connu,
36     // alors elle va se positionner en mode Point d'Accès, demandera sur l'adresse 192.168.4.1 quel nouveau
37     // Point d'Accès choisir. Par défaut, on restera bloqué tant que l'utilisateur n'aura pas fait de choix.
38     
39     Serial.println("Connexion au Wi-Fi ...");
40     if (myWiFiManager.autoConnect(mySSID, mySecKey)) {
41       
42         // Wi-Fi en mode standard ok --> On affiche l'adresse IP obtenue.
43 
44         Serial.println(); Serial.print("Connecté ! Adresse IP : ");
45         Serial.println(WiFi.localIP());
46         
47     }
48     else {
49         Serial.println("Connexion Wi-Fi KO :-(");     
50     }
51    
52 }
53 
54 /* --------------------------------------------------------------------------------------------------------------
55  *  LOOP : fonction appelée régulièrement par le système
56  *  ------------------------------------------------------------------------------------------------------------- */
57 void loop() { 
58   /* On ne fait rien de particulier sur cet exemple */
59 }

Code minimal  : mode non bloquant

 1 /* =========================================================================================================
 2  * 
 3  *          CODE MINIMAL RESEAU - ETAPE 2 : Connexion à un point d'accès choisi par l'utilisateur
 4  *          
 5  *          CAS B : MODE NON BLOQUANT - On peut faire autre chose en attendant que l'utilisateur ait choisi
 6  *                  son Point d'Accès Wi-Fi
 7  * 
 8  * ---------------------------------------------------------------------------------------------------------
 9  * Les petits Débrouillards - décembre 2022 - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
10  * ========================================================================================================= */
11 
12 // Bibliothèque WiFiManager. Un seule bibibliothèque suffit ici, quelque soit la carte (ESP32 ou Wemos D1 Mini)
13 
14 #include <WiFiManager.h>          // Gestion de la connexion Wi-Fi (recherche de points d'accès)  
15 WiFiManager myWiFiManager;        // Création de mon instance de WiFiManager.
16 
17 // Définition de la carte lorsqu'elle se positionne en mode "Point d'Accès".
18         
19 const char* mySSID   = "AP_PetitDeb" ;      // Nom du point d'accès
20 const char* mySecKey = "PSWD1234" ;         // Mot de passe, 8 caractères au minimum
21 
22 // Pour les besoins de l'exemple (traces)
23 
24 bool IAmNotConnected = true ;
25 
26 /* --------------------------------------------------------------------------------------------------------
27  *  SETUP : Initialisation
28  *  -------------------------------------------------------------------------------------------------------- */
29 void setup() {
30 
31     // Initialisation de la liaison série, affichage 1er message
32 
33     Serial.begin(115200);
34     delay(100) ;
35     Serial.println(); 
36     Serial.println("----------------------------------") ;
37     Serial.println("Exemple de connexion Wi-Fi évoluée") ;
38     Serial.println("----------------------------------") ;
39 
40     // Déclaration du mode "non bloquant".
41     // Bonus : suppression des traces fournies par le WiFiManager (il est très bavard)
42     
43      myWiFiManager.setConfigPortalBlocking(false); 
44      myWiFiManager.setDebugOutput(false);     
45 
46     // Tentative de connexion au Wi-Fi. Si la carte n'a pas réussi  se connecter au dernier Point d'Accès connu,
47     // alors elle va se positionner en mode Point d'Accès, demandera sur l'adresse 192.168.4.1 quel nouveau
48     // Point d'Accès choisir. On ne reste pas bloqué, la suite du setup() va se dérouler, et le WiFiManager
49     // traitera les demandes ultérieurement, dans la fonction loop().
50      
51     Serial.println("Connexion au Wi-Fi ...");
52     if (myWiFiManager.autoConnect(mySSID, mySecKey)) {
53       
54         // Wi-Fi en mode standard ok --> On affiche l'adresse IP obtenue.
55 
56         Serial.println(); Serial.print("Connecté ! Adresse IP : ");
57         Serial.println(WiFi.localIP());
58         
59     }
60     else {
61 
62         // Wi-Fi standard KO, on est passé en mode AP, qui sera traité dans le loop().
63         
64         Serial.println("Pas de point Wi-Fi connu, passage en mode AP (identifiant \"" + String(mySSID) + "\")");     
65     }
66    
67 }
68 
69 /* --------------------------------------------------------------------------------------------------------------
70  *  LOOP : fonction appelée régulièrement par le système
71  *  ------------------------------------------------------------------------------------------------------------- */
72 void loop() { 
73   
74   // Obligatoire en mode non bloquant, pour que le WiFiManager continue sa tâche.
75 
76   myWiFiManager.process() ;
77 
78   // Test pour savoir si on est enfin connecté - on ne l'affiche qu'une fois pour limiter les traces
79 
80   if (IAmNotConnected) {
81       if (WiFi.status() == WL_CONNECTED) {
82           Serial.print("Connecté au point d'accès " + String(WiFi.SSID()) + ", Adresse IP : ") ;
83           Serial.println(WiFi.localIP());
84           IAmNotConnected = false ;
85       }
86   }
87   
88 }

Étape 3 - Et si je veux rester en mode AP (Access Point) Wi-Fi ?

Il existe des cas particuliers où une application n'a en fait pas besoin du Wi-Fi pour aller envoyer ou recevoir des données d'Internet, mais souhaite être considérée comme une borne Wi-Fi (....) - A compléter, pas terrible la phrase ...

On peut trouver quelques exemples d'applications de ce type, réalisée par des Petits Débrouillards, en particulier le Petit Bot, petit robot commandable depuis une interface web, ou encore Commander un D1 mini avec une interface web, qui

Étape 4 - Et maintenant, on fait quoi avec le Wi-Fi ? (tiens, pourquoi pas un petit serveur web ?)

... Site web pour allumer une led (à détailler)

METTRE LIEN(S) vers description et exemples

		Site web
Avant le Setup	Importation de la bibliothèque
	Création de l’objet
Dans le Setup	Démarrage de l’objet
Dans le Loop	Utilisation

 1 ////////////////////////
 2 //   *Code Minimal*   //
 3 //    Wi-Fi de base   //
 4 ////////////////////////
 5 /*Les programmes "Code Minimal" des petits débrouillards sont conçu pour 
 6 permettre la prise en main rapide d'un composant électronique.
 7 A retrouver sur https://www.wikidebrouillard.org
 8 
 9 (...)
10  
11    ___
12  / ___ \
13 |_|   | |
14      /_/ 
15      _   ___   _ 
16     |_| |___|_| |_
17          ___|_   _|
18         |___| |_|
19 
20 Les petits Débrouillards - décembre 2020 - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
21 
22 */
23 
24 // Déclaration des variables constantes
25 (...)
26 
27 // Boucle d'initialisation
28 void setup() {
29 
30   (...)
31 
32 }
33 
34 //Boucle principale
35 void loop() {
36 
37   (...)
38 
39 }

Une application plus complète, permettant d'actionner plusieurs leds et un moteur, et de récupérer des données d'un capteur, est disponible ici.

L'utilisation de notre carte en mode n'est qu'un exemple de ce qu'il est possible de faire, il existe plein d'autres possibilités, détaillées dans les étapes suivantes !

Étape 5 - Interrogation de serveurs web (mode JSON)

Étape 6 - Diffusion d'information (mode MQTT)

Étape 7 - Utilisation de plusieurs cartes ...(DRAFT)

Identifiant unique (D1 min vs ESP ?) proposer code utilisant l'id unique de la pucey

d'ailleurs si même une seule carte à un endroit, id unique utile (MQTT par exemple). Introduire cette notion plus haut ?

Comment ça marche ?

Explications

Compléments d'information pour l'étape 2 "Oui, mais si mon Wi-Fi change ?"

Grâce à la bibliothèque WiFiManager, dans le cas où la carte n'a pas pu se connecter au dernier Wi-Fi connu, elle s'est elle-même positionnée comme un Point d'Accès Wi-Fi. La sélection de votre box Wi-Fi préférée se fait alors en trois étapes :

1. Avec un téléphone ou ordinateur, connectez-vous au point d'accès "AP_PetitDeb" et tapez le mot de passe associé (Cf. le code décrit à l'étape 2). Il y aura probablement un message indiquant qu'Internet n'est pas disponible, c'est normal, ne pas en tenir compte ;
2. Sur votre navigateur préféré, tapez "192.168.4.1", ce qui fera apparaître l'interface web générée par la bibliothèque WiFiManager. Cliquez sur "Configure WiFi", vous arrivez sur le choix du point d'accès.
3. Choisissez alors votre point d'accès Wi-Fi préféré, son nom sera reporté dans la case "SSID", complétez avec le mot de passe dans la case "Password", et cliquez sur Save

... Lors des prochaines réinitialisation, ou ré-allumage de la carte, celle-ci cherchera d'abord à se connecter à ce nouveau Point d'Accès Wi-Fi.

Dernière modification 6/02/2023 par user:Philby.

Draft