Home
Arduino UNO R4

Referência da API da Biblioteca DIYables WebApps - Documentação Completa

Visão Geral

A biblioteca DIYables WebApps oferece uma solução modular completa para criar aplicativos web baseados em WebSocket no Arduino Uno R4 WiFi e no DIYables STEM V4 IoT. Ela inclui vários aplicativos web prontos e um framework flexível para criar aplicativos personalizados. Especialmente otimizada para a plataforma educacional DIYables STEM V4 IoT, com recursos de IoT avançados e integração de sensores embutida.

A biblioteca usa uma arquitetura modular, na qual você inclui apenas os aplicativos web de que precisa, economizando memória e melhorando o desempenho.

Recursos

  • Arquitetura Modular: Adicione somente os web apps de que você precisa para otimizar o uso de memória
  • Eficiente em Memória: Cada web app pode ser ativado/desativado de forma independente
  • Mais de 11 Aplicativos Web Prontos para Usar: Controle completo do Arduino sem conhecimento de programação web
  • Framework de Web App Personalizado: Crie seus próprios aplicativos usando o sistema de classe base
  • Comunicação em Tempo Real: Baseada em WebSocket para atualizações instantâneas
  • Design Responsivo: Funciona em computadores, tablets e dispositivos móveis
  • Integração Fácil: API simples baseada em callbacks
  • Suporte a Vários Apps: Permite adicionar vários web apps simultaneamente
  • Extensível para Outras Plataformas: Atualmente implementado para o Arduino Uno R4 WiFi, mas pode ser estendido para outras plataformas de hardware. Veja DIYables_WebApps_ESP32

Classes Principais

DIYablesWebAppServer

A classe principal do servidor, que gerencia os aplicativos web, as requisições HTTP e a comunicação WebSocket.

Construtor

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

Cria uma instância do servidor de web apps.

  • httpPort: Porta do servidor HTTP (padrão: 80)
  • websocketPort: Porta do WebSocket (padrão: 81)

Métodos

Configuração e Conexão
bool begin()

Inicializa a conexão de rede (para Ethernet ou conexões pré-configuradas) e inicia o servidor web.

  • Retorna: true se bem-sucedido, false se falhar
  • Caso de uso: Para suporte futuro a Ethernet ou quando as credenciais de WiFi já estão pré-configuradas
bool begin(const char* ssid, const char* password)

Inicializa a conexão WiFi e inicia o servidor web.

  • ssid: Nome da rede WiFi
  • password: Senha do WiFi
  • Retorna: true se bem-sucedido, false se falhar
  • Caso de uso: Conexão WiFi padrão com credenciais
void loop()

Trata as requisições HTTP e a comunicação WebSocket. Deve ser chamado no loop principal.

bool isConnected()

Retorna true se o WiFi estiver conectado.

String getIPAddress()

Retorna o endereço IP do Arduino como uma string.

Gerenciamento de Aplicativos
void addApp(DIYablesWebAppPageBase* app)

Adiciona um aplicativo web ao servidor.

  • app: Ponteiro para uma instância de aplicativo web
void removeApp(const String& path)

Remove um aplicativo web pelo seu caminho de URL.

  • path: Caminho de URL do aplicativo (por exemplo, "/chat")
DIYablesWebAppPageBase* getApp(const String& path)

Obtém um aplicativo web pelo seu caminho de URL.

  • path: Caminho de URL do aplicativo
  • Retorna: Ponteiro para o app ou nullptr se não for encontrado
void setNotFoundPage(const DIYablesNotFoundPage& page)

Define a página 404 Not Found (opcional).

  • page: Instância da página 404
Acesso a Apps Especializados
DIYablesWebDigitalPinsPage* getWebDigitalPinsPage()

Obtém a instância da página de pinos digitais, se ela foi adicionada.

  • Retorna: Ponteiro para a página de pinos digitais ou nullptr
DIYablesWebSliderPage* getWebSliderPage()

Obtém a instância da página de slider, se ela foi adicionada.

  • Retorna: Ponteiro para a página de slider ou nullptr
DIYablesWebJoystickPage* getWebJoystickPage()

Obtém a instância da página de joystick, se ela foi adicionada.

  • Retorna: Ponteiro para a página de joystick ou nullptr

Classes Base

DIYablesWebAppPageBase

Classe base abstrata da qual todos os aplicativos web herdam. Fornece a funcionalidade comum para o tratamento de HTTP, a comunicação WebSocket e o gerenciamento de páginas.

Construtor

DIYablesWebAppPageBase(const String& pagePath)

Cria uma instância de página base com o caminho de URL especificado.

  • pagePath: Caminho de URL da página (por exemplo, "/web-joystick")

Métodos Virtuais (Devem ser implementados pelas classes derivadas)

virtual void handleHTTPRequest(IWebClient& client) = 0

Trata as requisições HTTP desta página. Método virtual puro.

  • client: Interface do cliente web para enviar a resposta
virtual void handleWebSocketMessage(IWebSocket& ws, const char* message, uint16_t length) = 0

Trata as mensagens WebSocket desta página. Método virtual puro.

  • ws: Interface da conexão WebSocket
  • message: Conteúdo da mensagem recebida
  • length: Tamanho da mensagem
virtual const char* getPageInfo() const = 0

Retorna a string de identificação da página usada na exibição das informações de conexão. Método virtual puro.

  • Retorna: String de informações da página (por exemplo, "🕹️ Web Joystick: ")
virtual String getNavigationInfo() const = 0

Retorna o HTML do botão de navegação da página inicial. Método virtual puro.

  • Retorna: String HTML do cartão de navegação

Métodos Virtuais (Sobrescritas opcionais)

virtual void onWebSocketConnection(IWebSocket& ws)

Chamado quando uma nova conexão WebSocket é estabelecida.

  • ws: Nova conexão WebSocket
virtual void onWebSocketClose(IWebSocket& ws)

Chamado quando uma conexão WebSocket é fechada.

  • ws: Conexão WebSocket fechada

Métodos Comuns

const char* getPagePath() const

Obtém o caminho de URL desta página.

  • Retorna: String do caminho da página
bool isEnabled() const

Verifica se a página está atualmente ativada.

  • Retorna: true se ativada, false se desativada
void setEnabled(bool enable)

Ativa ou desativa a página.

  • enable: true para ativar, false para desativar

Métodos Utilitários

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

Envia os cabeçalhos HTTP padrão ao cliente.

  • client: Interface do cliente web
  • contentType: Tipo MIME (padrão: "text/html")
void sendWebSocketMessage(IWebSocket& ws, const char* message)

Envia uma mensagem para um cliente WebSocket específico.

  • ws: Conexão WebSocket de destino
  • message: Mensagem a ser enviada
void broadcastToAllClients(const char* message)

Transmite (broadcast) uma mensagem para todos os clientes WebSocket conectados.

  • message: Mensagem a ser transmitida
void sendLargeHTML(IWebClient& client, const char* html)

Envia conteúdo HTML grande usando codificação de transferência em blocos (chunked).

  • client: Interface do cliente web
  • html: Conteúdo HTML a ser enviado

Exemplo de Uso

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 de Aplicativos Web

DIYablesHomePage

Hub central de navegação, com links para todos os aplicativos ativados.

Construtor

DIYablesHomePage()

Caminho da URL

  • Caminho: / (raiz)

DIYablesWebChatPage

Interface de chat interativa para comunicação bidirecional com o Arduino.

Construtor

DIYablesWebChatPage()

Caminho da URL

  • Caminho: /webchat

Métodos

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

Define o callback para as mensagens de chat recebidas.

void sendToWebChat(const String& message)

Envia uma mensagem para a interface de chat web.

DIYablesWebMonitorPage

Serial monitor baseado na web para saída em tempo real e entrada de comandos.

Construtor

DIYablesWebMonitorPage()

Caminho da URL

  • Caminho: /webmonitor

Métodos

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

Define o callback para as mensagens recebidas do monitor.

void sendToWebMonitor(const String& message)

Envia uma mensagem para a interface do monitor web.

DIYablesWebDigitalPinsPage

Controle e monitore os pinos digitais 0-13 pela interface web.

Construtor

DIYablesWebDigitalPinsPage()

Caminho da URL

  • Caminho: /webdigitalpins

Métodos

void enablePin(int pin, int mode)

Ativa um pino para controle pela web.

  • pin: Número do pino (0-13)
  • mode: WEB_PIN_OUTPUT ou WEB_PIN_INPUT
void onPinWrite(std::function<void(int, int)> callback)

Define o callback para operações de escrita no pino (pinos de saída).

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

Define o callback para operações de leitura no pino (pinos de entrada).

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

Define o callback para mudanças de modo do pino.

void updatePinState(int pin, int state)

Atualiza o estado do pino em tempo real para os clientes web.

DIYablesWebSliderPage

Controle com dois sliders para aplicações analógicas/PWM.

Construtor

DIYablesWebSliderPage()

Caminho da URL

  • Caminho: /webslider

Métodos

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

Define o callback para as mudanças de valor dos sliders vindas da web.

  • Parâmetros: slider1 (0-255), slider2 (0-255)
void onSliderValueToWeb(std::function<void()> callback)

Define o callback para quando o cliente web solicita os valores atuais.

void sendToWebSlider(int slider1, int slider2)

Envia os valores dos sliders para a interface web.

DIYablesWebJoystickPage

Controle de joystick 2D para aplicações de robótica e posicionamento.

Construtor

DIYablesWebJoystickPage(bool autoReturn = true, float sensitivity = 10.0)
  • autoReturn: Se o joystick retorna ao centro automaticamente
  • sensitivity: Porcentagem mínima de movimento para acionar as atualizações

Caminho da URL

  • Caminho: /webjoystick

Métodos

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

Define o callback para o movimento do joystick vindo da web.

  • Parâmetros: x (-100 a 100), y (-100 a 100)
void onJoystickValueToWeb(std::function<void()> callback)

Define o callback para quando o cliente web solicita a posição atual.

void sendToWebJoystick(int x, int y)

Envia a posição do joystick para a interface web.

void setAutoReturn(bool autoReturn)

Define o comportamento de retorno automático.

void setSensitivity(float sensitivity)

Define a sensibilidade do movimento (porcentagem).

DIYablesWebPlotterPage

Visualização de dados em tempo real com suporte a várias séries de dados.

Construtor

DIYablesWebPlotterPage()

Caminho da URL

  • Caminho: /webplotter

Métodos

void setPlotTitle(const String& title)

Define o título do gráfico.

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

Define os rótulos dos eixos.

void enableAutoScale(bool enable)

Ativa ou desativa o dimensionamento automático do eixo Y.

void setMaxSamples(int maxSamples)

Define o número máximo de pontos de dados a exibir.

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

Adiciona um ponto de dados a uma série.

void clearPlot()

Limpa todos os dados do gráfico.

DIYablesNotFoundPage

Página de erro 404 opcional para uma melhor experiência do usuário.

Construtor

DIYablesNotFoundPage()

Exemplo Básico de Uso

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

Visão Geral dos Aplicativos Web

Página Inicial

  • URL: http://[arduino-ip]/
  • Finalidade: Hub central de navegação
  • Recursos: Links para todos os aplicativos ativados, status da conexão

Aplicativo WebChat

  • URL: http://[arduino-ip]/webchat
  • Finalidade: Interface de comunicação bidirecional
  • Recursos: Mensagens em tempo real, histórico de mensagens, status do WebSocket

Web Monitor

  • URL: http://[arduino-ip]/webmonitor
  • Finalidade: Substituto do serial monitor
  • Recursos: Saída serial em tempo real, entrada de comandos, tema escuro

Controle de Pinos Digitais Web

  • URL: http://[arduino-ip]/webdigitalpins
  • Finalidade: Controlar os pinos digitais 0-13
  • Recursos: Controle individual de pinos, operações em lote, status em tempo real

Controle de Slider Web

  • URL: http://[arduino-ip]/webslider
  • Finalidade: Controle analógico/PWM duplo
  • Recursos: Dois sliders independentes (0-255), valores predefinidos, retorno em tempo real

Controle de Joystick Web

  • URL: http://[arduino-ip]/webjoystick
  • Finalidade: Controle de posição 2D para robôs/veículos
  • Recursos: Controle por toque/mouse, exibição de coordenadas, ajuste de sensibilidade

Web Plotter

  • URL: http://[arduino-ip]/webplotter
  • Finalidade: Visualização de dados em tempo real
  • Recursos: Várias séries de dados, dimensionamento automático, títulos e eixos configuráveis

Comunicação WebSocket

Todos os aplicativos usam WebSocket na porta 81 para comunicação em tempo real:

  • URL do WebSocket: ws://[arduino-ip]:81
  • Conexão: Reconexão automática em caso de desconexão
  • Protocolo: Formato de mensagem baseado em texto

Formatos de Mensagem

Mensagens do WebChat

  • Da Web: Mensagem de texto direta
  • Para a Web: Mensagem de texto direta

Mensagens do Web Monitor

  • Da Web: Mensagem de texto direta
  • Para a Web: Mensagem de texto direta

Mensagens de Pinos Digitais Web

  • Da Web: Formato JSON: {"pin": 13, "state": 1}
  • Para a Web: Formato JSON: {"pin": 13, "state": 1}

Mensagens do Slider Web

  • Da Web: Formato JSON: {"slider1": 128, "slider2": 255}
  • Para a Web: Formato JSON: {"slider1": 128, "slider2": 255}

Mensagens do Joystick Web

  • Da Web: Formato JSON: {"x": 50, "y": -25}
  • Para a Web: Formato JSON: {"x": 50, "y": -25}

Mensagens do Web Plotter

  • Da Web: Não se aplica (somente exibição)
  • Para a Web: Formato JSON: {"series": "temp", "x": 10.5, "y": 23.4}

Tratamento de Erros

A biblioteca inclui tratamento automático de erros para:

  • Falhas na conexão WiFi
  • Desconexões do WebSocket
  • Formatos de mensagem inválidos
  • Limites de conexões de clientes

Uso de Memória

Benefícios da Arquitetura Modular: Inclua apenas os aplicativos web de que você precisa para otimizar o uso de memória.

Uso aproximado de memória por componente:

  • DIYablesWebAppServer: ~8KB de Flash, ~2KB de RAM
  • DIYablesHomePage: ~3KB de Flash, ~1KB de RAM
  • DIYablesWebChatPage: ~6KB de Flash, ~1,5KB de RAM
  • DIYablesWebMonitorPage: ~5KB de Flash, ~1,5KB de RAM
  • DIYablesWebDigitalPinsPage: ~8KB de Flash, ~2KB de RAM
  • DIYablesWebSliderPage: ~6KB de Flash, ~1,5KB de RAM
  • DIYablesWebJoystickPage: ~7KB de Flash, ~1,5KB de RAM
  • DIYablesWebPlotterPage: ~10KB de Flash, ~2KB de RAM
  • Buffer do WebSocket: ~1KB de RAM por conexão

Total com todos os apps ativados: ~53KB de Flash, ~12KB de RAM

Configuração mínima (servidor + página inicial + 1 app): ~17KB de Flash, ~4,5KB de RAM

Compatibilidade com Navegadores

Navegadores compatíveis:

  • Chrome 50+
  • Firefox 45+
  • Safari 10+
  • Edge 79+
  • Navegadores móveis (iOS Safari, Chrome Mobile)

Observações de Segurança

  • Nenhuma autenticação implementada (adequado somente para redes locais)
  • Use somente em redes confiáveis
  • Considere adicionar autenticação para implantações públicas

Solução de Problemas

Problemas Comuns

  1. Não consigo conectar ao WiFi

- Verifique o SSID e a senha

- Verifique se a rede é de 2,4GHz (não de 5GHz)

- Verifique a intensidade do sinal

  1. A conexão WebSocket falha

- Verifique se o endereço IP está correto

- Verifique as configurações do firewall

- Tente outro navegador

  1. Alto uso de memória

- Desative os aplicativos não utilizados

- Limite as conexões simultâneas

- Reinicie o Arduino se ocorrer fragmentação de memória

  1. Resposta lenta

- Verifique a intensidade do sinal WiFi

- Reduza a frequência das mensagens WebSocket

- Use funções de callback mais curtas

Projetos de Exemplo

Aplicativos de Exemplo

A biblioteca DIYables WebApps inclui exemplos completos projetados para a plataforma educacional Arduino Uno R4 WiFi e DIYables STEM V4 IoT:

Exemplos Disponíveis

  • Exemplo Chat: Interface de comunicação bidirecional
  • Exemplo WebMonitor: Substituto do serial monitor com recursos aprimorados
  • Exemplo WebDigitalPins: Controle todos os pinos digitais com retorno visual
  • Exemplo WebSlider: Controle analógico/PWM duplo com valores predefinidos
  • Exemplo WebJoystick: Controle de posição 2D para projetos de robótica
  • Exemplo MultipleWebApps: Todos os aplicativos executados simultaneamente

Compatibilidade de Hardware

  • Recomendado: DIYables STEM V4 IoT (recursos aprimorados, sensores integrados)
  • Compatível: Arduino Uno R4 WiFi

Recursos do Tutorial

Tutoriais completos passo a passo disponíveis em:

  • Newbiely.com/tutorials/arduino/arduino-uno-r4-wifi-web-apps
  • Guias específicos do DIYables STEM V4 IoT e exemplos de integração de sensores

Veja a pasta examples/ para projetos completos e a pasta docs/ para instruções detalhadas de configuração.

Interfaces de Abstração de Plataforma

A biblioteca DIYables WebApps usa uma camada de abstração de plataforma, com interfaces que permitem o suporte a várias plataformas de hardware. Essas interfaces separam a funcionalidade principal do WebApp das implementações específicas de cada plataforma.

Interfaces Principais

IWebClient

Interface para conexões de cliente 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 para conexões WebSocket com suporte à comunicação bidirecional.

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 para a funcionalidade de servidor 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 para o servidor WebSocket com gerenciamento de conexões.

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

Interface para o gerenciamento da conectividade de rede.

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

Interface de fábrica (factory) para criar implementações específicas de cada plataforma.

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

Exemplo de Implementação de Plataforma

Para o Arduino Uno R4 WiFi, as interfaces são implementadas usando a biblioteca 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"; } };

Adicionando Suporte a Novas Plataformas

Para adicionar suporte a uma nova plataforma (por exemplo, ESP32):

  1. Implemente todas as interfaces para a plataforma de destino
  2. Crie uma ServerFactory que instancie as suas implementações
  3. Trate o uso de rede e os protocolos WebSocket específicos da plataforma
  4. Teste com as classes WebApp existentes (nenhuma alteração é necessária)

Exemplo de uso com diferentes plataformas:

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

Benefícios do Design Baseado em Interfaces

  • Independência de Plataforma: A lógica principal do WebApp funciona em qualquer plataforma
  • Extensibilidade: Fácil de adicionar suporte a novo hardware
  • Manutenibilidade: O código específico de cada plataforma fica isolado
  • Testabilidade: As interfaces podem ser simuladas (mock) para testes unitários
  • Consistência: A mesma API em todas as plataformas suportadas

Plataformas Suportadas Atualmente

  • ✅ Arduino Uno R4 WiFi: Totalmente implementado e testado
  • 🔄 ESP32: Disponível como extensão separada - DIYables_WebApps_ESP32
  • 🚀 Futuras Plataformas: Podem ser adicionadas usando o mesmo padrão de interface

Tutoriais Relacionados

※ NOSSAS MENSAGENS

  • Fique à vontade para compartilhar o link deste tutorial. Porém, por favor, não use nosso conteúdo em outros sites. Investimos muito esforço e tempo para criar este conteúdo, por favor respeite nosso trabalho!
DIVULGAÇÃO
pt.newbiely.com participa do Programa de Associados da Amazon Services LLC, um programa de publicidade de afiliados criado para oferecer aos sites um meio de ganhar taxas de publicidade ao anunciar e criar links para Amazon.com, Amazon.it, Amazon.de, Amazon.co.uk, Amazon.ca, Amazon.de, Amazon.es, Amazon.nl, Amazon.pl e Amazon.se
Copyright © 2026 pt.newbiely.com. Todos os direitos reservados.
Termos e Condições | Política de Privacidade
Email: newbiely.com@gmail.com