Fonctions utiles de la bibliothèque Wi-Fi ESP32 (Arduino IDE)

Cet article est une compilation de fonctions Wi-Fi utiles pour l’ESP32. Nous aborderons les sujets suivants : analyser les réseaux Wi-Fi, se connecter à un réseau Wi-Fi, obtenir la puissance de la connexion Wi-Fi, vérifier l’état de la connexion, se reconnecter au réseau après la perte d’une connexion, l’état Wi-Fi, Wi-Fi Modes Fi, obtenez l’adresse IP ESP32, définissez une adresse IP fixe et plus encore.

Ce n’est pas une nouveauté. Il existe de nombreux exemples de gestion du Wi-Fi avec l’ESP32. Cependant, nous avons pensé qu’il serait utile de compiler certaines des fonctions Wi-Fi les plus utilisées et les plus pratiques pour l’ESP32.

Table des matières

Voici une liste de ce qui sera couvert dans ce tutoriel (vous pouvez cliquer sur les liens pour accéder à la section correspondante) :

Y compris la bibliothèque Wi-Fi

La première chose que vous devez faire pour utiliser les fonctionnalités Wi-Fi de l’ESP32 est d’inclure la bibliothèque WiFi.h dans votre code, comme suit :

#include <WiFi.h>

Cette bibliothèque est automatiquement « installée » lorsque vous installez le module complémentaire ESP32 dans votre IDE Arduino. Si vous n’avez pas installé l’ESP32, vous pouvez suivre le tutoriel suivant :

Si vous préférez utiliser VS Code + PaltformIO, il vous suffit de démarrer un nouveau projet avec une carte ESP32 pour pouvoir utiliser la bibliothèque WiFi.h et ses fonctions.

Modes Wi-Fi ESP32

La carte ESP32 peut servir de station Wi-Fi, de point d’accès ou les deux. Pour définir le mode Wi-Fi, utilisez WiFi.mode() et définissez le mode souhaité comme argument :

Borne Wi-Fi

Lorsque l’ESP32 est défini comme une station Wi-Fi, il peut se connecter à d’autres réseaux (comme votre routeur). Dans ce scénario, le routeur attribue une adresse IP unique à votre carte ESP. Vous pouvez communiquer avec l’ESP en utilisant d’autres appareils (stations) également connectés au même réseau en vous référant à l’adresse IP unique de l’ESP.

Le routeur est connecté à Internet, nous pouvons donc demander des informations à Internet à l’aide de la carte ESP32, telles que des données d’API (données météorologiques, par exemple), publier des données sur des plateformes en ligne, utiliser des icônes et des images d’Internet ou inclure des bibliothèques JavaScript pour créer des pages de serveur Web.

Définissez l’ESP32 en tant que station et connectez-vous au réseau Wi-Fi

Aller à « Se connecter au réseau Wi-Fi » pour savoir comment définir l’ESP32 comme station et le connecter à un réseau.

Dans certains cas, ce n’est peut-être pas la meilleure configuration – lorsque vous n’avez pas de réseau à proximité et que vous souhaitez toujours vous connecter à l’ESP pour le contrôler. Dans ce scénario, vous devez définir votre carte ESP comme point d’accès.

Point d’accès

Lorsque vous définissez votre carte ESP32 comme point d’accès, vous pouvez être connecté à l’aide de n’importe quel appareil doté de capacités Wi-Fi sans vous connecter à votre routeur. Lorsque vous définissez l’ESP32 comme point d’accès, vous créez son propre réseau Wi-Fi et les appareils Wi-Fi (stations) à proximité peuvent s’y connecter, comme votre smartphone ou votre ordinateur. Ainsi, vous n’avez pas besoin d’être connecté à un routeur pour le contrôler.

Cela peut également être utile si vous souhaitez que plusieurs appareils ESP32 se parlent sans avoir besoin d’un routeur.

Parce que l’ESP32 ne se connecte pas davantage à un réseau câblé comme votre routeur, il s’appelle soft-AP (soft Access Point). Cela signifie que si vous essayez de charger des bibliothèques ou d’utiliser un micrologiciel à partir d’Internet, cela ne fonctionnera pas. Cela ne fonctionne pas non plus si vous faites des requêtes HTTP à des services sur Internet pour publier des lectures de capteurs sur le cloud ou utiliser des services sur Internet (comme l’envoi d’un e-mail, par exemple).

Définir l’ESP32 comme point d’accès

Pour définir l’ESP32 comme point d’accès, réglez le mode Wi-Fi sur point d’accès :

WiFi.mode(WIFI_AP)

Et ensuite, utilisez la méthode softAP() comme suit :

WiFi.softAP(ssid, password);

ssid est le nom que vous souhaitez donner au point d’accès ESP32, et la variable password est le mot de passe du point d’accès. Si vous ne souhaitez pas définir de mot de passe, définissez-le sur NULL.

Il existe également d’autres paramètres facultatifs que vous pouvez transmettre à la méthode softAP(). Voici tous les paramètres :

WiFi.softAP(const char* ssid, const char* password, int channel, int ssid_hidden, int max_connection)

• ssid : nom du point d’accès – maximum 63 caractères ;
• mot de passe : minimum 8 caractères ; réglez sur NULL si vous voulez que le point d’accès soit ouvert ;
• canal : numéro de canal Wi-Fi (1-13)
• ssid_hidden : (0 = diffuser le SSID, 1 = masquer le SSID)
• max_connection : nombre maximal de clients connectés simultanément (1-4)

Nous avons un tutoriel complet expliquant comment configurer l’ESP32 en point d’accès :

Borne Wi-Fi + Point d’accès

L’ESP32 peut être configuré en tant que station Wi-Fi et point d’accès simultanément. Définissez son mode sur WIFI_AP_STA.

WiFi.mode(WIFI_AP_STA);

Analyser les réseaux Wi-Fi

L’ESP32 peut analyser les réseaux Wi-Fi à proximité dans sa portée Wi-Fi. Dans votre IDE Arduino, accédez à Fichier > Exemples > WiFi > WiFiScan. Cela chargera une esquisse qui scanne les réseaux Wi-Fi dans la portée de votre carte ESP32.

Cela peut être utile pour vérifier si le réseau Wi-Fi auquel vous essayez de vous connecter est à portée de votre carte ou d’autres applications. Votre projet Wi-Fi peut ne pas fonctionner souvent car il peut ne pas être en mesure de se connecter à votre routeur en raison d’une puissance Wi-Fi insuffisante.

Voici l’exemple :

/*
  Example from WiFi > WiFiScan
  Complete details at https://Raspberryme.com/esp32-useful-wi-fi-functions-arduino/
*/

#include "WiFi.h"

void setup() {
  Serial.begin(115200);

  // Set WiFi to station mode and disconnect from an AP if it was previously connected
  WiFi.mode(WIFI_STA);
  WiFi.disconnect();
  delay(100);

  Serial.println("Setup done");
}

void loop() {
  Serial.println("scan start");

  // WiFi.scanNetworks will return the number of networks found
  int n = WiFi.scanNetworks();
  Serial.println("scan done");
  if (n == 0) {
      Serial.println("no networks found");
  } else {
    Serial.print(n);
    Serial.println(" networks found");
    for (int i = 0; i < n; ++i) {
      // Print SSID and RSSI for each network found
      Serial.print(i + 1);
      Serial.print(": ");
      Serial.print(WiFi.SSID(i));
      Serial.print(" (");
      Serial.print(WiFi.RSSI(i));
      Serial.print(")");
      Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN)?" ":"*");
      delay(10);
    }
  }
  Serial.println("");

  // Wait a bit before scanning again
  delay(5000);
}

Afficher le code brut

Vous pouvez le télécharger sur votre carte et vérifier les réseaux disponibles ainsi que le RSSI (indicateur de puissance du signal reçu).

WiFi.scanNetworks() renvoie le nombre de réseaux trouvés.

int n = WiFi.scanNetworks();

Après la numérisation, vous pouvez accéder aux paramètres de chaque réseau.

WiFi.SSID() imprime le SSID d’un réseau spécifique :

Serial.print(WiFi.SSID(i));

WiFi.RSSI() renvoie le RSSI de ce réseau. RSSI signifie Received Signal Strength Indicator. Il s’agit d’une mesure estimée du niveau de puissance qu’un périphérique client RF reçoit d’un point d’accès ou d’un routeur.

Serial.print(WiFi.RSSI(i));

Enfin, WiFi.encryptionType() renvoie le type de chiffrement du réseau. Cet exemple spécifique met un * dans le cas des réseaux ouverts. Cependant, cette fonction peut renvoyer l’une des options suivantes (pas seulement les réseaux ouverts) :

• WIFI_AUTH_OPEN
• WIFI_AUTH_WEP
• WIFI_AUTH_WPA_PSK
• WIFI_AUTH_WPA2_PSK
• WIFI_AUTH_WPA_WPA2_PSK
• WIFI_AUTH_WPA2_ENTERPRISE

Se connecter à un réseau Wi-Fi

Pour connecter l’ESP32 à un réseau Wi-Fi spécifique, vous devez connaître son SSID et son mot de passe. De plus, ce réseau doit être dans la portée Wi-Fi ESP32 (pour vérifier cela, vous pouvez utiliser l’exemple précédent pour analyser les réseaux Wi-Fi).

Vous pouvez utiliser la fonction suivante pour connecter l’ESP32 à un réseau Wi-Fi initWiFi() :

void initWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi ..");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(1000);
  }
  Serial.println(WiFi.localIP());
}

Les variables ssid et password contiennent le SSID et le mot de passe du réseau auquel vous souhaitez vous connecter.

// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

Ensuite, il vous suffit d’appeler la fonction initWiFi() dans votre setup().

Comment ça fonctionne?

Voyons rapidement comment fonctionne cette fonction.

Tout d’abord, définissez le mode Wi-Fi. Si l’ESP32 se connecte à un autre réseau (point d’accès/hotspot), il doit être en mode station.

WiFi.mode(WIFI_STA);

Ensuite, utilisez WiFi.begin() pour vous connecter à un réseau. Vous devez passer en arguments le SSID du réseau et son mot de passe :

WiFi.begin(ssid, password);

La connexion à un réseau Wi-Fi peut prendre un certain temps, nous ajoutons donc généralement une boucle while qui vérifie en permanence si la connexion a déjà été établie à l’aide de WiFi.status(). Lorsque la connexion est établie avec succès, elle renvoie WL_CONNECTED.

while (WiFi.status() != WL_CONNECTED) {

Obtenir l’état de la connexion Wi-Fi

Pour obtenir l’état de la connexion Wi-Fi, vous pouvez utiliser WiFi.status(). Cela renvoie l’une des valeurs suivantes qui correspondent aux constantes de la table :

Obtenez la force de la connexion WiFi

Pour obtenir la puissance de la connexion WiFi, vous pouvez simplement appeler WiFi.RSSI() après une connexion WiFi.

Voici un exemple :

/*
  Complete details at https://Raspberryme.com/esp32-useful-wi-fi-functions-arduino/
*/

#include <WiFi.h>

// Replace with your network credentials (STATION)
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

void initWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi ..");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(1000);
  }
  Serial.println(WiFi.localIP());
}

void setup() {
  Serial.begin(115200);
  initWiFi();
  Serial.print("RRSI: ");
  Serial.println(WiFi.RSSI());
}

void loop() {
  // put your main code here, to run repeatedly:
}

Afficher le code brut

Insérez vos informations d’identification réseau et téléchargez le code.

Ouvrez le moniteur série et appuyez sur le bouton RST embarqué ESP32. Il se connectera à votre réseau et imprimera le RSSI (indicateur de puissance du signal reçu).

Une valeur absolue inférieure signifie une connexion Wi-Fi la plus puissante.

Obtenir l’adresse IP ESP32

Lorsque l’ESP32 est défini comme une station Wi-Fi, il peut se connecter à d’autres réseaux (comme votre routeur). Dans ce scénario, le routeur attribue une adresse IP unique à votre carte ESP32. Pour obtenir l’adresse IP de votre carte, vous devez appeler WiFi.localIP() après avoir établi une connexion avec votre réseau.

Serial.println(WiFi.localIP());

Définir une adresse IP ESP32 statique

Au lieu d’obtenir une adresse IP attribuée au hasard, vous pouvez définir une adresse IP disponible de votre choix sur l’ESP32 à l’aide de WiFi.config().

En dehors des fonctions setup() et loop(), définissez les variables suivantes avec votre propre adresse IP statique et l’adresse IP de la passerelle correspondante. Par défaut, le code suivant attribue l’adresse IP 192.168.1.184 qui fonctionne dans la passerelle 192.168.1.1.

// Set your Static IP address
IPAddress local_IP(192, 168, 1, 184);
// Set your Gateway IP address
IPAddress gateway(192, 168, 1, 1);

IPAddress subnet(255, 255, 0, 0);
IPAddress primaryDNS(8, 8, 8, 8);   // optional
IPAddress secondaryDNS(8, 8, 4, 4); // optional

Ensuite, dans le setup() vous devez appeler la méthode WiFi.config() pour attribuer les configurations à votre ESP32.

// Configures static IP address
if (!WiFi.config(local_IP, gateway, subnet, primaryDNS, secondaryDNS)) {
  Serial.println("STA Failed to configure");
}

Les paramètres primaryDNS et SecondaryDNS sont facultatifs et vous pouvez les supprimer.

Nous vous recommandons de lire le tutoriel suivant pour savoir comment définir une adresse IP statique :

Se déconnecter du réseau Wi-Fi

Pour vous déconnecter d’un réseau Wi-Fi précédemment connecté, utilisez WiFi.disconnect() :

WiFi.disconnect()

Se reconnecter au réseau Wi-Fi après une connexion perdue

Pour vous reconnecter au Wi-Fi après une perte de connexion, vous pouvez utiliser WiFi.reconnect() pour essayer de vous reconnecter au point d’accès précédemment connecté :

WiFi.reconnect()

Ou, vous pouvez appeler WiFi.disconnect() suivi de WiFi.begin(ssid,password).

WiFi.disconnect();
WiFi.begin(ssid, password);

Alternativement, vous pouvez également essayer de redémarrer l’ESP32 avec ESP.restart() lorsque la connexion est perdue.

Vous pouvez ajouter quelque chose comme l’extrait ci-dessous à votre boucle () qui vérifie de temps en temps si la carte est connectée.

unsigned long currentMillis = millis();
// if WiFi is down, try reconnecting
if ((WiFi.status() != WL_CONNECTED) && (currentMillis - previousMillis >=interval)) {
  Serial.print(millis());
  Serial.println("Reconnecting to WiFi...");
  WiFi.disconnect();
  WiFi.reconnect();
  previousMillis = currentMillis;
}

N’oubliez pas de déclarer les variables previousMillis et interval. L’intervalle correspond au laps de temps entre chaque vérification en millisecondes (par exemple 30 secondes) :

unsigned long previousMillis = 0;
unsigned long interval = 30000;

Voici un exemple complet.

/*
  Rui Santos
  Complete project details at https://Raspberryme.com/solved-reconnect-esp32-to-wifi/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

#include <WiFi.h>

// Replace with your network credentials (STATION)
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

unsigned long previousMillis = 0;
unsigned long interval = 30000;

void initWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi ..");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(1000);
  }
  Serial.println(WiFi.localIP());
}

void setup() {
  Serial.begin(115200);
  initWiFi();
  Serial.print("RSSI: ");
  Serial.println(WiFi.RSSI());
}

void loop() {
  unsigned long currentMillis = millis();
  // if WiFi is down, try reconnecting every CHECK_WIFI_TIME seconds
  if ((WiFi.status() != WL_CONNECTED) && (currentMillis - previousMillis >=interval)) {
    Serial.print(millis());
    Serial.println("Reconnecting to WiFi...");
    WiFi.disconnect();
    WiFi.reconnect();
    previousMillis = currentMillis;
  }
}

Afficher le code brut

Cet exemple montre comment se connecter à un réseau et vérifie toutes les 30 secondes s’il est toujours connecté. Si ce n’est pas le cas, il se déconnecte et essaie de se reconnecter à nouveau.

Vous pouvez lire notre guide : [SOLVED] Reconnectez ESP32 au réseau Wi-Fi après une connexion perdue.

Alternativement, vous pouvez également utiliser les événements WiFi pour détecter que la connexion a été perdue et appeler une fonction pour gérer ce qu’il faut faire lorsque cela se produit (voir la section suivante).

Événements Wi-Fi ESP32

L’ESP32 peut gérer tous les événements Wi-Fi suivants (vérifiez le code source):

Pour un exemple complet d’utilisation de ces événements, dans votre IDE Arduino, accédez à Fichier > Exemples > WiFi > WiFiClientEvents.

/*   This sketch shows the WiFi event usage - Example from WiFi > WiFiClientEvents
     Complete details at https://Raspberryme.com/esp32-useful-wi-fi-functions-arduino/  */
/*
* WiFi Events

0  ARDUINO_EVENT_WIFI_READY               < ESP32 WiFi ready
1  ARDUINO_EVENT_WIFI_SCAN_DONE                < ESP32 finish scanning AP
2  ARDUINO_EVENT_WIFI_STA_START                < ESP32 station start
3  ARDUINO_EVENT_WIFI_STA_STOP                 < ESP32 station stop
4  ARDUINO_EVENT_WIFI_STA_CONNECTED            < ESP32 station connected to AP
5  ARDUINO_EVENT_WIFI_STA_DISCONNECTED         < ESP32 station disconnected from AP
6  ARDUINO_EVENT_WIFI_STA_AUTHMODE_CHANGE      < the auth mode of AP connected by ESP32 station changed
7  ARDUINO_EVENT_WIFI_STA_GOT_IP               < ESP32 station got IP from connected AP
8  ARDUINO_EVENT_WIFI_STA_LOST_IP              < ESP32 station lost IP and the IP is reset to 0
9  ARDUINO_EVENT_WPS_ER_SUCCESS       < ESP32 station wps succeeds in enrollee mode
10 ARDUINO_EVENT_WPS_ER_FAILED        < ESP32 station wps fails in enrollee mode
11 ARDUINO_EVENT_WPS_ER_TIMEOUT       < ESP32 station wps timeout in enrollee mode
12 ARDUINO_EVENT_WPS_ER_PIN           < ESP32 station wps pin code in enrollee mode
13 ARDUINO_EVENT_WIFI_AP_START                 < ESP32 soft-AP start
14 ARDUINO_EVENT_WIFI_AP_STOP                  < ESP32 soft-AP stop
15 ARDUINO_EVENT_WIFI_AP_STACONNECTED          < a station connected to ESP32 soft-AP
16 ARDUINO_EVENT_WIFI_AP_STADISCONNECTED       < a station disconnected from ESP32 soft-AP
17 ARDUINO_EVENT_WIFI_AP_STAIPASSIGNED         < ESP32 soft-AP assign an IP to a connected station
18 ARDUINO_EVENT_WIFI_AP_PROBEREQRECVED        < Receive probe request packet in soft-AP interface
19 ARDUINO_EVENT_WIFI_AP_GOT_IP6               < ESP32 ap interface v6IP addr is preferred
19 ARDUINO_EVENT_WIFI_STA_GOT_IP6              < ESP32 station interface v6IP addr is preferred
20 ARDUINO_EVENT_ETH_START                < ESP32 ethernet start
21 ARDUINO_EVENT_ETH_STOP                 < ESP32 ethernet stop
22 ARDUINO_EVENT_ETH_CONNECTED            < ESP32 ethernet phy link up
23 ARDUINO_EVENT_ETH_DISCONNECTED         < ESP32 ethernet phy link down
24 ARDUINO_EVENT_ETH_GOT_IP               < ESP32 ethernet got IP from connected AP
19 ARDUINO_EVENT_ETH_GOT_IP6              < ESP32 ethernet interface v6IP addr is preferred
25 ARDUINO_EVENT_MAX
*/

#include <WiFi.h>

const char* ssid     = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

void WiFiEvent(WiFiEvent_t event){
    Serial.printf("[WiFi-event] event: %d\n", event);

    switch (event) {
        case ARDUINO_EVENT_WIFI_READY: 
            Serial.println("WiFi interface ready");
            break;
        case ARDUINO_EVENT_WIFI_SCAN_DONE:
            Serial.println("Completed scan for access points");
            break;
        case ARDUINO_EVENT_WIFI_STA_START:
            Serial.println("WiFi client started");
            break;
        case ARDUINO_EVENT_WIFI_STA_STOP:
            Serial.println("WiFi clients stopped");
            break;
        case ARDUINO_EVENT_WIFI_STA_CONNECTED:
            Serial.println("Connected to access point");
            break;
        case ARDUINO_EVENT_WIFI_STA_DISCONNECTED:
            Serial.println("Disconnected from WiFi access point");
            break;
        case ARDUINO_EVENT_WIFI_STA_AUTHMODE_CHANGE:
            Serial.println("Authentication mode of access point has changed");
            break;
        case ARDUINO_EVENT_WIFI_STA_GOT_IP:
            Serial.print("Obtained IP address: ");
            Serial.println(WiFi.localIP());
            break;
        case ARDUINO_EVENT_WIFI_STA_LOST_IP:
            Serial.println("Lost IP address and IP address is reset to 0");
            break;
        case ARDUINO_EVENT_WPS_ER_SUCCESS:
            Serial.println("WiFi Protected Setup (WPS): succeeded in enrollee mode");
            break;
        case ARDUINO_EVENT_WPS_ER_FAILED:
            Serial.println("WiFi Protected Setup (WPS): failed in enrollee mode");
            break;
        case ARDUINO_EVENT_WPS_ER_TIMEOUT:
            Serial.println("WiFi Protected Setup (WPS): timeout in enrollee mode");
            break;
        case ARDUINO_EVENT_WPS_ER_PIN:
            Serial.println("WiFi Protected Setup (WPS): pin code in enrollee mode");
            break;
        case ARDUINO_EVENT_WIFI_AP_START:
            Serial.println("WiFi access point started");
            break;
        case ARDUINO_EVENT_WIFI_AP_STOP:
            Serial.println("WiFi access point  stopped");
            break;
        case ARDUINO_EVENT_WIFI_AP_STACONNECTED:
            Serial.println("Client connected");
            break;
        case ARDUINO_EVENT_WIFI_AP_STADISCONNECTED:
            Serial.println("Client disconnected");
            break;
        case ARDUINO_EVENT_WIFI_AP_STAIPASSIGNED:
            Serial.println("Assigned IP address to client");
            break;
        case ARDUINO_EVENT_WIFI_AP_PROBEREQRECVED:
            Serial.println("Received probe request");
            break;
        case ARDUINO_EVENT_WIFI_AP_GOT_IP6:
            Serial.println("AP IPv6 is preferred");
            break;
        case ARDUINO_EVENT_WIFI_STA_GOT_IP6:
            Serial.println("STA IPv6 is preferred");
            break;
        case ARDUINO_EVENT_ETH_GOT_IP6:
            Serial.println("Ethernet IPv6 is preferred");
            break;
        case ARDUINO_EVENT_ETH_START:
            Serial.println("Ethernet started");
            break;
        case ARDUINO_EVENT_ETH_STOP:
            Serial.println("Ethernet stopped");
            break;
        case ARDUINO_EVENT_ETH_CONNECTED:
            Serial.println("Ethernet connected");
            break;
        case ARDUINO_EVENT_ETH_DISCONNECTED:
            Serial.println("Ethernet disconnected");
            break;
        case ARDUINO_EVENT_ETH_GOT_IP:
            Serial.println("Obtained IP address");
            break;
        default: break;
    }}

void WiFiGotIP(WiFiEvent_t event, WiFiEventInfo_t info){
    Serial.println("WiFi connected");
    Serial.println("IP address: ");
    Serial.println(IPAddress(info.got_ip.ip_info.ip.addr));
}

void setup(){
    Serial.begin(115200);

    // delete old config
    WiFi.disconnect(true);

    delay(1000);

    // Examples of different ways to register wifi events
    WiFi.onEvent(WiFiEvent);
    WiFi.onEvent(WiFiGotIP, WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_GOT_IP);
    WiFiEventId_t eventID = WiFi.onEvent([](WiFiEvent_t event, WiFiEventInfo_t info){
        Serial.print("WiFi lost connection. Reason: ");
        Serial.println(info.wifi_sta_disconnected.reason);
    }, WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_DISCONNECTED);

    // Remove WiFi event
    Serial.print("WiFi Event ID: ");
    Serial.println(eventID);
    // WiFi.removeEvent(eventID);

    WiFi.begin(ssid, password);

    Serial.println();
    Serial.println();
    Serial.println("Wait for WiFi... ");
}

void loop(){
    delay(1000);
}

Afficher le code brut

Avec les événements Wi-Fi, vous n’avez pas besoin de vérifier constamment l’état du Wi-Fi. Lorsqu’un certain événement se produit, il appelle automatiquement la fonction de gestion correspondante.

Se reconnecter au réseau Wi-Fi après une connexion perdue (événements Wi-Fi)

Les événements Wi-Fi peuvent être utiles pour détecter qu’une connexion a été perdue et essayer de se reconnecter juste après (utilisez l’événement SYSTEM_EVENT_AP_STADISCONNECTED). Voici un exemple de code :

/*
  Rui Santos
  Complete project details at https://Raspberryme.com/solved-reconnect-esp32-to-wifi/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

#include <WiFi.h>
 
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

void WiFiStationConnected(WiFiEvent_t event, WiFiEventInfo_t info){
  Serial.println("Connected to AP successfully!");
}

void WiFiGotIP(WiFiEvent_t event, WiFiEventInfo_t info){
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

void WiFiStationDisconnected(WiFiEvent_t event, WiFiEventInfo_t info){
  Serial.println("Disconnected from WiFi access point");
  Serial.print("WiFi lost connection. Reason: ");
  Serial.println(info.wifi_sta_disconnected.reason);
  Serial.println("Trying to Reconnect");
  WiFi.begin(ssid, password);
}

void setup(){
  Serial.begin(115200);

  // delete old config
  WiFi.disconnect(true);

  delay(1000);

  WiFi.onEvent(WiFiStationConnected, WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_CONNECTED);
  WiFi.onEvent(WiFiGotIP, WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_GOT_IP);
  WiFi.onEvent(WiFiStationDisconnected, WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_DISCONNECTED);

  /* Remove WiFi event
  Serial.print("WiFi Event ID: ");
  Serial.println(eventID);
  WiFi.removeEvent(eventID);*/

  WiFi.begin(ssid, password);
    
  Serial.println();
  Serial.println();
  Serial.println("Wait for WiFi... ");
}

void loop(){
  delay(1000);
}

Afficher le code brut

Comment ça fonctionne?

Dans cet exemple, nous avons ajouté trois événements Wi-Fi : lorsque l’ESP32 se connecte, lorsqu’il obtient une adresse IP et lorsqu’il se déconnecte : ARDUINO_EVENT_WIFI_STA_CONNECTED, ARDUINO_EVENT_WIFI_STA_GOT_IP, ARDUINO_EVENT_WIFI_STA_DISCONNECTED.

Lorsque la station ESP32 se connecte au point d’accès (événement ARDUINO_EVENT_WIFI_STA_CONNECTED), la fonction WiFiStationConnected() sera appelée :

 WiFi.onEvent(WiFiStationConnected, WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_CONNECTED);

La fonction WiFiStationConnected() imprime simplement que l’ESP32 s’est connecté à un point d’accès (par exemple, votre routeur) avec succès. Cependant, vous pouvez modifier la fonction pour effectuer toute autre tâche (comme allumer une LED pour indiquer qu’elle est correctement connectée au réseau).

void WiFiStationConnected(WiFiEvent_t event, WiFiEventInfo_t info){
  Serial.println("Connected to AP successfully!");
}

Lorsque l’ESP32 obtient son adresse IP, la fonction WiFiGotIP() s’exécute.

 WiFi.onEvent(WiFiGotIP, WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_GOT_IP);

Cette fonction imprime simplement l’adresse IP sur le moniteur série.

void WiFiGotIP(WiFiEvent_t event, WiFiEventInfo_t info){
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

Lorsque l’ESP32 perd la connexion avec le point d’accès (ARDUINO_EVENT_WIFI_STA_DISCONNECTED), la fonction WiFiStationDisconnected() est appelée.

 WiFi.onEvent(WiFiStationDisconnected, WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_DISCONNECTED);

Cette fonction affiche un message indiquant que la connexion a été perdue et tente de se reconnecter :

void WiFiStationDisconnected(WiFiEvent_t event, WiFiEventInfo_t info){
  Serial.println("Disconnected from WiFi access point");
  Serial.print("WiFi lost connection. Reason: ");
  Serial.println(info.wifi_sta_disconnected.reason);
  Serial.println("Trying to Reconnect");
  WiFi.begin(ssid, password);
}

ESP32 WiFiMulti

L’ESP32 WiFiMulti vous permet d’enregistrer plusieurs réseaux (combinaisons SSID/mot de passe). L’ESP32 se connectera au réseau Wi-Fi avec le signal le plus fort (RSSI). Si la connexion est perdue, il se connectera au réseau suivant sur la liste. Cela nécessite que vous incluiez la bibliothèque WiFiMulti.h (vous n’avez pas besoin de l’installer, elle est fournie par défaut avec le package ESP32).

Pour apprendre à utiliser WiFiMulti, lisez le tutoriel suivant :

Changer le nom d’hôte ESP32

Pour définir un nom d’hôte personnalisé pour votre carte, appelez WiFi.setHostname(YOUR_NEW_HOSTNAME); avant WiFi.begin();

Le nom d’hôte ESP32 par défaut est espressif.

Il existe une méthode fournie par la bibliothèque WiFi.h qui vous permet de définir un nom d’hôte personnalisé.

Tout d’abord, commencez par définir votre nouveau nom d’hôte. Par exemple:

String hostname = "ESP32 Node Temperature";

Ensuite, appelez la fonction WiFi.setHostname() avant d’appeler WiFi.begin(). Vous devez également appeler WiFi.config() comme indiqué ci-dessous :

WiFi.config(INADDR_NONE, INADDR_NONE, INADDR_NONE, INADDR_NONE);
WiFi.setHostname(hostname.c_str()); //define hostname

Vous pouvez copier l’exemple complet ci-dessous :

/*
  Rui Santos
  Complete project details at https://Raspberryme.com/esp32-set-custom-hostname-arduino/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

#include <WiFi.h>

// Replace with your network credentials (STATION)
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

String hostname = "ESP32 Node Temperature";

void initWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.config(INADDR_NONE, INADDR_NONE, INADDR_NONE, INADDR_NONE);
  WiFi.setHostname(hostname.c_str()); //define hostname
  //wifi_station_set_hostname( hostname.c_str() );
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi ..");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(1000);
  }
  Serial.println(WiFi.localIP());
}

void setup() {
  Serial.begin(115200);
  initWiFi();
  Serial.print("RRSI: ");
  Serial.println(WiFi.RSSI());
}

void loop() {
  // put your main code here, to run repeatedly:
}

Afficher le code brut

Vous pouvez utiliser cet extrait de code précédent dans vos projets pour définir un nom d’hôte personnalisé pour l’ESP32.

Important : vous devrez peut-être redémarrer votre routeur pour que les modifications prennent effet.

Après cela, si vous accédez aux paramètres de votre routeur, vous verrez l’ESP32 avec le nom d’hôte personnalisé.

Conclusion

Cet article était une compilation de certaines des fonctions Wi-Fi ESP32 les plus utilisées et les plus utiles. Bien qu’il existe de nombreux exemples d’utilisation des fonctionnalités Wi-Fi de l’ESP32, il existe peu de documentation expliquant comment utiliser les fonctions Wi-Fi avec l’ESP32 à l’aide de l’IDE Arduino. Nous avons donc décidé de mettre en place ce guide pour faciliter l’utilisation des fonctions liées au Wi-Fi ESP32 dans vos projets.

Si vous avez d’autres suggestions, vous pouvez les partager dans la section des commentaires.

Nous espérons que vous avez trouvé ce tutoriel utile.

En savoir plus sur l’ESP32 avec nos ressources :

Cette vidéo vous emmène dans l’histoire de Raspberry Pi :