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
.mokxiexistem 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.
WiFiClientSecurecompila e depois falha, dizendo isso. Uma URLhttps://falha do mesmo jeito, a menos que Internet real esteja ligada: aí o gateway faz o TLS para uma requisiçãoHTTPClient. 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 oupdate()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 comPOSTvolta direto para você. Também é o único servidor WebSocket daqui: oWebSocketsClientda biblioteca WebSockets apontado paraecho.mokxienvia cada mensagem como uma requisição para ele e a recebe de volta comoWStype_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ãodigitalWrite(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_IPe, depois deETH.end(),ARDUINO_EVENT_ETH_DISCONNECTEDeARDUINO_EVENT_ETH_STOP. ETH.linkUp(),ETH.linkSpeed()(100) eETH.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, eETH.localIP()o informa. O painel Web continua alcançando a placa em192.168.4.2.- A placa tem um único link com a rede.
WiFi.begin()depois deETH.begin()o transfere para o WiFi, eWiFi.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:
HTTPClientcontraweather.mokxi, e uma requisição proposital paraexample.compara 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
HTTPClientparaapi.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.