El contrato de la red de Mokxi: qué puede hacer un sketch, qué es fiel y qué no existe en absoluto. El contrato propio de cada placa tiene la tabla de registros (docs/esp32c3.md 3.8, docs/esp32c6.md 3.8, docs/esp32.md 3.8, docs/esp32s3.md 3.10, docs/esp8266.md 3.9, docs/picow.md 3.8). crates/net es el modelo; este archivo prevalece sobre todos ellos.
En una sola frase
The radio is simulated. There is no 802.11, there is no real internet, and
the WiFi runtime is Mokxi's own. Nothing in Mokxi transmits, receives, scans,
associates, encrypts or opens a socket to the outside (boards of one project
can open TCP connections to each other, below). A password is compared as a string. The
only names that resolve are four made-up ones under .mokxi and the board's
own address, and nothing a sketch does can reach the network the browser is on.
Every page that mentions WiFi says this, in the properties panel, in the Web and
Cloud panels' first line, in the help article, on the board page, and in the
examples themselves.
La única excepción es opcional y está apagada en cada carga de página: el modo internet real (abajo), donde la página, no el motor, envía las peticiones de nombres fuera de .mokxi de un sketch a través de nuestro gateway, para cualquiera con sesión iniciada (una pequeña cuota en Gratis, más con Pro). Con él apagado, que es lo predeterminado y el único modo sin sesión iniciada, cada oración de arriba se cumple exactamente. Una placa que se une a Wokwi-GUEST lo enciende al iniciar una ejecución.
Por qué un buzón, y por qué eso es honesto
En un ESP32 real el hardware de WiFi no es un conjunto de registros documentados. Es un blob binario cerrado con una interfaz de comandos, y cada línea del WiFi.h de Arduino termina al otro lado de uno. Así que el modelo es un buzón: un registro de comandos, un registro de estado, un búfer circular en cada sentido y un bit de interrupción, en 0x6FFF_E000 en el ESP32-C3: un bloque propio de Mokxi, no del chip, por encima de cada periférico real, en una dirección que un C3 real deja sin mapear para que una imagen que lo use falle en el silicio en lugar de leer el registro de otro.
Esa es toda la mentira, y tiene la misma forma que la verdad. Lo que no es es un MAC 802.11 falso: no hay tramas, ni canales, ni tasas, ni intervalo de baliza en ninguna parte de este código, porque un modelo de eso sería una invención sin nada contra qué verificarlo.
Las seis placas, y el único número que difiere
El bloque es independiente de la placa. crates/net no sabe nada de ninguna placa; el SoC elige un número, la dirección base, y reenvía los accesos de palabra. Seis placas lo hacen, y son exactamente las seis que tienen radio en el hardware real:
| placa | el buzón está en | lo que la pieza real tiene ahí |
|---|---|---|
| ESP32-C3 DevKitM-1 | 0x6FFF_E000 |
nada: sus periféricos terminan muy por debajo |
| ESP32-C6-DevKitC-1 | 0x6FFF_E000 |
nada: el mismo lugar está vacío también en esta pieza |
| ESP32 DevKit (WROOM-32) | 0x3FEF_E000 |
un hueco reservado entre las ventanas de memoria externa y la ventana de periféricos |
| ESP32-S3-DevKitC-1 | 0x6FFF_E000 |
nada: los periféricos terminan en 0x600D_0FFF y la memoria RTC FAST en 0x600F_FFFF |
| ESP8266 NodeMCU | 0x6FFF_E000 |
nada: sus bloques reales están todos en los primeros kilobytes de esa ventana |
| Raspberry Pi Pico W | 0x4FFF_E000 |
nada: por encima de cada periférico APB, por debajo de AHB-Lite |
En una Pico W la costura tiene la misma forma por una razón distinta: la parte inalámbrica es una CYW43439 al otro lado de un enlace tipo SPI de tres pines manejado por un blob binario cerrado, que no es más un conjunto de registros documentados en el RP2040 de lo que la radio de un ESP32 lo es en su propio chip. Una interfaz de comandos es lo que realmente está ahí. (Los firmwares oficiales de MicroPython y CircuitPython para la Pico W manejan el chip por su cuenta, y para ellos se modela a partir de sus pines en cambio, con el buzón sin mapear: docs/cyw43.md.)
firmware/include/mokxi_net.h es la única definición de cada registro, bit y código de comando; el header de cada placa define la dirección base y lo incluye, y firmware/tools/check_registers.py obliga a los seis headers a cumplir las tablas de sus contratos, dirección base incluida. Un periférico inventado es justo el que más necesita que ambas mitades queden amarradas.
Every other board refuses. A plain Raspberry Pi Pico, the Uno, the Nano,
the Mega, the Leonardo, the ATtiny85, the XIAO SAMD21, the Uno R4, the STM32s
and the micro:bit have no wireless part on them, so WiFi.h, HTTPClient.h
and WebServer.h fail to compile with a sentence pointing here, rather than
letting a sketch write to an address its chip does not have. A stub that answered
"not connected" would be a lie with a plausible shape; a compile error is not.
The Pico and the Pico W therefore carry different program strings
(elf32 arm rp2040 and elf32 arm rp2040 picow), as the Uno's and the Nano's
do, so the editor offers each board its own examples.
Lo que un estudiante puede hacer
Join the network
El mismo código en las seis placas; el header es WiFi.h en todas, porque así se llama la API de Arduino en la familia ESP32 y en la Pico W.
#include <WiFi.h>
WiFi.mode(WIFI_STA);
WiFi.begin("Mokxi-Lab", "breadboard");
while (WiFi.status() != WL_CONNECTED) { Serial.print("."); delay(250); }
Serial.println(WiFi.localIP());
El SSID y la contraseña son propiedades de la placa: haz clic en la placa del editor y define wifiSsid, wifiPassword y wifiRssi. Las seis placas llevan las mismas tres, de crates/parts/src/wifi.rs, con los mismos valores por omisión y la misma validación. Sin radio no hay nada que escanear ni a dónde trasladar los ajustes de un componente aparte, así que el único punto de acceso que una placa puede ver es un ajuste de la placa. El panel Cloud edita esos mismos tres valores mientras el sketch se ejecuta.
WiFi.status() pasa por WL_IDLE_STATUS, luego WL_DISCONNECTED mientras se asocia, y luego WL_CONNECTED, que es la secuencia propia de Arduino, porque Arduino no tiene WL_CONNECTING y un componente que se está asociando reporta WL_DISCONNECTED. WiFi.localIP() es 192.168.4.2, gatewayIP() es 192.168.4.1, RSSI() es la propiedad wifiRssi, SSID() es el nombre del punto de acceso y macAddress() es la MAC propia de la placa: su ajuste wifiMac, o, si se deja vacío, una que el motor calcula a partir del id del componente (02:4D:4F: más tres bytes), igual en cada ejecución y distinta para cada placa del lienzo, de modo que ESP-NOW puede distinguirlas (docs/help/editor/esp-now.md).
Si te equivocas en la contraseña, WiFi.status() pasa a WL_CONNECT_FAILED. Si te equivocas en el nombre, pasa a WL_NO_SSID_AVAIL. WiFi.disconnect() la regresa a inactivo, y el siguiente begin() obtiene de nuevo la misma dirección en préstamo.
Obtener algo
#include <HTTPClient.h>
WiFiClient client;
HTTPClient http;
http.begin(client, "http://weather.mokxi/");
int code = http.GET();
String body = http.getString();
http.end();
Existen cuatro orígenes, y no hay otros:
| nombre | responde |
|---|---|
http://time.mokxi/ |
el reloj del kernel como cadena ISO, text/plain |
http://weather.mokxi/ |
JSON con una temperatura y una humedad que define el panel Cloud |
http://echo.mokxi/ |
el cuerpo que enviaste, de regreso; también el servidor de eco WebSocket simulado para WebSocketsClient |
http://api.mokxi/ |
el estado, el tipo de contenido y el cuerpo de respuesta configurados en el panel Cloud |
http://192.168.4.2/ (y http://board.mokxi/) es el servidor propio del sketch, que es la única dirección a la que un sketch no puede llamar con provecho, porque tendría que responderse a sí mismo; recibe un 404 que lo dice.
Cualquier otro .mokxi nombre es un 404. Todo lo que no esté bajo .mokxi no se resuelve en absoluto: http.GET() devuelve HTTPC_ERROR_CONNECTION_REFUSED y
HTTPClient::errorToString() devuelve la única frase en torno a la que se construye toda esta función: sin internet real: solo nombres bajo .mokxi. https:// devuelve
HTTPC_ERROR_NO_TLS.
Servir algo
#include <WebServer.h>
WebServer server(80);
server.on("/", [](){ server.send(200, "text/html", "<h1>hello</h1>"); });
server.begin();
// in loop():
server.handleClient();
on(path, handler), onNotFound(), send(code, type, body), arg(name), hasArg(), uri(), method() y handleClient(). Cuando no hay una solicitud en espera, handleClient() espera 1 ms, como lo hacen el núcleo de la ESP32 y arduino-pico (el de la ESP8266 no), así que un loop() que solo atiende solicitudes se queda en reposo dentro de delay() y corre más rápido que el tiempo real; enableDelay(false) hace que gire sin parar, igual que allí. Un bucle que sondea WiFiServer::available() gira sin parar en el chip real y aquí. Los manejadores son tu código en el núcleo de la placa, al reloj de la placa. El panel Web del panel inferior es el navegador para ellos: una barra de direcciones en http://192.168.4.2/, un botón Actualizar y la página renderizada en un marco aislado con scripts desactivados. Los enlaces y envíos de formularios dentro de él se capturan y se enrutan de vuelta a la red simulada, así que "prender el LED desde una página web" funciona de punta a punta.
Nada fuera de la pestaña del navegador puede alcanzar ese servidor. No hay un socket a la escucha. El panel Web es el único cliente que existe.
Ejecutar el punto de acceso propio de la placa (soft AP)
#include <WiFi.h>
#include <WebServer.h>
WebServer server(80);
WiFi.mode(WIFI_AP);
WiFi.softAP("MyESP", "12345678"); // true: the access point is up
Serial.println(WiFi.softAPIP()); // 192.168.4.1
server.on("/", [](){ server.send(200, "text/html", "<h1>hello from MyESP</h1>"); });
server.begin();
// in loop(): server.handleClient();
The soft AP is simulated the same way the station is: no beacon goes out, nothing associates, and the password is compared as a string. What is there is the board's own network, the Web panel's phone and any other ESP boards in the project that join it (below). When the access point comes up, the phone joins it 1.5 s later (a phone that has the network saved), and the Web panel shows a row under its address bar, Phone joined MyESP as 192.168.4.2, with Leave; left, the row has the password a phone would type (the sketch's, to start with) and Join. A wrong password is refused, wrong password for MyESP; an open network takes any. While the phone is joined:
- el panel alcanza el servidor del sketch en la dirección del punto de acceso (
http://192.168.4.1/, o la que definiósoftAPConfig()), y la barra de direcciones se mueve allí sola: presiona Ir.WebServer, unWiFiServerescrito a mano,AsyncWebServery los servidores de la ESP8266 y la Pico W responden todos, yserver.hostHeader()es la dirección (o el nombre) que pidió el panel; WiFi.softAPgetStationNum()(andWiFi.AP.stationCount()) counts the phone, one less once it leaves (boards that joined count too);WiFi.onEvent()recibe los eventos del núcleo en su orden:ARDUINO_EVENT_WIFI_AP_STARTdespués desoftAP(), luegoARDUINO_EVENT_WIFI_AP_STACONNECTED(la MAC del celular,02:50:48:4F:4E:45, aid 1) yARDUINO_EVENT_WIFI_AP_STAIPASSIGNED(192.168.4.2, la dirección posterior a la del punto de acceso, ya que el servidor DHCP de ESP-IDF entrega las direcciones en ese orden) en cada conexión,ARDUINO_EVENT_WIFI_AP_STADISCONNECTED(razón 8) en cada desconexión, yARDUINO_EVENT_WIFI_AP_STOPdespués desoftAPdisconnect()o de un modo sin la mitad de punto de acceso. Igual que los de la estación, se ejecutan desdedelay(), unos 100 ms después del cambio, así que un bucle que consultesoftAPgetStationNum()puede ver el conteo primero.
Lo que siguen los núcleos: softAP() rechaza un nombre vacío y una contraseña de uno a siete caracteres (o de más de 63), devuelve false y lo explica una vez en el monitor serie; softAPIP() es 0.0.0.0 mientras el punto de acceso está apagado;
softAPConfig() antes o después softAP() lo mueve (y el préstamo del celular a la dirección siguiente), y softAPSubnetMask(), softAPBroadcastIP(),
softAPNetworkID() y softAPSubnetCIDR() siguen; WiFi.getMode() es
WIFI_AP después de softAP() solo, WIFI_AP_STA con begin() también.
Otras placas del lienzo también se unen. Las placas ESP de un proyecto comparten un mismo aire simulado (el mismo que usa ESP-NOW), así que una estación en una placa se une al soft AP de otra: WiFi.begin("MyESP", "12345678") con el nombre y la contraseña que dio la otra placa softAP() termina en WL_CONNECTED, con una dirección de la subred del punto de acceso (192.168.4.2, luego .3, en el orden en que lo pidieron), y softAPgetStationNum() cuenta cada una. Una contraseña incorrecta termina en
WL_CONNECT_FAILED; una estación que pide antes de que el punto de acceso esté levantado sigue buscando y se une cuando lo está. HTTPClient reaches the access point's
WebServer at its address (192.168.4.1); an HTTPClient request for any
other address on that network, or for a board with no server, is a refused
connection (-1). WiFiClient y WiFiServer carry TCP from board to board,
stations included (next section). The Web panel's phone still joins by itself and gets its own address, so it
counts as one more station. Not simulated: the access point board's own events
carrying the joined station's MAC and address (they still carry the phone's). A name that is the board's own wifiSsid
setting still joins that built-in network, and sends nothing over the air.
WIFI_AP_STA runs both: the station keeps its lease at 192.168.4.2 and the
simulated internet (HTTPClient, Blynk, real internet mode), and the panel
reaches the board at either address. On the , Blynk, modo de internet real), y el panel alcanza la placa en cualquiera de las dos direcciones. En laPico W
WiFi.beginAP() es softAP() de arduino-pico (WL_CONNECTED cuando está activo) y el punto de acceso está en 192.168.42.1, or 192.168.4.1 when the station is on too (WIFI_AP_STA), as arduino-pico's beginAP chooses (libraries/WiFi/src/WiFiClass.cpp), unless softAPConfig() de arduino-pico (libraries/WiFi/src/WiFiClass.cpp), a menos que WiFi.localIP() haya fijado una; Uno R4 WiFi, WiFiS3's WiFi.beginAP() devuelve WL_AP_LISTENING,
WiFi.config(ip) , el WiFi.status() es
WL_AP_CONNECTED while the phone is joined, as its AP_SimpleWebServer
example waits for. The ESP8266's ESP8266WiFi . El
Un portal cautivo funciona como en un celular. DNSServer (dns.start(53, "*", WiFi.softAPIP())) le dice a la red qué nombres responde su servidor; mientras está iniciado, el celular resuelve cada nombre que cubre a esa dirección, y cuando el celular se conecta, el panel Web abre el portal por sí solo, como un celular muestra su pantalla de inicio de sesión: pide http://connectivitycheck.gstatic.com/generate_204, que el onNotFound() del sketch (o su redireccionamiento a su propia dirección) responde. Cualquier nombre escrito en la barra de direcciones también llega a la placa. No existe ningún paquete DNS, así que los nombres se resuelvan o no según si loop() llama a processNextRequest(). Los nombres .mokxi siguen llegando a los sitios simulados cuando ningún servidor DNS los cubre, algo que un celular real en la red de la placa no podría hacer.
Under MicroPython (the ESP32, ESP32-S3, ESP32-C3 and ESP32-C6 builds, and
the Pico W's) network.WLAN(network.AP_IF) is the same access point, carried
the way the station is: the firmware's own lwIP and DHCP server run as built,
and the phone is a second IP end in crates/net/src/lan.rs that answers ARP and
opens TCP connections to the board's port 80. ap.config(essid=..., password=..., authmode=...) (ssid and key on the Pico W) and
ap.active(True) bring it up at 192.168.4.1; ap.status('stations') lists the
phone while it is joined; a socket server on port 80 shows in the Web panel and
sees the phone at 192.168.4.2. The phone finds the access point's address from
what the board sends, so ap.ifconfig() moving it is followed. The station's
network is 192.168.4.0/24 too, so to run both under MicroPython give the access
point another address with ap.ifconfig(), as a home router at 192.168.4.1
would make you do on a desk.
Boards talking to each other (TCP between boards)
Boards in one project that share a soft AP can open TCP connections to each
other, as ESP32s on one access point do. One board runs a WiFiServer, another
calls WiFiClient::connect(ip, port) with the address that board holds, and
the two exchange bytes both ways until one of them closes. The server can be a
station or the access point's own board, and the client can be either too. Two
stations reach each other through the access point's board, which passes on
what is meant for one of its other stations, as an access point does.
Server station (the second board in the project):
#include <WiFi.h>
WiFiServer server(5000);
void setup() {
Serial.begin(115200);
WiFi.begin("MyESP", "12345678"); // the name and password the access point board gave softAP()
while (WiFi.status() != WL_CONNECTED) delay(100);
Serial.println(WiFi.localIP()); // for example 192.168.4.2: the client connects here
server.begin();
}
void loop() {
WiFiClient client = server.available();
if (client) {
while (client.connected()) {
if (client.available()) {
String line = client.readStringUntil('\n');
line.trim();
Serial.println("got: " + line);
client.println("echo: " + line);
}
}
client.stop();
}
}
Client station (the third board):
#include <WiFi.h>
void setup() {
Serial.begin(115200);
WiFi.begin("MyESP", "12345678");
while (WiFi.status() != WL_CONNECTED) delay(100);
WiFiClient client;
// Use the address the server station printed. Stations get 192.168.4.2,
// then .3, in the order they joined.
if (client.connect(IPAddress(192, 168, 4, 2), 5000)) {
client.println("hello");
while (!client.available()) delay(10);
Serial.println(client.readStringUntil('\n')); // echo: hello
client.stop();
} else {
Serial.println("connect failed");
}
}
void loop() {}
What a sketch sees matches the Arduino-ESP32 core:
connect()returns 1 when the server accepts. It returns 0 at once when the address is a board with noWiFiServeron that port, and after the core's three seconds (connect(ip, port, timeout)takes another) when nobody holds the address. A name is not looked up: only a dotted address connects.server.available()returns a client for the next waiting connection, or one that is false.client.connected(),available(),read(),peek(),readStringUntil(),readBytes(),print(),println(),write(),remoteIP(),remotePort(),localPort()andstop()work on it.- When one end closes, the other reads what was sent before the close, then
connected()goes false, as the core's does. A station that leaves its network (WiFi.disconnect()), or that the access point drops, ends its connections the same way. - Bytes arrive in order and none are lost while the link holds. A write waits (up to five seconds) while the radio has a great deal queued, as a full send buffer does.
- The board holds eight sockets. A
WiFiClienthas no destructor here, so one that goes out of scope withoutstop()keeps its connection until its other end closes and a new connection needs the slot. Callstop(). - The same ports serve the Web panel as before: its request reaches
server.available()as the bytes of an HTTP request. A raw connection to a port that only an HTTPWebServerserves is refused, as is a station'sHTTPClientrequest to another station'sWebServer.
What is not carried: UDP (WiFiUDP still sends nothing, below), a connection
to a name, TLS, and TCP to anything outside the project's boards. Two boards
that did not join the same soft AP have no way to reach each other.
Mira lo que pasó
El panel Cloud es la pestaña de red: cada solicitud que hizo la placa y cada solicitud que la página hizo hacia la placa, con el método, la URL, el estado, los cuerpos y, cuando una solicitud falla, una línea que dice por qué. También lleva las tres configuraciones del punto de acceso y los dos valores de weather.mokxi. También tiene un laboratorio de API: elige el estado HTTP, el tipo de contenido y el cuerpo de respuesta para api.mokxi, y luego mira cómo la siguiente solicitud devuelve exactamente esa respuesta. Un maestro puede modelar éxito, entrada incorrecta, datos faltantes y errores del servidor sin una clave de API ni una dependencia fuera de la lección.
Usar Blynk
#define BLYNK_TEMPLATE_ID "TMPLxxxxxx"
#define BLYNK_TEMPLATE_NAME "Light Intensity Monitor"
#define BLYNK_PRINT Serial
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h> // BlynkSimpleEsp32.h, or BlynkSimpleWifi.h on a Pico W or UNO R4 WiFi
BlynkTimer timer;
BLYNK_WRITE(V1) { digitalWrite(D1, param.asInt()); }
void sendLight() { Blynk.virtualWrite(V0, analogRead(A0)); }
void setup() {
Blynk.begin("token", "Mokxi-Lab", "breadboard");
timer.setInterval(1000L, sendLight);
}
void loop() { Blynk.run(); timer.run(); }
Real Blynk keeps a TCP connection to blynk.cloud, which this network does
not have, so the Blynk server is simulated (crates/net/src/blynk.rs), and
the library is Mokxi's own (firmware/lib/mokxi_blynk.h, the Blynk IoT
library's calls, v1.3). The sketch reaches the server through one mailbox
command, BLYNK, answered at once: there is no wire format and no latency to
model, because there is no wire. The Cloud panel's Blynk section, drawn
once a sketch logs in, is its console: each virtual pin the sketch wrote or
has a BLYNK_WRITE for, its value, who wrote it and when, and a box that sends
a value to it, as the Blynk app's switch or slider would. Blynk.logEvent's
events are listed under it.
Lo que sigue a la biblioteca: Blynk.begin() se bloquea hasta que la placa esté en la red e iniciada sesión; BLYNK_WRITE se ejecuta dentro de Blynk.run(), nunca entre dos líneas de loop(); BLYNK_CONNECTED se ejecuta en cada inicio de sesión; Blynk.syncVirtual() y syncAll() devuelven los valores guardados del servidor a BLYNK_WRITE; una escritura mientras la placa está desconectada se descarta, y un valor enviado desde el panel mientras está desconectada se guarda pero no se entrega; un float sale con tres decimales y un double con siete; una placa que deja la red pierde su servidor, y Blynk.run() inicia sesión de nuevo cinco segundos después de volver. Los datastreams sobreviven a un reinicio de la placa, como en un servidor real. BlynkTimer es el de la biblioteca: dieciséis temporizadores desde timer.run(). WidgetLED, WidgetTerminal y WidgetLCD escriben sus pines como lo hace la biblioteca (WidgetLCD.h y los otros headers de widgets que los sketches antiguos incluyen por nombre también están); el LCD no se dibuja, su pin muestra el último clr o p, x, y, text.
Lo que no: el token, el ID de plantilla y el nombre del servidor se muestran, nunca se comprueban ni se buscan (aquí no hay cuenta de Blynk); BLYNK_APP_CONNECTED compila y nunca se ejecuta, ya que nada abre una app (BLYNK_READ desapareció de Blynk 1.4.0, así que un sketch que lo use recibe un error de compilación que menciona Blynk.virtualWrite() desde un BlynkTimer en su lugar); Blynk.Edgent, OTA y los headers _SSL no están aquí. Los valores se limitan a 1024 bytes, 64 escrituras esperan a una placa que no está sondeando, y el panel conserva los últimos 20 eventos. El tráfico de Blynk no está en el registro de solicitudes, que llenaría.
Usar WebSockets (el servidor de eco)
#include <WiFi.h>
#include <WebSocketsClient.h> // the WebSockets library, Markus Sattler
WebSocketsClient webSocket;
void webSocketEvent(WStype_t type, uint8_t *payload, size_t length) {
if (type == WStype_CONNECTED) webSocket.sendTXT("Connected");
if (type == WStype_TEXT) Serial.printf("[WSc] get text: %s\n", payload);
}
void setup() {
// join Mokxi-Lab first
webSocket.begin("echo.mokxi", 80, "/");
webSocket.onEvent(webSocketEvent);
}
void loop() { webSocket.loop(); }
This is not a WebSocket on a wire. A WebSocket is a TCP connection that
outlives its opening HTTP request, and this network has no TCP to a server on the internet. So the
library (firmware/lib/WebSocketsClient.h, the calls of 2.6.1) gives
echo.mokxi one more job: it is the simulated echo server. The first
loop() after begin() makes an HTTP GET to http://echo.mokxi<url>, and
its answer raises WStype_CONNECTED. Each sendTXT() is then an HTTP POST of
the text to that URL, and what the echo site sends back is handed to the
callback from the next loop() as WStype_TEXT, in the order sent;
sendBIN() travels as base64 text and comes back as WStype_BIN, decoded;
sendPing() comes back as WStype_PONG, so enableHeartbeat() keeps the
connection. Every message is a request in the Cloud panel's log, because that
is all it is. A send blocks for the request's 60 ms, where upstream's returns
once the frame is buffered.
Cualquier otro host, y beginSSL() hacia cualquier host, nunca conecta y no hace ninguna petición: loop() genera WStype_DISCONNECTED, reintenta cada setReconnectInterval(), y el monitor serie dice una vez que los WebSockets hacia ese host necesitan una placa real. El modo de internet real no cambia eso: la puerta de enlace lleva una petición HTTP y una respuesta. WebSocketsServer compila y se ejecuta, y ningún cliente se conecta nunca a él, ya que el panel Web muestra páginas con los scripts desactivados; también lo dice una vez.
Pedir la hora
#include <WiFiUdp.h>
#include <NTPClient.h>
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "europe.pool.ntp.org", 3600, 60000);
// after WiFi.begin() has connected:
timeClient.begin();
timeClient.update();
Serial.println(timeClient.getFormattedTime()); // "01:00:03"
Esta no es la hora real actual. NTP es un intercambio UDP con un servidor en internet, y esta red no transporta UDP ni llega a ningún servidor; la simulación tampoco conoce la fecha de hoy, e inventar una sería una mentira que un estudiante no podría comprobar. Así que NTP se simula, igual en todas las placas WiFi: configTime() en las placas ESP32 y ESP8266, NTP.begin() en la Pico W, y NTPClient (firmware/lib/NTPClient.h, la versión 3.2.1 de arduino-libraries) ponen todas el reloj en el propio de la simulación: 2026-01-01 00:00:00 UTC (época 1767225600) al encender, más los segundos que la placa ha corrido, que también es lo que informa http://time.mokxi/. Cada uno lo dice una vez en el monitor serie. El getEpochTime() de NTPClient es eso, más su desplazamiento; update() pregunta cuando ha pasado el intervalo y forceUpdate() pregunta de inmediato, y ambos reciben respuesta mientras la placa esté en la red y expiran tras aproximadamente un segundo cuando no lo está. No se envía ningún paquete: el WiFiUDP que se le da no se usa.
Usar Ethernet por cable (ETH.h, las placas ESP32)
#include <ETH.h>
Network.onEvent(onEvent); // ARDUINO_EVENT_ETH_START, _CONNECTED, _GOT_IP
ETH.begin(); // or the core 2.x / 3.x RMII and W5500 forms
No hay PHY, no hay RMII, no hay W5500 ni cable. ETH.begin() es el NET_CMD_ETH del buzón (operación 1): la máquina de estados de la estación se conecta sin SSID y sin contraseña, WIRED_PS (1.5 s) después, con la misma concesión, y todo lo que viaja sobre la estación (HTTP, el servidor del sketch, Blynk, la compuerta de internet real y sus límites) viaja sobre esto sin cambios. Hay un solo enlace, así que WiFi.status() lo lee sin importar cómo se levantó, y WiFi.begin() lo devuelve a WiFi. Mientras el enlace sea el cableado, los manejadores de WiFi.onEvent() y Network.onEvent() reciben los eventos ETH del núcleo en lugar de los de la estación. ETH.config() se conserva para que localIP() lo reporte; la placa sigue respondiendo al panel Web en 192.168.4.2. El cable siempre está conectado.
Lo que es fiel
- La API. Las llamadas y sus firmas son las que un estudiante copia de un tutorial de ESP32:
WiFi.begin/status/localIP/gatewayIP/RSSI/SSID/ macAddress/disconnect/mode,WiFiClient,HTTPClient::begin/GET/POST/ addHeader/getString/getStream/getSize/end/errorToString,WebServer::on/onNotFound/ begin/handleClient/send/arg/hasArg/uri/method, y rutas con patrones dentro:UriBraces("/toggle/{}")conpathArg(0)yUriGlob("/files/*")(uri/UriBraces.h,uri/UriGlob.h; sinUriRegex). - Los códigos de estado.
wl_status_tes el enum de Arduino, valor por valor. Los códigos negativos deHTTPClientson los de Arduino donde Mokxi tiene el mismo fallo (-1rechazado,-4no conectado,-11expirado). - El margen de tiempos. Una asociación tarda entre uno y tres segundos, y una contraseña incorrecta falla a los cinco. Ambos están dentro de lo que hace un ESP32-C3 real en una red tranquila, y ambos se mantienen ahí mediante una prueba.
- El orden de los estados, que es aquello contra lo que se escribe un bucle de conexión.
- El costo. Un
http.GET()bloqueado de verdad le cuesta al sketch sus 60 ms de tiempo simulado, porque el resto del circuito avanza a través de él. Un sketch que olvidahandleClient()de verdad nunca responde. Unhttp.setTimeout()más corto que eso expira (-11), y la petición que abandonó se descarta y se registra cuando empieza la siguiente, igual que un cliente real cierra la conexión que dejó de esperar; la siguiente petición no se rechaza. - Cada
HTTPClientconserva su propia respuesta. Dos clientes que cada unoGET()antes de que cualquiera lea reciben de vuelta sus propios cuerpos, ygetString()dos veces da el cuerpo dos veces, como lo hace el del núcleo de ESP32.
Lo que no está
- No hay radio, y por lo tanto nada de 802.11. Sin canal, sin escaneo real, sin baliza, sin frames de asociación, sin WPA2, sin PMK, sin cifrado en ninguna parte. La contraseña es una comparación de cadenas.
WiFi.scanNetworks()compila y "encuentra" el único punto de acceso que la placa puede ver, suwifiSsid, y dice en el monitor serie que el escaneo es simulado (firmware/include/WiFi.h). - No real internet. No DNS protocol, no IP stack, no sockets to anything outside the project's boards. The
four origins are Rust functions. No request in Mokxi ever leaves the tab,
and the Web panel's frame is served with
default-src 'none'so it cannot fetch an image from outside either. - No hay TLS.
WiFiClientSecurecompila y luego falla:connect()devuelve 0 ywhyNot()dice TLS no está simulado en Mokxi: aquí no hay https, solo http:// bajo .mokxi. A unHTTPCliental que se le dé uno, o cualquier URLhttps://, devuelveHTTPC_ERROR_NO_TLScon la misma frase. Un TLS que confiara en todo le enseñaría a un estudiante que https es gratis. - No raw TCP to the internet.
WiFiClient::connect()reaches another board of the project (above) and nothing else: to a name or to an address outside the project's boards it returns 0. The type is also whathttp.begin(client, url)takes, the spelling every modern tutorial uses. So no WebSocket either: the WebSockets library's client reaches only the simulated echo server atecho.mokxi, each message carried as one HTTP request (above), and nothing can connect to its server. The server side works for HTTP too: a hand-writtenWiFiServer(the Random Nerd Tutorials web server, on the ESP32 and the ESP8266 alike) gets each Web panel request fromserver.available()as the bytes a browser sends, and what it prints untilstop()is read back as the HTTP response the panel shows. - Un celular en el AP soft y ese celular es el panel Web. Ningún otro dispositivo y ningún segundo celular puede unirse al punto de acceso de la placa;
maxConnections,hiddeny el canal se aceptan y no cambian nada que un sketch pueda ver. El celular toma su concesión sin preguntarle al servidor DHCP de la placa, no envía tráfico propio más que las peticiones del panel, y nada llega a internet a través de la placa (WiFi.AP.enableNAPT()dice que sí y no enruta nada).WiFi.mode(WIFI_AP)sinsoftAP()no levanta nada. Elwifi.radio.start_ap()de CircuitPython no está simulado. - A second board joins a network only through a soft AP. Every board has
its own private simulated network, and the Web and Cloud panels follow the
first one they find. What connects boards is the air every ESP board on the
canvas shares: ESP-NOW (
docs/help/editor/esp-now.md) and a station joining another board's soft AP (above), withHTTPClientto the access point'sWebServerand TCP between boards. Two boards that joined the same access point reach each other; nothing else routes between them. - El Bluetooth es una simulación aparte con la misma honestidad (
docs/bluetooth.md): el Bluetooth Classic y LE de las placas ESP32 hablan con un celular en el panel de Bluetooth del editor, a través de registros propios en este mismo bloque. El Bluetooth del Pico W no está modelado. - No hay interrupción en cuatro de las seis placas. En el ESP32 clásico, el ESP32-S3, el ESP8266 y el Pico W el buzón no genera ninguna interrupción de CPU: un número de fuente de la matriz de interrupciones y un número de IRQ del NVIC son de la placa, y este bloque no es de la placa, así que no hay un número honesto que darle. El runtime hace sondeo, y a un núcleo estacionado igual se le despierta cuando la red tiene algo que decir.
- Los números son configuración, no mediciones.
RSSI()es lo que diga la propiedadwifiRssi; nada calcula una pérdida de trayectoria, y mover la placa en el lienzo no cambia nada. - El reloj de
time.mokxies el del kernel, contado desde2026-01-01T00:00:00Z, no la hora del día. La simulación no sabe qué día es e inventar uno sería una mentira que un estudiante no podría comprobar. El cuerpo dicesimulatedtambién, yconfigTime(),NTP.begin()y NTPClient ponen el mismo reloj ("Pedir la hora", más arriba). Stringes el de Arduino, del núcleo compartido (firmware/lib/WString.h), con su texto en el heap. Los cuerpos siguen limitados por los tamaños de abajo.- Los tamaños tienen límite. Cada anillo de buzón es de 4096 bytes, un cuerpo de petición mide como máximo 2048 y una respuesta 4096; el panel Cloud conserva 512 bytes de cada cuerpo y las últimas 100 peticiones. Una página que envía el servidor del sketch comparte su anillo con su tipo de contenido, así que se corta unos pocos bytes antes de 4096, y cuando se corta los paneles Web y Cloud lo dicen ambos.
El final de la página
Los paneles llegan a la red por Component::ask, el tercer canal genérico del kernel además de poke y debug: una cadena JSON opaca hacia abajo, una cadena JSON opaca de vuelta, y un kernel que no lee ninguna. Las operaciones son state, log, setAp, setWeather, setApi, blynkWrite, clearLog, fetch, result, y apJoin y apLeave (el celular del panel Web en el AP soft); state y log responden ambos con "simulated": true dentro, así que un panel no puede renderizar sin él. crates/net/src/lib.rs es la lista.
Modo de internet real
Un modo opcional (worker/pro-pack.ts): el interruptor Internet real del panel Cloud, que se enciende solo después de que GET /api/gateway dice que la cuenta puede, y responde qué límites aplican. Gratis, con sesión iniciada y un correo confirmado, recibe FREE_GATEWAY; el paquete Pro (Pro, Student, Docente, Salón de clases, un grupo pagado, la prueba de Pro) recibe GATEWAY; un estudiante de grupo o un menor de 13 años solo donde un maestro con sus herramientas de grupo activadas lo encendió para su grupo (classes.real_internet, apagado por defecto), con GATEWAY; con la sesión cerrada y las cuentas suspendidas, nunca. Una placa cuyo wifiSsid sea Wokwi-GUEST, el punto de acceso que Wokwi le da a una placa y que una importación de Wokwi nombra, enciende el interruptor por sí solo cuando inicia una ejecución (autoFor), porque en Wokwi ese punto de acceso llega a internet; apagado a mano, se queda apagado por el resto de la sesión.
En el motor (crates/net): setReal {on} activa el modo. Mientras está encendido, una CMD_REQUEST cuya URL se enruta hacia afuera (http::routes_out: cualquier host fuera de .mokxi, https:// incluido, y mqtt.mokxi) no se atiende después de HTTP_LATENCY_PS. Espera, sin reloj propio, a que la página actúe: outbound responde a la única petición en espera (id, method, url, contentType, body), y outboundResult {id, status, contentType, body, note} la termina por el mismo camino que una respuesta simulada (anillo, registro, CMD_POLL). El estado 0 es un rechazo y llega al sketch como HTTPC_ERROR_CONNECTION_REFUSED. Un sketch que se rinde (su propio tiempo de espera de HTTPClient, cinco segundos por defecto) y vuelve a pedir descarta la petición vieja en lugar de recibir BUSY, y una respuesta tardía para ella no encuentra a nadie esperando. Los orígenes simulados y la dirección propia de la placa nunca se enrutan hacia afuera.
En la página (web/src/ui/real-internet.ts): una bomba pregunta por outbound cada 80 ms, envía lo que encuentra a POST /api/gateway, y devuelve la respuesta.
En el Worker (worker/gateway.ts): una petición entra, una respuesta sale. Solo GET y POST, http y https en los puertos 80, 443, 8080 y 8443, sin credenciales en la URL; hosts rechazados por rango de IP (privadas, loopback, link-local, CGNAT, documentación, pruebas de rendimiento, multidifusión, reservadas; IPv6 fuera de unidifusión global, y direcciones mapeadas o NAT64 juzgadas por su parte IPv4), por nombre (una sola etiqueta, localhost, .local, .internal y los demás sufijos locales, los nombres de plataforma de Cloudflare, mokxi.com), y de nuevo por lo que el nombre resuelva por DNS sobre HTTPS, y la lista de bloqueo del propietario (GATEWAY_DENY_HOSTS, una variable pública: cada nombre se rechaza a sí mismo y a todo nombre debajo de él, intermediarios incluidos). Las redirecciones nunca se siguen. Solo el tipo de contenido del sketch sale como encabezado. Los cuerpos tienen límite: en Pro a los propios tamaños del buzón, 2048 bytes de salida y 4096 de regreso, en Gratis la mitad; un cuerpo que no es texto se omite. El host tiene cuatro segundos. Por cuenta y por proyecto: una ráfaga de un minuto en memoria (Pro 30 y 20, Gratis 10 y 10) y un total por día UTC en gateway_counts (Pro 1000 y 500, Gratis 100 y 50). Gratis también se limita por dirección (FREE_GATEWAY_PER_IP: 20 por minuto en memoria, 300 por día), así que una pila de cuentas desechables en una misma conexión no suma; Pro no, así que un salón de clases detrás de una dirección sigue funcionando. Esa tabla es lo único que se escribe: conteos por día por ámbito, el ámbito de la dirección es un hash con sal que cambia cada día, nunca una URL, host, cuerpo ni dirección.
MQTT: POST http://mqtt.mokxi/publish?broker=<name>&topic=<topic> con el mensaje como cuerpo. La pasarela lo publica con QoS 0 sobre MQTT sobre WebSockets (worker/mqtt.ts) a uno de test.mosquitto.org, broker.hivemq.com o broker.emqx.io; un Worker no puede abrir un socket TCP al puerto 1883, así que PubSubClient y el TCP puro todavía no funcionan, y no se suscribe a nada ni se recibe nada de vuelta. Los temas con comodines se rechazan; un mensaje tiene como máximo 1024 bytes en Pro y 512 en Gratis.
WiFiClientSecure sigue siendo rechazado por el entorno de ejecución; http.begin("https://...") y un WiFiClient normal llegan a la pasarela, que hace el TLS.
Telegram (UniversalTelegramBot.h, Brian Lough's library, 1.3.0) is the
one library built on that path. Telegram is a real service, so a bot reaches
it only in this mode: each call (getMe, getUpdates?offset=...&limit=1,
sendMessage and the rest as a POST of JSON) is one HTTPClient request to
https://api.telegram.org/bot<token>/<method>, which the gateway sends and
answers. The WiFiClientSecure a sketch hands the bot, and the
TELEGRAM_CERTIFICATE_ROOT it gives that client, carry nothing: the gateway
checks Telegram's certificate. With real internet off, every call fails at
once (false, 0 or "") and the serial monitor says once: Telegram needs
the real internet: switch on Real internet in the Cloud panel (signed in), or
run this on a real board. A refusal, a 429 from the caps above, a wrong
token and an answer cut at the size cap each say what they were, once. The
caps shape a bot: the upstream EchoBot polls every second, which is twice
Pro's minute and six times Free's, so Mokxi's copy of it polls every ten
seconds, and on Free a project's 50 a day last about eight minutes of that.
longPoll is held to three seconds, since the host gets four. Photos and
files sent as bytes are not carried (the gateway takes text). The library
reads Telegram's answers with a small reader of its own rather than an
ArduinoJson document, which keeps the EchoBot small on every board.
Los ejemplos
wificonnect: el bucle de conexión, la dirección, la señal y la contraseña incorrecta a propósito.wifiweather:HTTPClientcontraweather.mokxi, el valor extraído del JSON y una solicitud deliberada aexample.compara que el estudiante lea el rechazo en su propio monitor serie.wifiapi: un GET normal aapi.mokxi, con su estado y JSON impresos en el puerto serie. Cambia la respuesta en Cloud y ejecuta la solicitud de nuevo.wifilamp:WebServercon dos enlaces y un formulario, encendiendo el LED del GPIO 8 desde el panel Web.softapserver(la clásica ESP32, la servidor web en punto de acceso del ESP32):WiFi.softAP("MyESP", "12345678"), una página que cuenta las estaciones, y botones de encendido y apagado para el LED del GPIO 26, navegada desde el celular del panel Web en 192.168.4.1.
wificonnect, wifiweather y wifilamp vienen para las seis placas y wifiapi para la ESP32-C3, la ESP32-C6, la ESP32-S3 y la Pico W, veintidós sketches, cada uno controlando el pin que controla el ejemplo blink de su propia placa, de modo que el circuito que vigila uno vigila al otro. En la Pico W ese es LED_BUILTIN y GP15, porque el LED integrado está en el CYW43439 y no en el header. En la ESP32-S3 es el LED RGB integrado, encendido en blanco, y el GPIO 2.
Cada placa con WiFi los compila en el navegador: los headers están en los paquetes del runtime, reconstruidos con node web/scripts/bundle-runtime.mjs. La clásica ESP32, la ESP32-S3 y la ESP8266 compilan con clang-v3, la compilación en wasm del fork de LLVM de Espressif, desde el 2026-09-28. Sus ejemplos intactos todavía ejecutan los ELF precompilados que generan las compilaciones de GCC de Espressif (deploy/fetch-xtensa.sh); docs/compile.md explica por qué.