ESP32 WebServer Bibliotheek Referentie
Overzicht
De DIYables_ESP32_WebServer bibliotheek biedt een complete oplossing voor het maken van multi-pagina webservers met WebSocket-ondersteuning op ESP32 boards.
Benodigde hardware
Of u kunt de volgende kits kopen:
| 1 | × | DIYables Sensorkit (30 sensoren/displays) | |
| 1 | × | DIYables Sensorkit (18 sensoren/displays) |
Openbaarmaking: Sommige van de links in deze sectie zijn Amazon-affiliate links. We kunnen een commissie ontvangen voor aankopen die via deze links worden gedaan, zonder extra kosten voor u. We waarderen uw steun.
Voorbeelden
Installatie
Snelle stappen
Volg deze instructies stap voor stap:
- Is dit de eerste keer dat u met ESP32 werkt? Raadpleeg dan de handleiding over het opzetten van de omgeving voor ESP32 in de Arduino IDE.
- Verbind de ESP32-board met uw computer via een USB-kabel.
- Start de Arduino IDE op uw computer.
- Selecteer het juiste ESP32 board (bijv. ESP32) en de bijbehorende COM-poort.
- Open de Bibliotheekbeheerder door te klikken op het Bibliotheekbeheerder-icoon aan de linkerzijde van de Arduino IDE.
- Zoek naar Web Server for ESP32 en vind de mWebSockets van DIYables.
- Klik op de Installeren-knop om de mWebSockets bibliotheek toe te voegen.
WebSocket Ondersteuning (Ingebouwd)
WebSocket-functionaliteit is nu direct geïntegreerd in deze bibliotheek!
De WebSocket-implementatie is gebaseerd op de uitstekende mWebSockets bibliotheek van Dawid Kurek, die speciaal is aangepast en geoptimaliseerd voor ESP32 om het gebruiksgemak te vergroten:
- Geen extra bibliotheekinstallatie nodig - WebSocket-support is ingebouwd
- Geoptimaliseerd voor ESP32 - Eenvoudige, platform-specifieke implementatie
- WiFi-compatibiliteit - Maakt gebruik van de native WiFi-stack van ESP32
- RFC 6455 compliant - Volledige ondersteuning van het WebSocket-protocol
- Realtime communicatie - Bidirectionele data-uitwisseling
Gebruik:
- Voor alles (Web Server + WebSocket): Gebruik #include <DIYables_ESP32_WebServer.h>
- Dat is alles! - WebSocket-functionaliteit is automatisch beschikbaar wanneer nodig
- Geheugenefficiënt - Ongebruikte WebSocket code wordt automatisch door de compiler geoptimaliseerd verwijderd
Credits: WebSocket-implementatie is aangepast van de mWebSockets bibliotheek (LGPL-2.1 Licentie) door Dawid Kurek, gemodificeerd en geïntegreerd voor naadloze ESP32-compatibiliteit.
Bibliotheek Klassen
DIYables_ESP32_WebServer Klasse
De hoofdklasse voor het creëren en beheren van webservers.
Constructor
DIYables_ESP32_WebServer(int port = 80)
Maakt een instantie van de webserver aan op de opgegeven poort (standaard: 80).
Methoden
begin()
void begin()
void begin(const char* ssid, const char* password)
Start de webserver en begint inkomende verbindingen te accepteren.
Alternatieve versies:
- begin(): Start alleen de server (WiFi dient door uw applicatie apart verbonden te zijn)
- begin(ssid, password): Verbind met WiFi en start server in één commando (verouderde methode)
setNotFoundHandler()
void setNotFoundHandler(RouteHandler handler)
Stelt een eigen handler in voor 404 Not Found antwoorden.
printWifiStatus()
void printWifiStatus()
Print de WiFi verbindingsstatus en het IP-adres naar de Serial Monitor.
handleClient()
void handleClient()
Verwerkt binnenkomende client verzoeken. Dit dient herhaaldelijk aangeroepen te worden in de main loop.
on()
void on(const String &uri, HTTPMethod method, THandlerFunction fn)
void on(const String &uri, THandlerFunction fn) // standaard GET
Registreert een handler-functie voor een specifieke URI en HTTP-methode.
Parameters:
- uri: Het URI-pad (bijv. "/", "/led", "/api/data")
- method: HTTP-methode (GET, POST, PUT, DELETE, etc.)
- fn: Handler-functie die wordt uitgevoerd wanneer de route wordt benaderd
Opmerking: Deze bibliotheek gebruikt in plaats van on() de addRoute()-methode. Zie hieronder voor hoe dit correct gebruikt wordt.
addRoute()
void addRoute(const String &uri, RouteHandler handler)
Registreert een handler-functie voor een specifieke URI. Dit is de daadwerkelijke methode die in de bibliotheek wordt gebruikt.
RouteHandler Functie Formaat:
Route handlers moeten deze exacte handtekening aanhouden:
void handlerFunction(WiFiClient& client, const String& method, const String& request,
const QueryParams& params, const String& jsonData)
Parameters:
- client: Referentie naar WiFiClient voor het verzenden van antwoorden
- method: HTTP-methode als string ("GET", "POST", etc.)
- request: Volledige request URI
- params: Query parameters (QueryParams object)
- jsonData: JSON payload voor POST-requests (leeg voor GET)
Voorbeelden handler implementaties:
- Basale GET handler:
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);
}
- JSON API handler (GET en 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;
}
// Verwerk 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);
}
- Query Parameters handler:
void handleLedControl(WiFiClient& client, const String& method, const String& request,
const QueryParams& params, const String& jsonData) {
if (method == "GET") {
// Toegang tot 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);
}
sendResponse()
void sendResponse(WiFiClient& client, const char* content, const char* contentType = "text/html")
Verstuurt een HTTP-antwoord naar de client.
Parameters:
- client: WiFiClient referentie (geleverd in handler functie)
- content: Inhoud van het antwoord
- contentType: MIME-type van het antwoord (standaard: "text/html")
Gebruik Voorbeelden:
// HTML antwoord versturen
server.sendResponse(client, "<h1>Hello World</h1>");
// JSON antwoord versturen
server.sendResponse(client, "{\"status\":\"ok\"}", "application/json");
// Platte tekst versturen
server.sendResponse(client, "Success", "text/plain");
Authenticatiemethoden
enableAuthentication()
void enableAuthentication(const char* username, const char* password, const char* realm = "ESP32 Server")
Schakelt HTTP Basic Authenticatie in voor alle routes. Na inschakeling vereisen alle routes authenticatie.
Parameters:
- username: Gebruikersnaam voor authenticatie (max 31 tekens)
- password: Wachtwoord voor authenticatie (max 31 tekens)
- realm: Authenticatierealm die in de browser wordt getoond (max 63 tekens, optioneel)
Voorbeeld gebruik:
// Authenticatie inschakelen met standaard realm
server.enableAuthentication("admin", "password123");
// Authenticatie inschakelen met eigen realm
server.enableAuthentication("admin", "secure456", "My ESP32 Device");
disableAuthentication()
void disableAuthentication()
Schakelt authenticatie uit, waardoor alle routes weer openbaar toegankelijk zijn.
Voorbeeld gebruik:
server.disableAuthentication();
isAuthenticationEnabled()
bool isAuthenticationEnabled()
Geeft true terug als authenticatie momenteel is ingeschakeld, anders false.
Voorbeeld gebruik:
if (server.isAuthenticationEnabled()) {
Serial.println("Authentication is active");
} else {
Serial.println("All routes are public");
}
send401()
void send401(WiFiClient& client)
Verstuurt een 401 Unauthorized antwoord met correcte WWW-Authenticate header. Wordt automatisch aangeroepen bij mislukte authenticatie, maar kan ook handmatig gebruikt worden in eigen handlers.
Voorbeeld gebruik:
// Handmatige 401 response in een custom handler
server.send401(client);
Handmatig Antwoord Versturen
Voor meer controle over HTTP-headers en statuscodes:
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\"}");
}
Query Parameters Toegang
QueryParams Structuur
Het QueryParams object bevat geparseerde query parameters uit de URL:
struct QueryParams {
int count; // Aantal parameters
struct {
const char* key; // Parameternaam
const char* value; // Parametewaarde
} params[MAX_PARAMS];
}
Query Parameters Benaderen
void handleWithParams(WiFiClient& client, const String& method, const String& request,
const QueryParams& params, const String& jsonData) {
// Specifieke parameter benaderen door te loopen
String unit = "C"; // standaardwaarde
for (int i = 0; i < params.count; i++) {
if (String(params.params[i].key) == "unit") {
unit = params.params[i].value;
break;
}
}
// Gebruik de parameter
String response = "Unit selected: " + unit;
server.sendResponse(client, response.c_str());
}
// URL voorbeelden:
// /temperature?unit=F
// /led?state=on&brightness=50
Helper Functies Voor Parameters
Creëer helper-functies voor eenvoudiger parameters ophalen:
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;
}
// Gebruik 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");
}
}
WebSocket Klassen (Ingebouwd)
WebSocketServer
WebSocketServer wsServer(81); // Poort 81 voor WebSocket
Alias voor net::WebSocketServer — vereenvoudigd voor beginners.
WebSocket
WebSocket ws;
Alias voor net::WebSocket — vertegenwoordigt een WebSocket verbinding.
WebSocket Methoden
begin()
void begin()
Start de WebSocket server.
loop()
void loop()
Verwerkt WebSocket-events. Roep dit aan in uw hoofdprogramma (loop).
onConnection()
void onConnection([](WebSocket &ws) {
// Behandel nieuwe WebSocket verbinding
});
Stelt callback in voor nieuwe WebSocket verbindingen.
onMessage()
void onMessage([](WebSocket &ws, const WebSocket::DataType dataType, const char *message, uint16_t length) {
// Behandel inkomende WebSocket berichten
});
Stelt callback in voor binnenkomende WebSocket berichten.
onClose()
void onClose([](WebSocket &ws, const WebSocket::CloseCode code, const char *reason, uint16_t length) {
// Behandel het sluiten van WebSocket verbindingen
});
Stelt callback in voor het sluiten van WebSocket verbindingen.
send()
void send(const String &message)
void send(const char *message, size_t length)
Verstuurt een bericht via de WebSocket.
close()
void close()
Sluit de WebSocket verbinding.
Extra WebSocket Methodes
broadcastTXT()
void broadcastTXT(const char* payload)
void broadcastTXT(const String& payload)
Zend een tekstbericht naar alle verbonden WebSocket-clients.
broadcastBIN()
void broadcastBIN(const uint8_t* payload, size_t length)
Zend binaire data naar alle verbonden WebSocket-clients.
connectedClients()
size_t connectedClients()
Geeft het aantal momenteel verbonden WebSocket-clients terug.
isListening()
bool isListening()
Geeft true terug als de WebSocket-server actief verbindingen accepteert.
WebSocket Event Types
##### DataType Enum
- WebSocket::DataType::TEXT - Type tekstbericht
- WebSocket::DataType::BINARY - Type binaire data
##### CloseCode Enum
Standaard WebSocket afsluitcodes voor verbindingsbeëindigingsredenen.
Geavanceerd WebSocket Gebruik
Event Handler Setup
void setup() {
Serial.begin(9600);
// Initialiseer WiFi en servers
WiFi.begin(ssid, password);
server.begin();
wsServer.begin();
// Zet WebSocket event handlers op
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");
});
}
Berichten Verwerken
void handleWebSocketMessage(WebSocket &ws, const char *message, uint16_t length) {
String msg = String(message);
Serial.println("Received: " + msg);
// JSON bericht afhandeling
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 functie
String response = "Echo: " + msg;
ws.send(response.c_str());
}
Sensor Data Uitzenden
void loop() {
server.handleClient();
wsServer.loop();
// Zend sensor data om de 5 seconden uit
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();
}
}
HTTP Methoden
De bibliotheek ondersteunt de standaard HTTP-methoden:
- HTTP_GET
- HTTP_POST
- HTTP_PUT
- HTTP_DELETE
- HTTP_PATCH
- HTTP_HEAD
- HTTP_OPTIONS
Client-Side JavaScript Integratie
Basis WebSocket Verbinding
// Verbind met 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) {
// Afhandeling platte tekst berichten
console.log('Text message:', event.data);
}
};
ws.onclose = function(event) {
console.log('Disconnected from ESP32');
document.getElementById('status').textContent = 'Disconnected';
// Automatisch opnieuw verbinden na 3 seconden
setTimeout(connectWebSocket, 3000);
};
ws.onerror = function(error) {
console.error('WebSocket error:', error);
};
Commando’s Verzenden
// Verstuur LED bedieningscommando
function controlLED(action) {
if (ws.readyState === WebSocket.OPEN) {
const command = {
type: 'led',
action: action,
timestamp: Date.now()
};
ws.send(JSON.stringify(command));
}
}
// Vraag sensor data op
function requestSensorData() {
if (ws.readyState === WebSocket.OPEN) {
ws.send(JSON.stringify({type: 'get_sensor'}));
}
}
Berichtafhandeling
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);
}
}
WebSocket Voorbeelden
Eenvoudige Echo Server
wsServer.onMessage([](WebSocket &ws, const WebSocket::DataType dataType,
const char *message, uint16_t length) {
String response = "Echo: " + String(message);
ws.send(response.c_str());
});
JSON Commando Verwerking
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());
}
}
Heartbeat Implementatie
void setupHeartbeat() {
static unsigned long lastHeartbeat = 0;
if (millis() - lastHeartbeat > 30000) { // Elke 30 seconden
if (wsServer.connectedClients() > 0) {
String heartbeat = "{\"type\":\"heartbeat\",\"timestamp\":" + String(millis()) + "}";
wsServer.broadcastTXT(heartbeat);
}
lastHeartbeat = millis();
}
}
WebSocket Probleemoplossing
Veelvoorkomende Problemen
WebSocket Verbinding Mislukt
- Controleer of de poort van de WebSocket server (standaard 81) bereikbaar is
- Controleer of het ESP32 IP-adres correct en bereikbaar is
- Gebruik browser developer tools om WebSocket verbindingsfouten te analyseren
Berichten Worden Niet Ontvangen
- Controleer de Serial Monitor voor WebSocket event logs
- Controleer of het JSON-bericht formaat klopt
- Test eerst met eenvoudige tekstberichten voordat u JSON gebruikt
- Zorg dat berichtlengtes niet de bufferlimieten overschrijden
Hoge Geheugenbelasting
- Beperk het aantal gelijktijdige WebSocket connecties
- Ruim message buffers regelmatig op
- Gebruik efficiënte String verwerking (vermijd veel concatenatie)
- Monitor beschikbare vrije heap geheugen
Debug Helpers
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("============================");
}
Performance Monitoring
void monitorPerformance() {
static unsigned long lastCheck = 0;
static int messageCount = 0;
messageCount++;
if (millis() - lastCheck > 10000) { // Elke 10 seconden
Serial.println("Messages/10s: " + String(messageCount));
Serial.println("Clients: " + String(wsServer.connectedClients()));
messageCount = 0;
lastCheck = millis();
}
}
De bibliotheek ondersteunt HTML-templates met placeholder vervanging:
String response = HTML_TEMPLATE;
response.replace("%TEMPERATURE%", String(temperature));
response.replace("%LED_STATUS%", ledStatus ? "ON" : "OFF");
server.send(200, "text/html", response);
Veelvoorkomende placeholders:
- %TEMPERATURE% - Temperatuur waarde
- %LED_STATUS% - LED status
- %QUERY_PARAM% - Query parameter waarden
Geavanceerde Web Server Functionaliteiten
CORS Ondersteuning
Schakel cross-origin aanvragen in voor webapplicaties:
// Behandel 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);
});
// Voeg CORS-headers toe aan alle antwoorden
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");
JSON Response Helpers
Vereenvoudig JSON API ontwikkeling:
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);
}
// Gebruik
sendJsonResponse(200, "{\"status\":\"success\",\"data\":\"value\"}");
sendError(400, "Invalid request format");
Validatie van Requests
Implementeer robuuste invoervalidatie:
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;
}
// Verwerk geldige aanvraag...
});
Uitgebreide JSON Verwerking
Voor complexere JSON-afhandeling met de ArduinoJson bibliotheek:
#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;
}
// Waarden veilig uitlezen
const char* action = doc["action"] | "none";
int value = doc["value"] | 0;
bool enabled = doc["enabled"] | false;
// Maak response aan
StaticJsonDocument<200> response;
response["status"] = "success";
response["received_action"] = action;
response["received_value"] = value;
String responseString;
serializeJson(response, responseString);
sendJsonResponse(200, responseString);
}
Foutafhandeling
Standaard 404 Handler
De bibliotheek biedt een standaard 404 foutpagina. U kunt deze overschrijven:
server.onNotFound([]() {
server.send(404, "text/html", "<h1>Custom 404 Page</h1>");
});
Beste Praktijken
- Geheugenbeheer: Gebruik de F() macro voor string literals die in flash geheugen opgeslagen worden
- Niet-blokkerende Code: Houd handler functies lichtgewicht om serverblocking te voorkomen
- Beveiliging: Valideer inputparameters en sanitize output
- Prestaties: Gebruik gepaste HTTP-statuscodes en content types
- WebSocket: Beheer verbindingstoestanden correct en implementeer reconnect logica
Debugging
Schakel seriële debugging in om serveractiviteit te monitoren:
void setup() {
Serial.begin(9600);
// ... overige setup
}
void loop() {
server.handleClient();
if (Serial.available()) {
String command = Serial.readString();
Serial.println("Debug: " + command);
}
}
Compatibiliteit
- ESP32: Volledig ondersteund
- WiFi Bibliotheek: Vereist (meegeleverd met Arduino IDE)
- Geheugenvereisten: Minimaal 32KB flash, 2KB RAM
Beperkingen
Web Server Beperkingen
- Maximaal gelijktijdige HTTP-verbindingen: 4 (hardware beperking)
- Maximale URL-lengte: 256 tekens
- Template placeholders: Geen geneste vervangingen
WebSocket Beperkingen
- Maximale WebSocket berichtgrootte: 1KB per bericht
- Maximaal aantal gelijktijdige WebSocket verbindingen: 4-6 (afhankelijk van beschikbaar geheugen)
- Fragmenteren van berichten: automatisch afgehandeld maar kan effect hebben op prestaties
- Binaire berichtgrootte: Beperkt door RAM
- Verbindings-timeout: standaard 60 seconden (aanpasbaar)
Geheugenbeperkingen
- Minimale flash geheugen: 32KB
- Minimale RAM: 2KB voor basisfunctionaliteit
- WebSocket overhead: ca. 200-500 bytes per verbinding
- Incoming bericht buffering: ca. 1KB per actieve verbinding