CAPTEURS/ACTIONNEURS

INTERNET OF THING (IoT)

Arduino UNO R4 - Ethernet.

Arduino UNO R4 - Courriel.

Référence API de la bibliothèque WebApps de DIYables - Documentation complète

Vue d'ensemble

La bibliothèque WebApps de DIYables fournit une solution complète et modulaire pour créer des applications Web basées sur WebSocket sur les plateformes Arduino Uno R4 WiFi et DIYables STEM V4 IoT. Elle comprend plusieurs applications Web préconstruites et un cadre flexible pour créer des applications personnalisées. Spécialement optimisée pour la plateforme éducative DIYables STEM V4 IoT avec des capacités IoT améliorées et une intégration de capteurs intégrée.

La bibliothèque utilise une architecture modulaire où vous n'incluez que les applications web dont vous avez besoin, ce qui permet d'économiser de la mémoire et d'améliorer les performances.

Fonctionnalités

Architecture modulaire: Ajoutez uniquement les applications web dont vous avez besoin pour optimiser l'utilisation de la mémoire
Économe en mémoire: Chaque application Web peut être activée/désactivée indépendamment
11+ applications web prêtes à l'emploi: Contrôle Arduino complet sans connaissances en programmation web
Cadre d'applications web personnalisées: Créez vos propres applications en utilisant le système de classes de base
Communication en temps réel: Basé sur WebSocket pour des mises à jour instantanées
Conception réactive: Fonctionne sur ordinateurs de bureau, tablettes et appareils mobiles
Intégration facile: API simple basée sur des callbacks
Support de plusieurs applications: Prise en charge de l'ajout de plusieurs applications web simultanément
Plateforme extensible: Actuellement implémenté pour Arduino Uno R4 WiFi, mais peut être étendu à d'autres plateformes matérielles. Voir DIYables_WebApps_ESP32

Classes centrales

DIYablesServeur d'application Web

La classe principale du serveur qui gère les applications web, les requêtes HTTP et la communication WebSocket.

Constructeur

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

Crée une instance de serveur d'applications Web.

httpPort: port du serveur HTTP (par défaut : 80)
websocketPort: port du serveur WebSocket (par défaut : 81)

Méthodes

Configuration et Connexion

bool begin()

Initialise la connexion réseau (pour Ethernet ou des connexions préconfigurées) et démarre le serveur web.

Retour: vrai si l'opération réussit, faux sinon
Cas d'utilisation: Pour une prise en charge Ethernet à venir ou lorsque les identifiants WiFi sont préconfigurés

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

Initialise la connexion Wi-Fi et démarre le serveur Web.

ssid: nom du réseau WiFi
password: mot de passe WiFi
Returns: vrai si réussi, faux si échoué
Use case: connexion WiFi standard avec identifiants

void loop()

Gère les requêtes HTTP et la communication WebSocket. Doit être appelée dans la boucle principale.

bool isConnected()

Renvoie vrai si le WiFi est connecté.

String getIPAddress()

Renvoie l'adresse IP de l'Arduino sous forme de chaîne.

Gestion des applications

void addApp(DIYablesWebAppPageBase* app)

Ajoute une application Web au serveur.

app: Pointeur vers une instance d'une application web

void removeApp(const String& path)

Supprime une application web par son chemin d’URL.

chemin: chemin URL de l'application (par exemple, "/chat")

DIYablesWebAppPageBase* getApp(const String& path)

Récupère une application Web à partir de son chemin d'URL.

chemin: chemin URL de l'application
Retour: pointeur vers l'application ou nullptr si non trouvé

void setNotFoundPage(const DIYablesNotFoundPage& page)

Définit la page 404 non trouvée (facultatif).

page: instance de page 404

Accès à des applications spécialisées

DIYablesWebDigitalPinsPage* getWebDigitalPinsPage()

Obtient l'instance de la page des broches numériques si elle est ajoutée.

Retour: Pointeur vers la page des broches numériques ou nullptr

DIYablesWebSliderPage* getWebSliderPage()

Obtient l’instance de la page du slider si elle est ajoutée.

Renvoie: Pointeur vers la page du curseur ou nullptr

DIYablesWebJoystickPage* getWebJoystickPage()

Obtient l'instance de la page joystick si elle est ajoutée.

Retour: pointeur vers la page du joystick ou nullptr

Classes de base

DIYablesWebAppPageBase

Classe de base abstraite dont toutes les applications web héritent. Fournit des fonctionnalités communes pour la gestion HTTP, la communication WebSocket et la gestion des pages.

Constructeur

DIYablesWebAppPageBase(const String& pagePath)

Crée une instance de page de base avec le chemin d'URL spécifié.

pagePath: chemin de l'URL de la page (par exemple, "/web-joystick")

Méthodes virtuelles (doivent être implémentées par les classes dérivées)

virtual void handleHTTPRequest(IWebClient& client) = 0

Gère les requêtes HTTP pour cette page. Méthode virtuelle pure.

client: Interface client Web pour l'envoi d'une réponse

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

Gère les messages WebSocket pour cette page. Méthode virtuelle pure.

ws: interface de connexion WebSocket
message: contenu du message reçu
length: longueur du message

virtual const char* getPageInfo() const = 0

Renvoie la chaîne d'identification de la page utilisée dans l'affichage des informations de connexion. Méthode virtuelle pure.

Retour: Chaîne d'informations de la page (par ex., "🕹️ Joystick Web: ")

virtual String getNavigationInfo() const = 0

Renvoie le HTML pour le bouton de navigation de la page d'accueil. Méthode virtuelle pure.

Retour: chaîne HTML pour la carte de navigation

Méthodes virtuelles (redéfinitions optionnelles)

virtual void onWebSocketConnection(IWebSocket& ws)

Appelé lorsqu'une nouvelle connexion WebSocket est établie.

ws: Nouvelle connexion WebSocket

virtual void onWebSocketClose(IWebSocket& ws)

Appelé lorsque la connexion WebSocket est fermée.

ws: Connexion WebSocket fermée

Méthodes courantes

const char* getPagePath() const

Obtient le chemin d'URL de cette page.

Renvoie: chaîne représentant le chemin de la page

bool isEnabled() const

Vérifie si la page est actuellement activée.

Retour: vrai si activé, faux si désactivé

void setEnabled(bool enable)

Activer ou désactiver la page.

activer: vrai pour activer, faux pour désactiver

Méthodes utilitaires

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

Envoie les en-têtes HTTP standards au client.

client: Interface du client Web
contentType: Type MIME (par défaut: "text/html")

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

Envoie un message à un client WebSocket spécifique.

ws: Connexion WebSocket cible
message: Message à envoyer

void broadcastToAllClients(const char* message)

Diffuse un message à tous les clients WebSocket connectés.

message: Message à diffuser

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

Envoie un grand contenu HTML en utilisant l'encodage par morceaux.

client: interface du client Web
html: contenu HTML à envoyer

Exemple d'utilisation

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>"; } };

Classes d'applications Web

Page d'accueil de DIYables

Centre de navigation central fournissant des liens vers toutes les applications activées.

Constructeur

DIYablesHomePage()

Chemin d'URL

Chemin: / (racine)

Page de chat Web de DIYables

Interface de chat interactive pour une communication bidirectionnelle avec Arduino.

Constructeur

DIYablesWebChatPage()

Chemin d'URL

Chemin: /webchat

Méthodes

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

Définit le rappel pour les messages de chat entrants.

void sendToWebChat(const String& message)

Envoyer un message à l'interface de chat Web.

Page de surveillance du Web

Moniteur série basé sur le Web pour la sortie en temps réel et l'entrée de commandes.

Constructeur

DIYablesWebMonitorPage()

Chemin d'URL

Chemin: /webmonitor

Méthodes

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

Définit la fonction de rappel pour les messages entrants du moniteur.

void sendToWebMonitor(const String& message)

Envoie un message à l'interface du moniteur Web.

Page des épingles numériques Web de DIYables

Contrôler et surveiller les broches numériques 0 à 13 via une interface Web.

Constructeur

DIYablesWebDigitalPinsPage()

Chemin d'URL

Chemin: /webdigitalpins

Méthodes

void enablePin(int pin, int mode)

Activer une broche pour le contrôle Web.

pin: Numéro de broche (0-13)
mode: WEB_PIN_OUTPUT ou WEB_PIN_INPUT

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

Définit la fonction de rappel pour les opérations d'écriture sur les broches (broches de sortie).

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

Définit le rappel pour les opérations de lecture des broches (broches d'entrée).

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

Définit une fonction de rappel pour les changements de mode des broches.

void updatePinState(int pin, int state)

Met à jour l'état du pin en temps réel pour les clients Web.

DIYablesWebSliderPage

Contrôle à double curseur pour les applications analogiques et PWM.

Constructeur

DIYablesWebSliderPage()

Chemin d'URL

Chemin: /webslider

Méthodes

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

Définit la fonction de rappel pour les changements de valeur du curseur depuis le Web.

Paramètres: slider1 (0-255), slider2 (0-255)

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

Définit la fonction de rappel pour le client Web qui demande les valeurs actuelles.

void sendToWebSlider(int slider1, int slider2)

Envoie les valeurs des curseurs à l'interface web.

Page Joystick Web DIYables

Contrôle par joystick 2D pour la robotique et les applications de positionnement.

Constructeur

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

autoReturn: Si le joystick revient automatiquement au centre
sensitivity: Pourcentage de déplacement minimum pour déclencher les mises à jour

Chemin d'URL

Chemin: /webjoystick

Méthodes

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

Définit une fonction de rappel pour le mouvement du joystick depuis le Web.

Paramètres: x (-100 à 100), y (-100 à 100)

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

Définit la fonction de rappel pour le client Web qui demande la position actuelle.

void sendToWebJoystick(int x, int y)

Envoie la position du joystick à l'interface Web.

void setAutoReturn(bool autoReturn)

Définit le comportement de retour automatique.

void setSensitivity(float sensitivity)

Définit la sensibilité au mouvement (en pourcentage).

DIYablesWebPlotterPage

Visualisation de données en temps réel avec prise en charge de plusieurs séries de données.

Constructeur

DIYablesWebPlotterPage()

Chemin d'URL

Chemin: /webplotter

Méthodes

void setPlotTitle(const String& title)

Définit le titre du graphique.

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

Définit les étiquettes des axes.

void enableAutoScale(bool enable)

Activation ou désactivation de la mise à l'échelle automatique de l'axe des ordonnées.

void setMaxSamples(int maxSamples)

Définit le nombre maximum de points de données à afficher.

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

Ajoute un point de données à une série.

void clearPlot()

Efface toutes les données du graphique.

DIYablesPageIntrouvable

Page d'erreur 404 optionnelle pour une meilleure expérience utilisateur.

Constructeur

DIYablesNotFoundPage()

Exemple d'utilisation de base

#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); }

Aperçu des applications web

Page d'accueil

URL: http://[arduino-ip]/
Objectif : Centre de navigation central
Fonctionnalités : Liens vers toutes les applications activées, État de connexion

Application WebChat

URL: http://[arduino-ip]/webchat
But: Interface de communication bidirectionnelle
Fonctionnalités: Messagerie en temps réel, historique des messages, État du WebSocket

Moniteur Web

URL: http://[arduino-ip]/webmonitor
Objectif: Remplacement du moniteur série
Fonctionnalités: Sortie série en temps réel, entrée de commande, thème sombre

Contrôle des broches numériques Web

URL: http://[arduino-ip]/webdigitalpins
But: Contrôler les broches numériques 0-13
Caractéristiques: Contrôle individuel des broches, opérations par lots, état en temps réel

Contrôle de curseur Web

URL: http://[arduino-ip]/webslider
But: Contrôle analogique et PWM double
Caractéristiques: Deux curseurs indépendants (0-255), valeurs prédéfinies, retour en temps réel

Contrôle du joystick Web

URL: http://[arduino-ip]/webjoystick
Objectif: Contrôle de position 2D pour les robots/véhicules
Fonctionnalités: Contrôle tactile/souris, affichage des coordonnées, réglage de la sensibilité

Traceur Web

URL: http://[arduino-ip]/webplotter
Objectif: Visualisation des données en temps réel
Fonctionnalités: Plusieurs séries de données, mise à l'échelle automatique, titres et axes configurables

Communication WebSocket

Toutes les applications utilisent WebSocket sur le port 81 pour la communication en temps réel :

URL du WebSocket: ws://[arduino-ip]:81
Connexion: Reconnexion automatique en cas de déconnexion
Protocole: Format de message basé sur du texte

Formats des messages

Messages WebChat

Depuis le Web: Message texte direct
Vers le Web: Message texte direct

Messages du moniteur Web

Depuis le Web : Message texte direct
Vers le Web : Message texte direct

Messages numériques épinglés sur le Web

Depuis le Web : format JSON : {"pin": 13, "state": 1}
Vers le Web : format JSON : {"pin": 13, "state": 1}

Messages du curseur Web

Depuis le Web : format JSON : {"slider1": 128, "slider2": 255}
Vers le Web : format JSON : {"slider1": 128, "slider2": 255}

Messages du joystick Web

Depuis le Web: format JSON: {"x": 50, "y": -25}
Vers le Web: format JSON: {"x": 50, "y": -25}

Messages du traceur Web

Depuis le Web: Non applicable (affichage uniquement)
Pour le Web: Format JSON: {"series": "temp", "x": 10.5, "y": 23.4}

Gestion des erreurs

La bibliothèque comprend une gestion automatique des erreurs pour :

Pannes de connexion Wi‑Fi
Déconnexions WebSocket
Formats de messages invalides
Limites de connexion des clients

Utilisation de la mémoire

Avantages de l'architecture modulaire: Incluez uniquement les applications web dont vous avez besoin pour optimiser l'utilisation de la mémoire.

Utilisation approximative de la mémoire par composant :

DIYablesWebAppServer: ≈8 Ko mémoire Flash, ≈2 Ko RAM
DIYablesHomePage: ≈3 Ko mémoire Flash, ≈1 Ko RAM
DIYablesWebChatPage: ≈6 Ko mémoire Flash, ≈1,5 Ko RAM
DIYablesWebMonitorPage: ≈5 Ko mémoire Flash, ≈1,5 Ko RAM
DIYablesWebDigitalPinsPage: ≈8 Ko mémoire Flash, ≈2 Ko RAM
DIYablesWebSliderPage: ≈6 Ko mémoire Flash, ≈1,5 Ko RAM
DIYablesWebJoystickPage: ≈7 Ko mémoire Flash, ≈1,5 Ko RAM
DIYablesWebPlotterPage: ≈10 Ko mémoire Flash, ≈2 Ko RAM
Tampon WebSocket: ≈1 Ko RAM par connexion

Total si toutes les applications sont activées: ~53 Ko mémoire flash, ~12 Ko RAM

Configuration minimale (serveur + domicile + 1 application) : ~17 Ko de mémoire flash, ~4,5 Ko de RAM

Compatibilité du navigateur

Navigateurs pris en charge :

Chrome 50+
Firefox 45+
Safari 10+
Edge 79+
Navigateurs mobiles (iOS Safari, Chrome Mobile)

Notes de sécurité

Aucune authentification n'est mise en œuvre (réseaux locaux uniquement)
Utiliser uniquement dans des réseaux de confiance
Envisagez d'ajouter une authentification pour les déploiements publics

Dépannage

Problèmes courants

i. Impossible de se connecter au Wi-Fi

Vérifier le SSID et le mot de passe
Vérifier que le réseau est en 2,4 GHz (pas en 5 GHz)
Vérifier la force du signal

La connexion WebSocket échoue

Vérifiez que l'adresse IP est correcte
Vérifier les paramètres du pare-feu
Essayez un navigateur différent

Forte utilisation de la mémoire

Désactiver les applications non utilisées
Limiter les connexions simultanées
Redémarrer l'Arduino en cas de fragmentation de mémoire.

Réponse lente

Vérifier la puissance du signal Wi-Fi
Réduire la fréquence des messages WebSocket
Utilisez des fonctions de rappel plus courtes

Exemples de projets

Exemples d'applications

La bibliothèque WebApps de DIYables comprend des exemples complets conçus pour la plateforme éducative Arduino Uno R4 WiFi et DIYables STEM V4 IoT:

Exemples disponibles

Exemple de chat: Interface de communication bidirectionnelle
Exemple de WebMonitor: Remplacement du moniteur série par des fonctionnalités améliorées
Exemple de WebDigitalPins: Contrôlez toutes les broches numériques avec un retour visuel
Exemple de WebSlider: Contrôle analogique/PWM double avec des préréglages
Exemple de WebJoystick: Contrôle de position en 2D pour des projets robotiques
Exemple de MultipleWebApps: Toutes les applications fonctionnent simultanément

Compatibilité matérielle

Recommandé : DIYables STEM V4 IoT (fonctionnalités améliorées, capteurs intégrés)
Compatible : Arduino Uno R4 WiFi

Ressources des tutoriels

Des tutoriels complets étape par étape disponibles sur :

Newbiely.com/tutorials/arduino/arduino-uno-r4-wifi-web-apps
Guides IoT spécifiques STEM V4 de DIYables et des exemples d'intégration de capteurs

Consultez le dossier examples/ pour des projets complets et le dossier docs/ pour des instructions d'installation détaillées.

Interfaces d'abstraction de la plate-forme

La bibliothèque WebApps DIYables utilise une couche d'abstraction de plate-forme avec des interfaces qui permettent de prendre en charge plusieurs plate-formes matérielles. Ces interfaces séparent les fonctionnalités centrales des WebApps de leurs implémentations spécifiques à la plate-forme.

Interfaces centrales

IWebClient

Interface pour les connexions du client HTTP.

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

Interface pour les connexions WebSocket avec prise en charge de la communication bidirectionnelle.

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

Interface pour la fonctionnalité du serveur HTTP.

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

Interface pour un serveur WebSocket avec la gestion des connexions.

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; };

IFournisseurDeRéseau

Interface de gestion de la connectivité réseau.

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; };

IFabriqueServeur

Interface de fabrique pour la création d'implémentations spécifiques à la plateforme.

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; };

Exemple de mise en œuvre de la plateforme

Pour l'Arduino Uno R4 WiFi, les interfaces sont implémentées en utilisant la bibliothèque UnoR4WiFi_WebServer :

class UnoR4ServerFactory : public IServerFactory { public: INetworkProvider* createNetworkProvider() override { return new UnoR4NetworkProvider(); } IWebServer* createWebServer(uint16_t port) override { return new UnoR4WebServer(port); } IWebSocketServer* createWebSocketServer(uint16_t port) override { return new UnoR4WebSocketServer(port); } String getPlatformName() const override { return "Arduino Uno R4 WiFi"; } };

Ajout du support pour une nouvelle plateforme

Pour ajouter la prise en charge d'une nouvelle plateforme (par exemple, l'ESP32) :

Implémentez toutes les interfaces pour la plate-forme cible
Créez une ServerFactory qui instancie vos implémentations
Gérez le réseau spécifique à la plate-forme et les protocoles WebSocket
Testez avec les classes WebApp existantes (aucun changement nécessaire)

Exemple d'utilisation avec différentes plateformes :

// Arduino Uno R4 WiFi UnoR4ServerFactory factory; DIYablesWebAppServer server(factory, 80, 81); // ESP32 (hypothetical) ESP32ServerFactory esp32Factory; DIYablesWebAppServer esp32Server(esp32Factory, 80, 81);

Avantages de la conception basée sur les interfaces

Indépendance vis-à-vis de la plateforme: La logique Core WebApp fonctionne sur n'importe quelle plateforme
Extensibilité: Facile d'ajouter la prise en charge de nouveaux matériels
Maintenabilité: Le code spécifique à la plateforme est isolé
Testabilité: Les interfaces peuvent être simulées pour les tests unitaires
Cohérence: La même API sur toutes les plateformes prises en charge

Support de la plateforme actuelle

✅ Arduino Uno R4 WiFi: Entièrement implémenté et testé
🔄 ESP32: Disponible en tant qu'extension séparée - DIYables_WebApps_ESP32
🚀 Plateformes futures: peuvent être ajoutées en utilisant le même modèle d'interface

Tutoriels connexes

※ 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 !