O editor

WiFi, simulado

A placa pode entrar numa rede, buscar uma página e servir uma. O rádio é simulado, e, com você conectado, a opção Internet real alcança servidores reais.

O rádio é simulado. Não há 802.11 em lugar nenhum do Mokxi e nada que um sketch faça pode alcançar a rede em que seu navegador está. O que é fiel é o código Arduino que você escreve, e é exatamente esse o ponto, porque é o código que você escreveria para uma placa real.

Toda placa com rádio no hardware real o tem: a família ESP32 (o ESP32-C3, ESP32-C6, o ESP32 clássico e o ESP32-S3, e as placas construídas sobre eles, como a XIAO e a Nano ESP32), as placas ESP8266, a Raspberry Pi Pico W e a Uno R4 WiFi. Em toda outra placa daqui, incluindo uma Raspberry Pi Pico comum, que não tem componente sem fio, #include <WiFi.h> para com uma frase dizendo isso em vez de escrever num endereço que seu chip não tem. Isso é de propósito: um stub que respondesse "não conectado" seria uma mentira com aparência plausível, e um erro de compilação não é.

O que é real e o que não é

Real, no sentido de que se comporta como sua placa vai se comportar:

  • as chamadas (WiFi.begin(), WiFi.status(), WiFi.localIP(), HTTPClient, WebServer) com as assinaturas que um tutorial dá;
  • os códigos de status, que são o próprio enum do Arduino, valor por valor;
  • o tempo: conectar leva entre um e três segundos, e uma senha errada falha depois de cinco, que é onde uma placa real numa rede tranquila chega;
  • o custo: uma requisição realmente leva 60 ms do tempo do sketch, e um sketch que esquece server.handleClient() realmente nunca responde.

Não real, e nunca fez de conta que era:

  • sem rádio. Sem canal, sem varredura, sem scanNetworks(), sem beacon, sem WPA2, sem criptografia de tipo algum. A senha é comparada como uma string.
  • sem internet real, a menos que você a ative. Sem TCP, sem DNS, sem sockets, nada que saia da aba do navegador. Quatro nomes inventados sob .mokxi existem e nenhum outro, até que o interruptor Internet real do painel Cloud esteja ligado: aí uma requisição para qualquer outro nome sai pelo gateway do Mokxi.
  • sem TLS na placa. WiFiClientSecure compila e depois falha, dizendo isso. Uma URL https:// falha do mesmo jeito, a menos que Internet real esteja ligada: aí o gateway faz o TLS para uma requisição HTTPClient. Um TLS na placa que confiasse em tudo ensinaria que https é de graça.
  • sem segunda máquina. Uma placa, uma rede, um endereço. Nada fora desta aba do navegador pode alcançar o servidor em que seu sketch roda. O ponto de acesso da própria placa (abaixo) tem exatamente um celular nele, o painel Web.
  • RSSI() é uma configuração, não uma medição. Mover a placa no canvas não muda nada.
  • O NTP dá o relógio da simulação, não a hora real. Não há UDP nem servidor NTP, e a simulação não sabe a data de hoje, então configTime() e o update() do NTPClient definem o relógio para 2026-01-01 00:00:00 UTC no boot mais os segundos desde então, e o monitor serial avisa isso uma vez.
  • Bluetooth is its own simulation. The ESP32 boards' Bluetooth serial and BLE talk to a phone in the Bluetooth pane (Bluetooth, simulado). O Bluetooth do Pico W não é simulado.

Configurando a rede

Clique na placa e olhe o painel de propriedades: wifiSsid, wifiPassword e wifiRssi. Esses três são o único ponto de acesso que esta placa consegue ver. Sem rádio não há o que escanear, então a rede é uma propriedade da placa em vez de um componente que você coloca ao lado dela.

Corresponda os dois no seu sketch e ele conecta. Erre um deles de propósito e veja o que acontece. Essa é a mais útil das duas lições.

O painel Cloud edita os mesmos três enquanto o sketch está rodando, então você pode tirar a rede de debaixo de uma placa em funcionamento e ver o laço de conexão começar de novo.

Entrando

#include <WiFi.h>

void setup() {
  Serial.begin(115200);
  WiFi.begin("Mokxi-Lab", "breadboard");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(250);
  }
  Serial.println(WiFi.localIP());   // 192.168.4.2
}

WiFi.status() passa por WL_IDLE_STATUS, depois WL_DISCONNECTED enquanto associa, e então WL_CONNECTED. Não existe WL_CONNECTING no Arduino, e é por isso que o laço acima é escrito do jeito que todo tutorial escreve.

Uma senha errada vira WL_CONNECT_FAILED depois de cinco segundos. Um nome que não é o da placa vira WL_NO_SSID_AVAIL. O endereço é sempre 192.168.4.2, e é o mesmo endereço depois de um disconnect() e um segundo begin().

Buscando dados

#include <HTTPClient.h>
WiFiClient client;
HTTPClient http;
http.begin(client, "http://weather.mokxi/");
int code = http.GET();
if (code > 0) Serial.println(http.getString());
else Serial.println(HTTPClient::errorToString(code));
http.end();

Existem quatro endereços nesta internet simulada:

  • http://time.mokxi/: o relógio da simulação, como uma string ISO. É o relógio do kernel contado a partir de uma meia-noite fixa, não a hora do dia, porque a simulação não sabe que dia é.
  • http://weather.mokxi/: JSON com uma temperatura e uma umidade que você define no painel Cloud. Mude um dos dois e a próxima busca traz o número novo de volta.
  • http://echo.mokxi/: o que você enviar com POST volta direto para você. Também é o único servidor WebSocket daqui: o WebSocketsClient da biblioteca WebSockets apontado para echo.mokxi envia cada mensagem como uma requisição para ele e a recebe de volta como WStype_TEXT. É um eco simulado carregado como HTTP, não um WebSocket no fio; qualquer outro host de WebSocket precisa de uma placa de verdade.
  • http://api.mokxi/: o status, o tipo de conteúdo e o corpo JSON que você define no painel Cloud, para você praticar um sucesso, um erro ou dados faltando.

Qualquer outro endereço não resolve. http://example.com/ volta como HTTPC_ERROR_CONNECTION_REFUSED, e HTTPClient::errorToString() diz o porquê em uma linha: no real internet: names under .mokxi only. Essa recusa é legível no sketch de propósito. É algo que vale a pena ensinar, não algo para esconder.

Servindo

#include <WebServer.h>
WebServer server(80);

void setup() {
  // ... join the network first ...
  server.on("/", [](){ server.send(200, "text/html", "<h1>hello</h1>"); });
  server.begin();
}

void loop() { server.handleClient(); }

on(path, handler), onNotFound(), send(code, type, body), arg(name), hasArg(), uri() e method(). Seus handlers são o seu código, rodando no core da placa no relógio da placa.

O painel Web (uma aba ao lado de Serial, na parte de baixo) é o navegador para eles. Tem uma barra de endereço que começa em http://192.168.4.2/, um botão de atualizar e a própria página num quadro com scripts desligados. Links e botões dessa página voltam para o seu sketch, e é isso que faz "acender o LED a partir de uma página web" funcionar de ponta a ponta.

Se a página nunca chega, o painel avisa, e depois de dez segundos a própria rede responde 504: o motivo habitual é um loop() que parou de chamar handleClient().

O próprio ponto de acesso da sua placa

Um sketch pode iniciar uma rede própria em vez de entrar numa, como uma página de configuração ou o controle de um robô faz:

#include <WiFi.h>
#include <WebServer.h>
WebServer server(80);

void setup() {
  Serial.begin(115200);
  WiFi.softAP("MyESP", "12345678");
  Serial.println(WiFi.softAPIP());   // 192.168.4.1
  server.on("/", [](){ server.send(200, "text/html", "<h1>hello</h1>"); });
  server.begin();
}

void loop() { server.handleClient(); }

O painel Web é o celular que se conecta a ele. Cerca de um segundo e meio depois que o ponto de acesso aparece, uma linha abaixo da barra de endereço diz Celular conectado a MyESP, e a barra de endereço muda para http://192.168.4.1/: aperte Ir. Aperte Sair e o celular desconecta; Conectar conecta de novo com a senha digitada na caixa, e uma senha errada é recusada, como em um celular. Enquanto está conectado, WiFi.softAPgetStationNum() é 1 e WiFi.onEvent() recebe os eventos de estação conectada e desconectada.

Uma senha precisa ter de 8 a 63 caracteres (ou nenhuma, para uma rede aberta), senão softAP() retorna false, como na placa de verdade. softAPConfig() muda o endereço. WIFI_AP_STA roda os dois: a placa mantém sua concessão na rede simulada e ainda pode buscar páginas .mokxi. No Pico W o endereço é 192.168.42.1 (192.168.4.1 com a estação ligada também), como o arduino-pico escolhe, e WiFi.beginAP() o inicia; no Uno R4 WiFi, WiFi.beginAP() e WL_AP_CONNECTED se comportam como nos exemplos do WiFiS3.

Portais cativos também funcionam: inicie um DNSServer com dnsServer.start(53, "*", WiFi.softAPIP()) e, quando o celular entra, o painel Web abre sua página sozinho, do jeito que um celular mostra uma tela de login. Em MicroPython, network.WLAN(network.AP_IF) é o mesmo ponto de acesso, e um servidor de socket na porta 80 aparece no painel Web.

O único celular é tudo o que existe: nenhum segundo aparelho pode entrar, e nada chega à internet pela placa.

O painel Cloud

Cada requisição, nos dois sentidos: o que a placa pediu à internet simulada, e o que o painel Web pediu à placa, com o método, o endereço, o status, os corpos e, quando algo falhou, uma linha explicando o porquê. É a aba de rede de uma placa.

Ele também tem os dois mostradores de weather.mokxi, as três configurações do ponto de acesso e o laboratório de API, onde você escolhe o que api.mokxi responde. Uma aula pode mudar um deles e ver o sketch perceber.

Um sketch Blynk ganha uma Blynk seção lá também, com seus pinos virtuais e uma caixa para enviar um valor a cada um: veja Blynk, simulado.

No Pico W

O Pico W é um Pico com um chip sem fio, e seu código de WiFi é o mesmo WiFi.h de cima. Duas coisas mudam em relação a um Pico comum, como na placa real:

  • LED_BUILTIN é o LED da placa, e GP25 não é. O LED fica no chip sem fio, então digitalWrite(LED_BUILTIN, HIGH) o acende. GP25 controla a linha de seleção do chip sem fio, então um sketch que escreve em GP25 não acende nada, aqui nem na mesa.
  • O LED fica apenas ligado ou desligado. analogWrite(LED_BUILTIN, ...) não faz nada, então use fade em um LED em um pino comum.

MicroPython and CircuitPython run on the Pico W as well, with its CYW43439 modeled from its pins: network.WLAN in MicroPython and wifi.radio in CircuitPython join the same simulated access point, with the board's WiFi properties as its name and password. See o Pico W; os detalhes completos estão em o modelo do Pico W.

Ethernet cabeada (ETH.h)

Nas placas ESP32, a biblioteca de Ethernet cabeada do core também compila e roda, para sketches escritos para um WT32-ETH01, um Olimex ESP32-POE ou um módulo W5500. Escolha um ESP32 DevKit para um sketch de WT32-ETH01 ou ESP32-POE: é o mesmo chip.

#include <ETH.h>

void onEvent(arduino_event_id_t event) {
  if (event == ARDUINO_EVENT_ETH_GOT_IP) Serial.println(ETH.localIP());
}

void setup() {
  Serial.begin(115200);
  Network.onEvent(onEvent);   // WiFi.onEvent(onEvent) on core 2.x
  ETH.begin();
}

Não há cabo nem chip de Ethernet. ETH.begin() entra na mesma rede simulada que o WiFi, sem nome de rede nem senha, e cerca de 1,5 segundo depois ele tem o endereço 192.168.4.2. A partir daí, WiFiClient, HTTPClient, WebServer e PubSubClient funcionam sobre ele exatamente como funcionam sobre WiFi, o painel Web alcança o servidor do sketch, e a chave Internet real e seus limites são os mesmos.

  • As chamadas de ETH.begin() dos dois cores compilam: no core 2.x, ETH.begin(addr, power, mdc, mdio, type, clock); no core 3.x, ETH.begin(ETH_PHY_LAN8720, addr, mdc, mdio, power, clock) e sua forma para W5500, ETH.begin(ETH_PHY_W5500, addr, cs, irq, rst, SPI).
  • Os eventos chegam na ordem do core: ARDUINO_EVENT_ETH_START, ARDUINO_EVENT_ETH_CONNECTED, ARDUINO_EVENT_ETH_GOT_IP e, depois de ETH.end(), ARDUINO_EVENT_ETH_DISCONNECTED e ARDUINO_EVENT_ETH_STOP.
  • ETH.linkUp(), ETH.linkSpeed() (100) e ETH.fullDuplex() (true) lêem como uma placa ligada a um switch. O cabo está sempre conectado.
  • ETH.config(ip, gateway, mask, dns) define um endereço estático, e ETH.localIP() o informa. O painel Web continua alcançando a placa em 192.168.4.2.
  • A placa tem um único link com a rede. WiFi.begin() depois de ETH.begin() o transfere para o WiFi, e WiFi.status() lê esse único link em qualquer caso.
  • Só o ESP32 clássico tem o controlador Ethernet de que um LAN8720 precisa. Em um ESP32-S3, C3 ou C6, uma placa real usa um W5500 via SPI; um sketch com LAN8720 ainda roda aqui, e o monitor serial avisa isso uma vez.

Internet de verdade

O interruptor Internet real no topo do painel Cloud funciona para qualquer pessoa com login: o Grátis envia 100 requisições por dia, e o Pro tem mais. Desligado, que é como toda sessão começa, nada acima muda. Ligado, uma requisição para um nome fora de .mokxi (incluindo https://) sai para a internet real pelo gateway do Mokxi, e a resposta volta para o seu sketch; os nomes .mokxi continuam simulados. Uma placa no ponto de acesso Wokwi-GUEST, como é o caso de uma importação do Wokwi, liga o interruptor sozinha ao rodar. Sem login, o interruptor convida para criar uma conta grátis, e a placa mantém a rede simulada. Um bot do Telegram (UniversalTelegramBot.h) também funciona assim, e só assim. Internet real tem os detalhes e os limites.

Experimente estes

  • WiFi: conectar na rede: o laço de conexão, o endereço e o sinal.
  • WiFi: buscar o clima: HTTPClient contra weather.mokxi, e uma requisição proposital para example.com para você ler a recusa com seus próprios olhos.
  • WiFi: uma lâmpada em uma página web: dois botões e um formulário que acendem o LED no GPIO 8.
  • Laboratório de API: buscar JSON: um GET normal com HTTPClient para api.mokxi. Mude a resposta no painel Cloud e rode a requisição de novo.
  • Servidor web no ponto de acesso do ESP32: a própria rede da placa, MyESP, e uma página que o telefone do painel Web abre em 192.168.4.1, com botões para um LED.

Os três primeiros vêm para o ESP32-C3, ESP32-C6, ESP32 DevKit, ESP32-S3, ESP8266 e Pico W, e o Uno R4 WiFi tem seu próprio exemplo de conexão. Todos compilam no navegador, exatamente como qualquer outro exemplo.

O contrato completo, registrador por registrador e limite por limite, está em WiFi simulado.