Referência

Contrato da placa Raspberry Pi Pico W (Fase 9)

O Pico com um CYW43439 nele: o chip não é modelado, o WiFi é simulado e o LED por trás dele funciona.

Esta é a referência de engenharia do modelo: o que ele implementa, registrador por registrador, para quem escreve firmware para ele. Para usar a placa no editor, comece por O Raspberry Pi Pico W e página da placa.

A Pico W é a Raspberry Pi Pico com um CYW43439. Para um sketch de Arduino o CYW43439 não é modelado; para os firmwares oficiais de MicroPython e CircuitPython, que o dirigem por conta própria pelos pinos, ele é, e docs/cyw43.md é esse contrato (seção 9 abaixo). Todo o resto da placa é da Pico, e docs/pico.md é o contrato de tudo isso: o mesmo RP2040, o mesmo header de quarenta pinos na mesma ordem, o mesmo mapa de memória, os mesmos registradores de periféricos, o mesmo modelo de tempo e o mesmo runtime. Um componente do kernel serve aos dois (pico em crates/parts, com uma flag de variante), porque abaixo do chip sem fio não há nada a distinguir.

O tipo no catálogo é picow. Este documento diz apenas o que difere: três GPIOs e onde o LED realmente está, e um bloco que é do próprio Mokxi.

Leia a seção 6 antes de planejar qualquer coisa em torno desta placa (e a seção 9 para um projeto em Python). Não há rádio aqui. O que há, desde docs/wifi.md, é uma rede simulada por trás de uma caixa postal num endereço que o RP2040 deixa sem mapear, e a palavra simulada é tudo: sem 802.11, sem firmware do CYW43, sem internet de verdade. O LED da placa funciona, porque ele é alcançado por essa mesma caixa postal, que é onde ele é alcançado no hardware também.

1. O que difere: três GPIOs e o LED

Três dos GPIOs do RP2040 nunca chegam ao header em nenhuma das placas, e estão ligados a coisas diferentes:

GPIO numa Pico numa Pico W
GP23 SMPS_MODE, o pino de modo do regulador WL_ON, a alimentação do CYW43439
GP24 VBUS_SENSE WL_D, a linha de dados half-duplex do CYW43439
GP25 o LED verde WL_CS, o chip select do CYW43439
GP29 ADC3, o divisor do VSYS WL_CLK, e o divisor do VSYS

O LED de uma Pico W pende do GPIO 0 do próprio CYW43439, alcançado pelo link que o rádio usa. Então:

  • LED_BUILTIN não é um número de GPIO nesta placa. Ele é MOKXI_WL_LED, um número de pino acima de qualquer um real, e pinMode, digitalWrite e digitalRead o envia para o componente sem fio pela caixa postal da seção 3.8 em vez de para um pad. Esse é o caminho que o core do Arduino toma no hardware real, onde LED_BUILTIN passa pelo driver do CYW43. digitalWrite(LED_BUILTIN, HIGH) portanto acende a lâmpada da placa aqui, exatamente como faz numa mesa, e probe o reporta como bit 2, que volta pela caixa postal e não sai de um pad.
  • GP25 não é o LED. Dirigi-lo para alto aqui dirige 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 o mantém assim.
  • Não há PWM atrás dessa lâmpada. O link carrega ligado e desligado, não um duty cycle, então analogWrite(LED_BUILTIN, …) não faz nada numa Pico W. fade avisa isso e faz o fade no GP14 em vez disso.
  • GP24 não é o VBUS sense. O modelo do Pico mantém esse pino em nível alto porque essa placa é sempre alimentada por USB; aqui nada o puxa e ele lê nível baixo.

A alternativa (chamar o GP25 de LED e torcer para dar certo) foi considerada e rejeitada. Ela faria um sketch que acende no simulador não fazer nada numa mesa, que é exatamente o tipo de erro que este projeto não vai entregar. Não ter lâmpada nenhuma foi a primeira resposta e também não era a certa: a lâmpada está ali na placa, e o caminho até ela é uma interface de comandos que este modelo agora tem. Então ela é modelada onde realmente está. DECISIONS.md, 17/09/2026.

Todo o resto da seção 1 de docs/pico.md vale: os mesmos quarenta pinos na mesma ordem do catálogo, os mesmos nomes, o mesmo comportamento de RUN e 3V3_EN, os mesmos trilhos nas mesmas tensões, os mesmos pull-ups de 55 k nos pads e o mesmo limiar de entrada de 1,65 V.

2. Mapa de memória, 3. Registradores de periféricos, 4. Canal do host

Como as seções 2, 3 e 4 de docs/pico.md, com um bloco adicionado que não é do chip e nada removido. É o mesmo RP2040: a mesma janela XIP da flash, os mesmos 264 KB de SRAM, os mesmos RESETS, IO_BANK0, PADS_BANK0, TIMER, UART0, PWM e SIO nos mesmos endereços com os mesmos bits, e a UART0 como canal do 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 Caixa postal de rede do Mokxi (0x4FFF_E000)

Este bloco não é do RP2040 e não existe num Pico comum. Todo outro endereço em docs/pico.md é do chip, tirado do datasheet, e uma imagem compilada contra ele roda num Pico real. Este é do próprio Mokxi: a rede simulada de crates/net, acima de todos os periféricos APB (eles param bem antes de 0x4008_0000) e abaixo da janela AHB-Lite em 0x5000_0000, para que uma imagem que o use falhe no silício em vez de ler o registrador de outro periférico. Essa falha é a resposta honesta, porque a coisa por trás deste bloco não existe no chip.

Por que uma caixa postal é o formato honesto aqui também. A parte sem fio de um Pico W real é um CYW43439 do outro lado de um link de três pinos parecido com SPI, dirigido por um blob fechado de firmware binário. Não é um conjunto de registradores documentados no RP2040, assim como o rádio de um ESP32 não é um conjunto de registradores documentados no próprio die, e o WiFi.h do Arduino num Pico W realmente termina do outro lado de uma interface de comandos. Então isto é uma interface de comandos: a mesma, byte por byte, que as quatro placas ESP usam, no endereço próprio desta placa.

Ela é mapeada somente num Pico W. firmware/pico/build.sh define MOKXI_BOARD_PICO_W para essa placa e não para o Pico, então WiFi.h compila para uma e se recusa para a outra, e o Soc::new de crates/rp2040 deixa o endereço como um buraco enquanto Soc::new_with_network o mapeia. Num Pico comum o acesso falha, que é o que uma placa sem parte sem fio deveria fazer.

O bloco não levanta nenhuma interrupção NVIC. Um número de IRQ é do chip, e este bloco não é do chip, então não recebe nenhum. O firmware faz polling, e um núcleo parado em WFI ainda é acordado quando a rede tem algo a dizer, do mesmo jeito que é acordado por uma borda de PWM.

Aqui não há rádio, nem 802.11, nem internet real. Nada no modelo transmite, escaneia, associa, criptografa ou abre um socket: uma senha é comparada como string, um nome que não está sob .mokxi não resolve, e as três origens que a rede serve são funções em crates/net/src/http.rs. A caixa de correio tem a forma da costura real em vez de uma ficção sobre um MAC: num ESP32 real o hardware de WiFi é um blob binário fechado com uma interface de comandos, e o WiFi.h do Arduino acaba do outro lado de um destes. docs/wifi.md é o contrato do que está por trás dele; esta seção é apenas os registradores.

Um registrador de comando, um registrador de status, um anel de 4096 bytes em cada sentido e um bit de interrupção. Escrever em NET_CMD_REG executa o comando; um comando que leva tempo simulado levanta BUSY e o limpa, com DONE em NET_INT_RAW_REG, quando termina.

offset nome bits
0x00 NET_ID_REG lê 0x494B4F4D, e nada mais o faz. Um sketch que quer saber se está no Mokxi lê isto; no silício o acesso falha
0x04 NET_CMD_REG escreva um código de comando (tabela abaixo); a escrita o executa
0x08 NET_ARG_REG uma palavra de argumento, lida de volta: a porta para LISTEN, o status 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 o que o último comando respondeu
0x14 NET_INT_RAW_REG bit 0 DONE, bit 1 EVENT
0x18 NET_INT_ENA_REG os mesmos dois bits
0x1C NET_INT_CLR_REG escreva 1 para limpar, os mesmos dois bits
0x20 NET_TX_LEN_REG bytes preparados no anel de saída
0x24 NET_TX_DATA_REG escrita: empurra um byte (bits 0..7) para o anel de saída
0x28 NET_RX_LEN_REG bytes aguardando no anel de entrada
0x2C NET_RX_DATA_REG leitura: retira um byte do anel de entrada, 0 quando está vazio
0x30 NET_RING_LEN_REG capacidade de cada anel em bytes, para o firmware não precisar fixar 4096
0x40 NET_BT_CMD_REG Bluetooth: escreva um código de comando Bluetooth (docs/bluetooth.md); a escrita o executa
0x44 NET_BT_ARG_REG Bluetooth: uma palavra de argumento, lida de volta; um evento deixa seu número aqui
0x48 NET_BT_RESULT_REG Bluetooth: o que o último comando Bluetooth respondeu
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 no seu próprio anel de saída
0x54 NET_BT_TX_DATA_REG Bluetooth: escrita: empurra um byte para esse anel
0x58 NET_BT_RX_LEN_REG Bluetooth: bytes aguardando no seu próprio anel de entrada
0x5C NET_BT_RX_DATA_REG Bluetooth: leitura: retira um byte, 0 quando está vazio

Os oito registradores NET_BT_ leem 0 e ignoram escritas nesta placa: o CYW43439 faz Bluetooth num Pico W real, e o Mokxi não o modela (docs/bluetooth.md).

STATE é onde está a estação: 0 ociosa, 1 iniciando, 2 conectando, 3 conectada, 4 falhou, 5 rede inexistente. NET_CMD_STATUS transforma a mesma coisa no código wl_status_t do Arduino que um sketch lê de WiFi.status().

NET_CMD_REG nome o que faz
0 NOP nada
1 RESET desconecta, zera ambos os anéis, descarta qualquer requisição
2 CONNECT o anel de saída contém ssid\0password; levanta BUSY por um a três segundos
3 DISCONNECT descarta a associação e o endereço
4 STATUS NET_RESULT_REG = o código wl_status_t
5 IP NET_RESULT_REG = o endereço obtido, primeiro octeto no byte menos significativo
6 RSSI NET_RESULT_REG = o sinal em dBm, com sinal estendido
7 SSID o anel de entrada recebe o nome do ponto de acesso
8 MAC o anel de entrada recebe os seis bytes de MAC da placa
9 REQUEST o anel de saída contém method\0url\0headers\0body; levanta BUSY
10 POLL NET_RESULT_REG = 0 em andamento, depois o status HTTP, ou um erro negativo com ERR ativo; o corpo chega no anel de entrada
11 LISTEN escuta na porta em NET_ARG_REG
12 ACCEPT NET_RESULT_REG = 1 e o anel de entrada contém method\0path\0query\0body, ou 0 quando nada está aguardando
13 REPLY responde à requisição aceita com o status em NET_ARG_REG; o anel de saída contém content-type\0body
14 STOP para de escutar
15 WL_GPIO_SET dirigir os GPIOs da própria parte sem fio a partir de NET_ARG_REG, bit 0 primeiro. O bit 0 é o LED desta placa
16 WL_GPIO_GET lê-los de volta em NET_RESULT_REG
17 BLYNK uma operação no servidor Blynk simulado, a operação em NET_ARG_REG e seus campos no anel de saída; respondida de imediato em NET_RESULT_REG, com ERR ativo, sem passar pela rede (docs/wifi.md, "Blynk")
20 SOFTAP o soft AP (crates/net/src/softap.rs, docs/wifi.md), a operação em NET_ARG_REG: 1 o levanta (o anel de saída ssid\0password\0 e o byte de canal; NET_RESULT_REG 1, ou 0 com ERR para um nome vazio ou uma senha de um a sete caracteres), 2 o derruba, 3 o configura (endereço, gateway e máscara de rede, quatro bytes cada), 4 seu endereço (0 enquanto estiver derrubado), 5 as estações conectadas, 6 as entradas, saídas e o bit de ativo que o runtime transforma em eventos, 7 e 8 um servidor DNS de portal cativo iniciando (o nome, um byte zero, o endereço) e parando, 9 seu nome no anel de entrada, 10 o endereço do telefone, 11 o Host da requisição sendo servida no anel de entrada. A única estação é o telefone do painel Web

Os comandos 15 e 16 são exclusivos desta placa. As quatro placas ESP mapeiam a mesma caixa postal e seus rádios não têm esse pino, então nelas ambos definem ERR e não acionam nada: inventar um pino seria inventar hardware. Aqui eles são o caminho que LED_BUILTIN percorre (seção 1).

Os códigos negativos de POLL: -1 o nome não resolve, -2 a estação não está associada, -3 https:// e o TLS não são simulados, -4 um corpo maior que o anel, -5 uma URL que esta rede não consegue interpretar, -6 já há uma requisição em andamento. firmware/include/HTTPClient.h os transforma nos códigos no formato Arduino que um sketch compara, e docs/wifi.md lista o mapeamento.

Temporização, toda ela própria deste modelo e toda declarada em docs/wifi.md: uma associação leva entre um e três segundos, decidida a partir do SSID para que uma aula leve o mesmo tempo nas duas vezes; uma senha errada vira WL_CONNECT_FAILED após cinco segundos; uma requisição a uma origem simulada volta 60 ms depois; uma requisição ao próprio servidor do sketch que o sketch nunca responde é fechada pela rede com um 504 após dez segundos.

5. Modelo de tempo e o componente

Como a seção 5 de docs/pico.md, com uma diferença em probe.

probe é uma máscara de bits: 1 em execução, 2 parado em WFI, 4 o LED da placa, 8 transmissão serial nos últimos 20 ms, 16 recepção serial, 32 BOOTSEL pressionado; 0 sem programa. O bit 2 significa a mesma coisa que num Pico e vem de outro lugar: no Pico é o pad GP25, e aqui é o GPIO 0 do CYW43439, lido de volta pela caixa postal. A descrição de probe na própria entrada do catálogo diz isso, então uma ferramenta que lê o catálogo aprende sem ler este documento.

poke é o do Pico: 1 pressiona BOOTSEL, 0 solta, 2 mantém RUN em nível baixo, 3 solta.

6. Rede sem fio

O rádio é simulado. Não há 802.11 em lugar nenhum do Mokxi, nenhum CYW43439, nenhuma internet real e nenhuma requisição que saia da aba do navegador. docs/wifi.md é o contrato e vence sobre esta seção; o que segue é a versão curta e o que é particular a esta placa.

Um sketch pode usar WiFi.h, WiFiClient.h, WiFiClientSecure.h, HTTPClient.h e WebServer.h (a mesma API no estilo Arduino que o dono de uma Pico W copia de um tutorial), e ele vai se conectar a uma rede, baixar uma página e servir outra. Por trás dessas chamadas estão a caixa postal da seção 3.8 e crates/net: uma máquina de estados de estação limitada a uma janela de um a três segundos, um lease DHCP em 192.168.4.2 e quatro origens inventadas sob .mokxi. O ponto de acesso são três propriedades da placa (wifiSsid, wifiPassword, wifiRssi), porque sem rádio não há nada para escanear.

Grafias do próprio arduino-pico. Os cabeçalhos são os do core do ESP32, porque o runtime é o do ESP32-C3, e a API WiFi do arduino-pico é essa com alguns nomes próprios. Os exemplos dele (HelloServer, BasicHttpsClient, os de WiFiServer) usam esses nomes, então nesta placa, e somente nesta placa, os cabeçalhos também os carregam (#if defined(ARDUINO_RASPBERRY_PI_PICO_W)):

arduino-pico aqui
WiFi.h declara WiFiMulti, WiFiClientSecure e NTP os mesmos, sem include próprio
WiFi.connected(), beginNoBlock(), end() status() == WL_CONNECTED, begin(), disconnect(true)
WiFi.lowPowerMode(), noLowPowerMode(), setTimeout() aceitos, não mudam nada
WiFi.beginAP() softAP(): o soft AP em 192.168.42.1, ou 192.168.4.1 em WIFI_AP_STA, como o beginAP do arduino-pico escolhe (libraries/WiFi/src/WiFiClass.cpp), a menos que softAPConfig() tenha definido um, que é o que o telefone do painel Web conecta (docs/wifi.md)
WiFi.ping() -1, e avisa uma vez que ICMP não é transportado
WiFi.getHostname() PicoW até setHostname()
LEAmDNS.h (MDNS.begin(), MDNS.update()) ESPmDNS.h: compila, e avisa que o nome não vai resolver
HTTPClient::setInsecure(), setFingerprint(), setCACert(), setX509Time(), setBufferSizes() aceitos; um GET em https:// ainda falha com HTTPC_ERROR_NO_TLS
rp2040.getFreeHeap(), getUsedHeap(), getTotalHeap() a heap do runtime (no Pico também)

As placas ESP não recebem esses nomes, porque seus cores não os têm, e um Pico comum ainda recusa WiFi.h; o conselho da compilação ali diz para trocar a placa por uma Pico W. web/src/compile/picow-wifi.test.ts roda os exemplos.

O que não está aqui, e não estará:

  • Nenhum 802.11 em qualquer forma. Sem canal, sem varredura, sem WiFi.scanNetworks(), sem beacon, sem quadros de associação, sem WPA2, sem PMK, sem criptografia. Uma senha é comparada como uma string. RSSI() é uma propriedade, não uma perda de sinal.
  • Nenhum CYW43439 como chip, para um sketch. Sem protocolo SPI até ele, sem blob de firmware, sem driver, sem registradores. (MicroPython e CircuitPython são outro assunto: seção 9.) O GPIO 0 dele é modelado, porque é o LED da placa e é um pino que um sketch realmente aciona; os dois comandos que chegam até ele estão na tabela da seção 3.8 e não acionam nada em nenhuma outra placa. Nenhum dos outros GPIOs dele é modelado, e não há PWM nesse que é.
  • 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.
  • Nenhum Bluetooth. Sem LE, sem GATT, sem pareamento, sem stub. O CYW43439 faz Bluetooth em hardware de verdade; o Mokxi não o modela, e não há um cabeçalho no qual um sketch possa falhar.
  • Nenhuma internet de verdade. Sem TCP, sem pilha IP, sem sockets, sem protocolo DNS. Um nome que não esteja sob .mokxi falha com uma frase que o sketch consegue ler e que o painel Cloud imprime.
  • Nenhum TLS. WiFiClientSecure compila e depois falha, porque um TLS que confiasse em tudo ensinaria a um aluno que https é de graça.

Se o wireless de verdade é o ponto central do seu projeto, esta placa no Mokxi não é a ferramenta para isso, e nenhuma outra é: não há rádio neste produto. Ela serve para aprender o formato do código (o loop de conexão, os códigos de status, HTTPClient, um handler de WebServer) e tudo aquilo para que o Pico serve por baixo disso.

7. Tempo de execução do firmware

firmware/pico/, com uma flag: firmware/picow/build.sh roda com BOARD=picow, o que adiciona -DMOKXI_BOARD_PICO_W. Essa flag define MOKXI_NET_BASE em include/rp2040.h e traz firmware/include/mokxi_net.h, que é o que faz os cabeçalhos de rede compilarem; ela também traz o wifi.cpp do ESP32-C3 para a linkagem, porque o runtime de rede não sabe nada sobre uma placa além daquele único endereço. Todo o resto (crt0.S, link.ld, src/, arduino.h) é da Pico, sem alterações e sem cópia.

O catálogo program é elf32 arm rp2040 picow, não a da Pico. As duas placas rodam o mesmo conjunto de instruções no mesmo mapa de memória, mas uma imagem compilada para a W grava em um endereço que uma Pico comum deixa sem mapear, então ela falha ali. Duas strings significam que o editor oferece a cada placa sua própria lista, exatamente como a string do Nano é mantida separada da do Uno (docs/nano.md seção 6), e web/public/firmware/picow/index.json é essa lista.

Os oito exemplos: blink, button, serial, fade e chaser são lidos direto de firmware/pico/examples/ em vez de copiados; wificonnect, wifiweather e wifilamp ficam em firmware/picow/examples/, porque só esta placa consegue compilá-los. blink aciona LED_BUILTIN e GP15, e nesta placa o primeiro desses vai pela mailbox até o GPIO 0 do CYW43, então as duas lâmpadas piscam. fade faz o fade apenas em GP14, porque não há PWM do outro lado dessa ligação. wifilamp aciona ambos, então a página acende uma lâmpada na placa e uma na protoboard.

Existe sim uma família de compilação separada e um pacote de runtime separado (picow), porque um pacote é identificado pela string program. Um sketch escrito no editor para uma Pico W compila no navegador, como o da Pico.

8. O que não é modelado

Tudo o que está na seção 6 de docs/pico.md (o segundo núcleo, PIO, DMA, SPI, I2C, USB, o RTC, a árvore de clocks, a boot ROM e o bootloader de segunda etapa; o ADC é modelado, docs/pico.md seção 5a), mais:

  • O CYW43439, para um sketch, em cada detalhe, exceto em um: seu protocolo SPI, seu blob de firmware, seus registradores, seu sensor de VBUS no GPIO 2, o 802.11 em qualquer banda, o Bluetooth e a antena. A exceção é o GPIO 0, o LED da placa, que é modelado porque um sketch realmente o aciona: pela mailbox, ligado ou desligado, sem PWM. A rede simulada da seção 6 não é um modelo deste chip e não está no endereço dele; é um bloco próprio do Mokxi, e a seção 3.8 diz isso na primeira linha.
  • GP23, GP24, GP25 e GP29 como sinais sem fio, para um sketch. Eles existem no modelo do RP2040 como GPIOs comuns, porque é isso que o chip tem, e nada está escutando na outra ponta.

9. MicroPython e CircuitPython: o CYW43439 nos seus pinos

Uma Pico W que inicializa pela sua ROM (um pacote de MicroPython ou CircuitPython, ou um UF2 pré-compilado do pico-sdk) tem o CYW43439 em GP23, GP24, GP25 e GP29, modelado a partir de seus pinos para dentro, na profundidade em que o cyw43-driver dos firmwares oficiais o alcança: o barramento PIO gSPI, o backplane e o upload de firmware (aceito e descartado), e um substituto SDPCM para o firmware de WiFi que responde seus ioctls e se conecta ao access point de crates/net. docs/cyw43.md é o contrato. Nesse caminho:

  • O LED é o GPIO 0 do chip, acionado por gpioout pelo barramento: Pin("LED") no MicroPython, board.LED no CircuitPython, bit 4 da ponta de prova como em um sketch.
  • O WiFi é o lwIP do próprio firmware sobre quadros Ethernet até o access point em 192.168.4.1 (crates/net/src/lan.rs), o mesmo que as placas MicroPython de ESP32 usam: DHCP, DNS para .mokxi, TCP na porta 80 e um servidor na placa que o painel Web alcança. Os wifiSsid, wifiPassword e wifiRssi da placa são o access point.
  • A mailbox em 0x4FFF_E000 não está mapeada: esses firmwares nunca a tocam, e no silício ela é um buraco.
  • O drive do CircuitPython começa em 1540 KB, depois dos 1536 KB de firmware da versão W e dos 4 KB de NVM.
  • Onde ele roda. Essa inicialização precisa do CYW43439 e da ponta IP da rede atrás dele (net/lan), a feature cyw43 do crate rp2040. O simulador do editor é compilado sem ela, então uma Pico W que inicializa pela sua ROM roda no modelo de chip inteiro rp2040::whole (kind KIND_PICO_W de esp_common::whole_chip) no módulo wasm dos modelos de chip, buscado no primeiro Rodar desse tipo, como fazem as placas MicroPython de ESP32 (docs/micropython-esp32.md seção 7). O componente carrega rp2040::chip::Chip: o RP2040 para um sketch, o modelo para uma inicialização pela ROM. Nativamente, o modelo é vinculado estaticamente. A seção 6 de docs/cyw43.md tem os detalhes.

Bluetooth, uma segunda estação no ponto de acesso de software (o telefone do painel Web entra na AP_IF, docs/cyw43.md), economia de energia e TLS também não são modelados lá.

Essa é toda a diferença. Qualquer coisa que este documento não mencione é do Pico, e é em docs/pico.md que isso está escrito.