Comment utiliser le module Wi-Fi intégré de l'ESP32 pour des applications IoT : Client, Point d'accès et communication directe

Le module Wi-Fi intégré de l'ESP32 prend en charge la norme 802.11b/g/n, ce qui lui permet d'agir à la fois comme un client Wi-Fi et un point d'accès. En mode client, il se connecte à des réseaux Wi-Fi existants, lui permettant ainsi d’accéder à Internet et de communiquer avec d'autres appareils sur le réseau. Cette fonctionnalité permet à l'ESP32 de récupérer des données depuis des serveurs en ligne, d'envoyer des données de capteurs vers des plateformes cloud, ou d'interagir avec des services web. De plus, l’ESP32 peut être configuré en tant que point d'accès Wi-Fi, permettant ainsi à d'autres appareils de se connecter directement à lui. En tant que point d'accès, l’ESP32 devient un concentrateur qui permet aux appareils de communiquer entre eux et d'accéder aux ressources hébergées par l'ESP32. Cette caractéristique est particulièrement utile pour la création de réseaux locaux (LAN) dans les applications IoT, où les appareils doivent interagir sans avoir besoin d'accéder à Internet.

L’ESP32 comme point d’accès Wi-Fi

Prenons l'exemple de l’utilisation de l’ESP32 comme point d’accès Wi-Fi. Un point d'accès est un dispositif de communication sans fil qui sert de concentrateur central pour connecter d'autres appareils à un réseau local. Dans cet exemple, l’ESP32 fonctionnera comme un point d'accès, permettant à d’autres appareils de se connecter directement à lui pour la communication et l’échange de données.

cpp
Copy code
#include <WiFi.h>
const char* ssid = "MyESP32AP";
const char* password = "password123";
void setup() {
  Serial.begin(115200);
  WiFi.softAP(ssid, password);

  IPAddress apIP(192, 168, 4, 1);

  IPAddress subnet(255, 255, 255, 0);
  WiFi.softAPConfig(apIP, apIP, subnet);
  Serial.print("Adresse IP du point d'accès : ");
  Serial.println(WiFi.softAPIP());
}
void loop() {
  // Votre code ici
}

En mode point d'accès, bien qu’il ne soit pas possible d’accéder à Internet, il est néanmoins possible de se connecter aux services et dispositifs du réseau local. Cette fonctionnalité est particulièrement adaptée pour des applications où la communication entre appareils est requise sans nécessité d'une connexion Internet.

L’ESP32 comme client Wi-Fi

Dans l'exemple suivant, nous allons configurer l'ESP32 en tant que client Wi-Fi. Un client Wi-Fi est un appareil qui se connecte à un réseau sans fil existant, tel qu'un réseau Wi-Fi domestique, un point d'accès public ou même un autre point d'accès créé avec l'ESP32. En tant que client Wi-Fi, l'ESP32 pourra accéder à Internet et interagir avec des services extérieurs à son réseau local, si le point d'accès auquel il se connecte offre une connexion Internet.

Voici un exemple de code pour connecter l'ESP32 à un réseau Wi-Fi existant :

cpp
Copy code
#include <WiFi.h>

const char* ssid = "MyESP32AP";
const char* password = "password123";
void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  Serial.print("Connexion au Wi-Fi...");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  Serial.print("Connecté au réseau Wi-Fi avec l'adresse IP : ");
  Serial.println(WiFi.localIP());
}
void loop() {
  // Votre code ici
}

Dans ce code, l’ESP32 se connecte à un réseau Wi-Fi en utilisant le SSID et le mot de passe fournis. Une fois la connexion établie, l'ESP32 affiche son adresse IP locale obtenue du routeur Wi-Fi. Cette configuration permet à l’ESP32 d’agir en tant que client, accédant ainsi aux ressources de l'Internet et permettant l’échange de données avec des serveurs distants ou d'autres appareils.

Utiliser le Wi-Fi Direct pour les connexions P2P

Voici un exemple pour créer un serveur Wi-Fi Direct sur l'ESP32, permettant de recevoir des connexions d'autres appareils ESP32 :

cpp
Copy code
#include <WiFi.h>
WiFiServer server(80);
const char* ssid = "MyESP32Direct";
const char* password = "password123";
void setup() {
  Serial.begin(115200);
  WiFi.softAP(ssid, password);

  IPAddress apIP(192, 168, 4, 1);

  IPAddress subnet(255, 255, 255, 0);
  WiFi.softAPConfig(apIP, apIP, subnet);
  server.begin();
  Serial.print("Adresse IP du propriétaire du groupe Wi-Fi Direct : ");
  Serial.println(WiFi.softAPIP());
}
void loop() {
  WiFiClient client = server.available();
  if (client) {
    Serial.println("Client connecté.");
    client.println("Bonjour du propriétaire du groupe !");
    while (client.connected()) {
      if (client.available()) {
        String message = client.readStringUntil('\n');
        // Traitement du message
      }
    }
  }
}

Dans cet exemple, l'ESP32 crée un serveur Wi-Fi Direct et attend qu'un autre appareil ESP32 se connecte. Une fois la connexion établie, le serveur envoie un message de bienvenue à l’appareil client.

Conclusion

Les capacités sans fil de l'ESP32, qu'il s'agisse de son mode client ou point d'accès, ainsi que de son utilisation du Wi-Fi Direct, permettent de créer une large gamme d'applications IoT flexibles et puissantes. Ces fonctionnalités sont essentielles pour concevoir des réseaux locaux ou des dispositifs capables de communiquer entre eux, que ce soit avec ou sans connexion à Internet. Il est important de bien comprendre les différents modes de fonctionnement du Wi-Fi sur l'ESP32 pour exploiter au maximum ses potentialités dans des systèmes embarqués complexes.

Comment configurer un ESP32 comme client BLE pour interagir avec des serveurs BLE et utiliser des services

L'ESP32, en tant que dispositif polyvalent, peut être utilisé non seulement pour communiquer comme un serveur BLE (Bluetooth Low Energy), mais aussi comme un client BLE, ce qui permet une interaction plus dynamique avec d'autres périphériques BLE. Lorsqu'on utilise un ESP32 en tant que client, celui-ci initie une connexion avec un serveur BLE pour interagir avec ses services et caractéristiques. Voici comment procéder pour mettre en œuvre cette fonctionnalité.

Lors de l'utilisation d'un client BLE, il est possible de scanner les périphériques disponibles et de découvrir les services qu'ils offrent. Chaque service représente un ensemble spécifique de fonctionnalités ou de capacités. Un client BLE peut lire des données à partir de ces services ou, dans certains cas, les modifier. Une fois qu'un client BLE est connecté à un serveur, il peut envoyer des requêtes pour lire ou écrire des caractéristiques et, dans certains cas, recevoir des notifications lorsque les données changent.

Prenons un exemple d'application dans laquelle un appareil mobile se connecte à un ESP32 configuré comme serveur BLE. Pour ce faire, l'utilisateur doit d'abord localiser l'ESP32 parmi les périphériques disponibles. Après avoir cliqué sur "Connecter" dans l'application, l'utilisateur pourra voir les données du périphérique, y compris les attributs génériques, l'accès, ainsi que le UUID du service. Le UUID du service est défini dans le code et est le même que celui affiché dans l'application, ce qui confirme que le client s'est bien connecté au serveur.

Cet exemple simple illustre comment utiliser l'application nRF Connect pour visualiser les données d'un serveur BLE via un client BLE. Une fois cette interaction comprise, on peut avancer vers l'exploration d'une autre facette du BLE, à savoir l'ESP32 en tant que client BLE.

Le code suivant montre comment un ESP32 peut être programmé pour fonctionner en tant que client BLE, permettant ainsi de se connecter à un serveur et d'interagir avec ses services et caractéristiques. Ce code utilise la bibliothèque BLEDevice et commence par définir deux UUID, l'un pour le service et l'autre pour la caractéristique à manipuler. Il intègre également des drapeaux logiques pour contrôler l'état de la connexion et du scan. Le processus commence par le scan des périphériques BLE et se poursuit avec l'établissement de la connexion, l'accès aux services et caractéristiques et l'écriture des données si nécessaire.

cpp
Copy code
#include "BLEDevice.h"

static BLEUUID serviceUUID("4fafc201-1fb5-459e-8fcc-c5c9c331914b");

static BLEUUID charUUID("beb5483e-36e1-4688-b7f5-ea07361b26a8");
static boolean doConnect = false;
static boolean connected = false;
static boolean doScan = false;
static BLERemoteCharacteristic* pRemoteCharacteristic;
static BLEAdvertisedDevice* myDevice;
if (connected) {

    String newValue = "Time since boot: " + String(millis()/1000);

    Serial.println("Setting new characteristic value to \"" + newValue + "\"");
    pRemoteCharacteristic->writeValue(newValue.c_str(), newValue.length());
} else if (doScan) {
    BLEDevice::getScan()->start(0);
}
delay(1000);

Le code décrit un client BLE basé sur Arduino. Il recherche un périphérique BLE dont le service et la caractéristique correspondent aux UUID définis, puis établit une connexion pour interagir avec ce périphérique. Une fois la connexion établie, il peut lire ou écrire dans la caractéristique définie.

Le rôle d'un client BLE ne se limite pas seulement à la lecture et à l'écriture des données. Il permet aussi des interactions plus avancées comme la notification en temps réel. En définissant un callback pour la caractéristique, le client peut recevoir des mises à jour dès que les données changent, ce qui est essentiel pour des applications telles que la surveillance de la santé ou l'automatisation domestique.

Les applications des clients BLE sont vastes et couvrent de nombreux domaines allant des appareils mobiles aux objets connectés dans l'Internet des objets (IoT). Leur efficacité énergétique et leur capacité à communiquer sans fil sur de courtes distances ont permis le développement de nombreuses solutions innovantes. L'ESP32, avec son faible coût, sa faible consommation d'énergie et sa flexibilité, s'avère être un choix idéal pour le développement de ces technologies.

Comment fonctionne le protocole MQTT dans les communications IoT ?

Le protocole MQTT (Message Queuing Telemetry Transport) repose sur un modèle de messagerie pub-sub (publication-abonnement), facilitant une communication efficace entre les dispositifs dans l'écosystème de l'Internet des objets (IoT). À sa base, MQTT se compose de trois éléments clés : les éditeurs, les abonnés et un courtier central. Examinons cette structure de manière plus détaillée.

Lorsqu'un éditeur envoie un message à un sujet, le courtier reçoit le message et évalue les abonnés intéressés par ce sujet. Il transmet ensuite le message à tous les abonnés concernés. Les abonnés peuvent choisir le niveau de QoS (Quality of Service) pour la remise des messages. Trois niveaux sont disponibles :

• QoS 0 : Le message est livré au plus une fois, sans besoin d'accusé de réception.

• QoS 1 : Le message est livré au moins une fois, et un accusé de réception est renvoyé à l'éditeur.

• QoS 2 : Le message est livré exactement une fois, en utilisant un processus de confirmation en quatre étapes pour assurer la fiabilité de la transmission.

Ce processus en quatre étapes comprend :

1. L'éditeur envoie un message de type PUBLISH.

2. Le récepteur reconnaît la réception du message.

3. L'éditeur renvoie le message PUBLISH.

4. Le récepteur confirme avec un dernier accusé de réception.

Dans son fonctionnement, MQTT repose principalement sur le courtier, qui orchestre le flux des messages entre les éditeurs et les abonnés. Ce protocole léger est particulièrement adapté aux scénarios où la bande passante et les ressources sont limitées, ce qui en fait un choix privilégié pour les communications IoT, où les dispositifs doivent échanger des informations de manière fluide et efficace. L'utilisation de MQTT permet de simplifier la communication entre des appareils disparates, tout en réduisant les exigences en termes de consommation de ressources et de bande passante.

Un exemple d'application pratique de MQTT avec le dispositif ESP32 montre clairement son efficacité. Dans cet exemple, deux clients sont impliqués : un utilisant un ESP32 avec divers capteurs et dispositifs, et l'autre étant un client web pour MQTT. L'ESP32 se connecte au courtier MQTT et s'abonne aux sujets LED et servo. À chaque fois qu'un message arrive sur ces sujets, l'ESP32 effectue des actions comme allumer ou éteindre la LED, ou bien déplacer le servo. En outre, l'ESP32 envoie régulièrement des données de température sur le sujet Tempdata.

Pour établir une communication via MQTT, il est nécessaire de disposer d'un courtier. Ce dernier peut être installé sur un ordinateur personnel ou une Raspberry Pi, ou bien utiliser un courtier cloud public, comme le HiveMQ gratuit. Cette plateforme est idéale pour des essais simples, sans avoir à gérer soi-même l'infrastructure du courtier.

Le code qui permet d'interfacer un ESP32 avec MQTT peut inclure différentes bibliothèques et configurations. Cela commence par l'inclusion des bibliothèques nécessaires, comme WiFi.h pour la connexion Wi-Fi et PubSubClient.h pour la communication MQTT. Une fois les connexions établies, l'ESP32 peut publier des données telles que la température ou l'humidité, et recevoir des commandes pour contrôler des périphériques comme des LED et des moteurs servos.

Une fois que l'ESP32 est connecté au courtier, un processus en plusieurs étapes est mis en place pour gérer les abonnements, les reconnections et l'exécution des actions liées aux messages reçus. Le système MQTT permet ainsi de gérer de manière centralisée les interactions entre les dispositifs IoT, offrant une solution efficace et flexible pour des applications nécessitant une communication en temps réel, même avec des ressources limitées.

Il est important de noter que le succès d’une telle communication repose sur la stabilité du courtier et la gestion des connexions. Si l'un des dispositifs se déconnecte de manière inattendue, la fonctionnalité LWT permet de maintenir une certaine transparence dans le système, en envoyant un message de notification à tous les abonnés concernés. En outre, l’utilisation du QoS adéquat garantit que les messages seront livrés selon le niveau de fiabilité requis par chaque application.