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:
3V3entrega 3.3 V conR_SUPPLYy cadaGND*yAGNDentrega 0 V conR_SUPPLY.VBUSentrega 5 V conR_SUPPLYyVSYSentrega 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_VREFentrega 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_ENes una entrada con una pull-up de 100 k haciaVSYS; 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í.RUNes 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..GP28son GPIO de entrada y salida. Con salida habilitada (bit deSIO.GPIO_OEactivo y el selector de función en SIO o PWM): push-pull a 3.3 V o 0 V a través deR_STRONG. Con salida deshabilitada: alta impedancia, más una pull-up de 55 k hacia 3.3 V cuandoPADS_BANK0.GPIOn.PUEestá activo, o una pull-down de 55 k cuandoPDEestá 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.mdsección 1).PADS_BANK0.GPIOn.ODdeshabilita el controlador de salida sin importar lo que pida el periférico seleccionado, yIEen 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,GP24yGP25existen en el modelo pero no están en el encabezado, como en la placa real:GP23es el control de power-save del SMPS,GP24es el sensor de VBUS (lee 1, porque el modelo siempre está alimentado por USB) yGP25es 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,GP27yGP28sonADC0..ADC2, y el ADC está modelado (sección 5a):analogRead(26)lee los voltios de la red.ADC_VREFes la referencia de 3.3 V del convertidor yAGNDuna tierra.GP0/GP1son 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 hacedocs/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
FUNCSELes 2 (UART) y es uno de 4 a 11 o de 20 a 27 (hoja de datos 2.19.2); conn % 40 esTXy 1 esRX. Así, GP4/GP5, GP8/GP9, GP20/GP21 y GP24/GP25 son sus pares.TXsiempre está manejado, en alto en reposo;RXes una entrada;CTSyRTSno 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
UARTDRinicia 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_Hdefine la trama:WLENde cinco a ocho bits,PENconEPS,STP2. Nada sale conUARTENoTXEen cero. - Recepción. El nivel del pad de
RXse 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.RTRISse 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,UARTMISyUARTICRcomo en la sección 3.5. Cualquier bit activado enUARTMISgeneraUART1_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.datadesde flash, limpiar.bss, ejecutar los constructores de C++, llamar amain), 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_llsly los ayudantes de memoria.link.ld:.texty.rodataen flash XIP en0x1000_0000,.datay.bssen SRAM en0x2000_0000, la pila desde la parte alta de la SRAM (0x2004_2000) hacia abajo. Sinboot2.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,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.- El objeto
rp2040de arduino-pico: el FIFO entreloop()yloop1(),f_cpu(),getCycleCount(), las llamadas al watchdog de la sección 3.9, ygetFreeHeap(),getUsedHeap()ygetTotalHeap(), 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 incorporaWiFi.h,HTTPClient.h,WebServer.hy los propios nombres de arduino-pico para ellos (docs/picow.mdsecciones 6 y 7). analogWrite(pin, 0..255)funciona en todos los GPIO, porque cada uno tiene un canal PWM:FUNCSELpasa 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 yTOPes 64,515.analogWriteFreq()(de 100 Hz a 1 MHz),analogWriteRange()yanalogWriteResolution()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í queanalogWrite(pin, 0)de verdad está apagado.millis()/micros()leen el TIMER, así que son exactos y nunca se desvían.delay()y undelayMicroseconds()de 50 us o más arman la alarma 0 del temporizador y ejecutanWFIhasta que se dispara; las esperas más cortas esperan activamente enTIMERAWL.attachInterrupt(pin, handler, mode)usaIO_IRQ_BANK0conRISING,FALLING,CHANGE,ONLOWyONHIGHasignados a los cuatro bits deINTR.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.
VSYSes 4.7 V, o seaVBUSmenos la caída del Schottky;3V3_ENes un pull-up de 100 kΩ y llevarlo por debajo de 1.2 V detiene la placa;RUNes un pull-up de 50 kΩ;ADC_VREFes 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 deVBUSen 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
BOOTSELes 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.