SENSOREN/AKTOREN

INTERNET DER DINGE (IoT)

ESP32 - Ethernet

ESP32 - GPIO-Unterbrechung

DIYables ESP32 WebApps Bibliotheks-API-Referenz – Vollständige Dokumentation

Überblick

Die DIYables ESP32 WebApps Library bietet eine umfassende modulare Lösung zur Erstellung von WebSocket-basierten Webanwendungen auf dem ESP32. Sie umfasst mehrere vorgefertigte Webanwendungen und ein flexibles Framework zur Erstellung eigener Anwendungen.

Die Bibliothek verwendet eine modulare Architektur, bei der Sie nur die Webanwendungen einbinden, die Sie benötigen, was Speicher spart und die Leistung verbessert.

Funktionen

Modulare Architektur: Fügen Sie nur die Web-Apps hinzu, die Sie benötigen, um den Speicherverbrauch zu optimieren
Speichereffizient: Jede Webanwendung kann unabhängig voneinander aktiviert/deaktiviert werden
11+ einsatzbereite Webanwendungen: Vollständige ESP32-Steuerung ohne Kenntnisse in der Webprogrammierung
Eigenes Web-App-Framework: Erstellen Sie Ihre eigenen Anwendungen mithilfe des Basisklassen-Systems
Echtzeit-Kommunikation: WebSocket-basiert für sofortige Aktualisierungen
Responsives Design: Funktioniert auf Desktop-, Tablet- und Mobilgeräten
Einfache Integration: Callback-basierte API
Unterstützung mehrerer Apps: Das gleichzeitige Hinzufügen mehrerer Webanwendungen wird unterstützt

Kernklassen

DIY-fähiger Web-App-Server

Die Hauptserverklasse, die Webanwendungen, HTTP-Anfragen und WebSocket-Kommunikation verwaltet.

Konstruktor

DIYablesWebAppServer(int httpPort = 80, int websocketPort = 81)

Erstellt eine Instanz eines Webanwendungsservers.

httpPort: HTTP-Server-Port (Standardwert: 80)
websocketPort: WebSocket-Server-Port (Standardwert: 81)

Methoden

Einrichtung und Verbindung

bool begin()

Initialisiert die Netzwerkverbindung (für Ethernet- oder vorkonfigurierte Verbindungen) und startet den Webserver.

Rückgabewert: true, falls erfolgreich, false, falls fehlgeschlagen
Anwendungsfall: Für zukünftige Ethernet-Unterstützung oder wenn WLAN-Zugangsdaten vorkonfiguriert sind

bool begin(const char* ssid, const char* password)

Initialisiert die WLAN-Verbindung und startet den Webserver.

SSID: WLAN-Netzwerkname
Passwort: WLAN-Passwort
Rückgabewert: wahr, falls erfolgreich; falsch, falls fehlgeschlagen
Anwendungsfall: Standard-WLAN-Verbindung mit Zugangsdaten

void loop()

Verarbeitet HTTP-Anfragen und WebSocket-Kommunikation. Muss in der Hauptschleife aufgerufen werden.

bool isConnected()

Gibt true zurück, wenn WLAN verbunden ist.

String getIPAddress()

Gibt die IP-Adresse des Arduino als String zurück.

Anwendungsmanagement

void addApp(DIYablesWebAppPageBase* app)

Fügt dem Server eine Webanwendung hinzu.

app: Zeiger auf eine Webanwendungsinstanz

void removeApp(const String& path)

Entfernt eine Webanwendung anhand ihres URL-Pfads.

Pfad: URL-Pfad der Anwendung (z. B. "/chat")

DIYablesWebAppPageBase* getApp(const String& path)

Ruft eine Webanwendung anhand ihres URL-Pfads ab.

Pfad: URL-Pfad der Anwendung
Rückgabe: Zeiger auf die App oder nullptr, falls nicht gefunden

void setNotFoundPage(const DIYablesNotFoundPage& page)

Legen Sie die 404-Fehlerseite fest (optional).

Seite: 404-Seiteninstanz

Spezialisierter App-Zugang

DIYablesWebDigitalPinsPage* getWebDigitalPinsPage()

Gibt die Instanz der Seite Digitale Pins zurück, sofern sie hinzugefügt wurde.

Rückgabewert: Zeiger auf die Seite der digitalen Pins oder nullptr

DIYablesWebSliderPage* getWebSliderPage()

Ruft die Instanz der Sliderseite ab, falls sie hinzugefügt wurde.

Rückgabewert: Zeiger auf die Slider-Seite oder nullptr

DIYablesWebJoystickPage* getWebJoystickPage()

Gibt die Joystick-Seiteninstanz zurück, falls sie hinzugefügt wurde.

Rückgabewert: Zeiger auf die Joystick-Seite oder nullptr

Basisklassen

DIYablesWebAppSeitenBasisklasse

Abstrakte Basisklasse, von der alle Webanwendungen erben. Bietet gemeinsame Funktionalität für die HTTP-Verarbeitung, WebSocket-Kommunikation und Seitenverwaltung.

Konstruktor

DIYablesWebAppPageBase(const String& pagePath)

Erstellt eine Basis-Seiteninstanz mit dem angegebenen URL-Pfad.

pagePath: URL-Pfad der Seite (z. B. "/web-joystick")

Virtuelle Methoden (müssen von abgeleiteten Klassen implementiert werden)

virtual void handleHTTPRequest(IWebClient& client) = 0

Bearbeitet HTTP-Anfragen für diese Seite. Reine virtuelle Methode.

Client: Web-Client-Schnittstelle zum Senden der Antwort

virtual void handleWebSocketMessage(IWebSocket& ws, const char* message, uint16_t length) = 0

Verarbeitet WebSocket-Nachrichten für diese Seite. Reine virtuelle Methode.

ws: WebSocket-Verbindungsschnittstelle
message: Inhalt der empfangenen Nachricht
length: Nachrichtenlänge

virtual const char* getPageInfo() const = 0

Gibt die Seitenidentifikationszeichenfolge zurück, die in der Anzeige von Verbindungsinformationen verwendet wird. Reine virtuelle Methode.

Rückgabewert: Seiten-Info-String (z. B. "🕹️ Web-Joystick: ")

virtual String getNavigationInfo() const = 0

Gibt HTML für die Navigationsschaltfläche der Startseite zurück. Reine virtuelle Methode.

Rückgabewert: HTML-Zeichenkette für Navigationskarte

Virtuelle Methoden (Optionale Überschreibungen)

virtual void onWebSocketConnection(IWebSocket& ws)

Wird aufgerufen, wenn eine neue WebSocket-Verbindung hergestellt wird.

ws: neue WebSocket-Verbindung

virtual void onWebSocketClose(IWebSocket& ws)

Wird aufgerufen, wenn eine WebSocket-Verbindung geschlossen wird.

ws: WebSocket-Verbindung geschlossen

Gängige Methoden

const char* getPagePath() const

Gibt den URL-Pfad dieser Seite zurück.

Rückgabewert: Seitenpfad-Zeichenkette

bool isEnabled() const

Prüft, ob die Seite derzeit aktiviert ist.

Rückgabewert: true, wenn aktiviert, false, wenn deaktiviert

void setEnabled(bool enable)

Aktiviert oder deaktiviert die Seite.

Aktivieren: wahr zum Aktivieren, falsch zum Deaktivieren

Hilfsfunktionen

void sendHTTPHeader(IWebClient& client, const char* contentType = "text/html")

Sendet standardmäßige HTTP-Header an den Client.

client: Web-Client-Schnittstelle
contentType: MIME-Typ (Standardwert: "text/html")

void sendWebSocketMessage(IWebSocket& ws, const char* message)

Sendet eine Nachricht an einen bestimmten WebSocket-Client.

ws: Ziel-WebSocket-Verbindung
message: Nachricht zum Senden

void broadcastToAllClients(const char* message)

Sendet eine Nachricht an alle verbundenen WebSocket-Clients.

Nachricht: Nachricht zur Verbreitung

void sendLargeHTML(IWebClient& client, const char* html)

Sendet großen HTML-Inhalt mit Chunked-Transfer-Encoding.

client: Web-Client-Schnittstelle
html: HTML-Inhalt zum Senden

Anwendungsbeispiel

class CustomPage : public DIYablesWebAppPageBase { public: CustomPage() : DIYablesWebAppPageBase("/custom") {} void handleHTTPRequest(IWebClient& client) override { sendHTTPHeader(client); client.println("<html><body>Custom Page</body></html>"); } void handleWebSocketMessage(IWebSocket& ws, const char* message, uint16_t length) override { // Handle WebSocket messages sendWebSocketMessage(ws, "Response: " + String(message)); } const char* getPageInfo() const override { return " 🔧 Custom Page: "; } String getNavigationInfo() const override { return "<a href=\"/custom\" class=\"app-card custom\">" "<h3>🔧 Custom</h3><p>Custom functionality</p></a>"; } };

Webanwendungsklassen

DIYablesStartseite

Zentrales Navigationszentrum, das Links zu allen aktivierten Anwendungen bereitstellt.

Konstruktor

DIYablesHomePage()

URL-Pfad

Pfad: / (Wurzel)

DIYablesWebChatPage

Interaktive Chat-Oberfläche für die bidirektionale Kommunikation mit Arduino.

Konstruktor

DIYablesWebChatPage()

URL-Pfad

Pfad: /webchat

Methoden

void onWebChatMessage(std::function<void(const String&)> callback)

Legt einen Callback für eingehende Chat-Nachrichten fest.

void sendToWebChat(const String& message)

Eine Nachricht an die Webchat-Oberfläche senden.

DIYablesWebMonitorPage

webbasierter serieller Monitor für Ausgabe in Echtzeit und Befehlseingabe.

Konstruktor

DIYablesWebMonitorPage()

URL-Pfad

Pfad: /webmonitor

Methoden

void onWebMonitorMessage(std::function<void(const String&)> callback)

Legt einen Callback für eingehende Monitormeldungen fest.

void sendToWebMonitor(const String& message)

Sendet eine Nachricht an die Webmonitor-Schnittstelle.

DIYablesWebDigitalPinsPage

Steuern und überwachen Sie digitale Pins 0–13 über die Weboberfläche.

Konstruktor

DIYablesWebDigitalPinsPage()

URL-Pfad

Pfad: /webdigitalpins

Methoden

void enablePin(int pin, int mode)

Ermöglicht eine PIN für die Websteuerung.

Pin: Pin-Nummer (0-13)
Modus: WEB_PIN_OUTPUT oder WEB_PIN_INPUT

void onPinWrite(std::function<void(int, int)> callback)

Legt einen Callback für Schreiboperationen an Pins (Ausgangspins) fest.

void onPinRead(std::function<int(int)> callback)

Legt einen Callback für das Auslesen von Pins fest (Eingangspins).

void onPinModeChange(std::function<void(int, int)> callback)

Setzt einen Callback für Änderungen des Pin-Modus.

void updatePinState(int pin, int state)

Aktualisiert den Pin-Status in Echtzeit für Web-Clients.

DIYablesWebSliderSeite

Dualer Schieberegler für analoge und PWM-Anwendungen.

Konstruktor

DIYablesWebSliderPage()

URL-Pfad

Pfad: /webslider

Methoden

void onSliderValueFromWeb(std::function<void(int, int)> callback)

Legt eine Callback-Funktion fest, die bei Änderungen des Sliderwerts aus dem Web aufgerufen wird.

Parameter: slider1 (0-255), slider2 (0-255)

void onSliderValueToWeb(std::function<void()> callback)

Setzt Callback-Funktion für den Web-Client, der aktuelle Werte anfordert.

void sendToWebSlider(int slider1, int slider2)

Sendet die Werte der Schieberegler an die Weboberfläche.

DIYablesWebJoystickSeite

2D-Joysticksteuerung für Robotik- und Positionierungsanwendungen.

Konstruktor

DIYablesWebJoystickPage(bool autoReturn = true, float sensitivity = 10.0)

autoReturn: Ob der Joystick automatisch zur Mitte zurückkehrt
sensitivity: Mindestbewegung in Prozent, um Updates auszulösen

URL-Pfad

Pfad: /webjoystick

Methoden

void onJoystickValueFromWeb(std::function<void(int, int)> callback)

Legt einen Callback für Joystick-Bewegungen aus dem Web fest.

Parameter: x (-100 bis 100), y (-100 bis 100)

void onJoystickValueToWeb(std::function<void()> callback)

Legt den Callback für den Web-Client fest, der die aktuelle Position anfordert.

void sendToWebJoystick(int x, int y)

Sendet die Joystick-Position an die Weboberfläche.

void setAutoReturn(bool autoReturn)

Legt das Verhalten der automatischen Rückkehr fest.

void setSensitivity(float sensitivity)

Bewegungsempfindlichkeit festlegen (Prozentsatz).

DIYables Web-Plotter-Seite

Echtzeit-Datenvisualisierung mit Unterstützung mehrerer Datenreihen.

Konstruktor

DIYablesWebPlotterPage()

URL-Pfad

Pfad: /webplotter

Methoden

void setPlotTitle(const String& title)

Legt den Plot-Titel fest.

void setAxisLabels(const String& xLabel, const String& yLabel)

Legt Achsenbeschriftungen fest.

void enableAutoScale(bool enable)

Aktiviert bzw. deaktiviert die automatische Skalierung der Y-Achse.

void setMaxSamples(int maxSamples)

Legt die maximale Anzahl der anzuzeigenden Datenpunkte fest.

void addDataPoint(const String& seriesName, float x, float y)

Fügt einen Datenpunkt zu einer Serie hinzu.

void clearPlot()

Löscht alle Daten aus dem Diagramm.

DIYablesSeiteNichtGefunden

Optionale 404-Fehlerseite für eine bessere Benutzererfahrung.

Konstruktor

DIYablesNotFoundPage()

Grundlegendes Anwendungsbeispiel

#include <DIYablesWebApps.h> // WiFi credentials const char* ssid = "YOUR_WIFI_SSID"; const char* password = "YOUR_WIFI_PASSWORD"; // Create server and web applications DIYablesWebAppServer webAppsServer(80, 81); DIYablesHomePage homePage; DIYablesWebChatPage chatPage; DIYablesWebMonitorPage monitorPage; void setup() { Serial.begin(9600); // Add only the applications you need webAppsServer.addApp(&homePage); webAppsServer.addApp(&chatPage); webAppsServer.addApp(&monitorPage); // Optional: Add 404 page webAppsServer.setNotFoundPage(DIYablesNotFoundPage()); // Start server if (webAppsServer.begin(ssid, password)) { Serial.println("Server started successfully"); Serial.print("IP: "); Serial.println(webAppsServer.getIPAddress()); } // Setup callbacks chatPage.onWebChatMessage([](const String& message) { Serial.println("Chat: " + message); chatPage.sendToWebChat("Arduino received: " + message); }); } void loop() { webAppsServer.loop(); delay(10); }

Überblick über Webanwendungen

Startseite

URL: http://[esp32-ip]/
Zweck: Zentrale Navigationsplattform
Funktionen: Links zu allen aktivierten Anwendungen, Verbindungsstatus

WebChat-Anwendung

Webadresse: http://[esp32-ip]/webchat
Zweck: Zweiseitige Kommunikationsschnittstelle
Funktionen: Nachrichten in Echtzeit, Nachrichtenverlauf, WebSocket-Status

Web-Monitor

URL: http://[esp32-ip]/webmonitor
Zweck: Ersatz für den seriellen Monitor
Funktionen: Echtzeit-serielle Ausgabe, Befehlseingabe, dunkles Design

Webbasierte Steuerung digitaler Pins

URL: http://[esp32-ip]/webdigitalpins
Purpose: Steuerung der digitalen Pins 0-13
Features: Individuelle Pin-Steuerung, Massenoperationen, Status in Echtzeit

Web-Schieberegler-Steuerung

URL: http://[esp32-ip]/webslider
Zweck: duale Analog-/PWM-Steuerung
Funktionen: Zwei unabhängige Schieberegler (0-255), voreingestellte Werte, Echtzeit-Feedback

Web-Joystick-Steuerung

URL: http://[esp32-ip]/webjoystick
Zweck: 2D-Positionssteuerung für Roboter/Fahrzeuge
Funktionen: Touch-/Maussteuerung, Koordinatenanzeige, Empfindlichkeitseinstellung

Web-Plotter

URL: http://[esp32-ip]/webplotter
Zweck: Echtzeit-Datenvisualisierung
Funktionen: Mehrere Datenreihen, automatische Skalierung, konfigurierbare Titel und Achsen

WebSocket-Kommunikation

Alle Anwendungen verwenden WebSocket auf Port 81 für die Echtzeitkommunikation:

WebSocket-URL: ws://[esp32-ip]:81
Verbindung: Automatische Wiederverbindung bei Verbindungsabbruch
Protokoll: Textbasiertes Nachrichtenformat

Nachrichtenformate

WebChat-Nachrichten

Aus dem Web: Direkte Textnachricht
Zum Web: Direkte Textnachricht

Webmonitor-Meldungen

Vom Web: direkte Textnachricht
Zum Web: direkte Textnachricht

Web Digitale PIN-Nachrichten

Aus dem Web: JSON-Format: {"pin": 13, "state": 1}
Zum Web: JSON-Format: {"pin": 13, "state": 1}

Web-Slider-Nachrichten

Aus dem Web: JSON-Format: {"slider1": 128, "slider2": 255}
Zum Web: JSON-Format: {"slider1": 128, "slider2": 255}

Web-Joystick-Nachrichten

Aus dem Web: JSON-Format: {"x": 50, "y": -25}
Zum Web: JSON-Format: {"x": 50, "y": -25}

Web Plotter Nachrichten

Aus dem Web: Nicht zutreffend (nur Anzeige)
Zum Web: JSON-Format: {"series": "temp", "x": 10.5, "y": 23.4}

Fehlerbehandlung

Die Bibliothek umfasst automatische Fehlerbehandlung für:

WLAN-Verbindungsabbrüche
WebSocket-Verbindungsabbrüche
Ungültige Nachrichtenformate
Client-Verbindungsgrenzen

Speicherverbrauch

Vorteile der modularen Architektur: Fügen Sie nur die Webanwendungen hinzu, die Sie benötigen, um den Speicherverbrauch zu optimieren.

Ungefährer Speicherverbrauch pro Komponente:

DIYablesWebAppServer: ~8KB Flash-Speicher, ~2KB Arbeitsspeicher
DIYablesHomePage: ~3KB Flash-Speicher, ~1KB Arbeitsspeicher
DIYablesWebChatPage: ~6KB Flash-Speicher, ~1.5KB Arbeitsspeicher
DIYablesWebMonitorPage: ~5KB Flash-Speicher, ~1.5KB Arbeitsspeicher
DIYablesWebDigitalPinsPage: ~8KB Flash-Speicher, ~2KB Arbeitsspeicher
DIYablesWebSliderPage: ~6KB Flash-Speicher, ~1.5KB Arbeitsspeicher
DIYablesWebJoystickPage: ~7KB Flash-Speicher, ~1.5KB Arbeitsspeicher
DIYablesWebPlotterPage: ~10KB Flash-Speicher, ~2KB Arbeitsspeicher
WebSocket-Puffer: ~1KB RAM pro Verbindung

Gesamt, wenn alle Apps aktiviert sind: ~53KB Flash-Speicher, ~12KB RAM

Minimale Einrichtung (Server + Home + 1 App): ~17 KB Flash-Speicher, ~4.5 KB RAM

Browser-Kompatibilität

Unterstützte Browser:

Chrome 50+
Firefox 45+
Safari 10+
Edge 79+
Mobile-Browser (iOS Safari, Chrome Mobile)

Sicherheitshinweise

Keine Authentifizierung implementiert (nur für lokale Netzwerke geeignet)
Nur in vertrauenswürdigen Netzwerken verwenden
Erwägen Sie, Authentifizierung für öffentliche Bereitstellungen hinzuzufügen

Fehlerbehebung

Häufige Probleme

i. Kann keine Verbindung zum WLAN herstellen

Prüfe SSID und Passwort
Überprüfen Sie, ob das Netzwerk 2,4 GHz nutzt (nicht 5 GHz)
Signalstärke überprüfen

WebSocket-Verbindung schlägt fehl

Überprüfen Sie, ob die IP-Adresse korrekt ist.
Firewall-Einstellungen überprüfen
Versuchen Sie einen anderen Browser

Hoher Speicherverbrauch

Nicht verwendete Anwendungen deaktivieren
Gleichzeitige Verbindungen begrenzen
Starte den ESP32 neu, wenn Speicherfragmentierung auftritt.

langsame Antwort

WLAN-Signalstärke überprüfen
Reduziere die Frequenz der WebSocket-Nachrichten
Verwenden Sie kürzere Callback-Funktionen.

Beispielprojekte

Beispielanwendungen

Die DIYables ESP32 WebApps-Bibliothek enthält umfassende Beispiele, die für die ESP32-Bildungsplattform entwickelt wurden:

Verfügbare Beispiele

Chat-Beispiel: zweiseitige Kommunikationsschnittstelle
WebMonitor-Beispiel: Seriemonitor-Ersatz mit erweiterten Funktionen
WebDigitalPins-Beispiel: Steuerung aller digitalen Pins mit visuellem Feedback
WebSlider-Beispiel: Duale Analog-/PWM-Steuerung mit Voreinstellungen
WebJoystick-Beispiel: 2D-Positionssteuerung für Robotikprojekte
MultipleWebApps-Beispiel: Alle Anwendungen laufen gleichzeitig

Siehe den Ordner examples/ für vollständige Projekte und den Ordner docs/ für detaillierte Setup-Anleitungen.

Plattformabstraktionsschnittstellen

Die DIYables ESP32 WebApps-Bibliothek verwendet eine Plattformabstraktionsschicht mit Schnittstellen, die die Unterstützung mehrerer Hardware-Plattformen ermöglichen. Diese Schnittstellen trennen die Kern-WebApp-Funktionalität von plattformabhängigen Implementierungen.

Kern-Schnittstellen

IWebClient

Schnittstelle für HTTP-Client-Verbindungen.

class IWebClient { public: virtual ~IWebClient() = default; // Stream interface methods virtual int available() = 0; virtual int read() = 0; virtual int peek() = 0; virtual size_t write(uint8_t data) = 0; virtual size_t write(const uint8_t* buffer, size_t size) = 0; virtual void flush() = 0; // Connection management virtual bool connected() = 0; virtual void stop() = 0; // Convenience methods virtual void print(const String& str) = 0; virtual void println(const String& str) = 0; };

IWebSocket

Schnittstelle für WebSocket-Verbindungen mit bidirektionaler Kommunikation.

class IWebSocket { public: enum DataType { TEXT = 1, BINARY = 2 }; enum CloseCode { NORMAL_CLOSURE = 1000, GOING_AWAY = 1001, PROTOCOL_ERROR = 1002, UNSUPPORTED_DATA = 1003, POLICY_VIOLATION = 1008, MESSAGE_TOO_BIG = 1009, INTERNAL_ERROR = 1011 }; virtual ~IWebSocket() = default; // Message handling virtual void sendText(const char* message) = 0; virtual void sendBinary(const uint8_t* data, size_t length) = 0; virtual bool isConnected() const = 0; virtual void close(CloseCode code = NORMAL_CLOSURE, const char* reason = nullptr) = 0; // Event callbacks virtual void onMessage(std::function<void(IWebSocket*, DataType, const char*, uint16_t)> callback) = 0; virtual void onClose(std::function<void(IWebSocket*, CloseCode, const char*, uint16_t)> callback) = 0; };

IWebServer

Schnittstelle für die Funktionalität eines HTTP-Servers.

class IWebServer { public: virtual ~IWebServer() = default; // Server lifecycle virtual bool begin() = 0; virtual void stop() = 0; virtual IWebClient* available() = 0; // Configuration virtual void setPort(uint16_t port) = 0; virtual uint16_t getPort() const = 0; };

IWebSocketServer

Schnittstelle für einen WebSocket-Server mit Verbindungsverwaltung.

class IWebSocketServer { public: using ConnectionCallback = std::function<void(IWebSocket*)>; using MessageCallback = std::function<void(IWebSocket*, IWebSocket::DataType, const char*, uint16_t)>; virtual ~IWebSocketServer() = default; // Server lifecycle virtual bool begin() = 0; virtual void stop() = 0; virtual void listen() = 0; // Event handling virtual void onConnection(ConnectionCallback callback) = 0; virtual void onMessage(MessageCallback callback) = 0; // Broadcasting virtual void broadcastText(const char* message) = 0; virtual void broadcastBinary(const uint8_t* data, size_t length) = 0; // Configuration virtual void setPort(uint16_t port) = 0; virtual uint16_t getPort() const = 0; };

INetworkProvider

Schnittstelle zur Verwaltung der Netzwerkverbindung.

class INetworkProvider { public: virtual ~INetworkProvider() = default; // Network lifecycle virtual bool begin(const char* ssid, const char* password) = 0; virtual void end() = 0; virtual bool isConnected() = 0; // Network information virtual String getLocalIP() = 0; virtual String getSSID() = 0; virtual int32_t getRSSI() = 0; };

IServerFactory

Fabrik-Schnittstelle zur Erstellung plattformabhängiger Implementierungen.

class IServerFactory { public: virtual ~IServerFactory() = default; // Factory methods virtual INetworkProvider* createNetworkProvider() = 0; virtual IWebServer* createWebServer(uint16_t port) = 0; virtual IWebSocketServer* createWebSocketServer(uint16_t port) = 0; // Platform information virtual String getPlatformName() const = 0; };

Plattform-Implementierungsbeispiel

Für den ESP32 werden die Schnittstellen mit der DIYables_ESP32_WebServer-Bibliothek implementiert:

class ESP32ServerFactory : public IServerFactory { public: INetworkProvider* createNetworkProvider() override { return new ESP32NetworkProvider(); } IWebServer* createWebServer(uint16_t port) override { return new ESP32WebServer(port); } IWebSocketServer* createWebSocketServer(uint16_t port) override { return new ESP32WebSocketServer(port); } String getPlatformName() const override { return "ESP32"; } };

Unterstützung für neue Plattformen hinzufügen

Um Unterstützung für eine neue Plattform hinzuzufügen (z. B. ESP32):

Alle Schnittstellen implementieren für die Zielplattform
Erstelle eine ServerFactory, die deine Implementierungen instanziiert
Behandle plattformabhängige Netzwerke und WebSocket-Protokolle
Teste mit vorhandenen WebApp-Klassen (keine Änderungen erforderlich)

Beispielverwendung mit verschiedenen Plattformen:

ESP32ServerFactory factory; DIYablesWebAppServer server(factory, 80, 81); // ESP32 (hypothetical) ESP32ServerFactory esp32Factory; DIYablesWebAppServer esp32Server(esp32Factory, 80, 81);

Vorteile des Schnittstellen-basierten Designs

Plattformunabhängigkeit: Die Kernlogik der WebApp funktioniert auf jeder Plattform
Erweiterbarkeit: Einfach neue Hardwareunterstützung hinzufügen
Wartbarkeit: Plattformspezifischer Code ist isoliert
Testbarkeit: Schnittstellen können für Unit-Tests gemockt werden
Konsistenz: Gleiche API über alle unterstützten Plattformen hinweg

Aktuelle Plattformunterstützung

✅ ESP32: Vollständig implementiert und getestet
🔄 ESP32: Verfügbar als eigenständige Erweiterung - DIYables_WebApps_ESP32
🚀 Zukünftige Plattformen: Können mit dem gleichen Schnittstellenmuster hinzugefügt werden