Referencia

Contrato de la placa Raspberry Pi Pico (Fase 4)

El RP2040 sobre nuestro núcleo Cortex-M0+, con GPIO de SIO, el TIMER, UART0 y PWM.

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 La Raspberry Pi Pico y la página de la placa.

El tercer microcontrolador, y el primero sobre el motor Cortex-M. Un componente del kernel (pico en crates/parts) envuelve un modelo del SoC RP2040 (crates/rp2040) construido sobre el núcleo Cortex-M (crates/cortexm-core, Profile::V6M, demostrado en proofs/cortexm/REPORT.md). El firmware es un ELF Thumb que se comunica con los periféricos de abajo en sus direcciones reales del RP2040, así que un programa compilado para Mokxi corre en una Pico real.

El tipo de catálogo es pico (Raspberry Pi Pico, RP2040). Tres agentes se compilan contra este archivo: el SoC y el componente (Rust), el entorno de ejecución del firmware y los ejemplos (C++, clang para thumbv6m-none-eabi), y el aspecto de la placa (TypeScript). Cámbialo solo editando primero este archivo. Todo lo que dice docs/esp32c3.md sobre cómo se comporta un componente de placa (slices, canal del host, reset, línea de fallo) aplica aquí salvo que este archivo diga lo contrario.

Ejecutar binarios compilados con el SDK de Raspberry Pi Pico no era un objetivo de la fase 4: el crt0 del SDK espera el cargador de arranque de segunda etapa, el árbol de relojes, el XOSC y los PLL. Desde octubre de 2026 existe una segunda forma de cargar el chip, el arranque completo, para MicroPython (docs/micropython.md): un UF2 en una flash de 2 MB borrada, la ROM de arranque (crates/rp2040/src/rom.rs, escrita a partir de la sección 2.8 de la hoja de datos), la segunda etapa ejecutada desde SRAM5, y el árbol de relojes, el SSI y el chip de flash, el controlador USB, la RTC y el resto mapeados (sysregs.rs, ssi.rs, usb.rs), y desde la fase 3 de Python los bloques de I2C, SPI y DMA (i2c.rs, spi.rs, dma.rs) que usan machine.I2C y machine.SPI de MicroPython. Todo lo que se describe en este archivo corresponde a la ruta ELF, que no ha cambiado: ninguno de esos bloques está mapeado para un ELF, y los Wire y SPI de un sketch de Arduino siguen siendo los buses por software de firmware/lib/ en pines ordinarios. Lo que se modela es el conjunto de periféricos que necesitan pinMode, digitalWrite, digitalRead, analogWrite, millis, micros, delay, Serial y attachInterrupt, en sus direcciones reales, de modo que el mismo código fuente compilado contra firmware/pico/ produce una imagen que también funciona en el hardware.

1. Pines de la placa (orden del catálogo)

El encabezado de 40 pines, vista superior con el conector USB arriba. La columna izquierda son los pines físicos 1..20 leídos de arriba abajo; la columna derecha son los pines físicos 40..21 leídos de arriba abajo, que es cómo quedan alineados los pines cuando se sostiene la placa así.

Columna izquierda (pines 1..20): GP0, GP1, GND, GP2, GP3, GP4, GP5, GNDb, GP6, GP7, GP8, GP9, GNDc, GP10, GP11, GP12, GP13, GNDd, GP14, GP15.

Columna derecha (pines 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 pines. Los nombres duplicados llevan un sufijo de letra porque los nombres de pines del catálogo son únicos; el serigrafiado de la placa muestra GND en los siete y AGND en el pin 33. Los tres puntos de prueba (TP1..TP6) y el encabezado SWD no son pines.

Eléctrica:

  • 3V3 entrega 3.3 V con R_SUPPLY y cada GND* y AGND entrega 0 V con R_SUPPLY. VBUS entrega 5 V con R_SUPPLY y VSYS entrega 4.7 V (5 V a través del diodo Schottky que la placa tiene entre ellos), porque la placa siempre está alimentada por USB. ADC_VREF entrega 3.3 V a través de 200 R, que es la referencia filtrada que la placa saca al exterior. La placa es una fuente de alimentación para el resto del circuito.
  • 3V3_EN es una entrada con una pull-up de 100 k hacia VSYS; llevarla por debajo de 1.2 V apaga el regulador, lo que detiene el chip y libera cada pad. Eso es lo único que hace aquí.
  • RUN es una entrada con una pull-up interna de 50 k hacia 3.3 V; si se lleva por debajo de 1.65 V mantiene la CPU en reset, y soltarla reinicia desde la tabla de vectores.
  • GP0..GP22, GP26..GP28 son GPIO de entrada y salida. Con salida habilitada (bit de SIO.GPIO_OE activo y el selector de función en SIO o PWM): push-pull a 3.3 V o 0 V a través de R_STRONG. Con salida deshabilitada: alta impedancia, más una pull-up de 55 k hacia 3.3 V cuando PADS_BANK0.GPIOn.PUE está activo, o una pull-down de 55 k cuando PDE está activo (ambos activos es un bus-keeper, modelado como alta impedancia). La entrada lee el voltaje de la red contra 1.65 V; Unknown se lee como 0, y una entrada flotante lee ruido, como en el Uno (docs/uno.md sección 1). PADS_BANK0.GPIOn.OD deshabilita el controlador de salida sin importar lo que pida el periférico seleccionado, y IE en cero hace que la entrada lea 0. Un pad del RP2040 no tiene modo de drenaje abierto; un controlador que quiera uno conduce en bajo y pasa a entrada para el alto.
  • GP23, GP24 y GP25 existen en el modelo pero no están en el encabezado, como en la placa real: GP23 es el control de power-save del SMPS, GP24 es el sensor de VBUS (lee 1, porque el modelo siempre está alimentado por USB) y GP25 es el LED verde integrado. El LED se muestra desde un bit de sonda (sección 5), y el pad lleva una carga de 1 k a tierra para que los voltajes sean honestos.
  • GP26, GP27 y GP28 son ADC0..ADC2, y el ADC está modelado (sección 5a): analogRead(26) lee los voltios de la red. ADC_VREF es la referencia de 3.3 V del convertidor y AGND una tierra.
  • GP0/GP1 son UART0 TX/RX en la placa real. Aquí UART0 se comunica con el canal del host (sección 4) y los dos pads siguen siendo GPIO, exactamente como lo hace docs/esp32c3.md.

2. Mapa de memoria (direcciones reales del RP2040)

región dirección tamaño notas
ROM 0x0000_0000 16 KB no modelada para un ELF: lee 0, las escrituras se ignoran y se cuentan (el arranque completo mapea rom.rs)
flash XIP 0x1000_0000 hasta 2 MB la imagen del programa; solo lectura para el núcleo
SRAM (entrelazada) 0x2000_0000 256 KB SRAM0..SRAM3, cuatro bancos entrelazados por palabra
SRAM4 0x2004_0000 4 KB
SRAM5 0x2004_1000 4 KB
RESETS 0x4000_C000 4 KB sección 3.1
IO_BANK0 0x4001_4000 4 KB sección 3.2
PADS_BANK0 0x4001_C000 4 KB sección 3.3
UART0 0x4003_4000 4 KB sección 3.5
UART1 0x4003_8000 4 KB sección 3.5a
PWM 0x4005_0000 4 KB sección 3.6
TIMER 0x4005_4000 4 KB sección 3.4
SIO 0xD000_0000 4 KB (no APB) sección 3.7
PPB 0xE000_0000 1 MB SysTick, NVIC y el SCB, dentro del núcleo

La SRAM es de 264 KB y contigua desde 0x2000_0000 hasta 0x2004_2000. El entrelazado de SRAM0..SRAM3 es un detalle de arbitraje sin efecto visible para el software en un solo núcleo, así que el modelo es un arreglo plano; 0x2100_0000 y 0x2110_0000, los alias sin entrelazado de los mismos bancos, no están mapeados, y tampoco lo está la ventana de mantenimiento de caché XIP en 0x4002_0000. Cualquier cosa fuera de una región mapeada produce un bus fault, que en ARMv6-M escala a HardFault; el componente cuenta las fallas e informa un choque (sección 5). Un registro no implementado dentro de un bloque mapeado se lee como 0 y descarta las escrituras, con un contador para diagnóstico.

Cada bloque periférico APB también tiene alias en +0x1000 (XOR atómico), +0x2000 (set atómico) y +0x3000 (clear atómico), que es como el firmware del RP2040 pone un bit sin hacer lectura-modificación-escritura. El modelo implementa los tres para cada periférico que implementa. SIO no es un bloque APB y no tiene alias, igual que en el chip.

Firmware ELF. loadProgram recibe un ejecutable ELF32 little-endian ARM (e_machine 40). Cada segmento PT_LOAD debe caer dentro de la flash XIP o de la SRAM; .data se carga en su p_paddr (en flash) y el crt0 del runtime lo copia, como en el hardware. No hay bootloader de segunda etapa: el modelo no requiere, ejecuta ni verifica con checksum un bloque boot2, y una sección .boot2 de 256 bytes en la imagen simplemente se carga y nunca se ejecuta. El reset toma la tabla de vectores en la dirección de flash cargada más baja: VTOR se fija ahí, SP_main viene de la palabra 0 y el punto de entrada de la palabra 1, exactamente como hace el procesador al salir del reset. El e_entry del ELF no se usa; se requiere una tabla de vectores. Una carga en tiempo de ejecución reinicia la placa.

3. Registros de periféricos (subconjunto, offsets reales, posiciones de bits reales)

Los registros son de 32 bits y alineados a palabra. El acceso por byte o media palabra a un registro de periférico no está soportado (una lectura devuelve la palabra alineada reducida, una escritura escribe la palabra completa con el valor reducido); el firmware no debe hacerlo. La SRAM y la flash aceptan todos los anchos.

3.1 RESETS (0x4000_C000)

offset nombre bits
0x00 RESET 1 = bloque mantenido en reset
0x04 WDSEL se guarda, se lee de vuelta
0x08 RESET_DONE 1 = bloque fuera de reset y listo

La numeración de bits es la del datasheet: 5 io_bank0, 8 pads_bank0, 14 pwm, 21 timer, 22 uart0, 23 uart1. RESET_DONE es el inverso de RESET, sin retardo: un bloque sale de reset en el instante en que su bit se limpia, así que el típico ciclo while (!(resets_hw->reset_done & bits)) pasa de inmediato. Al salir de reset cada bloque aquí lee sus valores de encendido; mantener un bloque en reset lo devuelve a ellos, y mientras io_bank0 o pads_bank0 se mantiene así, cada pad está en alta impedancia. Los bloques que el modelo no implementa aceptan sus bits e informan que están listos.

3.2 IO_BANK0 (0x4001_4000)

offset nombre bits
0x00 + 8n GPIOn_STATUS bit 8 OUTTOPAD, bit 13 OETOPAD, bit 17 INFROMPAD, solo lectura
0x04 + 8n GPIOn_CTRL bits 4..0 FUNCSEL, 9..8 OUTOVER, 13..12 OEOVER, 17..16 INOVER
0x0F0 + 4m INTRm interrupción en bruto para los GPIO 8m..8m+7, cuatro bits cada uno
0x100 + 4m PROC0_INTEm habilitación, misma disposición
0x110 + 4m PROC0_INTFm forzado, misma disposición
0x120 + 4m PROC0_INTSm bruto Y habilitación, O forzado

FUNCSEL: 4 = PWM, 5 = SIO, 31 = NULL (el pad se libera). Todo lo demás (SPI 1, UART 2, I2C 3, PIO0 6, PIO1 7, clocks 8, USB 9) se acepta, se guarda y se lee de vuelta, pero deja el pad liberado, porque esos periféricos no están modelados. El valor de encendido es 31 en cada pin, como en el chip, así que el firmware tiene que seleccionar SIO antes de que un pad haga algo, y firmware/pico/ lo hace.

OUTOVER/OEOVER: 0 = la señal del periférico, 1 = invertida, 2 = manejar en bajo (OEOVER 2 = deshabilitar), 3 = manejar en alto (OEOVER 3 = habilitar). INOVER son las mismas cuatro para la entrada.

Los cuatro bits de interrupción por GPIO son 0 LEVEL_LOW, 1 LEVEL_HIGH, 2 EDGE_LOW, 3 EDGE_HIGH. Los bits de flanco se enganchan y se limpian escribiendo 1 en ellos en INTRm; los bits de nivel siguen al pad y no se pueden limpiar. Cualquier bit en 1 en un PROC0_INTSm activa IO_IRQ_BANK0 (IRQ 13).

3.3 PADS_BANK0 (0x4001_C000)

offset nombre bits
0x00 VOLTAGE_SELECT se guarda, se lee de vuelta
0x04 + 4n GPIOn 0 SLEWFAST, 1 SCHMITT, 2 PDE, 3 PUE, 4..5 DRIVE, 6 IE, 7 OD

El valor de encendido es IE en 0, PUE en 0, PDE en 1, SCHMITT en 1, DRIVE = 1 (4 mA) en cada pad, como lo da el datasheet. IE en 0 hace que la entrada se lea 0 sin importar lo que haga la red; OD en 1 libera el pad sin importar lo que pida el periférico seleccionado; DRIVE y SLEWFAST se guardan y se leen de vuelta pero no cambian la impedancia de la fuente, que siempre es R_STRONG.

3.4 TIMER (0x4005_4000)

Un contador de 64 bits en microsegundos y cuatro alarmas de 32 bits. Este es el reloj de la pieza: micros() y millis() lo leen y delay() duerme en una alarma.

offset nombre bits
0x00 0x04 TIMEHW TIMELW solo escritura, engancha la escritura del contador completo
0x08 TIMEHR palabra alta, enganchada por la última lectura de TIMELR
0x0C TIMELR palabra baja; leerla engancha la palabra alta en TIMEHR
0x10 + 4n ALARMn n = 0..3; escribir la arma, escribir también limpia su bit INTR
0x20 ARMED bit n = alarma n armada; escribe 1 para desarmar
0x24 0x28 TIMERAWH TIMERAWL el contador sin enganchar
0x2C DBGPAUSE se guarda, se lee de vuelta
0x30 PAUSE el bit 0 detiene el contador
0x34 INTR bit n = alarma n disparada; escribe 1 para limpiar
0x38 0x3C 0x40 INTE INTF INTS habilitación, forzado, y bruto Y habilitación O forzado

El contador se deriva del tiempo del kernel: microseconds = (now_ps - origin_ps) / 1_000_000, con el origen fijado en el primer slice. Nunca se desvía del circuito. Una alarma se dispara cuando los 32 bits bajos del contador alcanzan el valor armado, se desarma sola y pone su bit INTR; el bit n de INTS activa TIMER_IRQ_n (IRQ 0..3). Escribir una alarma también limpia su bit INTR. El comparador solo ve los 32 bits bajos, así que una alarma armada en un valor que acaba de pasar no se dispara durante 71.6 minutos, exactamente como en el hardware, y por eso firmware/pico/ relee el reloj después de armar y antes de estacionarse.

3.5 UART0 (0x4003_4000)

Un PL011. Este es el canal del host; los pads no intervienen.

offset nombre bits
0x00 UARTDR escritura: transmitir; lectura: recibir (bits bajos 8, los bits de error se leen 0)
0x04 UARTRSR se lee 0
0x18 UARTFR 3 BUSY, 4 RXFE, 5 TXFF, 6 RXFF, 7 TXFE
0x24 0x28 UARTIBRD UARTFBRD baud = 125 MHz / (16 (IBRD + FBRD/64)); se guarda y se usa para el ritmo de TX
0x2C UARTLCR_H se guarda; el bit 4 FEN activa los FIFO (desactivarlo los vacía)
0x30 UARTCR 0 UARTEN, 8 TXE, 9 RXE
0x34 UARTIFLS se guarda, se lee de vuelta
0x38 UARTIMSC 4 RXIM, 5 TXIM, 6 RTIM
0x3C 0x40 UARTRIS UARTMIS estado de interrupción en bruto y enmascarado
0x44 UARTICR escribe 1 para limpiar
0x48 UARTDMACR se guarda, se lee de vuelta

Ambos FIFO son de 32 entradas, como en el chip, y de una entrada de profundidad con FEN en cero. Los bytes de TX salen del FIFO hacia el canal del host con el baud rate configurado (un divisor sin programar recurre a 115200: un byte, diez bits, cada 86.8 us) y BUSY se activa mientras aún queda algún byte saliendo; una escritura en un TX FIFO lleno se descarta, que es lo que hace el hardware. Los bytes de RX llegan del canal del host al instante. RXRIS se activa mientras el FIFO de RX está en o por encima de su nivel de disparo (la mitad, el valor de reset de UARTIFLS, o sea 16 entradas) y RTRIS siempre que RX tenga algo y no haya llegado ningún byte durante 32 tiempos de bit, de modo que un controlador que espere en cualquiera de los dos ve un solo carácter tecleado. Cualquier bit activado en UARTMIS genera UART0_IRQ (IRQ 20).

Detrás del FIFO de recepción hay un búfer de host de 256 bytes que no es hardware: se drena hacia el FIFO a medida que el programa lo vacía, así que pegar una línea en el monitor serie mientras el sketch está entre llamadas a Serial.read() no pierde caracteres. El modelo del Uno tiene lo mismo por la misma razón. Un búfer que también está lleno descarta, como lo haría un desbordamiento real.

3.5a UART1 (0x4003_8000)

El otro PL011, con los registros de UART0 en los desplazamientos de UART0, y mapeado en cada arranque. A diferencia de UART0 está conectado a sus pads, no al canal del host, así que es Serial2 en el runtime de Arduino y machine.UART(1) en MicroPython, y se comunica con lo que esté conectado a sus pines: un módulo GPS, un HC-05, el RX y TX de otra placa. Sus tramas salen y entran bit por bit a través del motor de tramas que usan UART1 y UART2 del ESP32 (crates/esp-common/src/wire_uart.rs):

  • Pines. Un GPIO es de UART1 cuando su FUNCSEL es 2 (UART) y es uno de 4 a 11 o de 20 a 27 (hoja de datos 2.19.2); con n % 4 0 es TX y 1 es RX. Así, GP4/GP5, GP8/GP9, GP20/GP21 y GP24/GP25 son sus pares. TX siempre está manejado, en alto en reposo; RX es una entrada; CTS y RTS no se modelan. La misma función en un pin de UART0 no maneja nada (UART0 es el canal del host).
  • Transmisión. Un byte escrito en UARTDR inicia su trama en el momento en que el registro de desplazamiento queda libre, con el tiempo de bit que da el divisor, 16 (IBRD + FBRD/64) ciclos, y cada cambio de nivel llega al pad en el ciclo en que ocurre. LCR_H define la trama: WLEN de cinco a ocho bits, PEN con EPS, STP2. Nada sale con UARTEN o TXE en cero.
  • Recepción. El nivel del pad de RX se toma tal como lo reporta el componente de la placa, en el instante que este describe. Una caída en una línea en reposo inicia una trama, cada bit se muestrea en la mitad de su casilla y el byte aterriza en la mitad de su bit de parada, así que un baud rate que no coincide lee basura aquí como en el escritorio. RTRIS se activa 32 tiempos de bit después del último byte con el FIFO no vacío.
  • FIFO y banderas. 32 entradas cada una con FEN, una sin él, como en UART0; UARTFR, UARTRIS, UARTMIS y UARTICR como en la sección 3.5. Cualquier bit activado en UARTMIS genera UART1_IRQ (IRQ 21).

El Serial2.begin() del runtime de Arduino pone a GP4 y GP5 (o a los pines que eligieron setTX() y setRX()) en la función UART y activa la resistencia pull-up de RX, de modo que un puerto sin nada conectado lee una línea en reposo.

3.6 PWM (0x4005_0000)

Ocho rebanadas, dos canales cada una. El GPIO n es el canal A de la rebanada (n / 2) % 8 cuando n es par y el canal B cuando es impar, así que GP25, el LED de la placa, es la rebanada 4 canal B.

offset nombre 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 entero, 3..0 fracción: el contador avanza una vez cada DIV/16 relojes del sistema
0x08 + 0x14 s CHs_CTR el contador, 16 bits; escribible
0x0C + 0x14 s CHs_CC 15..0 comparación del canal A, 31..16 canal B
0x10 + 0x14 s CHs_TOP 15..0 valor de envolvente; reset 0xFFFF
0xA0 EN el bit s activa la rebanada s, el mismo bit que su CSR.EN
0xA4 0xA8 0xAC 0xB0 INTR INTE INTF INTS interrupción de envolvente por rebanada

La salida de un canal está en alto mientras CTR < CC y en bajo desde CTR == CC hasta la envolvente, así que CC = 0 siempre está en bajo y CC > TOP siempre está en alto. Por eso analogWrite(pin, 255) pone CC en TOP + 1 en lugar de en TOP. A_INV y B_INV invierten la salida. La salida llega al pad siempre que el FUNCSEL de ese GPIO sea 4: el bloque PWM afirma por sí mismo la habilitación de salida del pad, así que seleccionar la función es todo lo que un programa tiene que hacer, y no se consulta SIO.GPIO_OE.

Se modela DIVMODE 0 (libre). Los modos 1..3 cuentan con compuerta o disparados desde el pin B, lo que necesita una entrada que el modelo no enruta, así que se aceptan y se guardan pero cuentan como libres. PH_CORRECT no se modela: una rebanada con ese bit activado cuenta de todos modos por flanco de salida, lo que reduce su período a la mitad. Cualquier bit activado en INTS genera PWM_IRQ_WRAP (IRQ 4).

3.7 SIO (0xD000_0000)

E/S de un solo ciclo: el GPIO que el núcleo realmente escribe, más el divisor por hardware.

offset nombre bits
0x000 CPUID lee 0: el núcleo 0 es el único núcleo (sección 5)
0x004 GPIO_IN bit n = nivel de entrada del GPIO n (necesita PADS.IE)
0x008 GPIO_HI_IN los seis pads QSPI; lee 0
0x010 0x014 0x018 0x01C GPIO_OUT _SET _CLR _XOR nivel de salida, bits 0..29
0x020 0x024 0x028 0x02C GPIO_OE _SET _CLR _XOR habilitación de salida, bits 0..29
0x030..0x04C GPIO_HI_OUT/_OE y sus alias se guarda; sin pad
0x050 FIFO_ST lee 2 (RDY activado, VLD en cero): el núcleo 1 nunca responde
0x054 0x058 FIFO_WR FIFO_RD la escritura se descarta, la lectura da 0
0x05C SPINLOCK_ST bit n = spinlock n tomado
0x060..0x078 DIV_UDIVIDEND DIV_UDIVISOR DIV_SDIVIDEND DIV_SDIVISOR DIV_QUOTIENT DIV_REMAINDER DIV_CSR el divisor por hardware
0x100 + 4n SPINLOCKn leer para reclamar (0 si ya está tomado), escribir 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 Interrupciones

El NVIC, el SysTick y el SCB están dentro de cortexm-core en sus direcciones PPB arquitectónicas; el bus nunca los ve. ARMv6-M da dos bits de prioridad y 32 líneas de interrupción externa. Las líneas que este modelo maneja:

IRQ nombre generada por
0..3 TIMER_IRQ_0..3 bit n de TIMER.INTS
4 PWM_IRQ_WRAP PWM.INTS distinto de cero
13 IO_IRQ_BANK0 cualquier IO_BANK0.PROC0_INTS* distinto de cero
20 UART0_IRQ UART0.UARTMIS distinto de cero

Cada una es un nivel, en alto mientras el estado del periférico lo indique, así que un manejador que no limpia la fuente se vuelve a invocar, exactamente como en el hardware. Todo otro número de IRQ existe en el NVIC y nunca se activa.

WFI estaciona el núcleo hasta que haya pendiente cualquier interrupción habilitada (sección 5). WFE se comporta igual, más el registro de eventos que define la arquitectura; SEV se acepta y lo activa.

3.9 WATCHDOG (0x4005_8000) y PSM.WDSEL (0x4001_0000)

CTRL (ENABLE, TRIGGER, los bits de pausa guardados, TIME la cuenta), LOAD, REASON, SCRATCH0..7 y TICK (guardado; el tick es un microsegundo sin importar lo que contenga). La cuenta baja dos por microsegundo, que es la errata RP2040-E1 y la razón por la que el SDK carga ms * 2000. Al llegar a cero, o con TRIGGER, REASON dice TIMER o FORCE y, si PSM.WDSEL selecciona el núcleo 0 (el SDK selecciona todo menos los osciladores), el chip se reinicia con el reloj del circuito corriendo: REASON y los registros scratch sobreviven y el watchdog queda apagado. El runtime ofrece el hardware/watchdog.h del SDK y los rp2040.wdt_begin(), wdt_reset(), reboot() y restart() de arduino-pico sobre estos registros. El salto del boot ROM a una pc de watchdog_reboot() no está modelado: un reinicio arranca el programa desde el principio.

4. Canal del host

host = "bytes UTF-8 por UART0". readHost devuelve los bytes del TX del UART0 conforme salen del FIFO a la velocidad configurada; writeHost mete bytes al FIFO del RX del UART0 (el desbordamiento descarta, como en el chip). El monitor serie muestra los bytes como texto, decodificando UTF-8 y tratando \n como fin de línea (\r se ignora). Misma semántica que el canal del ESP32-C3.

5. Modelo de tiempo y el componente

Un núcleo a 125 MHz. El SoC corre en porciones de 10 us = 1250 ciclos, con el contador de ciclos del núcleo como reloj: cortexm-core cobra el costo en ciclos del datasheet de cada instrucción, así que el tiempo simulado es el conteo de ciclos dividido entre 125 MHz. El contador de ciclos se ancla al tiempo del kernel al inicio de cada porción, igual que el modelo del ATmega328P ancla el suyo, así que un temporizador nunca se desvía del circuito sin importar cómo caigan las porciones.

El segundo núcleo no está modelado. SIO.CPUID lee 0, el FIFO entre núcleos está vacío para siempre y nunca está listo para leer, y no hay forma de lanzar el núcleo 1: un programa que escribe la secuencia de lanzamiento en FIFO_WR y espera una respuesta espera para siempre. proofs/cortexm/REPORT.md mide el único núcleo que sí tenemos a 0.85x un RP2040 real de 125 MHz en un navegador, así que un segundo núcleo interpretado reduciría eso a la mitad; es una decisión de la Fase 5, no una omisión de la Fase 4 que haya que tapar. Todo lo que hay en firmware/pico/ es de un solo núcleo.

Dos marchas. A diferencia del modelo del Uno, el núcleo no avanza una instrucción a la vez todo el tiempo: no hay margen para eso. Una porción se ejecuta en bloques de 128 ciclos (1.024 us), lo que acota el error de la marca de tiempo de un cambio de pin; varios cambios dentro de un bloque conservan su orden y se reparten a lo largo del bloque, así que nunca coinciden. Un bloque se corta en el ciclo exacto del siguiente evento temporizado de un periférico (una alarma de temporizador, un flanco de PWM, un byte saliendo del UART), para que caigan en el ciclo que les corresponde y micros() sea exacta.

Una escritura que cambia SIO.GPIO_OUT o SIO.GPIO_OE (por cualquiera de sus alias) pasa a la marcha fina durante los siguientes rp2040::FINE_CYCLES (12,500 ciclos, 100 us): una instrucción por bloque, así que cada cambio de pin lleva el ciclo del store que lo provocó. Eso es lo que necesita un protocolo bit-banged; el pulso corto en alto de un bit de WS2812 dura 0.4 us, y mokxi_ws2812.h maneja la tira de esa forma (el modelo del Uno R4 tiene las mismas dos marchas). El store que enciende la marcha se marca igualmente en su bloque grueso, así que un driver al que le importa hace uno primero.

El modo Sleep estaciona. WFI detiene el slicing: el componente programa su próximo despertar en el más temprano entre las alarmas del temporizador armadas, el próximo flanco PWM en un pad controlado y el próximo evento UART, y un cambio de pin o un byte del host lo despierta de inmediato. Un sketch inactivo le cuesta al kernel un puñado de eventos por segundo en lugar de 125 millones de ciclos, que es toda la razón por la que delay() en el runtime duerme.

Las lecturas de SIO.GPIO_IN ven los niveles de los pines según estaban al inicio del bloque, más cualquier cambio que el propio sketch haya hecho dentro de él.

Sonda: una máscara de bits, 0 sin programa.

bit significado
1 en ejecución (ejecutando, sin reset, sin caída)
2 estacionado en WFI
4 el LED integrado en GP25 está encendido
8 transmisión serie en los últimos 20 ms
16 recepción serie en los últimos 20 ms

Poke: 1 = presionar BOOTSEL, 0 = soltar (el modelo no tiene una función de botón bootsel: presionarlo solo enciende el visual, porque BOOTSEL se lee a través del pad de selección de chip de la QSPI, que no está modelado); 2 = mantener RUN en bajo, 3 = soltar.

Manejo de caídas como en la sección 5 de docs/esp32c3.md. En ARMv6-M toda falla es un HardFault, y una falla tomada a prioridad HardFault es un Lockup, que cortexm-core reporta como Trap::Lockup. El componente se detiene ante un Trap (un Lockup o un BKPT sin depurador) e imprime una línea en el canal del host:

firmware crashed at pc=0x100002a4, lockup in exception 3

5a. El 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.

El runtime (firmware/pico/src/gpio.c) hace lo que hace arduino-pico: analogRead() toma GP26 a GP29 (A0 a A3) y nada más, le cede el pad al convertidor (sin pull-ups, sin entrada digital) y devuelve diez bits salvo que analogReadResolution() haya pedido otro ancho; analogReadTemp() lee la entrada 4 con la fórmula del datasheet.

No modelado: el FIFO y el DMA, el round robin, la interrupción del ADC, el ritmo de DIV, el ruido de conversión y la carga que la entrada impone a la fuente.

6. Lo que no está modelado

PIO, DMA, SPI, I2C, el controlador USB, el RTC, el árbol de relojes (CLOCKS, XOSC, PLL_SYS, PLL_USB: el reloj del sistema es de 125 MHz desde el reset), los pines QSPI y la interfaz de flash más allá de leer la imagen, el segundo núcleo, la ROM del chip y su tabla de funciones, y los interpoladores. Sus bloques de direcciones están sin mapear, así que tocar uno produce una falla de bus y no un cero silencioso (una placa de MicroPython, arrancada por completo, mapea I2C, SPI y DMA: sección 3 de docs/micropython.md). Las excepciones son los bloques listados en la sección 3, donde un registro no implementado dentro de un bloque implementado lee 0 y se cuenta.

7. Entorno de ejecución del firmware (firmware/pico/)

Un entorno de ejecución autónomo en C y C++ para el RP2040, compilado con clang 18 (--target=thumbv6m-none-eabi -mcpu=cortex-m0plus -mthumb -Os) y ld.lld, sin Pico SDK, sin newlib, sin libgcc ni compiler-rt, nada con GPL:

  • crt0.S: la tabla de vectores (16 entradas de sistema más 32 IRQs), Reset_Handler (copiar .data desde flash, limpiar .bss, ejecutar los constructores de C++, llamar a main), y los ayudantes de AEABI que un Cortex-M0+ necesita porque no tiene instrucción de división ni multiplicación larga: __aeabi_uidiv, __aeabi_uidivmod, __aeabi_idiv, __aeabi_idivmod, __aeabi_lmul, __aeabi_llsr, __aeabi_llsl y los ayudantes de memoria.
  • link.ld: .text y .rodata en flash XIP en 0x1000_0000, .data y .bss en SRAM en 0x2000_0000, la pila desde la parte alta de la SRAM (0x2004_2000) hacia abajo. Sin boot2.
  • include/rp2040.h: los registros de la sección 3 como macros con sus nombres reales.
  • include/arduino.h: the same sketch surface as the other two runtimes: pinMode, digitalWrite, digitalRead, analogWrite, delay, delayMicroseconds, millis, micros, shiftOut, attachInterrupt, Serial with begin/print/println/write/available/read/peek, with LED_BUILTIN = 25. Serial1 is Serial (both UART0, the serial monitor); Serial2 is UART1 on GP4 and GP5, or the UART1 pins setTX() and setRX() pick (section 3.5a). src/serial.c drives both by base address. The Nano RP2040 Connect has no Serial2.
  • El objeto rp2040 de arduino-pico: el FIFO entre loop() y loop1(), f_cpu(), getCycleCount(), las llamadas al watchdog de la sección 3.9, y getFreeHeap(), getUsedHeap() y getTotalHeap(), que leen el montón del entorno de ejecución entre los datos del programa y la pila.
  • No hay WiFi.h. Una Pico no tiene chip inalámbrico, así que los headers de red no compilan para ella, y el consejo de la compilación dice cambiar la placa a una Pico W, que tiene los mismos pines. La Pico W es este entorno de ejecución con -DMOKXI_BOARD_PICO_W, que mapea el buzón de red simulado e incorpora WiFi.h, HTTPClient.h, WebServer.h y los propios nombres de arduino-pico para ellos (docs/picow.md secciones 6 y 7).
  • analogWrite(pin, 0..255) funciona en todos los GPIO, porque cada uno tiene un canal PWM: FUNCSEL pasa a 4 y la porción recibe el divisor más pequeño cuyos 65,536 conteos alcancen un periodo, así que a los 1 kHz predeterminados el divisor es 1.9375 y TOP es 64,515. analogWriteFreq() (de 100 Hz a 1 MHz), analogWriteRange() y analogWriteResolution() son de arduino-pico: una frecuencia nueva reconfigura una porción la siguiente vez que se escribe un pin de ella, y el rango es el valor que significa totalmente encendido (255 por defecto). 0 y el valor máximo desconectan el PWM y llevan el pin a bajo o alto, así que analogWrite(pin, 0) de verdad está apagado.
  • millis()/micros() leen el TIMER, así que son exactos y nunca se desvían. delay() y un delayMicroseconds() de 50 us o más arman la alarma 0 del temporizador y ejecutan WFI hasta que se dispara; las esperas más cortas esperan activamente en TIMERAWL.
  • attachInterrupt(pin, handler, mode) usa IO_IRQ_BANK0 con RISING, FALLING, CHANGE, ONLOW y ONHIGH asignados a los cuatro bits de INTR. digitalPinToInterrupt(pin) es el pin mismo: cada GPIO tiene uno.

Ejemplos en firmware/pico/examples/<name>/sketch.ino, compilados a web/public/firmware/pico/<name>.elf con web/public/firmware/pico/index.json con la misma estructura que el índice del Uno, cada entrada con "program": "elf32 arm rp2040": blink (GP25), button (GP15 con la pull-up interna encendiendo GP25), serial (imprime millis() una vez por segundo y repite lo que recibe), fade (PWM en GP25).

La interfaz elige la lista de firmware según la cadena program del catálogo del componente: "elf32 riscv32imc" lee /firmware/index.json, "elf32 avr atmega328p" lee /firmware/uno/index.json, "elf32 arm rp2040" lee /firmware/pico/index.json.

8. De qué está seguro este modelo, y de qué no

Tres grupos, con el mismo orden que usa la sección 7 de docs/esp32c6.md. Existe porque un modelo de placa que adivina silenciosamente una dirección es peor que uno que dice que no lo sabía.

Tomado de la hoja de datos, y comprobado con firmware real. Cada dirección base, desplazamiento de registro y posición de bit en las secciones 2 y 3 proviene de la RP2040 Datasheet (Raspberry Pi Ltd), incluidos los tres alias atómicos en +0x1000, +0x2000 y +0x3000 que hacen funcionar hw_set_bits. El orden del header de cuarenta pines de la sección 1 es el de la propia Pico. crates/rp2040/tests/firmware.rs carga ELFs reales y maneja RESETS, IO_BANK0, PADS_BANK0, SIO, TIMER, UART0 y las porciones de PWM a través de ellos.

Modelado, pero sin sujeción a los números de la hoja de datos. Comportamientos en lugar de direcciones:

  • El núcleo se ejecuta en bloques de 128 ciclos, no una instrucción a la vez, salvo durante 100 us después de que el programa mueva un pin (sección 5, "Dos velocidades"). Un bloque dura 1.024 us y se corta en el ciclo exacto del siguiente evento cronometrado de un periférico, así que una alarma del temporizador, un flanco de PWM y un byte de UART caen donde corresponde, pero el primer cambio de pin que hace el software después de un período tranquilo arrastra el redondeo del bloque y puede desviarse hasta 1.024 us; los que vienen después son exactos. El modelo del Uno marca cada cambio de pad en su ciclo exacto; este no puede permitírselo todo el tiempo, porque no hay margen a 125 MHz (proofs/cortexm/REPORT.md: 0.85x del tiempo real en un navegador).
  • El reloj del sistema es de 125 MHz desde el reset y nunca cambia. El árbol de relojes no se modela, así que clocks_init, el cristal, ambas PLLs y cualquier frecuencia que el sketch configure se ignoran y la respuesta siempre es 125 MHz. Tampoco están los tiempos de espera de flash ni la caché XIP, así que execute-in-place corre a la velocidad de la SRAM.
  • Los pads son tres estados y un umbral. Push-pull a 3.3 V, alta impedancia, o una resistencia interna de pull de 55 kΩ (la hoja de datos da entre 50 kΩ y 80 kΩ), leídos contra la mitad del suministro, sin histéresis, sin ajuste de fuerza de manejo, sin control de slew rate, sin tiempo de subida y sin límite de corriente.
  • Los pines de alimentación son números en lugar de un árbol de energía. VSYS es 4.7 V, o sea VBUS menos la caída del Schottky; 3V3_EN es un pull-up de 100 kΩ y llevarlo por debajo de 1.2 V detiene la placa; RUN es un pull-up de 50 kΩ; ADC_VREF es 3.3 V detrás de 200 Ω. No se modela ningún comportamiento del regulador, nada se hunde y nada se cae por baja tensión, y el sensor de VBUS en GP24 simplemente está fijo en alto.
  • El arranque es un microsegundo, sin ROM de arranque y sin bootloader de segunda etapa: la imagen se coloca y se ejecuta. Mantener BOOTSEL es un toque que el modelo reporta; no hay ningún dispositivo de almacenamiento masivo detrás.

Ausentes a propósito, como lista la sección 6: el segundo núcleo, PIO, DMA, SPI, I2C, USB, el RTC, el árbol de relojes, los pads QSPI y la interfaz de flash más allá de leer la imagen, la ROM del chip y su tabla de funciones, y los interpoladores. Sus bloques de direcciones están sin mapear, así que tocar uno es una falla de bus y no un cero silencioso. La excepción es el ADC: sección 5a.