ESP32 S3 - WebSocket

WebSocket permet une communication bidirectionnelle en temps réel entre un navigateur web et un appareil comme l'ESP32 S3 - sans jamais recharger la page. Dans ce tutoriel, nous allons apprendre ce qu'est WebSocket, pourquoi il est idéal pour un contrôle et une surveillance fluides de l'ESP32 S3, et comment le mettre en place avec un exemple pratique d'application de chat.

Ce que vous allez construire :

  1. Un serveur WebSocket fonctionnant sur l'ESP32 S3.
  2. Une page web servie par l'ESP32 S3 qui se connecte au serveur WebSocket.
  3. Une interface de chat qui vous permet de taper un message dans le navigateur et de l'envoyer à l'ESP32 S3.
  4. Des réponses en temps réel de l'ESP32 S3 affichées dans le navigateur sans rechargement de page.
ESP32 S3 WebSocket - échange en temps réel entre un navigateur web et l'ESP32 S3

Matériel nécessaire

1×ESP32 S3 WROOM N16R8
1×Alternativement: ESP32 S3 SuperMini Dev Module
1×Alternativement: ESP32 S3 Uno-form Board
1×Alternativement: ESP32 S3 Camera Board
1×Câble USB Type-A vers Type-C (pour PC USB-A)
1×Câble USB Type-C vers Type-C (pour PC USB-C)
1×Recommandé: Screw Terminal Expansion Board for ESP32 S3
1×Recommandé: Breakout Expansion Board for ESP32 S3
1×Recommandé: Power Splitter for ESP32 S3

Ou vous pouvez acheter les kits suivants:

1×Kit de Démarrage DIYables ESP32 S3 (ESP32 S3 inclus)
1×Kit de Capteurs DIYables (18 capteurs/écrans)
Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.

Qu'est-ce que le WebSocket sur l'ESP32 S3 ?

WebSocket est une technologie qui permet à un navigateur web de communiquer directement avec un serveur web en temps réel, en maintenant une connexion persistante ouverte afin que les données puissent circuler dans les deux sens à tout moment. Sans WebSocket, le navigateur doit sans cesse rafraîchir ou interroger le serveur pour recevoir des mises à jour, ce qui est lent et inefficace. Avec WebSocket, l'ESP32 S3 et le navigateur restent connectés en continu, permettant un échange de données instantané sans rechargement de page - exactement le type de réactivité nécessaire pour les projets de contrôle et de surveillance.

Spécifications clés

  • Protocole : WebSocket bidirectionnel basé sur TCP (RFC 6455)
  • Direction : navigateur vers ESP32 S3 et ESP32 S3 vers navigateur simultanément
  • Latence : quasi instantanée ; aucun rechargement de page requis
  • Cas d'usage courants : jeux en ligne, messagerie instantanée, tableaux de bord en direct, panneaux de contrôle IoT

Pourquoi avons-nous besoin de WebSocket pour contrôler l'ESP32 S3 en douceur ?

Imaginez contrôler un appareil télécommandé à l'aide d'une interface web sur votre téléphone. Sans WebSocket, chaque changement de direction ou de vitesse nécessite un rechargement de page - comme appuyer sur un bouton « recharger » avant que chaque commande n'atteigne l'appareil. Avec WebSocket, vous avez une connexion continue et directe entre le navigateur et l'ESP32 S3, de sorte que les commandes arrivent instantanément sans délai causé par le rechargement.

En général, WebSocket vous permet de :

  • Envoyer des données du navigateur web vers l'ESP32 S3 sans recharger la page web.
  • Envoyer des données de l'ESP32 S3 vers le navigateur web sans recharger la page web.

Cela permet une véritable communication bidirectionnelle en temps réel.

Avantages de WebSocket avec l'ESP32 S3 :

  • Contrôle en temps réel : WebSocket permet une communication instantanée avec l'ESP32 S3, garantissant des réponses rapides aux commandes pour une expérience utilisateur fluide.
  • Connexion persistante : maintenez un lien continu sans rafraîchir la page de contrôle, créant une ligne de communication toujours prête pour des instructions immédiates.
  • Efficacité : bénéficiez de réponses rapides sans avoir besoin de recharger constamment la page, améliorant le confort et l'efficacité globale de l'utilisateur.

Chat web avec l'ESP32 S3 via WebSocket

Le contenu de la page web (HTML, CSS, JavaScript) est stocké séparément dans un fichier index.h. Nous aurons donc deux fichiers de code dans l'Arduino IDE :

  • Un fichier .ino qui est le code de l'ESP32 S3, créant un serveur web et un serveur WebSocket
  • Un fichier .h, qui contient le contenu de la page web.

Étapes rapides

  1. Nouveau sur l'ESP32 S3 ? Suivez d'abord notre guide ESP32 S3 - Premiers pas.
  2. Connectez la carte ESP32 S3 à votre PC via un câble USB Type-C.
  3. Ouvrez l'Arduino IDE sur votre PC.
  4. Sélectionnez la bonne carte ESP32 S3 (par exemple ESP32S3 Dev Module) et le bon port COM.
  5. Ouvrez le gestionnaire de bibliothèques en cliquant sur l'icône Library Manager dans la barre de navigation de gauche de l'Arduino IDE.
  6. Recherchez « DIYables ESP32 WebServer », puis trouvez la bibliothèque Web Server créée par DIYables.
  7. Cliquez sur le bouton Install pour installer la bibliothèque Web Server.
ESP32 S3 Web Server library
  1. Dans l'Arduino IDE, créez un nouveau sketch et donnez-lui un nom, par exemple newbiely.com.ino.
  2. Le code suivant met en œuvre le serveur WebSocket de l'ESP32 S3 - il gère les connexions entrantes du navigateur, reçoit les messages, et envoie des réponses en temps réel. Copiez-le et ouvrez-le avec l'Arduino IDE.
/* * Ce code ESP32 S3 a été développé par newbiely.fr * Ce code ESP32 S3 est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/tutorials/esp32-s3/esp32-s3-websocket */ /* * This ESP32-S3 code is created by esp32io.com * * This ESP32-S3 code is released in the public domain * * For more detail (instruction and wiring diagram), visit https://esp32io.com/tutorials/esp32-s3-websocket */ #include <DIYables_ESP32_WebServer.h> #include "index.h" // WiFi credentials const char WIFI_SSID[] = "YOUR_WIFI_SSID"; const char WIFI_PASSWORD[] = "YOUR_WIFI_PASSWORD"; // Create web server instance DIYables_ESP32_WebServer server; DIYables_ESP32_WebSocket* webSocket; // Web Page handlers void handleHome(WiFiClient& client, const String& method, const String& request, const QueryParams& params, const String& jsonData) { // HTML_CONTENT from the index.h file server.sendResponse(client, HTML_CONTENT); } // WebSocket event handlers void onWebSocketOpen(net::WebSocket& ws) { Serial.println("New WebSocket connection"); // Send welcome message const char welcome[] = "Connected to ESP32-S3 WebSocket Server!"; } void onWebSocketMessage(net::WebSocket& ws, const net::WebSocket::DataType dataType, const char* message, uint16_t length) { Serial.print("WebSocket Received ("); Serial.print(length); Serial.print(" bytes): "); Serial.println(message); // Broadcast response to all connected clients using the library if (webSocket != nullptr) { String response = "Received: " + String((char*)message); webSocket->broadcastTXT(response); Serial.print("WebSocket sent ("); Serial.print(response.length()); Serial.print(" bytes): "); Serial.println(response); } } void onWebSocketClose(net::WebSocket& ws, const net::WebSocket::CloseCode code, const char* reason, uint16_t length) { Serial.println("WebSocket client disconnected"); } void setup() { Serial.begin(9600); delay(1000); Serial.println("ESP32-S3 Web Server and WebSocket Server"); // Configure web server routes server.addRoute("/", handleHome); // Start web server with WiFi connection server.begin(WIFI_SSID, WIFI_PASSWORD); // Enable WebSocket functionality webSocket = server.enableWebSocket(81); if (webSocket != nullptr) { // Set up WebSocket event handlers webSocket->onOpen(onWebSocketOpen); webSocket->onMessage(onWebSocketMessage); webSocket->onClose(onWebSocketClose); } else { Serial.println("Failed to start WebSocket server"); } } void loop() { // Then handle HTTP requests server.handleClient(); // Handle WebSocket server.handleWebSocket(); }
  1. Modifiez les informations WiFi (SSID et mot de passe) dans le code pour correspondre aux identifiants de votre propre réseau.
  2. Créez le fichier index.h dans l'Arduino IDE en procédant ainsi :
    • Cliquez sur le bouton juste en dessous de l'icône du moniteur série et choisissez New Tab, ou utilisez les touches Ctrl+Shift+N.
    Arduino IDE 2 adds file
    • Donnez au fichier le nom index.h et cliquez sur le bouton OK.
    Arduino IDE 2 adds file index.h
    • Le code suivant définit la page web servie au navigateur, y compris l'interface de chat et le JavaScript qui gère la connexion WebSocket. Copiez-le et collez-le dans index.h.
    /* * Ce code ESP32 S3 a été développé par newbiely.fr * Ce code ESP32 S3 est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/tutorials/esp32-s3/esp32-s3-websocket */ const char *HTML_CONTENT = R"=====( <!DOCTYPE html> <!-- saved from url=(0019)http://192.168.0.2/ --> <html><head><meta http-equiv="Content-Type" content="text/html; charset=windows-1252"> <title>ESP32 WebSocket</title> <meta name="viewport" content="width=device-width, initial-scale=0.7"> <link rel="icon" href="https://diyables.io/images/page/diyables.svg"> <style> /* Add some basic styling for the chat window */ body { font-size: 16px; } .chat-container { width: 400px; margin: 0 auto; padding: 10px; } .chat-messages { height: 250px; overflow-y: auto; border: 1px solid #444; padding: 5px; margin-bottom: 5px; } .user-input { display: flex; margin-bottom: 20px; } .user-input input { flex: 1; border: 1px solid #444; padding: 5px; } .user-input button { margin-left: 5px; background-color: #007bff; color: #fff; border: none; padding: 5px 10px; cursor: pointer; } .websocket { display: flex; align-items: center; margin-bottom: 5px; } .websocket button { background-color: #007bff; color: #fff; border: none; padding: 5px 10px; cursor: pointer; } .websocket .label { margin-left: auto; } </style> <script> var ws; var wsm_max_len = 4096; /* bigger length causes uart0 buffer overflow with low speed smart device */ function update_text(text) { var chat_messages = document.getElementById("chat-messages"); chat_messages.innerHTML += text + '<br>'; chat_messages.scrollTop = chat_messages.scrollHeight; } function send_onclick() { if(ws != null) { var message = document.getElementById("message").value; if (message) { document.getElementById("message").value = ""; ws.send(message + "\n"); update_text('<span style="color:navy">' + message + '</span>'); // You can send the message to the server or process it as needed } } } function connect_onclick() { if(ws == null) { ws = new WebSocket("ws://" + window.location.host + ":81"); document.getElementById("ws_state").innerHTML = "CONNECTING"; ws.onopen = ws_onopen; ws.onclose = ws_onclose; ws.onmessage = ws_onmessage; } else ws.close(); } function ws_onopen() { document.getElementById("ws_state").innerHTML = "<span style='color:blue'>CONNECTED</span>"; document.getElementById("bt_connect").innerHTML = "Disconnect"; document.getElementById("chat-messages").innerHTML = ""; } function ws_onclose() { document.getElementById("ws_state").innerHTML = "<span style='color:gray'>CLOSED</span>"; document.getElementById("bt_connect").innerHTML = "Connect"; ws.onopen = null; ws.onclose = null; ws.onmessage = null; ws = null; } function ws_onmessage(e_msg) { e_msg = e_msg || window.event; // MessageEvent console.log(e_msg.data); update_text('<span style="color:blue">' + e_msg.data + '</span>'); } </script> </head> <body> <div class="chat-container"> <h2>ESP32 WebSocket</h2> <div class="websocket"> <button class="connect-button" id="bt_connect" onclick="connect_onclick()">Connect</button> <span class="label">WebSocket: <span id="ws_state"><span style="color:blue">CLOSED</span></span></span> </div> <div class="chat-messages" id="chat-messages"></div> <div class="user-input"> <input type="text" id="message" placeholder="Type your message..."> <button onclick="send_onclick()">Send</button> </div> <div class="sponsor">Sponsored by <a href="https://amazon.com/diyables">DIYables</a></div> </div> </body></html> )=====";
    1. Vous avez maintenant le code dans deux fichiers : newbiely.com.ino et index.h.
    2. Cliquez sur le bouton Upload dans l'Arduino IDE pour téléverser le code sur l'ESP32 S3.
    3. Ouvrez le Serial Monitor et vérifiez la sortie. Vous devriez voir des lectures similaires à ce qui suit (les horodatages sont donnés à titre indicatif) :
    ∞
    Newbiely | Arduino IDE 2.3.8
    ──
    ☐
    ✕
    File
    Edit
    Sketch
    Tools
    Help
    ESP32S3 Dev Module
    Newbiely.ino
    ···
    8 Serial.println("Hello World!");
    Output
    Serial Monitor
    Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
    New Line
    9600 baud
    [2026-01-15 09:12:03] Connecting to WiFi... [2026-01-15 09:12:05] Connected to WiFi [2026-01-15 09:12:05] ESP32 S3 Web Server's IP address: 192.168.0.2 [2026-01-15 09:12:11] WebSocket client connected
    Ln 11, Col 1
    ESP32S3 Dev Module on COM15
    2
    1. Notez l'adresse IP affichée, et saisissez cette adresse dans la barre d'adresse d'un navigateur web sur votre smartphone ou PC.
    2. Vous verrez la page web comme ci-dessous :
    ESP32 S3 websocket web browser
    1. Cliquez sur le bouton CONNECT pour connecter la page web à l'ESP32 S3 via WebSocket.
    2. Tapez quelques mots et envoyez-les à l'ESP32 S3.
    3. Vous verrez la réponse de l'ESP32 S3.
    ESP32 S3 websocket chat server
    1. Astuce : si vous modifiez uniquement le contenu HTML dans index.h sans toucher à newbiely.com.ino, l'Arduino IDE pourrait ne pas recompiler le HTML. Pour forcer une mise à jour, faites un changement trivial dans le fichier .ino (par exemple, ajoutez une ligne vide ou un commentaire) avant de téléverser.

    ※ Note:

    • Si vous modifiez le contenu HTML dans index.h et ne touchez à rien dans le fichier newbiely.com.ino, lorsque vous compilez et téléversez le code sur l'ESP32 S3, l'Arduino IDE ne mettra pas à jour le contenu HTML.
    • Pour que l'Arduino IDE mette à jour le contenu HTML dans ce cas, faites un changement dans le fichier newbiely.com.ino (par exemple, ajouter une ligne vide, ajouter un commentaire...)

    Explication du code ligne par ligne

    Le code ESP32 S3 ci-dessus contient une explication ligne par ligne. Veuillez lire les commentaires dans le code !

Comment le système fonctionne

Le code de l'ESP32 S3 fonctionne en créant à la fois un serveur web et un serveur WebSocket, permettant au navigateur et à la carte de maintenir un canal bidirectionnel en direct. Le processus se déroule comme suit :

  • Lorsque vous saisissez l'adresse IP de l'ESP32 S3 dans un navigateur web, une requête est faite pour obtenir la page web (interface utilisateur) depuis l'ESP32 S3.
  • Le serveur web de l'ESP32 S3 répond en transmettant le contenu de la page web (HTML, CSS, JavaScript).
  • Ensuite, votre navigateur web affiche la page web.
  • Lorsque vous cliquez sur le bouton CONNECT, le code JavaScript intégré dans la page web établit une connexion WebSocket vers le serveur WebSocket sur l'ESP32 S3.
  • Une fois la connexion WebSocket établie, lorsque vous tapez quelque chose et cliquez sur le bouton SEND, le code JavaScript envoie ce texte à l'ESP32 S3 via la connexion WebSocket en arrière-plan.
  • En recevant le message, le serveur WebSocket renvoie une réponse à la page web.

Applications concrètes

WebSocket est le fondement d'un large éventail de projets interactifs ESP32 S3 nécessitant une communication continue et à faible latence entre la carte et une interface basée sur navigateur.

  1. Contrôle de robot à distance : envoyez des commandes de mouvement à une voiture robot depuis le navigateur et recevez des retours de capteurs en direct sans aucun rechargement de page.
  2. Tableau de bord de capteurs en direct : transmettez en flux la température, l'humidité, ou les données de mouvement de l'ESP32 S3 vers un graphique de navigateur qui se met à jour en temps réel.
  3. Panneau de maison intelligente : contrôlez des lumières, ventilateurs, et relais depuis une seule page web avec un retour marche/arrêt instantané.
  4. Moniteur industriel : affichez l'état des machines, les alertes d'erreur, et les compteurs d'équipements d'usine connectés à l'ESP32 S3.
  5. Jeux IoT multijoueurs : coordonnez plusieurs appareils ESP32 S3 via un serveur WebSocket partagé pour des expériences interactives synchronisées.

Tutoriel vidéo

Regardez le tutoriel vidéo étape par étape pour ce projet ESP32 S3 ci-dessous.

Défis

Une fois que votre chat WebSocket de base fonctionne, essayez de le pousser plus loin avec ces défis d'extension. Chacun renforce un aspect différent de la communication web en temps réel avec l'ESP32 S3.

  1. Débutant : ajoutez un bouton sur la page web qui envoie une chaîne de commande fixe (par exemple, « LED_ON ») à l'ESP32 S3 et faites en sorte que la carte la renvoie en écho avec un message de confirmation.
  2. Intermédiaire : modifiez le sketch de l'ESP32 S3 pour diffuser une valeur de compteur à tous les clients WebSocket connectés toutes les secondes, et affichez-la comme un nombre en direct sur la page web.
  3. Avancé : mettez en œuvre une connexion WebSocket protégée par mot de passe - le navigateur doit envoyer un jeton secret comme premier message, et l'ESP32 S3 ferme la connexion si le jeton est incorrect.

Vous pouvez découvrir d'autres exemples de WebSocket sur l'ESP32 S3 ci-dessous :

※ NOS MESSAGES

  • N'hésitez pas à partager le lien de ce tutoriel. Cependant, veuillez ne pas utiliser notre contenu sur d'autres sites web. Nous avons investi beaucoup d'efforts et de temps pour créer ce contenu, veuillez respecter notre travail !