Se connecter à un réseau Wi-Fi avec l’ESP32
La librairie
WiFi.h
(installée automatiquement) va nous permettre d’utiliser facilement les fonctionnalités Wi-Fi de la carte ESP32.
L’ESP32 possède 2 modes WiFi possibles :
-
STATION (
WIFI_STA
) : Le mode Station (STA) est utilisé pour connecter le module ESP32 à un point d’accès Wi-Fi. L’ESP32 se comporte comme un ordinateur qui serait connecté à notre box. Si la box est relié à Internet, alors l’ESP32 peut accéder à Internet. L’ESP32 peut se comporter en tant que client , c’est-à-dire faire des requêtes aux autres appareils connectés sur le réseau ou en tant que serveur , c’est-à-dire que d’autres appareils connectés sur le réseau vont envoyer des requêtes à l’ESP32. Dans les 2 cas, l’ESP32 peut accéder à Internet. -
AP (Access Point) (
WIFI_AP
) : En mode Access Point, l’ESP32 se comporte comme un réseau Wi-Fi (un peu comme une box) : d’autres appareils peuvent s’y connecter dessus. Dans ce mode, l’ESP32 n’est relié à aucun autre réseau et n’est donc pas connecté à Internet. Ce mode est plus gourmand en calcul et en énergie (la carte ESP32 va chauffer) puisque l’ESP32 doit simuler un routeur Wifi complet (Soft AP). La latence et le débit seront moins bons qu’avec une box classique.
Note
L’ESP32 est par défaut en mode STATION.
Pour le choix du mode :
-
En général, on utilise le mode STATION . On pourra accéder à internet pour récupérer des informations d’API, avoir un serveur “domotique” avec des capteurs …
-
On utilise en général le mode AP provisoirement pour rentrer les paramètres de connexion du réseau WiFi (SSID + MDP). On peut également l’utiliser pour avoir un réseau séparé de son réseau domestique et non relié à Internet.
Connexion à un réseau Wi-Fi
Le programme pour se connecter à sa box se résume à :
#include <WiFi.h>
const char* ssid = "yourNetworkName";
const char* password = "yourNetworkPassword";
void setup(){
Serial.begin(115200);
delay(1000);
WiFi.mode(WIFI_STA); //Optional
WiFi.begin(ssid, password);
Serial.println("\nConnecting");
while(WiFi.status() != WL_CONNECTED){
Serial.print(".");
delay(100);
}
Serial.println("\nConnected to the WiFi network");
Serial.print("Local ESP32 IP: ");
Serial.println(WiFi.localIP());
}
void loop(){}
Important
Il faut modifier
"yourNetworkName"
par le nom du réseau Wi-Fi et
"yourNetworkPassword"
par le mot de passe du réseau.
Sortie du terminal
Connecting
................
Connected to the WiFi network
Local ESP32 IP: 192.168.43.129
Astuce
Un moyen simple d’avoir un AP pour tester le programme est de faire un partage de connexion Wi-Fi depuis son smartphone.
Le code fonctionne de la manière suivante :
-
On pense à bien inclure la librairie
WiFi.h
. -
Puis on rentre le nom du réseau et son mot de passe.
-
On met l’ESP32 en mode STATION avec la fonction
WiFi.mode(WIFI_STA)
-
L’ESP32 essaye de se connecter au réseau WiFi à l’aide de la fonction
WiFi.begin(ssid, password)
-
La connexion n’est pas instantanée ! Il faut donc regarder régulièrement l’état de la connexion : tant que l’ESP32 n’est pas connecté au réseau, on reste bloqué dans la boucle
while
. On ajoute un petit délai pour éviter de regarder en permanence le statut. -
Une fois que l’on est connecté, on affiche l’adresse IP locale de l’ESP32 sur ce réseau.
S’il s’agit d’un réseau ouvert (sans mot de passe), alors le programme se simplifie :
#include <WiFi.h>
const char* ssid = "yourNetworkName";
void setup(){
Serial.begin(115200);
delay(1000);
WiFi.begin(ssid);
Serial.println("\nConnecting");
while(WiFi.status() != WL_CONNECTED){
Serial.print(".");
delay(100);
}
Serial.println("\nConnected to the WiFi network");
Serial.print("Local ESP32 IP: ");
Serial.println(WiFi.localIP());
}
void loop(){}
Obtenir des informations sur le réseau Wi-Fi
On peut obtenir des informations sur le réseau une fois que l’on est connecté sur celui-ci :
-
La puissance du signal WiFi (RSSI) avec la fonction
WiFi.RSSI()
-
L’adresse MAC du réseau WiFi avec
WiFi.BSSIDstr()
ouWiFi.macAddress()
-
L’adresse IP locale de l’ESP32 attribuée par le serveur DHCP du réseau WiFi
WiFi.localIP()
-
L’adresse IP locale du réseau WiFi (passerelle) avec
WiFi.gatewayIP()
(en général 192.168.0.1) -
Le masque de sous-réseau avec
WiFi.subnetMask()
(en général 255.255.255.0)
Le code ci-dessous affiche toute ces informations :
#include <WiFi.h>
const char* ssid = "yourNetworkName";
const char* password = "yourNetworkPassword";
void get_network_info(){
if(WiFi.status() == WL_CONNECTED) {
Serial.print("[*] Network information for ");
Serial.println(ssid);
Serial.println("[+] BSSID : " + WiFi.BSSIDstr());
Serial.print("[+] Gateway IP : ");
Serial.println(WiFi.gatewayIP());
Serial.print("[+] Subnet Mask : ");
Serial.println(WiFi.subnetMask());
Serial.println((String)"[+] RSSI : " + WiFi.RSSI() + " dB");
Serial.print("[+] ESP32 IP : ");
Serial.println(WiFi.localIP());
}
}
void setup(){
Serial.begin(115200);
delay(1000);
WiFi.begin(ssid, password);
Serial.println("\nConnecting");
while(WiFi.status() != WL_CONNECTED){
Serial.print(".");
delay(100);
}
Serial.println("\nConnected to the WiFi network");
get_network_info();
}
void loop(){}
Sortie du terminal
Connecting
..............
Connected to the WiFi network
[*] Network information for HUAWEI_**
[+] BSSID : F0:43:47:32:1F:4D
[+] Gateway IP : 192.168.43.1
[+] Subnet Mask : 255.255.255.0
[+] RSSI : -25 dB
[+] ESP32 IP : 192.168.43.129
Débugger les problèmes de connexion
Regarder le statut de la connexion
On peut connaître le statut de la connexion WiFi avec la fonction
WiFi.status()
. Cette fonction renvoie un entier en fonction de l’état actuel de la connexion.
Les statuts possibles sont :
-
WL_IDLE_STATUS
: C’est le statut par défaut avant d’essayer de se connecter à un réseau. -
WL_SCAN_COMPLETED
: Le scan des réseaux WiFi est terminé. -
WL_NO_SSID_AVAIL
: L’ESP32 n’arrive pas à trouver le nom du réseau WiFi. Soit le réseau est trop loin de l’ESP32, soit le nom (SSID) du réseau est incorrect. -
WL_CONNECT_FAILED
: L’ESP32 n’arrive pas à se connecter au réseau WiFi désigné. -
WL_CONNECTION_LOST
: La connexion WiFi avec le réseau est perdue. Si cette erreur se répète c’est peut être un problème d’alimentation de l’ESP32. -
WL_CONNECTED
: L’ESP32 est connecté au réseau WiFi. -
WL_DISCONNECTED
: L’ESP32 est déconnecté du réseau WiFi.
Code qui permet d’afficher les statuts de la connexion WiFi
#include <WiFi.h>
const char* ssid = "yourNetworkName";
const char* password = "yourNetworkPassword";
String get_wifi_status(int status){
switch(status){
case WL_IDLE_STATUS:
return "WL_IDLE_STATUS";
case WL_SCAN_COMPLETED:
return "WL_SCAN_COMPLETED";
case WL_NO_SSID_AVAIL:
return "WL_NO_SSID_AVAIL";
case WL_CONNECT_FAILED:
return "WL_CONNECT_FAILED";
case WL_CONNECTION_LOST:
return "WL_CONNECTION_LOST";
case WL_CONNECTED:
return "WL_CONNECTED";
case WL_DISCONNECTED:
return "WL_DISCONNECTED";
}
}
void setup(){
Serial.begin(115200);
delay(1000);
int status = WL_IDLE_STATUS;
Serial.println("\nConnecting");
Serial.println(get_wifi_status(status));
WiFi.begin(ssid, password);
while(status != WL_CONNECTED){
delay(500);
status = WiFi.status();
Serial.println(get_wifi_status(status));
}
Serial.println("\nConnected to the WiFi network");
Serial.print("Local ESP32 IP: ");
Serial.println(WiFi.localIP());
}
void loop(){}
Exemples de scénarios possibles
Si la connexion est réussie :
Connecting
WL_IDLE_STATUS
WL_DISCONNECTED
WL_DISCONNECTED
WL_CONNECTED
Connected to the WiFi network
Local ESP32 IP: 192.168.43.129
Si le SSID est introuvable :
Connecting
WL_IDLE_STATUS
WL_DISCONNECTED
WL_DISCONNECTED
WL_NO_SSID_AVAIL
WL_NO_SSID_AVAIL
WL_NO_SSID_AVAIL
WL_NO_SSID_AVAIL
Si ce n’est pas le bon mot de passe :
Connecting
WL_IDLE_STATUS
WL_DISCONNECTED
WL_DISCONNECTED
WL_NO_SSID_AVAIL
WL_NO_SSID_AVAIL
WL_NO_SSID_AVAIL
WL_NO_SSID_AVAIL
Redémarrer l’ESP32
De temps en temps, pour une raison inconnue, l’ESP32 peut ne pas arriver temporairement à se connecter au réseau WiFi. La meilleure solution est de dire qu’au bout de
n
secondes si l’ESP32 ne s’est toujours pas connecté au WiFi, on redémarre l’ESP32. Il suffit d’ajouter un timeout et d’utiliser la fonction
ESP.restart()
pour redémarrer l’ESP32 depuis le code.
Voici un exemple qui permet de redémarrer l’ESP32 au bout de 10 s s’il n’est toujours pas connecté au WiFi.
#include <WiFi.h>
#define CONNECTION_TIMEOUT 10
const char* ssid = "yourNetworkName";
const char* password = "yourNetworkPassword";
void setup(){
Serial.begin(115200);
delay(1000);
WiFi.mode(WIFI_STA); //Optional
WiFi.begin(ssid, password);
Serial.println("\nConnecting");
int timeout_counter = 0;
while(WiFi.status() != WL_CONNECTED){
Serial.print(".");
delay(200);
timeout_counter++;
if(timeout_counter >= CONNECTION_TIMEOUT*5){
ESP.restart();
}
}
Serial.println("\nConnected to the WiFi network");
Serial.print("Local ESP32 IP: ");
Serial.println(WiFi.localIP());
}
void loop(){}
L’ESP32 est bien reset au bout de 10 s en cas d’échec de connexion depuis le code avec le flag
SW_CPU_RESET
lors du boot.
Connecting
.......................................................
ets Jun 8 2016 00:22:57
rst:0xc (SW_CPU_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0018,len:4
load:0x3fff001c,len:1044
load:0x40078000,len:8896
load:0x40080400,len:5816
entry 0x400806ac
Connecting
.......
Connected to the WiFi network
Local ESP32 IP: 192.168.43.129
Pour aller plus loin
Attribuer une adresse IP fixe
L’adresse IP locale de l’ESP32 a été attribuée automatiquement par le serveur DHCP de la box. C’est pratique d’avoir une adresse IP automatiquement sur l’ordinateur car on n’a pas à la rentrer manuellement. L’inconvénient (ou avantage en fonction des cas) est que l’adresse IP est dynamique : elle peut changer. Cela peut devenir gênant si par exemple, dès que l’on redémarre l’ESP32 (ou que le bail du DHCP est expiré) l’adresse IP change, alors qu’on a un serveur web qui tourne sur l’ESP32. Il faudrait à chaque fois retrouver l’IP de l’ESP32. On peut pallier ce problème en fixant l’adresse IP de l’ESP32 sur le réseau. Il faut utiliser pour cela la fonction
WiFi.config(ip,
dns,
gateway,
subnet)
Les paramètres à renseigner sont :
-
IP
: L’adresse IP que l’on souhaite attribuer. -
DNS
: Service qui fait le lien entre une url et une IP. Par défaut, on utilise le serveur DNS de la box internet ou le routeur : donc on indique la même adresse que le routeur (en général 192.168.0.1). -
GATEWAY
: C’est l’adresse IP de la box internet ou du routeur (en général 192.168.0.1) -
SUBNET
: Masque de sous-réseau (en général 255.255.255.0)
Note
Il faut connaître l’adresse IP du routeur : le plus simple est d’utiliser le code qui affiche les informations du réseau WiFi dans le moniteur série
Dans cet exemple, en utilisant le partage WiFi d’un téléphone l’adresse IP du routeur est 192.168.43.1 . Je choisis d’avoir comme IP statique 192.168.43.42 pour l’ESP32.
Code qui permet de fixer l’adresse IP de l’ESP32
#include <WiFi.h>
const char* ssid = "yourNetworkName";
const char* password = "yourNetworkPassword";
IPAddress ip(192, 168, 43, 42);
IPAddress dns(192, 168, 43, 1);
IPAddress gateway(192, 168, 43, 1);
IPAddress subnet(255, 255, 255, 0);
void setup(){
Serial.begin(115200);
delay(1000);
WiFi.config(ip, dns, gateway, subnet);
WiFi.begin(ssid, password);
Serial.println("\nConnecting");
while(WiFi.status() != WL_CONNECTED){
Serial.print(".");
delay(100);
}
Serial.println("\nConnected to the WiFi network");
Serial.print("[+] ESP32 IP : ");
Serial.println(WiFi.localIP());
}
void loop(){}
On peut ensuite faire un ping depuis l’ordinateur vers l’IP 192.168.43.42 pour voir si la nouvelle adresse a bien été prise en compte :
Avertissement
Il faut penser à ne pas utiliser une IP déjà prise par un autre appareil sur le réseau. On peut aussi assigner une adresse IP fixe liée à l’adresse MAC directement depuis les paramètres du routeur.
Changer l’adresse MAC
Dans certaines applications, il peut être intéressant de modifier l’adresse MAC de l’ESP32. On peut changer l’adresse MAC avec quelques lignes de code en utilisant la fonction
esp_wifi_set_mac()
Note
Le changement de l’adresse MAC est temporaire, elle ne remplace pas celle d’origine. Il suffit d’uploader un nouveau programme pour retrouver l’adresse MAC d’origine.
#include <WiFi.h>
#include <esp_wifi.h>
uint8_t new_mac[] = {0x60, 0x8B, 0x0E, 0x01, 0x5A, 0x32};
void setup(){
Serial.begin(115200);
WiFi.mode(WIFI_STA);//Needed to change MAC adress
Serial.print("[+] Current MAC Address: ");
Serial.println(WiFi.macAddress());
esp_wifi_set_mac(ESP_IF_WIFI_STA, new_mac);
Serial.print("[+] New MAC Address: ");
Serial.println(WiFi.macAddress());
}
void loop(){}
Terminal série :
[+] Current MAC Address: 24:6F:28:BB:2E:E8
[+] New MAC Address: 60:8B:0E:01:5A:32
Code qui se connecte à un réseau Wi-Fi avec une adresse MAC modifiée
#include <WiFi.h>
#include <esp_wifi.h>
const char* ssid = "yourNetworkName";
const char* password = "yourNetworkPassword";
uint8_t new_mac[] = {0x6C, 0x8D, 0xC1, 0x01, 0x5A, 0x32};
void setup(){
Serial.begin(115200);
WiFi.mode(WIFI_STA);//Needed to change MAC adress
esp_wifi_set_mac(ESP_IF_WIFI_STA, new_mac);
delay(1000);
WiFi.begin(ssid, password);
Serial.println("\nConnecting");
while(WiFi.status() != WL_CONNECTED){
Serial.print(".");
delay(100);
}
Serial.println("\nConnected to the WiFi network");
Serial.print("Local ESP32 IP: ");
Serial.println(WiFi.localIP());
}
void loop(){}
Une capture Wireshark montre que l’adresse a bien été changée (ici par une adresse MAC d’Apple):
Economiser de l’énergie
Si on utilise un ESP32 dans un projet qui doit forcément utiliser le WiFi pour fonctionner, il est judicieux de mettre l’ESP32 en mode Deep Sleep en cas d’échec de connexion, pour minimiser la consommation d’énergie. C’est un code similaire avec celui de l’ESP32 qui “dort” pendant 10 secondes entre chaque tentative.
Code qui permet de mettre l’ESP32 en Deep Sleep entre 2 tentatives
#include <WiFi.h>
#include <esp_wifi.h>
//Time in seconds
#define CONNECTION_TIMEOUT 5
#define DEEP_SLEEP_DURATION 10
const char* ssid = "yourNetworkName";
const char* password = "yourNetworkPassword";
void setup(){
Serial.begin(115200);
WiFi.begin(ssid, password);
Serial.println("\nConnecting");
int timeout_counter = 0;
while(WiFi.status() != WL_CONNECTED){
Serial.print(".");
delay(100);
timeout_counter++;
if(timeout_counter >= CONNECTION_TIMEOUT*10){
Serial.println("\nCan't establish WiFi connexion");
//Setup timer
esp_sleep_enable_timer_wakeup(DEEP_SLEEP_DURATION * 1000000);
//Start deep sleep
esp_deep_sleep_start();
}
}
Serial.println("\nConnected to the WiFi network");
Serial.print("Local ESP32 IP: ");
Serial.println(WiFi.localIP());
}
void loop(){}
Utiliser les Wi-Fi events pour avoir un code optimisé
Jusqu’à maintenant, on faisait du polling avec les fonctions Wi-Fi, c’est-à-dire que l’ESP32 reste bloquée tant qu’elle n’a pas reçue un évènement (event) par le contrôleur Wi-Fi. On faisait de la programmation séquentielle. Prenons un exemple :
while(WiFi.status() != WL_CONNECTED){
Serial.print(".");
delay(100);
}
On regarde (poll en anglais) régulièrement si l’ESP32 a réussi à se connecter au réseau Wi-Fi. Pendant l’attente, on ne fait rien (on pourrait cependant faire des calculs entre 2 polls) et on reste bloqué dans la boucle while. Difficile de s’y retrouver s’il on veut faire des choses différentes en fonction du statut du Wi-Fi.
Une manière plus propre est de faire de la programmation évènementielle en utilisant les évènements. En effet, des évènements sont générés quand le wifi change d’état. L’intérêt est que l’on peut exécuter du code automatiquement en fonction de l’événement reçu. Cela ressemble beaucoup aux interruptions que l’on utilisent sur les pins GPIO. Un changement d’état du pin génère une interruption, qui va exécuter une portion de code prioritaire. Ici un changement d’état du Wi-Fi génère un évènement qui va également exécuter une portion de code.
Le code de base pour gérer les évènements est :
#include <WiFi.h>
const char* ssid = "yourNetworkName";
const char* password = "yourNetworkPassword";
void my_function(WiFiEvent_t wifi_event, WiFiEventInfo_t wifi_info){
//Code
}
void setup(){
Serial.begin(115200);
delay(1000);
WiFi.mode(WIFI_STA); //Optional
WiFi.onEvent(my_function, WIFI_EVENT_ID);
WiFi.begin(ssid, password);
}
void loop(){}
On utilise la fonction
WiFi.onEvent(my_function,
WIFI_EVENT_ID)
pour préciser quelle fonction sera exécutée quand l’événement
WIFI_EVENT_ID
sera détecté. Il faut remplacer
WIFI_EVENT_ID
par le nom ou le numéro de l’event (voir tableau ci-dessous). La fonction
my_function()
doit avoir les paramètres
WiFiEvent_t
wifi_event,
WiFiEventInfo_t
wifi_info
même s’ils ne sont pas utilisés.
Le code suivant fait la même chose que le code du tout début pour se connecter à une box mais cette fois avec l’utilisation d’événements lorsque l’on est connecté à un réseau.
Code qui permet de se connecter à une box avec les évenements Wi-Fi
#include <WiFi.h>
const char* ssid = "yourNetworkName";
const char* password = "yourNetworkPassword";
void connected_to_ap(WiFiEvent_t wifi_event, WiFiEventInfo_t wifi_info){
Serial.println("\nConnected to the WiFi network");
}
void got_ip_from_ap(WiFiEvent_t wifi_event, WiFiEventInfo_t wifi_info){
Serial.print("Local ESP32 IP: ");
Serial.println(WiFi.localIP());
}
void setup(){
Serial.begin(115200);
delay(1000);
WiFi.mode(WIFI_STA); //Optional
WiFi.onEvent(connected_to_ap, SYSTEM_EVENT_STA_CONNECTED);
WiFi.onEvent(got_ip_from_ap, SYSTEM_EVENT_STA_GOT_IP);
WiFi.begin(ssid, password);
Serial.println("\nConnecting");
}
void loop(){}
Sortie de la console :
Connecting
.............
Connected to the WiFi network
Local ESP32 IP: 192.168.43.167