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 A Raspberry Pi Pico e página da placa.
O terceiro microcontrolador, e o primeiro no motor Cortex-M. Um componente do kernel (pico em crates/parts) envolve um modelo de SoC RP2040 (crates/rp2040) construído sobre o núcleo Cortex-M (crates/cortexm-core, Profile::V6M, comprovado em proofs/cortexm/REPORT.md). O firmware é um ELF Thumb que conversa com os periféricos abaixo nos endereços reais do RP2040, então um programa compilado para o Mokxi roda em um Pico real.
O tipo do catálogo é pico (Raspberry Pi Pico, RP2040). Três agentes compilam contra este arquivo: o SoC e o componente (Rust), o runtime de firmware e os exemplos (C++, clang para thumbv6m-none-eabi), o visual da placa (TypeScript). Altere-o apenas editando este arquivo primeiro. Tudo o que está em docs/esp32c3.md sobre como um componente de placa se comporta (slices, canal do host, reset, linha de crash) vale aqui, exceto quando este arquivo disser o contrário.
Rodar binários compilados com o Raspberry Pi Pico SDK não era um objetivo da Fase 4: o crt0 do SDK espera o bootloader de segundo estágio, a árvore de clocks, o XOSC e os PLLs. Desde outubro de 2026 existe uma segunda forma de carregar o chip, o full boot, para o MicroPython (docs/micropython.md): um UF2 numa flash de 2 MB apagada, a boot ROM (crates/rp2040/src/rom.rs, escrita a partir da seção 2.8 do datasheet), o segundo estágio executado a partir da SRAM5, e a árvore de clocks, a SSI e o chip de flash, o controlador USB, o RTC e o restante mapeados (sysregs.rs, ssi.rs, usb.rs), e desde a fase 3 do Python os blocos de I2C, SPI e DMA (i2c.rs, spi.rs, dma.rs) que o machine.I2C e o machine.SPI do MicroPython acionam. Tudo neste arquivo descreve o caminho do ELF, que não mudou: nenhum desses blocos é mapeado para um ELF, e o Wire e o SPI de um sketch Arduino continuam sendo os barramentos por software de firmware/lib/ em pinos comuns. O que é modelado é o conjunto de periféricos de que pinMode, digitalWrite, digitalRead, analogWrite, millis, micros, delay, Serial e attachInterrupt precisam, nos seus endereços reais, de modo que o mesmo código-fonte compilado com firmware/pico/ produza uma imagem que também roda no hardware.
1. Pinos da placa (ordem do catálogo)
O cabeçalho de 40 pinos, vista superior com o conector USB em cima. A coluna esquerda são os pinos físicos 1..20 lidos de cima para baixo; a coluna direita são os pinos físicos 40..21 lidos de cima para baixo, que é como os pinos se alinham quando a placa é segurada desse jeito.
Coluna esquerda (pinos 1..20): GP0, GP1, GND, GP2, GP3, GP4, GP5, GNDb, GP6, GP7, GP8, GP9, GNDc, GP10, GP11, GP12, GP13, GNDd, GP14, GP15.
Coluna direita (pinos 40..21): VBUS, VSYS, GNDe, 3V3_EN, 3V3, ADC_VREF, GP28, AGND, GP27, GP26, RUN, GP22, GNDf, GP21, GP20, GP19, GP18, GNDg, GP17, GP16.
40 pinos. Nomes duplicados recebem um sufixo em letra porque os nomes de pinos do catálogo são únicos; a serigrafia da placa marca GND em todos os sete e AGND no pino 33. Os três pontos de teste (TP1..TP6) e o cabeçalho SWD não são pinos.
Elétrico:
3V3fornece 3,3 V emR_SUPPLYe cadaGND*eAGNDfornece 0 V emR_SUPPLY.VBUSfornece 5 V emR_SUPPLYeVSYSfornece 4,7 V (5 V através do diodo Schottky que a placa tem entre eles), porque a placa é sempre alimentada por USB.ADC_VREFfornece 3,3 V através de 200 R, que é a referência filtrada que a placa expõe. A placa é uma fonte para o resto do circuito.3V3_ENé uma entrada com pull-up de 100 k paraVSYS; puxá-lo abaixo de 1,2 V desliga o regulador, o que para o chip e libera cada pad. Essa é a única coisa que ele faz aqui.RUNé uma entrada com pull-up interno de 50 k para 3,3 V; acionado abaixo de 1,65 V mantém a CPU em reset, e soltá-lo reinicia a partir da tabela de vetores.GP0..GP22,GP26..GP28são GPIO inout. Saída habilitada (bit deSIO.GPIO_OEdefinido e a seleção de função é SIO ou PWM): push-pull a 3,3 V ou 0 V através deR_STRONG. Saída desabilitada: alta impedância, mais um pull-up de 55 k para 3,3 V quandoPADS_BANK0.GPIOn.PUEestá definido, um pull-down de 55 k quandoPDEestá definido (ambos definidos é um bus-keeper, modelado como alta impedância). A entrada lê a tensão do nó contra 1,65 V; Unknown lê 0, e uma entrada flutuante lê ruído, como no Uno (docs/uno.mdseção 1).PADS_BANK0.GPIOn.ODdesabilita o driver de saída seja lá o que o periférico selecionado pedir, eIEzerado faz a entrada ler 0. Um pad do RP2040 não tem modo open-drain; um driver que queira um aciona nível baixo e vai para entrada no nível alto.GP23,GP24eGP25existem no modelo mas não estão no cabeçalho, como na placa real:GP23é o controle de power-save do SMPS,GP24é o sensor de VBUS (lê 1, porque o modelo é sempre alimentado por USB) eGP25é o LED verde da placa. O LED é mostrado a partir de um bit de probe (seção 5), e o pad carrega uma carga de 1 k para o terra para que a tensão seja honesta.GP26,GP27eGP28sãoADC0..ADC2, e o ADC é modelado (seção 5a):analogRead(26)lê a tensão no nó.ADC_VREFé a referência de 3,3 V do conversor eAGNDum terra.GP0/GP1são UART0 TX/RX na placa real. Aqui a UART0 conversa com o canal do host (seção 4) e os dois pads continuam GPIO, exatamente comodocs/esp32c3.mdfaz.
2. Mapa de memória (endereços reais do RP2040)
| região | endereço | tamanho | notas |
|---|---|---|---|
| ROM | 0x0000_0000 |
16 KB | não modelada para um ELF: lê 0, escritas ignoradas e contadas (o boot completo mapeia rom.rs) |
| flash XIP | 0x1000_0000 |
até 2 MB | a imagem do programa; somente leitura para o núcleo |
| SRAM (striped) | 0x2000_0000 |
256 KB | SRAM0..SRAM3, quatro bancos intercalados por palavra |
| SRAM4 | 0x2004_0000 |
4 KB | |
| SRAM5 | 0x2004_1000 |
4 KB | |
| RESETS | 0x4000_C000 |
4 KB | seção 3.1 |
| IO_BANK0 | 0x4001_4000 |
4 KB | seção 3.2 |
| PADS_BANK0 | 0x4001_C000 |
4 KB | seção 3.3 |
| UART0 | 0x4003_4000 |
4 KB | seção 3.5 |
| UART1 | 0x4003_8000 |
4 KB | seção 3.5a |
| PWM | 0x4005_0000 |
4 KB | seção 3.6 |
| TIMER | 0x4005_4000 |
4 KB | seção 3.4 |
| SIO | 0xD000_0000 |
4 KB (não APB) | seção 3.7 |
| PPB | 0xE000_0000 |
1 MB | SysTick, NVIC e o SCB, dentro do núcleo |
A SRAM tem 264 KB e é contígua de 0x2000_0000 a 0x2004_2000. O striping de SRAM0..SRAM3 é um detalhe de arbitragem sem efeito visível para o software em um núcleo só, então o modelo é um único array plano; 0x2100_0000 e 0x2110_0000, os aliases não striped dos mesmos bancos, não são mapeados, e o mesmo vale para a janela de manutenção do cache XIP em 0x4002_0000. Qualquer acesso fora de uma região mapeada gera um bus fault, que no ARMv6-M escala para HardFault; o componente conta as falhas e relata um crash (seção 5). Um registrador não implementado dentro de um bloco mapeado lê 0 e ignora escritas, com um contador para diagnóstico.
Todo bloco periférico APB também é espelhado em +0x1000 (XOR atômico), +0x2000 (set atômico) e +0x3000 (clear atômico), e é assim que o firmware do RP2040 define um bit sem um read-modify-write. O modelo implementa os três para cada periférico que implementa. O SIO não é um bloco APB e não tem aliases, como no chip.
Firmware ELF. loadProgram recebe um executável ELF32 little-endian ARM (e_machine 40). Cada segmento PT_LOAD precisa estar dentro da flash XIP ou da SRAM; .data é carregado no seu p_paddr (na flash) e o crt0 do runtime o copia, como no hardware. Não há bootloader de segundo estágio: o modelo não exige, executa nem valida por checksum um bloco boot2, e uma seção .boot2 de 256 bytes na imagem é simplesmente carregada e nunca executada. O reset usa a tabela de vetores no menor endereço de flash carregado: VTOR é definido ali, SP_main vem da palavra 0 e o ponto de entrada da palavra 1, exatamente como o processador faz ao sair do reset. O e_entry do ELF não é usado; uma tabela de vetores é obrigatória. Um carregamento em tempo de execução reseta a placa.
3. Registradores de periféricos (subconjunto, offsets reais, posições de bits reais)
Os registradores têm 32 bits e são alinhados por palavra. Acesso por byte ou halfword a um registrador de periférico não é suportado (uma leitura retorna a palavra alinhada estreitada, uma escrita grava a palavra inteira a partir do valor estreito); o firmware não deve fazer isso. SRAM e flash aceitam qualquer largura.
3.1 RESETS (0x4000_C000)
| offset | nome | bits |
|---|---|---|
0x00 |
RESET |
1 = bloco mantido em reset |
0x04 |
WDSEL |
armazenado, lido de volta |
0x08 |
RESET_DONE |
1 = bloco fora de reset e pronto |
A numeração de bits é a do datasheet: 5 io_bank0, 8 pads_bank0, 14 pwm, 21 timer, 22 uart0, 23 uart1. RESET_DONE é o inverso de RESET, sem atraso: um bloco sai do reset no instante em que seu bit é limpo, então o loop usual while (!(resets_hw->reset_done & bits)) passa direto. Ao sair do reset, todo bloco aqui lê seus valores de power-on; manter um bloco em reset o devolve a eles e, enquanto io_bank0 ou pads_bank0 estiver mantido, todo pad fica em alta impedância. Blocos que o modelo não implementa aceitam seus bits e reportam concluído.
3.2 IO_BANK0 (0x4001_4000)
| offset | nome | bits |
|---|---|---|
0x00 + 8n |
GPIOn_STATUS |
bit 8 OUTTOPAD, bit 13 OETOPAD, bit 17 INFROMPAD, somente leitura |
0x04 + 8n |
GPIOn_CTRL |
bits 4..0 FUNCSEL, 9..8 OUTOVER, 13..12 OEOVER, 17..16 INOVER |
0x0F0 + 4m |
INTRm |
interrupção crua dos GPIOs 8m..8m+7, quatro bits cada |
0x100 + 4m |
PROC0_INTEm |
enable, mesmo layout |
0x110 + 4m |
PROC0_INTFm |
force, mesmo layout |
0x120 + 4m |
PROC0_INTSm |
crua AND enable, OR force |
FUNCSEL: 4 = PWM, 5 = SIO, 31 = NULL (o pad é liberado). Todo o resto (SPI 1, UART 2, I2C 3, PIO0 6, PIO1 7, clocks 8, USB 9) é aceito, armazenado e lido de volta, mas deixa o pad liberado, porque esses periféricos não são modelados. O valor de power-on é 31 em todo pino, como no chip, então o firmware precisa selecionar SIO antes que um pad faça qualquer coisa, e firmware/pico/ faz isso.
OUTOVER/OEOVER: 0 = o sinal do periférico, 1 = invertido, 2 = drive baixo (OEOVER 2 = desabilitar), 3 = drive alto (OEOVER 3 = habilitar). INOVER usa os mesmos quatro para a entrada.
Os quatro bits de interrupção por GPIO são 0 LEVEL_LOW, 1 LEVEL_HIGH, 2 EDGE_LOW, 3 EDGE_HIGH. Bits de borda ficam travados e são limpos escrevendo 1 neles em INTRm; bits de nível acompanham o pad e não podem ser limpos. Qualquer bit definido em um PROC0_INTSm levanta IO_IRQ_BANK0 (IRQ 13).
3.3 PADS_BANK0 (0x4001_C000)
| offset | nome | bits |
|---|---|---|
0x00 |
VOLTAGE_SELECT |
armazenado, lido de volta |
0x04 + 4n |
GPIOn |
0 SLEWFAST, 1 SCHMITT, 2 PDE, 3 PUE, 4..5 DRIVE, 6 IE, 7 OD |
O power-on é IE limpo, PUE limpo, PDE definido, SCHMITT definido, DRIVE = 1 (4 mA) em todo pad, como o datasheet indica. IE limpo faz a entrada ler 0 independente do que o nó estiver fazendo; OD definido libera o pad qualquer que seja a solicitação do periférico selecionado; DRIVE e SLEWFAST são armazenados e lidos de volta, mas não mudam a impedância de saída, que é sempre R_STRONG.
3.4 TIMER (0x4005_4000)
Um contador de 64 bits em microssegundos e quatro alarmes de 32 bits. Este é o relógio do componente: micros() e millis() o leem e delay() dorme em um alarme.
| offset | nome | bits |
|---|---|---|
0x00 0x04 |
TIMEHW TIMELW |
somente escrita, escrita travada do contador inteiro |
0x08 |
TIMEHR |
palavra alta, travada pela última leitura de TIMELR |
0x0C |
TIMELR |
palavra baixa; lê-la trava a palavra alta em TIMEHR |
0x10 + 4n |
ALARMn |
n = 0..3; escrever o arma, escrever também limpa seu bit INTR |
0x20 |
ARMED |
bit n = alarme n armado; escreva 1 para desarmar |
0x24 0x28 |
TIMERAWH TIMERAWL |
o contador sem travamento |
0x2C |
DBGPAUSE |
armazenado, lido de volta |
0x30 |
PAUSE |
o bit 0 para o contador |
0x34 |
INTR |
bit n = alarme n disparado; escreva 1 para limpar |
0x38 0x3C 0x40 |
INTE INTF INTS |
enable, force, e o bruto é AND de enable com OR de force |
O contador é derivado do tempo do kernel: microseconds = (now_ps - origin_ps) / 1_000_000, com a origem fixada no primeiro slice. Ele nunca se dessincroniza do circuito. Um alarme dispara quando os 32 bits baixos do contador atingem o valor armado, desarma a si mesmo e define seu bit INTR; o bit n de INTS levanta TIMER_IRQ_n (IRQ 0..3). Escrever em um alarme também limpa seu bit INTR. O comparador só enxerga os 32 bits baixos, então um alarme armado em um valor que acabou de passar não dispara por 71,6 minutos, exatamente como no hardware, e por isso firmware/pico/ relê o relógio depois de armar e antes de estacionar.
3.5 UART0 (0x4003_4000)
Um PL011. Este é o canal do host; os pads não estão envolvidos.
| offset | nome | bits |
|---|---|---|
0x00 |
UARTDR |
escrita: transmite; leitura: recebe (8 bits baixos, bits de erro leem 0) |
0x04 |
UARTRSR |
lê 0 |
0x18 |
UARTFR |
3 BUSY, 4 RXFE, 5 TXFF, 6 RXFF, 7 TXFE |
0x24 0x28 |
UARTIBRD UARTFBRD |
baud = 125 MHz / (16 (IBRD + FBRD/64)); armazenado e usado para o ritmo da transmissão |
0x2C |
UARTLCR_H |
armazenado; o bit 4 FEN ativa as FIFOs (limpá-lo as esvazia) |
0x30 |
UARTCR |
0 UARTEN, 8 TXE, 9 RXE |
0x34 |
UARTIFLS |
armazenado, lido de volta |
0x38 |
UARTIMSC |
4 RXIM, 5 TXIM, 6 RTIM |
0x3C 0x40 |
UARTRIS UARTMIS |
estado de interrupção bruto e mascarado |
0x44 |
UARTICR |
escreva 1 para limpar |
0x48 |
UARTDMACR |
armazenado, lido de volta |
As duas FIFOs têm 32 entradas, como no chip, e uma entrada de profundidade com FEN limpo. Os bytes de transmissão saem da FIFO para o canal do host no baud configurado (um divisor não programado volta a 115200: um byte, dez bits, a cada 86.8 us) e BUSY fica ativo enquanto qualquer byte ainda estiver saindo; uma escrita em uma FIFO de transmissão cheia é descartada, que é o que o hardware faz. Os bytes de recepção chegam do canal do host instantaneamente. RXRIS é ativado enquanto a FIFO de recepção está no nível de disparo ou acima dele (metade, o valor de reset do UARTIFLS, ou seja, 16 entradas) e RTRIS sempre que a recepção tem qualquer coisa e nenhum byte chegou por 32 tempos de bit, então um driver que espera em qualquer um dos dois vê um único caractere digitado. Qualquer bit ativo em UARTMIS levanta UART0_IRQ (IRQ 20).
Atrás da FIFO de recepção há um buffer do host de 256 bytes, que não é hardware: ele escoa para a FIFO conforme o programa a esvazia, então colar uma linha no monitor serial enquanto o sketch está entre chamadas de Serial.read() não perde caracteres. O modelo do Uno tem a mesma coisa pelo mesmo motivo. Um buffer que também esteja cheio descarta, como um overrun real faria.
3.5a UART1 (0x4003_8000)
O outro PL011, com os registradores da UART0 nos offsets da UART0, e mapeado em todo boot. Diferente da UART0, ele está ligado aos seus pads, não ao canal do host, então é a Serial2 no runtime do Arduino e machine.UART(1) no MicroPython, conversando com o que estiver ligado aos seus pinos: um módulo GPS, um HC-05, o RX e TX de outra placa. Seus quadros saem e entram um bit por vez através do motor de quadros que a UART1 e a UART2 do ESP32 usam (crates/esp-common/src/wire_uart.rs):
- Pinos. Um GPIO é da UART1 quando seu
FUNCSELé 2 (UART) e ele é um de 4 a 11 ou 20 a 27 (datasheet 2.19.2); comn % 4, 0 éTX, 1 éRX. Então GP4/GP5, GP8/GP9, GP20/GP21 e GP24/GP25 são seus pares.TXé sempre dirigido, em nível alto quando ocioso;RXé uma entrada;CTSeRTSnão são modelados. A mesma função em um pino da UART0 não dirige nada (a UART0 é o canal do host). - Transmissão. Um byte escrito em
UARTDRinicia seu quadro no momento em que o deslocador está livre, no tempo de bit que o divisor dá,16 (IBRD + FBRD/64)ciclos, e cada mudança de nível chega ao pad no ciclo em que acontece.LCR_Hdá o quadro:WLENde cinco a oito bits,PENcomEPS,STP2. Nada sai comUARTENouTXElimpo. - Recepção. O nível do pad
RXé tomado como o componente da placa o reporta, no instante que ele descreve. Uma queda em uma linha ociosa inicia um quadro, cada bit é amostrado no meio do seu slot e o byte chega no meio do seu bit de parada, então um baud incompatível lê lixo aqui como na bancada.RTRISé ativado 32 tempos de bit após o último byte com a FIFO não vazia. - FIFOs e flags. 32 entradas cada com
FEN, uma sem, como na UART0;UARTFR,UARTRIS,UARTMISeUARTICRcomo na seção 3.5. Qualquer bit ativo emUARTMISlevantaUART1_IRQ(IRQ 21).
O Serial2.begin() do runtime do Arduino coloca GP4 e GP5 (ou os pinos que setTX() e setRX() escolheram) na função UART e liga o pull-up do RX, então uma porta sem nada ligado lê uma linha ociosa.
3.6 PWM (0x4005_0000)
Oito fatias, dois canais cada. O GPIO n é o canal A da fatia (n / 2) % 8 quando n é par e o canal B quando é ímpar, então GP25, o LED da placa, é a fatia 4 canal B.
| offset | nome | bits |
|---|---|---|
0x00 + 0x14 s |
CHs_CSR |
0 EN, 1 PH_CORRECT, 2 A_INV, 3 B_INV, 5..4 DIVMODE, 6 PH_RET, 7 PH_ADV |
0x04 + 0x14 s |
CHs_DIV |
11..4 inteiro, 3..0 fração: o contador avança uma vez a cada DIV/16 clocks do sistema |
0x08 + 0x14 s |
CHs_CTR |
o contador, 16 bits; gravável |
0x0C + 0x14 s |
CHs_CC |
15..0 comparação do canal A, 31..16 canal B |
0x10 + 0x14 s |
CHs_TOP |
15..0 valor de wrap; reset 0xFFFF |
0xA0 |
EN |
o bit s ativa a fatia s, o mesmo bit do seu CSR.EN |
0xA4 0xA8 0xAC 0xB0 |
INTR INTE INTF INTS |
interrupção de wrap por fatia |
A saída de um canal fica em nível alto enquanto CTR < CC e em baixo de CTR == CC até o wrap, então CC = 0 é sempre baixo e CC > TOP é sempre alto. É por isso que analogWrite(pin, 255) define CC como TOP + 1 em vez de TOP. A_INV e B_INV invertem a saída. A saída chega ao pad sempre que o FUNCSEL daquele GPIO é 4: o bloco PWM ativa por conta própria a saída do pad, então selecionar a função é tudo que um programa precisa fazer, e SIO.GPIO_OE não é consultado.
DIVMODE 0 (livre) é modelado. Os modos 1..3 contam com gatilho ou disparo do pino B, o que precisa de uma entrada que o modelo não roteia, então são aceitos e armazenados mas contam como livres. PH_CORRECT não é modelado: uma fatia com ele ativo conta na borda final de todo modo, o que corta seu período pela metade. Qualquer bit ativo em INTS levanta PWM_IRQ_WRAP (IRQ 4).
3.7 SIO (0xD000_0000)
I/O de ciclo único: o GPIO que o núcleo realmente escreve, mais o divisor de hardware.
| offset | nome | bits |
|---|---|---|
0x000 |
CPUID |
lê 0: o núcleo 0 é o único núcleo (seção 5) |
0x004 |
GPIO_IN |
bit n = nível de entrada do GPIO n (precisa de PADS.IE) |
0x008 |
GPIO_HI_IN |
os seis pads QSPI; lê 0 |
0x010 0x014 0x018 0x01C |
GPIO_OUT _SET _CLR _XOR |
nível de saída, bits 0..29 |
0x020 0x024 0x028 0x02C |
GPIO_OE _SET _CLR _XOR |
habilitação de saída, bits 0..29 |
0x030..0x04C |
GPIO_HI_OUT/_OE e seus apelidos |
armazenado; sem pad |
0x050 |
FIFO_ST |
lê 2 (RDY ativo, VLD limpo): o núcleo 1 nunca responde |
0x054 0x058 |
FIFO_WR FIFO_RD |
a escrita é descartada, a leitura dá 0 |
0x05C |
SPINLOCK_ST |
bit n = spinlock n ocupado |
0x060..0x078 |
DIV_UDIVIDEND DIV_UDIVISOR DIV_SDIVIDEND DIV_SDIVISOR DIV_QUOTIENT DIV_REMAINDER DIV_CSR |
o divisor de hardware |
0x100 + 4n |
SPINLOCKn |
ler para reivindicar (0 quando já ocupado), escrever para liberar |
The divider completes immediately: a read of DIV_CSR always shows READY
(bit 0) set, and DIRTY (bit 1) is set by writing an operand and cleared by
reading DIV_REMAINDER. Division by zero gives the hardware's answer (quotient
all ones for unsigned, +/-1 for signed by the dividend's sign, remainder the
dividend). Reading DIV_QUOTIENT before DIV_REMAINDER is the SDK's order and
both are readable in any order here. The interpolators (INTERP0/INTERP1 at
0x080 and 0x0C0) are not modeled: they read 0.
3.8 Interrupções
O NVIC, o SysTick e o SCB estão dentro de cortexm-core nos seus endereços arquiteturais do PPB; o barramento nunca os vê. O ARMv6-M dá dois bits de prioridade e 32 linhas de interrupção externas. As linhas que este modelo dirige:
| IRQ | nome | ativada por |
|---|---|---|
| 0..3 | TIMER_IRQ_0..3 |
bit n de TIMER.INTS |
| 4 | PWM_IRQ_WRAP |
PWM.INTS não zero |
| 13 | IO_IRQ_BANK0 |
qualquer IO_BANK0.PROC0_INTS* diferente de zero |
| 20 | UART0_IRQ |
UART0.UARTMIS diferente de zero |
Cada uma é um level, mantida em nível alto enquanto o status do periférico indicar, então um handler que não limpa a origem é reentrado, exatamente como no hardware. Todo outro número de IRQ existe no NVIC e nunca é disparado.
WFI estaciona o núcleo até que qualquer interrupção habilitada esteja pendente (seção 5). WFE se comporta igual, mais o registrador de evento que a arquitetura define; SEV é aceito e o define.
3.9 WATCHDOG (0x4005_8000) e PSM.WDSEL (0x4001_0000)
CTRL (ENABLE, TRIGGER, os bits de pausa armazenados, TIME a contagem), LOAD, REASON, SCRATCH0..7 e TICK (armazenado; o tick é um microssegundo, seja qual for o valor contido). A contagem diminui dois por microssegundo, o que é o erratum RP2040-E1 e o motivo de o SDK carregar ms * 2000. Quando chega a zero, ou com TRIGGER, REASON diz TIMER ou FORCE e, se PSM.WDSEL selecionar o núcleo 0 (o SDK seleciona tudo, exceto os osciladores), o chip reinicia com o clock do circuito rodando: REASON e os registradores scratch sobrevivem e o watchdog fica desligado. O runtime oferece o hardware/watchdog.h do SDK e os rp2040.wdt_begin(), wdt_reset(), reboot() e restart() do arduino-pico nesses registradores. O salto da boot ROM para um pc de watchdog_reboot() não é modelado: uma reinicialização inicia o programa do começo.
4. Canal do host
host = "bytes UTF-8 na UART0". readHost devolve os bytes de TX da UART0 conforme saem do FIFO no baud configurado; writeHost empurra bytes para o FIFO de RX da UART0 (estouro descarta, como no chip). O monitor serial mostra os bytes como texto, decodificando UTF-8 e tratando \n como fim de linha (\r ignorado). A mesma semântica do canal do ESP32-C3.
5. Modelo de tempo e o componente
Um núcleo a 125 MHz. O SoC roda em fatias de 10 us = 1250 ciclos, com o contador de ciclos do núcleo como clock: cortexm-core cobra a contagem de ciclos do datasheet de cada instrução, então o tempo simulado é a contagem de ciclos dividida por 125 MHz. O contador de ciclos é ancorado ao tempo do kernel no início de cada fatia, do mesmo jeito que o modelo do ATmega328P ancora o seu, então um timer nunca se afasta do circuito, não importa como as fatias caiam.
O segundo núcleo não é modelado. SIO.CPUID lê 0, o FIFO entre núcleos está permanentemente vazio e nunca pronto para leitura, e não há como lançar o núcleo 1: um programa que escreve a sequência de lançamento em FIFO_WR e espera uma resposta espera para sempre. proofs/cortexm/REPORT.md mede o único núcleo que temos a 0.85x de um RP2040 real de 125 MHz num navegador, então um segundo núcleo interpretado reduziria isso à metade; é uma decisão da Fase 5, não uma omissão da Fase 4 a ser disfarçada. Tudo em firmware/pico/ é single core.
Duas marchas. Diferente do modelo do Uno, o núcleo não é avançado uma instrução por vez o tempo todo: não há margem para isso. Uma fatia é executada em blocos de 128 ciclos (1.024 us), o que limita o erro no tempo carimbado numa mudança de pino; várias mudanças dentro de um bloco mantêm sua ordem e são espalhadas ao longo dele, então nunca coincidem. Um bloco é interrompido no ciclo exato do próximo evento temporizado de periférico (um alarme de timer, uma borda de PWM, um byte de UART saindo), então esses caem no ciclo a que pertencem e micros() é exato.
Uma escrita que muda SIO.GPIO_OUT ou SIO.GPIO_OE (por qualquer um de seus aliases) muda para a marcha fina pelos próximos rp2040::FINE_CYCLES (12.500 ciclos, 100 us): uma instrução por bloco, então cada mudança de pino carrega o ciclo do store que a fez. É isso que um protocolo bit-banged precisa; o alto curto de um bit de WS2812 dura 0.4 us, e mokxi_ws2812.h dirige a fita desse jeito (o modelo do Uno R4 tem as mesmas duas marchas). O store que liga a marcha ainda é carimbado no seu bloco grosso, então um driver que se importa faz um primeiro.
Sono estaciona. WFI para as fatias: o componente agenda seu próximo despertar no mais cedo entre os alarmes de timer armados, a próxima borda de PWM num pino dirigido e o próximo evento de UART, e uma mudança de pino ou um byte do host o desperta imediatamente. Um sketch ocioso custa ao kernel um punhado de eventos por segundo em vez de 125 milhões de ciclos, que é todo o motivo de delay() no runtime dormir.
Leituras de SIO.GPIO_IN veem os níveis dos pinos como no início do bloco, mais qualquer mudança que o próprio sketch tenha feito nele.
Ponta de prova: uma bitmask, 0 sem programa.
| bit | significado |
|---|---|
| 1 | executando (não em reset, não travado) |
| 2 | estacionado em WFI |
| 4 | o LED da placa em GP25 está aceso |
| 8 | transmissão serial nos últimos 20 ms |
| 16 | recepção serial nos últimos 20 ms |
Poke: 1 = pressionar BOOTSEL, 0 = soltar (o modelo não tem função de botão bootsel: pressioná-lo só acende o visual, porque BOOTSEL é lido pelo pad de chip-select da QSPI, que não é modelado); 2 = manter RUN em nível baixo, 3 = soltar.
Tratamento de crash como em docs/esp32c3.md seção 5. No ARMv6-M toda falta é um HardFault, e uma falta tomada na prioridade de HardFault é Lockup, que cortexm-core reporta como Trap::Lockup. O componente para num Trap (um Lockup ou um BKPT sem depurador) e imprime uma linha no canal do host:
firmware crashed at pc=0x100002a4, lockup in exception 3
5a. O ADC
crates/rp2040/src/adc.rs, at 0x4004_C000 (datasheet section 4.9): one
12-bit converter behind a five-way mux, inputs 0 to 3 on GP26 to GP29 and
input 4 on the temperature sensor. CS.EN, CS.TS_EN, CS.AINSEL,
CS.START_ONCE (CS.READY 2 us later, 96 clocks of the 48 MHz ADC clock),
CS.START_MANY and RESULT are modeled. The reference is 3.3 V, so a count is
volts / 3.3 * 4096, rounded and held to 0..4095; a pin with nothing on it
reads 0. The temperature sensor gives the datasheet's 0.706 V, which is 27 C,
while TS_EN is set. The board part hands the ADC the net voltage on the four
pins every time it samples its inputs.
O runtime (firmware/pico/src/gpio.c) faz o que o arduino-pico faz: analogRead() usa GP26 a GP29 (A0 a A3) e nada mais, entrega o pad ao conversor (sem pulls, sem entrada digital) e devolve dez bits, a não ser que analogReadResolution() tenha pedido outra largura; analogReadTemp() lê a entrada 4 pela fórmula do datasheet.
Não modelados: o FIFO e o DMA, o round robin, a interrupção do ADC, o pacing de DIV, o ruído de conversão e a carga da entrada sobre a fonte.
6. O que não é modelado
PIO, DMA, SPI, I2C, o controlador USB, o RTC, a árvore de clock (CLOCKS, XOSC, PLL_SYS, PLL_USB: o clock do sistema é 125 MHz desde o reset), os pads de QSPI e a interface de flash além da leitura da imagem, o segundo núcleo, a ROM do chip e sua tabela de funções, e os interpoladores. Os blocos de endereço deles não estão mapeados, então tocar em um deles gera um bus fault em vez de um zero silencioso (uma placa MicroPython, inicializada do jeito completo, mapeia I2C, SPI e DMA: docs/micropython.md seção 3). As exceções são os blocos listados na seção 3, onde um registrador não implementado dentro de um bloco implementado lê 0 e é contabilizado.
7. Runtime do firmware (firmware/pico/)
Um runtime C e C++ standalone para o RP2040 compilado com clang 18 (--target=thumbv6m-none-eabi -mcpu=cortex-m0plus -mthumb -Os) e ld.lld, sem Pico SDK, sem newlib, sem libgcc ou compiler-rt, nada de GPL:
crt0.S: a tabela de vetores (16 entradas de sistema mais 32 IRQs), oReset_Handler(copia.datada flash, zera.bss, executa os construtores de C++, chamamain) e os helpers AEABI que um Cortex-M0+ precisa porque não tem instrução de divisão nem multiplicação longa:__aeabi_uidiv,__aeabi_uidivmod,__aeabi_idiv,__aeabi_idivmod,__aeabi_lmul,__aeabi_llsr,__aeabi_llsle os helpers de memória.link.ld:.texte.rodatana flash XIP em0x1000_0000,.datae.bssna SRAM em0x2000_0000, a pilha a partir do topo da SRAM (0x2004_2000) para baixo. Semboot2.include/rp2040.h: os registradores da seção 3 como macros com seus nomes reais.include/arduino.h: the same sketch surface as the other two runtimes:pinMode,digitalWrite,digitalRead,analogWrite,delay,delayMicroseconds,millis,micros,shiftOut,attachInterrupt,Serialwithbegin/print/println/write/available/read/peek, withLED_BUILTIN= 25.Serial1isSerial(both UART0, the serial monitor);Serial2is UART1 on GP4 and GP5, or the UART1 pinssetTX()andsetRX()pick (section 3.5a).src/serial.cdrives both by base address. The Nano RP2040 Connect has noSerial2.- O objeto
rp2040do arduino-pico: a FIFO entreloop()eloop1(),f_cpu(),getCycleCount(), as chamadas de watchdog da seção 3.9 egetFreeHeap(),getUsedHeap()egetTotalHeap(), que leem a heap do runtime entre os dados do programa e a pilha. - Sem
WiFi.h. Uma Pico não tem chip sem fio, então os cabeçalhos de rede não compilam para ela, e o conselho da compilação diz para trocar a placa por uma Pico W, que tem os mesmos pinos. A Pico W é este runtime com-DMOKXI_BOARD_PICO_W, que mapeia a caixa de correio de rede simulada e trazWiFi.h,HTTPClient.h,WebServer.he os próprios nomes do arduino-pico para eles (docs/picow.mdseções 6 e 7). analogWrite(pin, 0..255)funciona em todo GPIO, porque cada um tem um canal de PWM: oFUNCSELvai para 4 e a fatia recebe o menor divisor cujos 65.536 contagens alcançam um período, então a 1 kHz padrão o divisor é 1.9375 e oTOPé 64.515.analogWriteFreq()(100 Hz a 1 MHz),analogWriteRange()eanalogWriteResolution()são do arduino-pico: uma nova frequência remodela uma fatia na próxima vez que um pino nela for escrito, e o intervalo é o valor que significa totalmente ligado (255 por padrão). 0 e o valor máximo desconectam o PWM e levam o pino a nível baixo ou alto, entãoanalogWrite(pin, 0)realmente está desligado.millis()/micros()leem o TIMER, então são exatos e nunca atrasam.delay()e umdelayMicroseconds()de 50 us ou mais armam o alarme 0 do timer e fazemWFIaté ele disparar; esperas mais curtas ficam girando emTIMERAWL.attachInterrupt(pin, handler, mode)usaIO_IRQ_BANK0comRISING,FALLING,CHANGE,ONLOWeONHIGHmapeados para os quatro bits deINTR.digitalPinToInterrupt(pin)é o próprio pino: cada GPIO tem um.
Exemplos em firmware/pico/examples/<name>/sketch.ino, compilados para web/public/firmware/pico/<name>.elf com web/public/firmware/pico/index.json no mesmo formato do índice do Uno, cada entrada carregando "program": "elf32 arm rp2040": blink (GP25), button (GP15 com o pull-up interno acendendo GP25), serial (imprime millis() uma vez por segundo e ecoa o que recebe), fade (PWM no GP25).
A interface escolhe a lista de firmware pela string program do componente: "elf32 riscv32imc" lê /firmware/index.json, "elf32 avr atmega328p" lê /firmware/uno/index.json, "elf32 arm rp2040" lê /firmware/pico/index.json.
8. O que este modelo sabe com certeza, e o que não sabe
Três grupos, a mesma ordenação que a seção 7 de docs/esp32c6.md usa. Ela existe porque um modelo de placa que adivinha silenciosamente um endereço é pior do que um que diz que não sabia.
Tirado da folha de dados, e percorrido por firmware real. Todo endereço base, offset de registrador e posição de bit nas seções 2 e 3 vem da RP2040 Datasheet (Raspberry Pi Ltd), incluindo os três aliases atômicos em +0x1000, +0x2000 e +0x3000 que fazem hw_set_bits funcionar. A ordem do cabeçalho de quarenta pinos na seção 1 é a da própria Pico. crates/rp2040/tests/firmware.rs carrega ELFs reais e aciona RESETS, IO_BANK0, PADS_BANK0, SIO, TIMER, UART0 e as fatias de PWM através deles.
Modelado, mas não cobrado pelos números da folha de dados. Comportamentos em vez de endereços:
- O núcleo roda em blocos de 128 ciclos, não uma instrução por vez, exceto por 100 us depois que o programa move um pino (seção 5, "Duas marchas"). Um bloco tem 1,024 us e é cortado no ciclo exato do próximo evento temporizado de periférico, então um alarme do timer, uma borda de PWM e um byte de UART caem todos onde devem, mas a primeira mudança de pino que o software faz depois de um período calmo carrega o arredondamento do bloco e pode até 1,024 us de diferença; as seguintes são exatas. O modelo do Uno marca cada mudança de pad no seu ciclo exato; este não pode se dar ao luxo de fazer isso o tempo todo, porque não há margem a 125 MHz (
proofs/cortexm/REPORT.md: 0,85x do tempo real em um navegador). - O clock do sistema é 125 MHz desde o reset e nunca muda. A árvore de clock não é modelada, então
clocks_init, o cristal, ambos os PLLs e qualquer frequência que o sketch configure são todos ignorados e a resposta é sempre 125 MHz. Esperas de flash e o cache de XIP também não existem, então execute-in-place roda na velocidade da SRAM. - Os pads são três estados e um limiar. Push-pull a 3,3 V, alta impedância, ou um pull interno de 55 kΩ (a folha de dados indica cerca de 50 kΩ a 80 kΩ), lidos contra metade da alimentação, sem histerese, sem configuração de força de acionamento, sem controle de slew rate, sem tempo de subida e sem limite de corrente.
- Os pinos de alimentação são números, e não uma árvore de alimentação.
VSYSé 4,7 V, ou seja,VBUSmenos a queda do diodo Schottky;3V3_ENé um pull-up de 100 kΩ e puxá-lo abaixo de 1,2 V para a placa;RUNé um pull-up de 50 kΩ;ADC_VREFé 3,3 V atrás de 200 Ω. Nada do comportamento do regulador é modelado, nada sofre queda e nada sofre brown-out, e a leitura deVBUSno GP24 simplesmente fica em nível alto. - A inicialização leva um microssegundo, sem boot ROM e sem bootloader de segunda etapa: a imagem é carregada e executada. Segurar
BOOTSELé um toque que o modelo relata; não há nenhum dispositivo de armazenamento em massa por trás dele.
Deliberadamente ausente, como a seção 6 lista: o segundo núcleo, o PIO, o DMA, o SPI, o I2C, o USB, o RTC, a árvore de clocks, os pads QSPI e a interface de flash além da leitura da imagem, a ROM do chip e sua tabela de funções, e os interpoladores. Seus blocos de endereço não estão mapeados, então tocá-los causa uma falta de barramento, e não um zero silencioso. O ADC é a exceção: seção 5a.