El editor

WiFi, simulado

La placa puede conectarse a una red, descargar una página y servir una. La radio es simulada y, con sesión iniciada, el interruptor de internet real llega a servidores reales.

La radio está simulada. No hay 802.11 en ninguna parte de Mokxi y nada que haga un sketch puede llegar a la red en la que está tu navegador. Lo que sí es fiel es el código de Arduino que escribes, que es toda la idea, porque es el código que escribirías para una placa real.

Toda placa que tiene radio en el hardware real la tiene aquí: la familia ESP32 (el ESP32-C3, ESP32-C6, el ESP32 clásico y el ESP32-S3, y las placas basadas en ellos, como la XIAO y la Nano ESP32), las placas ESP8266, la Raspberry Pi Pico W y la Uno R4 WiFi. En todas las demás placas de aquí, incluida una Raspberry Pi Pico común, que no tiene pieza inalámbrica, #include <WiFi.h> se detiene con una oración que lo dice, en lugar de escribir en una dirección que su chip no tiene. Eso es a propósito: un stub que respondiera "no conectado" sería una mentira con forma creíble, y un error de compilación no.

Qué es real y qué no

Real, en el sentido de que se comporta como lo hará tu placa:

  • las llamadas (WiFi.begin(), WiFi.status(), WiFi.localIP(), HTTPClient, WebServer) con las firmas que te da un tutorial;
  • los códigos de estado, que son el propio enum de Arduino, valor por valor;
  • los tiempos: conectarse tarda entre uno y tres segundos, y una contraseña incorrecta falla a los cinco, que es lo que pasa con una placa real en una red tranquila;
  • el costo: una petición realmente toma 60 ms del tiempo del sketch, y un sketch que olvida server.handleClient() de verdad nunca responde.

No real, y nunca se pretendió que lo fuera:

  • sin radio. Sin canal, sin escaneo, sin scanNetworks(), sin baliza, sin WPA2, sin cifrado de ningún tipo. La contraseña se compara como una cadena de texto.
  • sin internet real a menos que lo actives. Sin TCP, sin DNS, sin sockets, nada que salga de la pestaña del navegador. Existen cuatro nombres inventados bajo .mokxi y ningún otro, hasta que activas el interruptor de Internet real del panel de Nube: entonces una petición a cualquier otro nombre sale por la pasarela de Mokxi.
  • sin TLS en la placa. WiFiClientSecure compila y luego falla, diciéndolo. Una URL https:// falla igual, a menos que Internet real esté activado: entonces la pasarela hace el TLS para una petición de HTTPClient. Un TLS en la placa que confiara en todo te enseñaría que https es gratis.
  • sin segunda máquina. Una placa, una red, una dirección. Nada fuera de esta pestaña del navegador puede llegar al servidor donde corre tu sketch. El punto de acceso propio de la placa (abajo) tiene exactamente un celular conectado, el panel Web.
  • RSSI() es una configuración, no una medición. Mover la placa en el lienzo no cambia nada.
  • NTP da el reloj de la simulación, no la hora real. No hay UDP ni servidor NTP, y la simulación no sabe la fecha de hoy, así que configTime() y el update() de NTPClient ponen el reloj en 2026-01-01 00:00:00 UTC al encender, más los segundos transcurridos, y el monitor serie lo dice una vez.
  • Bluetooth is its own simulation. The ESP32 boards' Bluetooth serial and BLE talk to a phone in the Bluetooth pane (Bluetooth, simulado). El Bluetooth de la Pico W no está simulado.

Configurar la red

Haz clic en la placa y mira el panel de propiedades: wifiSsid, wifiPassword y wifiRssi. Esos tres son el único punto de acceso que esta placa puede ver. Sin radio no hay nada que escanear, así que la red es una propiedad de la placa y no un componente que colocas junto a ella.

Escríbelos igual en tu sketch y se conecta. Escribe uno de los dos mal a propósito y observa qué pasa. De las dos, esa es la lección más útil.

El panel Nube edita esas mismas tres opciones mientras el sketch está en ejecución, así que puedes quitarle la red a una placa encendida y ver el ciclo de conexión empezar de nuevo.

Unirse

#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() pasa por WL_IDLE_STATUS, luego WL_DISCONNECTED mientras se asocia y después WL_CONNECTED. No existe WL_CONNECTING en Arduino, y por eso el ciclo de arriba está escrito como lo escriben todos los tutoriales.

Una contraseña incorrecta se convierte en WL_CONNECT_FAILED después de cinco segundos. Un nombre que no es el de la placa se convierte en WL_NO_SSID_AVAIL. La dirección siempre es 192.168.4.2, y es la misma dirección después de un disconnect() y un segundo begin().

Consultas

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

En esta internet simulada existen cuatro direcciones:

  • http://time.mokxi/: el reloj de la simulación, como una cadena ISO. Es el reloj del kernel contado desde una medianoche fija, no la hora del día, porque la simulación no sabe qué día es.
  • http://weather.mokxi/: un JSON con una temperatura y una humedad que tú defines en el panel Cloud. Cambia una y la siguiente consulta devuelve el nuevo valor.
  • http://echo.mokxi/: lo que envíes con POST te regresa tal cual. También es el único servidor WebSocket que hay aquí: el WebSocketsClient de la biblioteca WebSockets apuntado a echo.mokxi envía cada mensaje como una solicitud a esa dirección y lo recibe de vuelta como WStype_TEXT. Es un eco simulado que viaja como HTTP, no un WebSocket por cable; cualquier otro servidor WebSocket necesita una placa real.
  • http://api.mokxi/: el estado, el tipo de contenido y el cuerpo JSON que tú defines en el panel Cloud, para que practiques un caso de éxito, un error o datos faltantes.

Cualquier otra cosa no resuelve. http://example.com/ devuelve HTTPC_ERROR_CONNECTION_REFUSED, y HTTPClient::errorToString() te dice el motivo en una línea: no real internet: names under .mokxi only. Esa negativa se puede leer desde el sketch a propósito. Es algo que vale la pena enseñar, no algo que haya que esconder.

Servir páginas

#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() y method(). Tus manejadores son tu código, corriendo en el núcleo de la placa al reloj de la placa.

El panel Web (una pestaña junto a Serie en la parte de abajo) es el navegador para ellos. Tiene una barra de direcciones que empieza en http://192.168.4.2/, un botón de Actualizar y la página misma en un marco con los scripts desactivados. Los enlaces y botones de esa página regresan a tu sketch, y eso es lo que hace que "encender el LED desde una página web" funcione de punta a punta.

Si la página nunca llega, el panel lo avisa, y después de diez segundos la red responde 504 por sí misma: la razón habitual es un loop() que dejó de llamar a handleClient().

El punto de acceso de tu placa

Un sketch puede iniciar su propia red en lugar de unirse a una, como lo hace una página de configuración o el control de un robot:

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

El panel Web es el celular que se une a ella. Como segundo y medio después de que el punto de acceso se activa, una fila bajo la barra de direcciones dice Phone joined MyESP, y la barra pasa a http://192.168.4.1/: presiona Go. Presiona Leave y el celular se va; Join lo conecta de nuevo con la contraseña del cuadro, y una incorrecta es rechazada, igual que en un celular. Mientras está conectado, WiFi.softAPgetStationNum() devuelve 1 y WiFi.onEvent() recibe los eventos de estación conectada y desconectada.

La contraseña debe tener de 8 a 63 caracteres (o ninguna, para una red abierta), o softAP() devuelve false, como en la placa real. softAPConfig() cambia la dirección. WIFI_AP_STA ejecuta ambos: la placa conserva su concesión en la red simulada y todavía puede obtener páginas .mokxi. En la Pico W la dirección es 192.168.42.1 (192.168.4.1 con la estación también activa), como lo decide arduino-pico, y WiFi.beginAP() la inicia; en la Uno R4 WiFi, WiFi.beginAP() y WL_AP_CONNECTED se comportan como en los ejemplos de WiFiS3.

Los portales cautivos también funcionan: inicia un DNSServer con dnsServer.start(53, "*", WiFi.softAPIP()) y, cuando el celular se conecta, el panel Web abre tu página por sí solo, como cuando un celular muestra una hoja de inicio de sesión. En MicroPython, network.WLAN(network.AP_IF) es el mismo punto de acceso, y un servidor de sockets en el puerto 80 se ve en el panel Web.

Ese único celular es todo lo que hay: ningún segundo dispositivo puede conectarse, y nada llega a internet a través de la placa.

El panel Cloud

Cada solicitud, en ambos sentidos: lo que la placa pidió a la internet simulada y lo que el panel Web le pidió a la placa, con el método, la dirección, el estado, los cuerpos y, cuando algo falla, una línea que dice por qué. Es la pestaña de red de una placa.

También contiene los dos diales de weather.mokxi, las tres opciones del punto de acceso y el laboratorio de API, donde eliges qué responde api.mokxi. Una clase puede cambiar una opción y ver cómo el sketch lo nota.

Un sketch de Blynk obtiene una Blynk sección ahí también, con sus pines virtuales y un cuadro para enviarle un valor a cada uno: consulta Blynk, simulado.

En la Pico W

La Pico W es una Pico con chip inalámbrico, y su código WiFi es el mismo WiFi.h de arriba. Dos cosas cambian respecto a una Pico normal, igual que en la placa real:

  • LED_BUILTIN es el LED integrado, y GP25 no lo es. El LED está en el chip inalámbrico, así que digitalWrite(LED_BUILTIN, HIGH) lo enciende. GP25 controla la línea de selección del chip inalámbrico, así que un sketch que escriba en GP25 no enciende nada, ni aquí ni sobre un escritorio.
  • El LED solo está encendido o apagado. analogWrite(LED_BUILTIN, ...) no hace nada, así que desvanece un LED en un pin normal.

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 la Pico W; el detalle completo está en el modelo de la Pico W.

Ethernet por cable (ETH.h)

En las placas ESP32, la biblioteca Ethernet por cable del núcleo también compila y corre, para sketches escritos para una WT32-ETH01, una Olimex ESP32-POE o un módulo W5500. Elige una ESP32 DevKit para un sketch de WT32-ETH01 o ESP32-POE: es el mismo 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();
}

No hay cable ni chip de Ethernet. ETH.begin() se une a la misma red simulada que usa el WiFi, sin nombre de red ni contraseña, y aproximadamente 1.5 segundos después tiene la dirección 192.168.4.2. A partir de ese momento WiFiClient, HTTPClient, WebServer y PubSubClient funcionan sobre ella igual que lo hacen sobre WiFi, el panel Web llega al servidor del sketch, y el interruptor de Internet real y sus límites son los mismos.

  • Compilan las llamadas a ETH.begin() de ambos núcleos: la de 2.x, ETH.begin(addr, power, mdc, mdio, type, clock), la de 3.x, ETH.begin(ETH_PHY_LAN8720, addr, mdc, mdio, power, clock), y su forma para W5500, ETH.begin(ETH_PHY_W5500, addr, cs, irq, rst, SPI).
  • Los eventos llegan en el orden del núcleo: ARDUINO_EVENT_ETH_START, ARDUINO_EVENT_ETH_CONNECTED, ARDUINO_EVENT_ETH_GOT_IP, y después de ETH.end(), ARDUINO_EVENT_ETH_DISCONNECTED y ARDUINO_EVENT_ETH_STOP.
  • ETH.linkUp(), ETH.linkSpeed() (100) y ETH.fullDuplex() (true) se leen como una placa conectada a un switch. El cable siempre está conectado.
  • ETH.config(ip, gateway, mask, dns) fija una dirección estática, y ETH.localIP() la reporta. El panel Web todavía llega a la placa en 192.168.4.2.
  • La placa tiene un solo enlace a la red. WiFi.begin() después de ETH.begin() lo pasa a WiFi, y WiFi.status() lee ese único enlace en cualquier caso.
  • Solo el ESP32 clásico tiene el controlador Ethernet que necesita un LAN8720. En un ESP32-S3, C3 o C6 una placa real usa un W5500 por SPI; un sketch de LAN8720 de todos modos corre aquí, y el monitor serie lo dice una vez.

Internet real

El interruptor Internet real en la parte superior del panel Cloud funciona para cualquiera con sesión iniciada: Gratis envía 100 peticiones al día, y Pro tiene más. Apagado, que es como inicia cada sesión, nada de lo anterior cambia. Encendido, una petición a un nombre fuera de .mokxi (https:// incluido) sale al internet real por la pasarela de Mokxi, y la respuesta regresa a tu sketch; los nombres .mokxi siguen simulados. Una placa en el punto de acceso Wokwi-GUEST, como es una importación de Wokwi, lo enciende sola al ejecutarse. Sin sesión iniciada, el interruptor te dice que inicies sesión gratis, y la placa conserva la red simulada. Un bot de Telegram (UniversalTelegramBot.h) funciona también así, y solo así. Internet real tiene los detalles y los límites.

Prueba estos

  • WiFi: conectarse a la red: el bucle de conexión, la dirección y la señal.
  • WiFi: obtener el clima: HTTPClient contra weather.mokxi, y una petición deliberada a example.com para que leas la negativa tú mismo.
  • WiFi: una lámpara en una página web: dos botones y un formulario que encienden y apagan el LED del GPIO 8.
  • Laboratorio de API: obtener JSON: un GET normal de HTTPClient a api.mokxi. Cambia la respuesta en el panel Cloud y ejecuta la petición de nuevo.
  • Servidor web en modo punto de acceso con ESP32: la red propia de la placa, MyESP, y una página que el celular del panel Web abre en 192.168.4.1, con botones para un LED.

Los primeros tres vienen para el ESP32-C3, ESP32-C6, ESP32 DevKit, ESP32-S3, ESP8266 y Pico W, y el Uno R4 WiFi tiene su propio ejemplo de conexión. Todos se compilan en el navegador, igual que cualquier otro ejemplo.

Todo el contrato, registro por registro y límite por límite, está en WiFi simulado.