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_BUILTINnão é um número de GPIO nesta placa. Ele éMOKXI_WL_LED, um número de pino acima de qualquer um real, epinMode,digitalWriteedigitalReado 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, ondeLED_BUILTINpassa pelo driver do CYW43.digitalWrite(LED_BUILTIN, HIGH)portanto acende a lâmpada da placa aqui, exatamente como faz numa mesa, eprobeo reporta como bit 2, que volta pela caixa postal e não sai de um pad.GP25não é o LED. Dirigi-lo para alto aqui dirigeWL_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 ownblinkELF, which writes GP25, lights nothing on this board, andcrates/parts'gp25_is_wl_cs_here_and_lights_nothingo 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.fadeavisa isso e faz o fade no GP14 em vez disso. GP24nã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
.mokxifalha com uma frase que o sketch consegue ler e que o painel Cloud imprime. - Nenhum TLS.
WiFiClientSecurecompila 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,GP25eGP29como 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
gpiooutpelo barramento:Pin("LED")no MicroPython,board.LEDno 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. OswifiSsid,wifiPasswordewifiRssida placa são o access point. - A mailbox em
0x4FFF_E000nã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 featurecyw43do craterp2040. O simulador do editor é compilado sem ela, então uma Pico W que inicializa pela sua ROM roda no modelo de chip inteirorp2040::whole(kindKIND_PICO_Wdeesp_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.mdseção 7). O componente carregarp2040::chip::Chip: o RP2040 para um sketch, o modelo para uma inicialização pela ROM. Nativamente, o modelo é vinculado estaticamente. A seção 6 dedocs/cyw43.mdtem 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.