Référence de la bibliothèque ESP32 WebServer
Vue d'ensemble
La bibliothèque DIYables_ESP32_WebServer offre une solution complète pour créer des serveurs Web multi-pages avec la prise en charge des WebSockets sur les cartes ESP32.
Préparation du matériel
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Démarrage DIYables ESP32 (ESP32 inclus) | |
| 1 | × | Kit de Capteurs DIYables (30 capteurs/écrans) | |
| 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.
Exemples
Installation
Étapes rapides
Suivez ces instructions étape par étape :
- Si c'est votre première utilisation de l'ESP32, consultez le tutoriel sur la mise en place de l'environnement pour l'ESP32 dans l'IDE Arduino.
- Connectez la carte ESP32 à votre ordinateur à l'aide d'un câble USB.
- Lancez l'IDE Arduino sur votre ordinateur.
- Sélectionnez la carte ESP32 appropriée (par exemple, ESP32) et le port COM.
- Ouvrez le Gestionnaire de bibliothèques en cliquant sur l'icône Gestionnaire de bibliothèques sur le côté gauche de l'IDE Arduino.
- Recherchez Serveur Web pour ESP32 et localisez la bibliothèque mWebSockets par DIYables.
- Cliquez sur le bouton Install pour ajouter la bibliothèque mWebSockets.
Prise en charge de WebSocket (intégré)
La fonctionnalité WebSocket est désormais intégrée directement dans cette bibliothèque !
L’implémentation de WebSocket est basée sur l’excellente bibliothèque mWebSockets de Dawid Kurek, qui a été intégrée et optimisée spécifiquement pour l’ESP32 afin de la rendre facile à utiliser :
- Aucune installation de bibliothèque supplémentaire n'est requise - Le support WebSocket est intégré
- Optimisé pour l'ESP32 - Implémentation spécifique à la plateforme simplifiée
- Compatibilité Wi-Fi - Utilise la pile WiFi native de l'ESP32
- Conforme à la RFC 6455 - Support complet du protocole WebSocket
- Communication en temps réel - Échange bidirectionnel de données
Utilisation :
- Pour tout (serveur Web + WebSocket): Utilisez #include <DIYables_ESP32_WebServer.h>
- C'est tout ! - La fonctionnalité WebSocket est automatiquement disponible lorsque cela est nécessaire
- Économe en mémoire - Le code WebSocket inutilisé est automatiquement optimisé par le compilateur
Crédits : Implémentation WebSocket adaptée à partir de la bibliothèque mWebSockets (Licence LGPL-2.1) par Dawid Kurek, modifiée et intégrée pour une compatibilité transparente avec l'ESP32.
Classes de bibliothèque
DIYables_ESP32_WebServer Classe
La classe principale pour créer et gérer des serveurs web.
Constructeur
DIYables_ESP32_WebServer(int port = 80)
Crée une instance de serveur Web sur le port spécifié (par défaut : 80).
Méthodes
début()
void begin()
void begin(const char* ssid, const char* password)
Démarre le serveur Web et commence à écouter les connexions entrantes.
Versions surchargées:
- begin(): Démarrer le serveur uniquement (le WiFi doit être connecté séparément par votre application)
- begin(ssid, password): Se connecter au WiFi et démarrer le serveur en un seul appel (ancienne approche)
setNotFoundHandler()
void setNotFoundHandler(RouteHandler handler)
Configure un gestionnaire personnalisé pour les réponses 404 Non trouvé.
imprimerEtatWifi()
void printWifiStatus()
Imprime l'état de la connexion WiFi et l'adresse IP dans le Moniteur Série.
gérerClient()
void handleClient()
Traite les requêtes entrantes des clients. Cette fonction doit être appelée à plusieurs reprises dans la boucle principale.
on()
void on(const String &uri, HTTPMethod method, THandlerFunction fn)
void on(const String &uri, THandlerFunction fn) // defaults to GET
Enregistre une fonction de gestion de requête pour une URI et une méthode HTTP spécifiques.
Paramètres :
- uri: Le chemin URI (par exemple, "/", "/led", "/api/data")
- method: Méthode HTTP (GET, POST, PUT, DELETE, etc.)
- fn: Fonction gestionnaire à exécuter lorsque la route est accédée
Remarque : Cette bibliothèque utilise la méthode addRoute() au lieu de on(). Voir ci-dessous l'utilisation correcte.
ajouterRoute()
void addRoute(const String &uri, RouteHandler handler)
Enregistre une fonction de gestion pour une URI spécifique. Il s'agit de la méthode réelle utilisée dans la bibliothèque.
Format de la fonction RouteHandler:
Les gestionnaires de routes doivent suivre cette signature exacte :
void handlerFunction(WiFiClient& client, const String& method, const String& request,
const QueryParams& params, const String& jsonData)
Paramètres :
- client: référence WiFiClient pour l'envoi des réponses
- method: méthode HTTP sous forme de chaîne ("GET", "POST", etc.)
- request: URI de la requête complète
- params: paramètres de requête (objet QueryParams)
- jsonData: charge utile JSON pour les requêtes POST (vide pour GET)
Exemples d'implémentation de gestionnaires :
- Gestionnaire GET basique:
void handleHome(WiFiClient& client, const String& method, const String& request,
const QueryParams& params, const String& jsonData) {
if (method == "GET") {
String response = "<html><body><h1>Hello World</h1></body></html>";
server.sendResponse(client, response.c_str());
}
}
void setup() {
server.addRoute("/", handleHome);
}
- Gestionnaire d'API JSON (GET et POST) :
void handleApiData(WiFiClient& client, const String& method, const String& request,
const QueryParams& params, const String& jsonData) {
if (method == "POST") {
if (jsonData.length() == 0) {
client.println("HTTP/1.1 400 Bad Request");
client.println("Content-Type: application/json");
client.println("Connection: close");
client.println();
client.print("{\"status\":\"error\",\"message\":\"No JSON data received\"}");
return;
}
// Process JSON data
StaticJsonDocument<200> doc;
DeserializationError error = deserializeJson(doc, jsonData);
if (error) {
client.println("HTTP/1.1 400 Bad Request");
client.println("Content-Type: application/json");
client.println("Connection: close");
client.println();
client.print("{\"status\":\"error\",\"message\":\"Invalid JSON\"}");
return;
}
const char* key = doc["key"] | "none";
String response = "{\"status\":\"success\",\"received_key\":\"" + String(key) + "\"}";
server.sendResponse(client, response.c_str(), "application/json");
} else if (method == "GET") {
String response = "{\"status\":\"success\",\"message\":\"GET request received\"}";
server.sendResponse(client, response.c_str(), "application/json");
} else {
client.println("HTTP/1.1 405 Method Not Allowed");
client.println("Content-Type: application/json");
client.println("Connection: close");
client.println();
client.print("{\"status\":\"error\",\"message\":\"Method not allowed\"}");
}
}
void setup() {
server.addRoute("/api/data", handleApiData);
}
- Gestionnaire des paramètres de requête:
void handleLedControl(WiFiClient& client, const String& method, const String& request,
const QueryParams& params, const String& jsonData) {
if (method == "GET") {
// Access query parameters
String action = params.getValue("action"); // ?action=on
if (action == "on") {
digitalWrite(LED_PIN, HIGH);
server.sendResponse(client, "LED turned ON");
} else if (action == "off") {
digitalWrite(LED_PIN, LOW);
server.sendResponse(client, "LED turned OFF");
} else {
client.println("HTTP/1.1 400 Bad Request");
client.println("Content-Type: text/plain");
client.println("Connection: close");
client.println();
client.print("Invalid action. Use ?action=on or ?action=off");
}
}
}
void setup() {
server.addRoute("/led", handleLedControl);
}
envoyerRéponse()
void sendResponse(WiFiClient& client, const char* content, const char* contentType = "text/html")
Envoie une réponse HTTP au client.
Paramètres :
- client: référence WiFiClient (fournie dans la fonction gestionnaire)
- content: contenu du corps de la réponse
- contentType: type MIME de la réponse (par défaut : "text/html")
Exemples d'utilisation :
// Send HTML response
server.sendResponse(client, "<h1>Hello World</h1>");
// Send JSON response
server.sendResponse(client, "{\"status\":\"ok\"}", "application/json");
// Send plain text
server.sendResponse(client, "Success", "text/plain");
Méthodes d'authentification
activer l'authentification()
void enableAuthentication(const char* username, const char* password, const char* realm = "ESP32 Server")
Active l'authentification HTTP Basic sur toutes les routes. Une fois activée, toutes les routes exigent une authentification.
Paramètres:
- username: Nom d'utilisateur pour l'authentification (31 caractères maximum)
- password: Mot de passe pour l'authentification (31 caractères maximum)
- realm: Domaine d'authentification affiché dans le navigateur (63 caractères maximum, optionnel)
Exemple d'utilisation:
// Enable authentication with default realm
server.enableAuthentication("admin", "password123");
// Enable authentication with custom realm
server.enableAuthentication("admin", "secure456", "My ESP32 Device");
désactiver l'authentification()
void disableAuthentication()
Désactive l'authentification, ce qui rend toutes les routes à nouveau accessibles au public.
Exemple d'utilisation :
server.disableAuthentication();
estAuthentificationActive()
bool isAuthenticationEnabled()
Renvoie vrai si l'authentification est actuellement activée, faux sinon.
Exemple d'utilisation :
if (server.isAuthenticationEnabled()) {
Serial.println("Authentication is active");
} else {
Serial.println("All routes are public");
}
envoyer401()
void send401(WiFiClient& client)
Renvoie une réponse 401 non autorisée avec l'en-tête WWW-Authenticate approprié. Cette fonction est appelée automatiquement lorsque l’authentification échoue, mais peut être utilisée manuellement dans des gestionnaires personnalisés.
Exemple d'utilisation :
// Manual 401 response in a custom handler
server.send401(client);
Envoi manuel de la réponse
Pour un meilleur contrôle des en-têtes HTTP et des codes d'état :
void sendCustomResponse(WiFiClient& client) {
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: application/json");
client.println("Access-Control-Allow-Origin: *");
client.println("Connection: close");
client.println();
client.print("{\"custom\":\"response\"}");
}
Accès aux paramètres de requête
Structure des paramètres de requête
L'objet QueryParams contient les paramètres de requête analysés à partir de l'URL :
struct QueryParams {
int count; // Number of parameters
struct {
const char* key; // Parameter name
const char* value; // Parameter value
} params[MAX_PARAMS];
}
Accéder aux paramètres de requête
void handleWithParams(WiFiClient& client, const String& method, const String& request,
const QueryParams& params, const String& jsonData) {
// Access specific parameter by looping through
String unit = "C"; // default value
for (int i = 0; i < params.count; i++) {
if (String(params.params[i].key) == "unit") {
unit = params.params[i].value;
break;
}
}
// Use the parameter
String response = "Unit selected: " + unit;
server.sendResponse(client, response.c_str());
}
// URL examples:
// /temperature?unit=F
// /led?state=on&brightness=50
Fonctions d'aide pour les paramètres
Créer des fonctions d'aide pour un accès plus facile aux paramètres:
String getParam(const QueryParams& params, const String& key, const String& defaultValue = "") {
for (int i = 0; i < params.count; i++) {
if (String(params.params[i].key) == key) {
return String(params.params[i].value);
}
}
return defaultValue;
}
bool hasParam(const QueryParams& params, const String& key) {
for (int i = 0; i < params.count; i++) {
if (String(params.params[i].key) == key) {
return true;
}
}
return false;
}
// Usage in handlers:
void handleLed(WiFiClient& client, const String& method, const String& request,
const QueryParams& params, const String& jsonData) {
String state = getParam(params, "state", "off");
int brightness = getParam(params, "brightness", "100").toInt();
if (state == "on") {
digitalWrite(LED_PIN, HIGH);
server.sendResponse(client, "LED turned ON with brightness " + String(brightness));
} else {
digitalWrite(LED_PIN, LOW);
server.sendResponse(client, "LED turned OFF");
}
}
Classes WebSocket (intégrées)
Serveur WebSocket
WebSocketServer wsServer(81); // Port 81 for WebSocket
Alias de net::WebSocketServer - simplifié pour les débutants.
WebSocket
WebSocket ws;
Alias pour net::WebSocket - représente une connexion WebSocket.
Méthodes WebSocket
commencer()
void begin()
Démarre le serveur WebSocket.
boucle()
void loop()
Traite les événements WebSocket. Appelez ceci dans votre boucle principale.
surConnexion()
void onConnection([](WebSocket &ws) {
// Handle new WebSocket connection
});
Définit une fonction de rappel pour les nouvelles connexions WebSocket.
onMessage()
void onMessage([](WebSocket &ws, const WebSocket::DataType dataType, const char *message, uint16_t length) {
// Handle incoming WebSocket message
});
Définit la fonction de rappel pour les messages WebSocket entrants.
à la fermeture()
void onClose([](WebSocket &ws, const WebSocket::CloseCode code, const char *reason, uint16_t length) {
// Handle WebSocket connection close
});
Définit la fonction de rappel pour les fermetures des connexions WebSocket.
envoyer()
void send(const String &message)
void send(const char *message, size_t length)
Envoie un message via le WebSocket.
fermer()
void close()
Ferme la connexion WebSocket.
Méthodes WebSocket supplémentaires
broadcastTXT()
void broadcastTXT(const char* payload)
void broadcastTXT(const String& payload)
Diffuse un message texte à tous les clients WebSocket connectés.
diffuserBIN()
void broadcastBIN(const uint8_t* payload, size_t length)
Diffuse des données binaires à tous les clients WebSocket connectés.
clientsConnectés()
size_t connectedClients()
Renvoie le nombre de clients WebSocket actuellement connectés.
estEnEcoute()
bool isListening()
Renvoie vrai si le serveur WebSocket écoute activement les connexions.
Types d'événements WebSocket
Énumération des types de données
- WebSocket::DataType::TEXT - type de message texte
- WebSocket::DataType::BINARY - type de données binaires
Énumération CloseCode
Codes de fermeture WebSocket standards pour les raisons de terminaison de la connexion.
Utilisation avancée de WebSocket
Mise en place du gestionnaire d'événements
void setup() {
Serial.begin(9600);
// Initialize WiFi and servers
WiFi.begin(ssid, password);
server.begin();
wsServer.begin();
// Set up WebSocket event handlers
wsServer.onConnection([](WebSocket &ws) {
Serial.print("Client connected from: ");
Serial.println(ws.getRemoteIP());
ws.send("{\"type\":\"welcome\",\"message\":\"Connected to ESP32\"}");
});
wsServer.onMessage([](WebSocket &ws, const WebSocket::DataType dataType,
const char *message, uint16_t length) {
handleWebSocketMessage(ws, message, length);
});
wsServer.onClose([](WebSocket &ws, const WebSocket::CloseCode code,
const char *reason, uint16_t length) {
Serial.println("Client disconnected");
});
}
Traitement des messages
void handleWebSocketMessage(WebSocket &ws, const char *message, uint16_t length) {
String msg = String(message);
Serial.println("Received: " + msg);
// JSON message handling
if (msg.indexOf("\"type\":\"led\"") >= 0) {
if (msg.indexOf("\"action\":\"on\"") >= 0) {
digitalWrite(LED_PIN, HIGH);
ws.send("{\"type\":\"led_status\",\"status\":\"on\"}");
} else if (msg.indexOf("\"action\":\"off\"") >= 0) {
digitalWrite(LED_PIN, LOW);
ws.send("{\"type\":\"led_status\",\"status\":\"off\"}");
}
}
// Echo functionality
String response = "Echo: " + msg;
ws.send(response.c_str());
}
Diffusion des données des capteurs
void loop() {
server.handleClient();
wsServer.loop();
// Broadcast sensor data every 5 seconds
static unsigned long lastBroadcast = 0;
if (millis() - lastBroadcast > 5000) {
if (wsServer.connectedClients() > 0) {
float temperature = getTemperature();
String sensorData = "{";
sensorData += "\"type\":\"sensor\",";
sensorData += "\"temperature\":" + String(temperature, 1) + ",";
sensorData += "\"timestamp\":" + String(millis());
sensorData += "}";
wsServer.broadcastTXT(sensorData);
}
lastBroadcast = millis();
}
}
Méthodes HTTP
La bibliothèque prend en charge les méthodes HTTP standard :
- HTTP_GET
- HTTP_POST
- HTTP_PUT
- HTTP_DELETE
- HTTP_PATCH
- HTTP_HEAD
- HTTP_OPTIONS
Intégration JavaScript côté client
Connexion WebSocket basique
// Connect to ESP32 WebSocket server
const ws = new WebSocket('ws://your-esp32-ip:81');
ws.onopen = function(event) {
console.log('Connected to ESP32 WebSocket');
document.getElementById('status').textContent = 'Connected';
};
ws.onmessage = function(event) {
console.log('Received:', event.data);
try {
const data = JSON.parse(event.data);
handleEsp32Message(data);
} catch (e) {
// Handle plain text messages
console.log('Text message:', event.data);
}
};
ws.onclose = function(event) {
console.log('Disconnected from ESP32');
document.getElementById('status').textContent = 'Disconnected';
// Auto-reconnect after 3 seconds
setTimeout(connectWebSocket, 3000);
};
ws.onerror = function(error) {
console.error('WebSocket error:', error);
};
Envoi de commandes
// Send LED control command
function controlLED(action) {
if (ws.readyState === WebSocket.OPEN) {
const command = {
type: 'led',
action: action,
timestamp: Date.now()
};
ws.send(JSON.stringify(command));
}
}
// Send sensor request
function requestSensorData() {
if (ws.readyState === WebSocket.OPEN) {
ws.send(JSON.stringify({type: 'get_sensor'}));
}
}
Gestion des messages
function handleEsp32Message(data) {
switch(data.type) {
case 'sensor':
updateTemperatureDisplay(data.temperature);
break;
case 'led_status':
updateLEDStatus(data.status);
break;
case 'welcome':
console.log('Welcome message:', data.message);
break;
default:
console.log('Unknown message type:', data);
}
}
Exemples de WebSocket
Serveur d'écho simple
wsServer.onMessage([](WebSocket &ws, const WebSocket::DataType dataType,
const char *message, uint16_t length) {
String response = "Echo: " + String(message);
ws.send(response.c_str());
});
Traitement des commandes JSON
void processWebSocketCommand(WebSocket &ws, const String& message) {
if (message.indexOf("\"type\":\"led\"") >= 0) {
if (message.indexOf("\"action\":\"on\"") >= 0) {
digitalWrite(LED_PIN, HIGH);
ws.send("{\"type\":\"led_status\",\"status\":\"on\",\"success\":true}");
} else if (message.indexOf("\"action\":\"off\"") >= 0) {
digitalWrite(LED_PIN, LOW);
ws.send("{\"type\":\"led_status\",\"status\":\"off\",\"success\":true}");
}
} else if (message.indexOf("\"type\":\"get_sensor\"") >= 0) {
float temp = getTemperature();
String response = "{\"type\":\"sensor\",\"temperature\":" + String(temp, 1) + "}";
ws.send(response.c_str());
}
}
Implémentation du battement de cœur
void setupHeartbeat() {
static unsigned long lastHeartbeat = 0;
if (millis() - lastHeartbeat > 30000) { // Every 30 seconds
if (wsServer.connectedClients() > 0) {
String heartbeat = "{\"type\":\"heartbeat\",\"timestamp\":" + String(millis()) + "}";
wsServer.broadcastTXT(heartbeat);
}
lastHeartbeat = millis();
}
}
Dépannage des WebSockets
Problèmes courants
Échec de la connexion WebSocket
- Vérifier que le port du serveur WebSocket (par défaut : 81) est accessible
- S'assurer que l'adresse IP de l'ESP32 est correcte et joignable
- Utiliser les outils de développement du navigateur pour vérifier les erreurs de connexion WebSocket
Messages non reçus
- Vérifiez le moniteur série pour les journaux d’événements WebSocket
- Vérifiez que le format des messages JSON est correct
- Testez avec des messages texte simples avant d'utiliser JSON
- Assurez-vous que la longueur du message ne dépasse pas les limites du tampon
Utilisation élevée de la mémoire
- Limiter le nombre de connexions WebSocket simultanées
- Vider régulièrement les tampons de messages
- Utiliser une gestion efficace des chaînes (éviter les concaténations fréquentes)
- Surveiller la mémoire libre du tas
Aides au débogage
void debugWebSocket() {
Serial.println("=== WebSocket Debug Info ===");
Serial.println("Connected clients: " + String(wsServer.connectedClients()));
Serial.println("Server listening: " + String(wsServer.isListening() ? "Yes" : "No"));
Serial.println("Free memory: " + String(ESP.getFreeHeap()) + " bytes");
Serial.println("Uptime: " + String(millis() / 1000) + " seconds");
Serial.println("============================");
}
Surveillance des performances
void monitorPerformance() {
static unsigned long lastCheck = 0;
static int messageCount = 0;
messageCount++;
if (millis() - lastCheck > 10000) { // Every 10 seconds
Serial.println("Messages/10s: " + String(messageCount));
Serial.println("Clients: " + String(wsServer.connectedClients()));
messageCount = 0;
lastCheck = millis();
}
}
La bibliothèque prend en charge les modèles HTML avec remplacement des espaces réservés :
String response = HTML_TEMPLATE;
response.replace("%TEMPERATURE%", String(temperature));
response.replace("%LED_STATUS%", ledStatus ? "ON" : "OFF");
server.send(200, "text/html", response);
Espaces réservés courants :
- %TEMPERATURE% - Valeur de la température
- %LED_STATUS% - État de la LED
- %QUERY_PARAM% - Valeurs du paramètre de requête
Fonctionnalités avancées du serveur Web
Prise en charge de CORS
Activer les requêtes entre origines croisées pour les applications web:
// Handle preflight OPTIONS requests
server.on("/api/data", HTTP_OPTIONS, []() {
server.sendHeader("Access-Control-Allow-Origin", "*");
server.sendHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
server.sendHeader("Access-Control-Allow-Headers", "Content-Type");
server.send(200);
});
// Add CORS headers to all responses
server.sendHeader("Access-Control-Allow-Origin", "*");
server.sendHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE");
server.sendHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
Aides pour les réponses JSON
Simplifier le développement d'API JSON:
void sendJsonResponse(int statusCode, const String& json) {
server.send(statusCode, "application/json", json);
}
void sendError(int statusCode, const String& message) {
String error = "{\"error\":\"" + message + "\"}";
sendJsonResponse(statusCode, error);
}
// Usage
sendJsonResponse(200, "{\"status\":\"success\",\"data\":\"value\"}");
sendError(400, "Invalid request format");
Validation de la requête
Mettre en place une validation d’entrée robuste :
bool isValidJsonAction(const String& action) {
return (action == "on" || action == "off" || action == "toggle");
}
bool validateRequiredFields(const String& jsonData, const String& field) {
return (jsonData.indexOf("\"" + field + "\":") >= 0);
}
server.on("/api/control", HTTP_POST, []() {
if (!server.hasArg("plain")) {
sendError(400, "JSON body required");
return;
}
String body = server.arg("plain");
if (!validateRequiredFields(body, "action")) {
sendError(400, "Missing required field: action");
return;
}
// Process valid request...
});
Traitement JSON amélioré
Pour la gestion complexe du JSON avec la bibliothèque ArduinoJson :
#include <ArduinoJson.h>
void handleJsonRequest() {
String requestBody = server.arg("plain");
StaticJsonDocument<200> doc;
DeserializationError error = deserializeJson(doc, requestBody);
if (error) {
sendError(400, "Invalid JSON format");
return;
}
// Extract values safely
const char* action = doc["action"] | "none";
int value = doc["value"] | 0;
bool enabled = doc["enabled"] | false;
// Create response
StaticJsonDocument<200> response;
response["status"] = "success";
response["received_action"] = action;
response["received_value"] = value;
String responseString;
serializeJson(response, responseString);
sendJsonResponse(200, responseString);
}
Gestion des erreurs
Gestionnaire d'erreurs 404 par défaut
La bibliothèque fournit une page d'erreur 404 par défaut. Vous pouvez la remplacer :
server.onNotFound([]() {
server.send(404, "text/html", "<h1>Custom 404 Page</h1>");
});
Bonnes pratiques
- Gestion de la mémoire: Utilisez la macro F() pour les littéraux de chaîne stockés dans la mémoire flash
- Code non bloquant: Gardez les fonctions gestionnaires légères pour éviter de bloquer le serveur
- Sécurité: Validez les paramètres d'entrée et assainissez les sorties
- Performance: Utilisez des codes d'état HTTP appropriés et des types de contenu
- WebSocket: Gérez correctement les états de connexion et mettez en œuvre une logique de reconnexion
Débogage
Activer le débogage série pour surveiller l'activité du serveur :
void setup() {
Serial.begin(9600);
// ... rest of setup
}
void loop() {
server.handleClient();
if (Serial.available()) {
String command = Serial.readString();
Serial.println("Debug: " + command);
}
}
Compatibilité
- ESP32: Entièrement pris en charge
- Bibliothèque WiFi: Requise (incluse avec l'IDE Arduino)
- Exigences de mémoire: 32 Ko de flash minimum, 2 Ko de RAM
Limites
Limitations du serveur Web
- Connexions HTTP simultanées maximales : 4 (limitation matérielle)
- Longueur maximale de l'URL : 256 caractères
- Emplacements du modèle : aucun remplacement imbriqué
Limitations des WebSockets
- Taille maximale des messages WebSocket : 1 Ko par message
- Nombre maximal de connexions WebSocket simultanées : 4 à 6 (selon la mémoire disponible)
- Fragmentation des messages : gérée automatiquement mais peut avoir un impact sur les performances
- Taille des messages binaires : limitée par la RAM disponible
- Délai d'expiration de la connexion : 60 secondes par défaut (configurable)
Contraintes de mémoire
- Mémoire flash minimale requise : 32 Ko
- Mémoire RAM minimale requise : 2 Ko pour le fonctionnement de base
- Surcharge WebSocket : ~200-500 octets par connexion
- Mise en tampon des messages : ~1 Ko par connexion active