Referencia

Contrato de la placa Raspberry Pi Pico W (Fase 9)

La Pico con una CYW43439 encima: el chip no está modelado, el WiFi está simulado, y el LED que tiene detrás funciona.

Esta es la referencia de ingeniería del modelo: qué implementa, registro por registro, para quienes escriben firmware sobre él. Para usar la placa en el editor, empieza por El Raspberry Pi Pico W y la página de la placa.

La Pico W es la Raspberry Pi Pico con una CYW43439 encima. Para un sketch de Arduino la CYW43439 no se modela; para los firmwares oficiales de MicroPython y CircuitPython, que la manejan por sí mismos a través de sus pines, sí se modela, y docs/cyw43.md es ese contrato (sección 9 más abajo). Todo lo demás de la placa es lo de la Pico, y docs/pico.md es el contrato para todo ello: el mismo RP2040, el mismo header de cuarenta pines en el mismo orden, el mismo mapa de memoria, los mismos registros de periféricos, el mismo modelo de tiempo y el mismo runtime. Un solo componente del kernel atiende a ambas (pico en crates/parts, con una bandera de variante), porque por debajo del chip inalámbrico no hay nada que distinguir.

El tipo de catálogo es picow. Este documento solo dice lo que cambia: tres GPIOs y dónde está realmente el LED, y un bloque que es propio de Mokxi.

Lee la sección 6 antes de planear nada con esta placa (y la sección 9 para un proyecto en Python). Aquí no hay radio. Lo que sí hay, desde docs/wifi.md, es una red simulada detrás de un buzón en una dirección que el RP2040 deja sin mapear, y la palabra simulada lo resume todo: nada de 802.11, nada de firmware CYW43, nada de internet real. El LED integrado sí funciona, porque se accede a través de ese mismo buzón, que también es donde se accede en el hardware.

1. Lo que cambia: tres GPIOs y el LED

Tres de los GPIOs del RP2040 nunca llegan al header en ninguna de las dos placas, y están cableados a cosas distintas:

GPIO en una Pico en una Pico W
GP23 SMPS_MODE, el pin de modo del regulador WL_ON, la alimentación de la CYW43439
GP24 VBUS_SENSE WL_D, la línea de datos half-duplex de la CYW43439
GP25 el LED verde WL_CS, el chip select de la CYW43439
GP29 ADC3, el divisor de VSYS WL_CLK, y el divisor de VSYS

El LED de una Pico W cuelga del GPIO 0 propio de la CYW43439, al que se llega por el enlace que usa la radio. Así que:

  • LED_BUILTIN no es un número de GPIO en esta placa. Es MOKXI_WL_LED, un número de pin por encima de todos los reales, y pinMode, digitalWrite y digitalRead lo envía a la parte inalámbrica a través del buzón de la sección 3.8 en lugar de a un pin. Ese es el camino que toma el núcleo Arduino en el hardware real, donde LED_BUILTIN pasa por el controlador CYW43. digitalWrite(LED_BUILTIN, HIGH) por tanto enciende la lámpara de la placa aquí, exactamente como lo hace en un escritorio, y probe lo reporta como el bit 2, que regresa por el buzón y no desde una patilla.
  • GP25 no es el LED. Ponerlo en alto aquí activa WL_CS, which is connected to a chip that is not modeled, and on a desk it would do the same. A sketch that writes GP25 expecting a light gets nothing, in Mokxi and on the bench. The Pico's own blink ELF, which writes GP25, lights nothing on this board, and crates/parts' gp25_is_wl_cs_here_and_lights_nothing lo mantiene así.
  • No hay PWM detrás de esa lámpara. El enlace lleva encendido y apagado, no un ciclo útil, así que analogWrite(LED_BUILTIN, …) no hace nada en una Pico W. fade lo dice y desvanece GP14 en su lugar.
  • GP24 no es detección de VBUS. El modelo de la Pico lo mantiene en alto porque esa placa siempre se alimenta por USB; aquí nada lo impulsa y se lee en bajo.

La alternativa (llamar GP25 al LED y cruzar los dedos) se consideró y se rechazó. Haría que un sketch que se enciende en el simulador no haga nada en un escritorio, que es el único tipo de error que este proyecto no va a permitir. No tener ninguna lámpara fue la primera respuesta y tampoco era la correcta: la lámpara está ahí en la placa, y el camino hacia ella es una interfaz de comandos que este modelo ahora tiene. Así que se modela donde realmente está. DECISIONS.md, 2026-09-17.

Todo lo demás de la sección 1 de docs/pico.md se mantiene: los mismos cuarenta pines en el mismo orden del catálogo, los mismos nombres, el mismo comportamiento de RUN y 3V3_EN, los mismos rieles a los mismos voltajes, las mismas resistencias de pull-up de 55 k en los pads y el mismo umbral de entrada de 1.65 V.

2. Mapa de memoria, 3. Registros de periféricos, 4. Canal con el host

Como las secciones 2, 3 y 4 de docs/pico.md, con un bloque añadido que no es del chip y sin quitar nada. Es el mismo RP2040: la misma ventana XIP de flash, los mismos 264 KB de SRAM, los mismos RESETS, IO_BANK0, PADS_BANK0, TIMER, UART0, PWM y SIO en las mismas direcciones con los mismos bits, y UART0 como canal con el host.

The CYW43439 is on SPI-like signals that never leave the module, so nothing in the peripheral map changes to make room for it. What is added instead is Mokxi's own simulated network mailbox, which is not the CYW43 and does not pretend to be:

3.8 Buzón de red de Mokxi (0x4FFF_E000)

Este bloque no es del RP2040 y no existe en una Pico común. Todas las demás direcciones de docs/pico.md son del chip, tomadas de la hoja de datos, y una imagen compilada contra ellas corre en una Pico real. Esta es propia de Mokxi: la red simulada de crates/net, por encima de todos los periféricos APB (terminan bastante antes de 0x4008_0000) y por debajo de la ventana AHB-Lite en 0x5000_0000, para que una imagen que la use falle en silicio en lugar de leer el registro de otro periférico. Esa falla es la respuesta honesta, porque lo que hay detrás de este bloque no existe en el chip.

Por qué un buzón también es la forma honesta aquí. La parte inalámbrica de una Pico W real es un CYW43439 al otro lado de un enlace de tres pines tipo SPI, impulsado por un blob de firmware binario cerrado. No es un conjunto de registros documentados del RP2040, igual que la radio de un ESP32 no es un conjunto de registros documentados de su propio chip, y el WiFi.h de Arduino en una Pico W realmente termina al otro lado de una interfaz de comandos. Así que esto es una interfaz de comandos: la misma, byte por byte, que usan las cuatro placas ESP, en la dirección propia de esta placa.

Se mapea solo en una Pico W. firmware/pico/build.sh define MOKXI_BOARD_PICO_W para esa placa y no para la Pico, así que WiFi.h compila en una y se niega en la otra, y Soc::new de crates/rp2040 deja la dirección como un hueco mientras que Soc::new_with_network la mapea. En una Pico común el acceso falla, que es lo que debe hacer una placa sin parte inalámbrica.

El bloque no genera ninguna interrupción NVIC. Un número de IRQ es del chip, y este bloque no lo es, así que no se le asigna ninguno. El firmware hace sondeo, y un núcleo detenido en WFI también despierta cuando la red tiene algo que decir, igual que despierta por un flanco de PWM.

Aquí no hay radio, ni 802.11, ni internet real. Nada en el modelo transmite, escanea, asocia, cifra o abre un socket: una contraseña se compara como cadena, un nombre que no esté bajo .mokxi no se resuelve, y los tres orígenes que la red sirve son funciones en crates/net/src/http.rs. El buzón tiene la forma de la costura real en vez de una ficción sobre una MAC: en un ESP32 real el hardware de WiFi es un blob binario cerrado con una interfaz de comandos, y el WiFi.h de Arduino termina al otro lado de uno de estos. docs/wifi.md es el contrato de lo que hay detrás; esta sección son solo los registros.

Un registro de comandos, un registro de estado, un anillo de 4096 bytes en cada sentido y un bit de interrupción. Escribir NET_CMD_REG ejecuta el comando; un comando que tarda tiempo simulado activa BUSY y lo limpia, con DONE en NET_INT_RAW_REG, cuando termina.

offset nombre bits
0x00 NET_ID_REG lee 0x494B4F4D, y nada más lo hace. Un sketch que quiera saber si está en Mokxi lee esto; en silicio el acceso falla
0x04 NET_CMD_REG escribe un código de comando (tabla abajo); la escritura lo ejecuta
0x08 NET_ARG_REG una palabra de argumento, leída de vuelta: el puerto para LISTEN, el estado para REPLY
0x0C NET_STATUS_REG bit 0 BUSY, bit 1 ERR, bit 2 RX_READY, bit 3 LINK, bit 4 SERVE, bits 8..11 STATE
0x10 NET_RESULT_REG lo que respondió el último comando
0x14 NET_INT_RAW_REG bit 0 DONE, bit 1 EVENT
0x18 NET_INT_ENA_REG los mismos dos bits
0x1C NET_INT_CLR_REG escribe 1 para limpiar, los mismos dos bits
0x20 NET_TX_LEN_REG bytes preparados en el anillo de salida
0x24 NET_TX_DATA_REG escritura: empuja un byte (bits 0..7) al anillo de salida
0x28 NET_RX_LEN_REG bytes en espera en el anillo de entrada
0x2C NET_RX_DATA_REG lectura: saca un byte del anillo de entrada, 0 cuando está vacío
0x30 NET_RING_LEN_REG capacidad de cada anillo en bytes, para que el firmware no tenga que fijar 4096 a mano
0x40 NET_BT_CMD_REG Bluetooth: escribe un código de comando de Bluetooth (docs/bluetooth.md); la escritura lo ejecuta
0x44 NET_BT_ARG_REG Bluetooth: una palabra de argumento, leída de vuelta; un evento deja aquí su número
0x48 NET_BT_RESULT_REG Bluetooth: lo que respondió el último comando de Bluetooth
0x4C NET_BT_STATUS_REG bit 0 CLASSIC_ON, bit 1 CLASSIC_LINK, bit 2 EVENT, bit 3 BLE_ADV, bit 4 BLE_LINK, bit 5 BT_ERR, bit 8 HAS_CLASSIC, bit 9 HAS_BLE
0x50 NET_BT_TX_LEN_REG Bluetooth: bytes preparados en su propio anillo de salida
0x54 NET_BT_TX_DATA_REG Bluetooth: escritura: empuja un byte a ese anillo
0x58 NET_BT_RX_LEN_REG Bluetooth: bytes en espera en su propio anillo de entrada
0x5C NET_BT_RX_DATA_REG Bluetooth: lectura: saca un byte, 0 cuando está vacío

Los ocho registros NET_BT_ leen 0 y omiten las escrituras en esta placa: el CYW43439 hace Bluetooth en una Pico W real, y Mokxi no lo modela (docs/bluetooth.md).

STATE es dónde está la estación: 0 inactiva, 1 iniciando, 2 conectando, 3 conectada, 4 falló, 5 no existe esa red. NET_CMD_STATUS convierte lo mismo en el código wl_status_t de Arduino que un sketch lee de WiFi.status().

NET_CMD_REG nombre qué hace
0 NOP nada
1 RESET desconecta, descarta ambos anillos, descarta cualquier solicitud
2 CONNECT el anillo de salida contiene ssid\0password; activa BUSY de uno a tres segundos
3 DISCONNECT descarta la asociación y la dirección
4 STATUS NET_RESULT_REG = el código wl_status_t
5 IP NET_RESULT_REG = la dirección asignada, primer octeto en el byte bajo
6 RSSI NET_RESULT_REG = la señal en dBm, con signo extendido
7 SSID el anillo de entrada recibe el nombre del punto de acceso
8 MAC el anillo de entrada recibe los seis bytes MAC de la placa
9 REQUEST el anillo de salida contiene method\0url\0headers\0body; activa BUSY
10 POLL NET_RESULT_REG = 0 mientras está en curso, luego el estado HTTP, o un error negativo con ERR arriba; el cuerpo llega al anillo de entrada
11 LISTEN escucha en el puerto de NET_ARG_REG
12 ACCEPT NET_RESULT_REG = 1 y el anillo de entrada contiene method\0path\0query\0body, o 0 cuando no hay nada en espera
13 REPLY responde la solicitud aceptada con el estado en NET_ARG_REG; el anillo de salida contiene content-type\0body
14 STOP deja de escuchar
15 WL_GPIO_SET impulsar los GPIO propios de la parte inalámbrica desde NET_ARG_REG, primero el bit 0. El bit 0 es el LED de esta placa
16 WL_GPIO_GET leerlos de vuelta en NET_RESULT_REG
17 BLYNK una operación en el servidor Blynk simulado, la operación en NET_ARG_REG y sus campos en el anillo de salida; se responde de inmediato en NET_RESULT_REG, con ERR arriba sin pasar por la red (docs/wifi.md, "Blynk")
20 SOFTAP el AP por software (crates/net/src/softap.rs, docs/wifi.md), la operación en NET_ARG_REG: 1 lo levanta (el anillo de salida ssid\0password\0 y el byte de canal; NET_RESULT_REG 1, o 0 con ERR por un nombre vacío o una contraseña de uno a siete caracteres), 2 lo baja, 3 lo configura (dirección, puerta de enlace y máscara de red, cuatro bytes cada una), 4 su dirección (0 mientras está inactivo), 5 las estaciones conectadas, 6 las conexiones, desconexiones y el bit de actividad que el entorno de ejecución convierte en eventos, 7 y 8 el servidor DNS del portal cautivo iniciándose (el nombre, un byte cero, la dirección) y deteniéndose, 9 su nombre hacia el anillo de entrada, 10 la dirección del celular, 11 el Host de la petición que se atiende hacia el anillo de entrada. La única estación es el celular del panel Web

Los comandos 15 y 16 son solo de esta placa. Las cuatro placas ESP mapean el mismo buzón y sus radios no tienen ese pin, así que en ellas ambos activan ERR y no impulsan nada: inventar un pin sería inventar hardware. Aquí son el camino que toma LED_BUILTIN (sección 1).

Los códigos negativos de POLL: -1 el nombre no se resuelve, -2 la estación no está asociada, -3 https:// y TLS no se simula, -4 un cuerpo más largo que el anillo, -5 una URL que esta red no puede analizar, -6 ya hay una petición en curso. firmware/include/HTTPClient.h los convierte en los códigos con forma de Arduino con los que un sketch se compara, y docs/wifi.md lista la correspondencia.

Tiempos, todos propios de este modelo y todos indicados en docs/wifi.md: una asociación tarda entre uno y tres segundos, decididos a partir del SSID para que una lección tarde lo mismo las dos veces; una contraseña errónea se convierte en WL_CONNECT_FAILED a los cinco segundos; una petición a un origen simulado regresa 60 ms después; una petición al propio servidor del sketch que el sketch nunca responde la cierra la red con un 504 a los diez segundos.

5. Modelo de tiempo y el componente

Como la sección 5 de docs/pico.md, con una diferencia en probe.

probe es una máscara de bits: 1 en ejecución, 2 detenido en WFI, 4 el LED de la placa, 8 transmisión serie en los últimos 20 ms, 16 recepción serie, 32 BOOTSEL mantenido; 0 sin programa. El bit 2 significa lo mismo que en una Pico y viene de otro lugar: en una Pico es el pad GP25, y aquí es el GPIO 0 del CYW43439, leído a través del buzón. La descripción de probe en la propia entrada del catálogo lo dice, así que una herramienta que lea el catálogo lo aprende sin leer este documento.

poke es el de la Pico: 1 presiona BOOTSEL, 0 lo suelta, 2 mantiene RUN en bajo, 3 lo suelta.

6. Inalámbrico

La radio es simulada. No hay 802.11 en ninguna parte de Mokxi, no hay CYW43439, no hay internet real y ninguna petición sale de la pestaña del navegador. docs/wifi.md es el contrato y prevalece sobre esta sección; lo que sigue es la versión corta y lo particular de esta placa.

Un sketch puede usar WiFi.h, WiFiClient.h, WiFiClientSecure.h, HTTPClient.h y WebServer.h (la misma API estilo Arduino que el dueño de una Pico W copia de un tutorial), y se conectará a una red, descargará una página y servirá una. Detrás de esas llamadas están el buzón de la sección 3.8 y crates/net: una máquina de estados de estación limitada a un intervalo de uno a tres segundos, una concesión DHCP en 192.168.4.2 y cuatro orígenes inventados bajo .mokxi. El punto de acceso son tres propiedades de la placa (wifiSsid, wifiPassword, wifiRssi), porque sin radio no hay nada que escanear.

Las grafías propias de arduino-pico. Los headers son los del núcleo de ESP32, porque el runtime es el del ESP32-C3, y la API WiFi de arduino-pico es esa con algunos nombres propios. Sus ejemplos (HelloServer, BasicHttpsClient, los de WiFiServer) usan esos nombres, así que en esta placa, y solo en esta, los headers también los llevan (#if defined(ARDUINO_RASPBERRY_PI_PICO_W)):

arduino-pico aquí
WiFi.h declara WiFiMulti, WiFiClientSecure y NTP lo mismo, sin include propio
WiFi.connected(), beginNoBlock(), end() status() == WL_CONNECTED, begin(), disconnect(true)
WiFi.lowPowerMode(), noLowPowerMode(), setTimeout() se aceptan, no cambian nada
WiFi.beginAP() softAP(): el AP suave en 192.168.42.1, o 192.168.4.1 en WIFI_AP_STA, como elige beginAP de arduino-pico (libraries/WiFi/src/WiFiClass.cpp), salvo que softAPConfig() haya fijado uno, que es al que se conecta el celular del panel Web (docs/wifi.md)
WiFi.ping() -1, y avisa una vez que no se transporta ICMP
WiFi.getHostname() PicoW hasta setHostname()
LEAmDNS.h (MDNS.begin(), MDNS.update()) ESPmDNS.h: compila, y avisa que el nombre no se resolverá
HTTPClient::setInsecure(), setFingerprint(), setCACert(), setX509Time(), setBufferSizes() se aceptan; un GET de https:// aun así falla con HTTPC_ERROR_NO_TLS
rp2040.getFreeHeap(), getUsedHeap(), getTotalHeap() el montón del runtime (también en la Pico)

Las placas ESP no reciben estos nombres, porque sus núcleos no los tienen, y una Pico común sigue rechazando WiFi.h; el consejo de la compilación ahí dice que cambies la placa por una Pico W. web/src/compile/picow-wifi.test.ts ejecuta los ejemplos.

Lo que no está aquí, y no estará:

  • No hay 802.11 en ninguna forma. Sin canal, sin escaneo, sin WiFi.scanNetworks(), sin baliza, sin tramas de asociación, sin WPA2, sin PMK, sin cifrado. Una contraseña se compara como una cadena de texto. RSSI() es la propiedad, no una pérdida de señal.
  • No hay CYW43439 como chip, para un sketch. Sin protocolo SPI hacia él, sin blob de firmware, sin controlador, sin registros. (MicroPython y CircuitPython son otro asunto: sección 9.) Su GPIO 0 sí se modela, porque es el LED de la placa y es un pin que un sketch realmente maneja; los dos comandos que lo alcanzan están en la tabla de la sección 3.8 y no accionan nada en ninguna otra placa. Ninguno de sus otros GPIO se modela, y no hay PWM en el que sí se modela.
  • No sequencing. On real hardware the CYW43 has to be powered and its firmware blob loaded before its GPIO 0 will do anything, which the Arduino core does at start-up. Here the command works from the first instruction, whether or not the sketch has called WiFi.begin(). That is a simplification and this is where it is written down.
  • No hay Bluetooth. Sin LE, sin GATT, sin vinculación, sin stub. El CYW43439 hace Bluetooth en hardware real; Mokxi no lo modela, y no hay ningún header donde un sketch falle.
  • No hay internet real. Sin TCP, sin pila IP, sin sockets, sin protocolo DNS. Un nombre que no esté bajo .mokxi falla con una frase que el sketch puede leer y que el panel Nube imprime.
  • No hay TLS. WiFiClientSecure compila y luego falla, porque un TLS que confiara en todo le enseñaría a un estudiante que https es gratis.

Si lo que importa en tu proyecto es la red inalámbrica real, esta placa en Mokxi no es la herramienta para eso, y ninguna otra lo es: no hay radio en este producto. Para lo que sirve es para aprender la forma del código (el bucle de conexión, los códigos de estado, HTTPClient, un manejador de WebServer) y todo aquello para lo que sirve una Pico por debajo de eso.

7. Tiempo de ejecución del firmware

firmware/pico/, con una bandera: firmware/picow/build.sh lo ejecuta con BOARD=picow, lo que agrega -DMOKXI_BOARD_PICO_W. Esa bandera define MOKXI_NET_BASE en include/rp2040.h e incorpora firmware/include/mokxi_net.h, que es lo que hace que los headers de red compilen; también mete en el enlace el wifi.cpp del ESP32-C3, porque el tiempo de ejecución de red no sabe nada de una placa más allá de esa única dirección. Todo lo demás (crt0.S, link.ld, src/, arduino.h) es de la Pico, sin cambios y sin copia.

El catálogo program la cadena es elf32 arm rp2040 picow, no la de la Pico. Las dos placas ejecutan el mismo conjunto de instrucciones sobre el mismo mapa de memoria, pero una imagen compilada para la W escribe en una dirección que una Pico común deja sin mapear, así que ahí falla. Dos cadenas significan que el editor le ofrece a cada placa su propia lista, igual que la cadena del Nano se mantiene aparte de la del Uno (docs/nano.md sección 6), y web/public/firmware/picow/index.json es esa lista.

Los ocho ejemplos: blink, button, serial, fade y chaser se leen directamente de firmware/pico/examples/ en lugar de copiarse; wificonnect, wifiweather y wifilamp viven en firmware/picow/examples/, porque solo esta placa puede compilarlos. blink controla LED_BUILTIN y GP15, y en esta placa el primero de ellos pasa por el buzón al GPIO 0 del CYW43, así que ambas luces parpadean. fade atenúa solo GP14, porque no hay PWM del otro lado de ese enlace. wifilamp controla ambos, así que la página enciende una luz en la placa y otra en la protoboard.

Sí hay una familia de compilación separada y un paquete de tiempo de ejecución separado (picow), porque un paquete se identifica por la cadena program. Un sketch escrito en el editor para una Pico W se compila en el navegador, como el de la Pico.

8. Lo que no se modela

Todo lo de docs/pico.md sección 6 (el segundo núcleo, PIO, DMA, SPI, I2C, USB, el RTC, el árbol de relojes, la ROM de arranque y el cargador de segunda etapa; el ADC sí se modela, docs/pico.md sección 5a), más:

  • El CYW43439, para un sketch, en todo detalle menos uno: su protocolo SPI, su blob de firmware, sus registros, su detección de VBUS en el GPIO 2, el 802.11 en cualquier banda, el Bluetooth y la antena. La excepción es el GPIO 0, el LED de la placa, que sí se modela porque un sketch realmente lo maneja: por el buzón, encendido o apagado, sin PWM. La red simulada de la sección 6 no es un modelo de este chip y no está en su dirección; es un bloque propio de Mokxi, y la sección 3.8 lo dice en su primera línea.
  • GP23, GP24, GP25 y GP29 como señales inalámbricas, para un sketch. Existen en el modelo del RP2040 como GPIO comunes, porque eso es lo que tiene el chip, y no hay nada escuchando en el otro extremo.

9. MicroPython y CircuitPython: el CYW43439 en sus pines

Una Pico W que arranca a través de su ROM (un paquete de MicroPython o CircuitPython, o un UF2 precompilado del pico-sdk) tiene el CYW43439 en GP23, GP24, GP25 y GP29, modelado desde sus pines hacia adentro hasta la profundidad a la que llega el cyw43-driver de los firmwares oficiales: el bus PIO gSPI, el backplane y la carga de firmware (aceptada y descartada), y un sustituto SDPCM para el firmware de WiFi que responde sus ioctls y se une al punto de acceso de crates/net. docs/cyw43.md es el contrato. En ese camino:

  • El LED es el GPIO 0 del chip, manejado por gpioout por el bus: Pin("LED") en MicroPython, board.LED en CircuitPython, bit 4 de la sonda como en un sketch.
  • WiFi es el lwIP del propio firmware sobre tramas Ethernet hacia el punto de acceso en 192.168.4.1 (crates/net/src/lan.rs), el mismo que usan las placas MicroPython del ESP32: DHCP, DNS para .mokxi, TCP al puerto 80, y un servidor en la placa al que llega el panel Web. Los wifiSsid, wifiPassword y wifiRssi de la placa son el punto de acceso.
  • El buzón en 0x4FFF_E000 no está mapeado: estos firmwares nunca lo tocan, y en el silicio es un hueco.
  • La unidad de CircuitPython empieza en 1540 KB, después de los 1536 KB de firmware de la compilación para W y los 4 KB de NVM.
  • Dónde se ejecuta. Ese arranque necesita el CYW43439 y el extremo IP de la red detrás de él (net/lan), la característica cyw43 del crate rp2040. El simulador del editor se compila sin ella, así que una Pico W que arranca a través de su ROM corre en el modelo de chip completo rp2040::whole (kind KIND_PICO_W de esp_common::whole_chip) en el módulo wasm de los modelos de chip, que se descarga en el primer Ejecutar de ese tipo, como lo hacen las placas ESP32 de MicroPython (docs/micropython-esp32.md sección 7). El componente contiene rp2040::chip::Chip: el RP2040 para un sketch, el modelo para un arranque por ROM. De forma nativa el modelo queda enlazado. La sección 6 de docs/cyw43.md tiene los detalles.

Bluetooth, una segunda estación en el punto de acceso por software (el celular del panel Web se une a AP_IF, docs/cyw43.md), el ahorro de energía y TLS tampoco se modelan ahí.

Esa es toda la diferencia. Todo lo que este documento no menciona es del Pico, y docs/pico.md es donde está escrito.