Referencia

Contrato de la placa ESP32-S3-DevKitC-1 (Boards Wave C)

El S3 en un Xtensa LX7: una sola SRAM vista a través de dos buses, la matriz GPIO, el puerto serie USB, LEDC, el RMT detrás del LED RGB, y un solo núcleo donde el chip tiene dos.

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 El ESP32-S3-DevKitC-1 y la página de la placa.

La ESP32-S3-DevKitC-1 es la placa propia de Espressif para el ESP32-S3: un módulo ESP32-S3-WROOM-1, dos núcleos Xtensa LX7 a 240 MHz, dos puertos micro-USB y un LED RGB direccionable. Un componente del núcleo (esp32s3 en crates/parts) envuelve un modelo del SoC ESP32-S3 (crates/esp32s3) sobre el mismo intérprete Xtensa que usan el ESP32 clásico y el ESP8266 (crates/xtensa-core). Este documento es el contrato, y prevalece sobre cualquier comentario en el código.

El tipo en el catálogo es esp32s3. La cadena program del catálogo es elf32 xtensa lx7 esp32s3.

Lee primero la sección 6 si vas a llevar una compilación de aquí a silicio real. A diferencia del contrato del ESP32 clásico, casi todos los números aquí se verificaron contra una página del Manual de referencia técnica del ESP32-S3 (versión 1.8), la hoja de datos de la serie ESP32-S3 y la guía de usuario y el dibujo de dimensiones del DevKitC-1 de Espressif. La sección 6 enumera los pocos que no se verificaron y todo lo que no está modelado: entre ellos, el segundo núcleo, la extensión de vectores, la caché, la flash, la PSRAM y ambas radios.

A sketch for this board compiles in the browser with clang-v3, the wasm build of Espressif's LLVM fork (-mcpu=esp32s3), published 2026-09-28 and checked on this simulator (docs/compile.md). An untouched example still runs its prebuilt ELF from web/public/firmware/esp32s3/, built by Espressif's GCC for the S3. Section 7 has the details.

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

Vista superior, con los dos puertos micro-USB abajo y el módulo WROOM-1 con su antena arriba. El dibujo de dimensiones de Espressif da la placa como 62.74 x 25.40 mm con cada fila de pines a 1.27 mm de su borde, así que los dos conectores de 22 pines están a 22.86 mm (0.9 pulgadas) de distancia y la placa cabalga una protoboard dejando libre una fila de orificios a cada lado. El dibujo la representa a ese tamaño.

J1, el conector izquierdo, pin 1 arriba (22 orificios): 3V3, 3V3b, RST, 4, 5, 6, 7, 15, 16, 17, 18, 8, 3, 46, 9, 10, 11, 12, 13, 14, 5V, G.

J3, el conector derecho, pin 1 arriba (22 orificios): Gb, TX, RX, 1, 2, 42, 41, 40, 39, 38, 37, 36, 35, 0, 45, 48, 47, 21, 20, 19, Gc, Gd.

44 pines. Un número es el GPIO n. TX y RX son GPIO43 y GPIO44, UART0. RST es el habilitador del chip. 5V es el riel de 5 V del USB. G es tierra. Los nombres duplicados llevan una letra porque los nombres de pines del catálogo son únicos; la serigrafía no la imprime.

Verificado: el orden de ambos conectores, pin por pin, contra las tablas J1 y J3 de la guía de usuario (las guías v1.0 y v1.1 dan el mismo orden), y la posición de las filas contra el dibujo de dimensiones.

GPIO 26 a 32 no están en ningún header. Son la flash SPI. GPIO 22 a 25 no existen en el componente (la tabla de funciones del IO MUX no tiene fila para ellos). GPIO 33 y 34 tampoco están en el header. crates/parts/src/parts/esp32s3.rs tiene una prueba que contiene todo esto.

GPIO 35, 36 y 37 sí están en el header, y en las variantes con PSRAM octal (la DevKitC-1-N8R8 que compra la mayoría) son de la PSRAM y no deben usarse. Este modelo no tiene PSRAM, así que aquí son pines ordinarios, y la nota de la guía del usuario se repite en la página de ayuda.

GPIO 19 y 20 son el USB D- y D+ del chip, a los que está conectado el conector "USB" de la placa. Aquí siguen siendo pads ordinarios y el puerto serie USB sigue funcionando incluso cuando un sketch los maneja, cosa que una placa real no haría (sección 3.4).

Cosas en la placa:

  • The RGB LED. An addressable LED, on GPIO48 on the first revision and on GPIO38 on v1.1. The user guide's "Hardware Revision Details" says this is the one difference between the two. The revision property picks which, 1.0 or 1.1, and defaults to 1.0, which is where the Arduino core's board definition puts it. The LED's data line is the pad; the board part decodes the pad the way the LED's own receiver does (section 5).
  • BOOT es GPIO0, activo en bajo; hacer clic en él en la placa conecta el pin a tierra. También está en J3 como 0.
  • RST reinicia el chip.
  • Un LED rojo de alimentación de 3.3 V, dibujado encendido, porque la placa siempre está en USB aquí.

Eléctrico: cada GPIO impulsa en push-pull a 3.3 V a través de R_STRONG, queda en alta impedancia, o se conecta con pull-up o pull-down a través de 45 k. Una entrada lee alto a 1.65 V (la mitad del suministro de E/S); una red en conflicto (Unknown) lee 0, y una flotante lee ruido, como en el Uno (docs/uno.md sección 1). GPIO0 lee alto cuando nada lo sostiene, por el pull-up de la placa junto al botón BOOT. 3V3 entrega 3.3 V en R_SUPPLY, 5V entrega 5 V, G entrega 0 V. RST lleva un pull-up de 10 k hacia 3.3 V y llevarlo por debajo de 1.65 V mantiene el núcleo en reset. El capacitor junto a esa resistencia, el reset de encendido de la placa, no está modelado.

2. Mapa de memoria

SRAM1, bus de instrucciones 416 KB en 0x4037_8000 a 0x403D_FFFF
IROM (flash code) 0x4200_0000, read-only, up to 1,310,720 bytes
DROM (flash constants) 0x3C00_0000, read-only, up to 1,310,720 bytes
SRAM1 y SRAM2, bus de datos 480 KB en 0x3FC8_8000 a 0x3FCF_FFFF
tope de la pila 0x3FD0_0000
UART0 0x6000_0000, sección 3.3
matriz de GPIO 0x6000_4000, sección 3.1
SENS 0x6000_8800, sección 3.6
IO MUX 0x6000_9000, sección 3.2
RMT 0x6001_6000, sección 3.8
LEDC 0x6001_9000, sección 3.7
SYSTIMER 0x6002_3000, sección 3.5
USB Serial/JTAG 0x6003_8000, sección 3.4
SYSTEM 0x600C_0000, sección 3.9
Matriz de interrupciones 0x600C_2000, sección 3.9

Cada bloque de periférico ocupa aquí 4 KB, excepto SENS, que es los 2 KB superiores del bloque de gestión de baja potencia.

Verificado: cada dirección de la tabla, contra las tablas 4.3-1 (memoria interna) y 4.3-3 (periféricos) del manual. SENS es "la dirección base de gestión de baja potencia + 0x800" en el resumen de registros 39.6.2 del manual.

Una SRAM, dos ventanas, y el modelo tiene ambas. El manual dice que a SRAM1 la direcciona la CPU por el bus de datos o el bus de instrucciones en el mismo orden: el byte en 0x4037_8000 + n es el byte en 0x3FC8_8000 + n. El modelo mantiene un búfer para la ventana de datos y mapea la ventana de instrucciones sobre sus primeros 416 KB, de modo que un programa puede leer su propio código por el bus de datos y obtener los bytes correctos, algo que el modelo del ESP32 clásico no puede ofrecer. SRAM2 está solo en el bus de datos, justo después de SRAM1. firmware/esp32s3/link.ld coloca el código en la dirección de instrucciones e inicia las secciones de datos en la dirección del bus de datos del primer byte después del código, así que nunca comparten RAM, y elfcheck.py rechaza una imagen en la que sí lo harían.

SRAM0, los 32 KB en 0x4037_0000 que la caché de instrucciones puede tomar, no está modelada; un acceso a ella es una falta.

Flash. A real ESP32-S3 runs almost all of a sketch from flash through the cache: code is read at IROM and const data at DROM, and the Arduino IDE's default partition gives the sketch 1,310,720 bytes of it. That is the room a sketch has here, counted as the IDE counts it (code, literals, constants, startup code and the initial values of the variables), and the number the editor prints after a build. firmware/esp32s3/link.ld keeps the vectors, the exception entry and the startup code in SRAM1 on the instruction bus and puts every other function in the code window and every constant in the constants window. The windows are read-only views of the loaded image, not a cache: no misses, no timing (a fetch from flash costs what one from SRAM1 costs), and a store to one faults. Literal pools sit in front of their own functions (L32R reaches 256 KB backwards) and the startup code calls through registers (CALL4 reaches 128 KB). The upload build (link-hw.ld) is loaded into RAM by the ROM and keeps SRAM1 as its room.

Every PT_LOAD segment must land in one of the two SRAM windows or one of the two flash windows; anything else is refused with the offending address in the message, and the chip is left with no program. An image built for the classic ESP32 is refused this way, since its RAM is at other addresses.

El núcleo se restablece con pc en el punto de entrada del ELF y todos los registros de dirección en cero. Aquí no hay ROM de arranque: el cargador de primera etapa, las lecturas de flash, el árbol de relojes y la configuración de la caché están todos ausentes, y el runtime deja explícito el estado que necesita.

3. Registros de periféricos

Solo está implementado el subconjunto de abajo. Cualquier otra cosa dentro de un bloque mapeado se lee como 0 y cuenta como acceso errante; cualquier cosa fuera de todo bloque es una falta de acceso.

3.1 Matriz GPIO (0x6000_4000)

Los números de GPIO van de 0 a 48, así que todo registro con un bit por pin llega en dos mitades: la normal cubre GPIO 0 a 31 y la de 1 cubre GPIO 32 a 48 en sus diecisiete bits bajos.

offset registro
0x04 GPIO_OUT_REG
0x08 GPIO_OUT_W1TS_REG
0x0C GPIO_OUT_W1TC_REG
0x10 GPIO_OUT1_REG
0x14 GPIO_OUT1_W1TS_REG
0x18 GPIO_OUT1_W1TC_REG
0x20 GPIO_ENABLE_REG
0x24 GPIO_ENABLE_W1TS_REG
0x28 GPIO_ENABLE_W1TC_REG
0x2C GPIO_ENABLE1_REG
0x30 GPIO_ENABLE1_W1TS_REG
0x34 GPIO_ENABLE1_W1TC_REG
0x38 GPIO_STRAP_REG
0x3C GPIO_IN_REG
0x40 GPIO_IN1_REG
0x44 GPIO_STATUS_REG
0x4C GPIO_STATUS_W1TC_REG
0x50 GPIO_STATUS1_REG
0x58 GPIO_STATUS1_W1TC_REG
0x74 + 4n GPIO_PINn_REG
0x154 + 4y GPIO_FUNCy_IN_SEL_CFG_REG, almacenado
0x554 + 4n GPIO_FUNCn_OUT_SEL_CFG_REG

Las formas W1TS de los registros de estado, GPIO_CPU_INT_REG/GPIO_CPU_INT1_REG (se leen como el estado), GPIO_BT_SELECT_REG, GPIO_SDIO_SELECT_REG y GPIO_CLOCK_GATE_REG también reciben respuesta.

Verificado: la base y cada desplazamiento, contra el resumen de registros 6.14.

GPIO_PINn_REG (registro 6.18): el bit 2 PAD_DRIVER pone el pad en drenaje abierto; los bits 7..9 INT_TYPE eligen qué activa la interrupción del pin (0 desactivada, 1 flanco de subida, 2 flanco de bajada, 3 cualquier flanco, 4 nivel bajo, 5 nivel alto); el bit 13 es la habilitación de interrupción de la CPU. Verificado.

GPIO_FUNCn_OUT_SEL_CFG_REG (register 6.20): bits 0..8 OUT_SEL, bit 9 OUT_INV_SEL, bit 10 OEN_SEL, bit 11 OEN_INV_SEL. OUT_SEL 256 makes the pad follow GPIO_OUT with GPIO_ENABLE as its output enable. 73 to 80 hand the pad to LEDC channels 0 to 7 (ledc_ls_sig_out0 to 7) and 81 to 84 to RMT channels 0 to 3 (rmt_sig_out0 to 3); those numbers are table 6.11-1's, verified. Both peripherals' output enables are tied high in that table ("1'd1"), so with OEN_SEL clear an LEDC or RMT channel drives its pad whatever GPIO_ENABLE says, and with OEN_SEL set GPIO_ENABLE decides. Any other OUT_SEL selects a peripheral that is not modeled, and the model treats it as 256 rather than invent a level.

GPIO_STRAP_REG lee 0x08: el bit 3 (GPIO0) en alto, los bits 2, 4 y 5 (GPIO46, GPIO45, GPIO3) en bajo, lo que es un arranque normal desde flash de 3.3 V. La asignación de bits es la del registro 6.15; el valor aquí es una constante, no un registro de lo que hicieron los pines al restablecerse.

3.2 IO MUX (0x6000_9000)

IO_MUX_PIN_CTRL_REG en 0x00, luego un registro por GPIO en 0x04 + 4n. A diferencia del ESP32 clásico, el IO MUX de la S3 está en orden de GPIO. Bit 7 FUN_WPD, bit 8 FUN_WPU, bit 9 FUN_IE, bits 10..11 FUN_DRV (almacenado), bits 12..14 MCU_SEL. Un pad solo llega a GPIO_IN_REG con su búfer de entrada habilitado.

Verificado: la base, los desplazamientos y los bits, contra el registro 6.36; la tabla de funciones y los valores de restablecimiento contra la tabla 6.12-1.

MCU_SEL elige una de hasta cinco funciones. La función 1 es la matriz GPIO en cada pin. En la mayoría de los pines la función 0 también es la matriz GPIO, pero en los pines 26 a 32 es la flash, en los 39 a 42 los pines JTAG, en el 43 y el 44 UART0 y en el 47 y el 48 el par de reloj de la flash, así que un programa que quiera uno de esos como GPIO tiene que poner MCU_SEL en 1. El pinMode del runtime siempre lo hace. El LED RGB en GPIO48 es uno de ellos: hasta que algo establezca su MCU_SEL, nada de lo que un programa escriba en la matriz llega a ese pad.

Cada pad arranca con el valor de reinicio del manual. Columna "RST" de la tabla 6.12-1: GPIO0 y los pines de flash con sus pull-ups, GPIO45 y GPIO46 con sus pull-downs, la mayoría de los pines con solo el búfer de entrada activado, y los GPIO 4 a 8, 15, 16 y 19 a 21 sin siquiera eso, así que digitalRead en uno de esos devuelve 0 hasta que se active el búfer. MTCK, GPIO39, arranca con pull-up, que es lo que dice la tabla para una pieza cuyos pads JTAG no han sido deshabilitados por eFuse. GPIO43, U0TXD, arranca con su salida habilitada en el UART; la propia forma de onda del UART no se modela (sección 3.3), así que ese pad mantiene la línea en reposo en alto hasta que un programa lo toma.

3.3 UART0 (0x6000_0000)

offset registro
0x00 UART_FIFO_REG
0x04 UART_INT_RAW_REG
0x08 UART_INT_ST_REG
0x0C UART_INT_ENA_REG
0x10 UART_INT_CLR_REG
0x14 UART_CLKDIV_REG
0x1C UART_STATUS_REG
0x20 UART_CONF0_REG
0x24 UART_CONF1_REG
0x78 UART_CLK_CONF_REG

Verificado: la base y cada offset (resumen de registros 26.6), y los bits de abajo.

Dos FIFOs de 128 bytes. Los bits 0..9 de UART_STATUS_REG son RXFIFO_CNT y los bits 16..25 TXFIFO_CNT. El bit 17 de UART_CONF0_REG, RXFIFO_RST, y el bit 18, TXFIFO_RST, los vacían (registro 26.9; el modelo del ESP32 clásico tiene estos dos al revés, sección 6). UART_CONF1_REG contiene los dos umbrales de FIFO, diez bits cada uno, 96 al reiniciar. En UART_CLKDIV_REG los bits 0..11 son la parte entera del divisor y los bits 20..23 sus dieciseisavos, 694 al reiniciar.

El divisor divide el reloj del núcleo del UART, que los bits 20..21 de UART_CLK_CONF_REG, SCLK_SEL, eligen: 1 el reloj APB de 80 MHz, 3 el cristal de 40 MHz, y el cristal es el valor al reiniciar (registro 26.18). El 2, el oscilador RC_FAST, no se modela y se toma como el cristal. SCLK_DIV_NUM (bits 12..19) divide el reloj del núcleo entre SCLK_DIV_NUM + 1, lo cual se cree: el manual llama al campo "la parte integral del divisor de frecuencia" e imprime el divisor sin el uno, y al reiniciar el campo vale 1. El runtime pone SCLK_SEL en 1 y SCLK_DIV_NUM en 0, y entonces 694 es 115 274 baudios. Las partes fraccionales SCLK_DIV_A/SCLK_DIV_B no se modelan.

Los bytes salen del FIFO de transmisión al ritmo de los baudios, no al instante, así que un puerto de 115 200 baudios transmite 11 520 bytes por segundo aquí como en una mesa de trabajo; crates/esp32s3/tests/runtime.rs comprueba que no haya dos bytes del ejemplo serial más cerca que un tiempo de byte.

UART1 y UART2 no se modelan. La forma de onda del pin de U0TXD tampoco se modela: los bytes son el canal del host, no bits en GPIO43.

3.4 USB Serial/JTAG (0x6003_8000)

La mitad serie del controlador: el puerto CDC-ACM que lleva el conector "USB" de la placa, al que un sketch accede como USBSerial.

offset registro
0x00 USB_SERIAL_JTAG_EP1_REG
0x04 USB_SERIAL_JTAG_EP1_CONF_REG
0x08 USB_SERIAL_JTAG_INT_RAW_REG
0x0C USB_SERIAL_JTAG_INT_ST_REG
0x10 USB_SERIAL_JTAG_INT_ENA_REG
0x14 USB_SERIAL_JTAG_INT_CLR_REG
0x18 USB_SERIAL_JTAG_CONF0_REG, almacenado

Verificado: la base, los offsets (resumen de registros 33.5) y los bits: EP1_CONF bit 0 WR_DONE, bit 1 SERIAL_IN_EP_DATA_FREE, bit 2 SERIAL_OUT_EP_DATA_AVAIL (registro 33.2); INT_* bit 2 SERIAL_OUT_RECV_PKT_INT y bit 3 SERIAL_IN_EMPTY_INT, que está activo al reiniciar (registro 33.6).

The behavior is section 33.3.3's: bytes written to EP1 wait in a 64-byte buffer and leave only when it is flushed, by WR_DONE or by the hardware when the 64th byte goes in; from the flush until the host has the packet, SERIAL_IN_EP_DATA_FREE is clear and a byte written is lost; when the host has it, SERIAL_IN_EMPTY_INT rises. Host bytes arrive a packet (up to 64) at a time, SERIAL_OUT_EP_DATA_AVAIL stays set while any are unread, and the next packet is accepted once the last byte of this one has been read.

El tiempo es propio de este modelo. El manual dice que el host "revisará periódicamente". Aquí el host siempre tiene una terminal abierta y recoge un paquete vaciado tan pronto como podría cruzar un bus de 12 Mbit/s: el paquete más trece bytes de token, handshake y enmarcado, o sea 51.3 us para 64 bytes. Un host real añade hasta una trama (1 ms) de planificación; eso no se modela.

No se modela: la mitad JTAG, la enumeración, las interrupciones de error de bus, las solicitudes de reinicio por RTS/DTR y de modo de descarga, y la suspensión. El host siempre está conectado.

3.5 SYSTIMER (0x6002_3000)

Unidad 0: el contador de 52 bits detrás de micros() y millis().

offset registro
0x00 SYSTIMER_CONF_REG
0x04 SYSTIMER_UNIT0_OP_REG
0x0C SYSTIMER_UNIT0_LOAD_HI_REG
0x10 SYSTIMER_UNIT0_LOAD_LO_REG
0x40 SYSTIMER_UNIT0_VALUE_HI_REG
0x44 SYSTIMER_UNIT0_VALUE_LO_REG
0x5C SYSTIMER_UNIT0_LOAD_REG

Verificado: la base, los offsets (resumen de registros 11.5), los bits (CONF bit 30 TIMER_UNIT0_WORK_EN, activo al reiniciar; OP bit 30 UPDATE, bit 29 VALUE_VALID) y el reloj de conteo de 16 MHz ("XTAL_CLK/2.5, que es 16 MHz", sección 11.4).

La lectura es capturar y luego leer: escribe UPDATE, espera VALUE_VALID, lee VALUE_HI y VALUE_LO. El contador no se cuenta: es el tiempo simulado dividido entre 62.5 ns, más lo que una carga haya puesto ahí, así que no tiene nada contra lo que derivar. La unidad 1, los tres comparadores y sus alarmas no se modelan; el tick del runtime es el propio CCOMPARE0 del núcleo (sección 4).

3.6 SENS: ADC1, una sola conversión (0x6000_8800)

La conversión iniciada por software del controlador RTC ADC1.

offset registro bits
0x00 SENS_SAR_READER1_CTRL_REG guardado
0x0C SENS_SAR_MEAS1_CTRL2_REG bits 0..15 MEAS1_DATA_SAR (solo lectura), bit 16 MEAS1_DONE_SAR, bit 17 MEAS1_START_SAR, bit 18 MEAS1_START_FORCE, bits 19..30 SAR1_EN_PAD (un bit por canal), bit 31 SAR1_EN_PAD_FORCE
0x10 SENS_SAR_MEAS1_MUX_REG bit 31 SAR1_DIG_FORCE: set, ADC1 belongs to the digital controller and a software start converts nothing
0x14 SENS_SAR_ATTEN1_REG two bits of attenuation per channel, channel n at bits 2n..2n+1; all ones at reset

Verificado: la base, los tres offsets y cada bit, contra los registros 39.10 a 39.13.

Una conversión: pon la atenuación en ATTEN1, activa START_FORCE y EN_PAD_FORCE, pon el bit del canal en SAR1_EN_PAD, sube MEAS1_START_SAR, espera MEAS1_DONE_SAR y lee el dato. Una conversión toma 5 us fijos de tiempo simulado, una cifra del propio modelo.

Diez canales, y el canal n es el GPIO n + 1: ADC1_CH0 es GPIO1 y ADC1_CH9 GPIO10 (las tablas de encabezado de la guía del usuario, pin por pin).

El resultado son doce bits del voltaje de la red en el momento en que inició la conversión. En ATTEN0 a ATTEN2 es round(4095 x Vin / Vtop), saturado, donde Vtop es el límite superior del "rango de medición efectivo" de la hoja de datos: 850 mV, 1100 mV y 1600 mV. ATTEN3 (12 dB), la atenuación al reiniciar y la predeterminada del núcleo de Arduino, sigue la curva sin procesar de un componente típico (CURVE_ATTEN3 en crates/esp32s3/src/adc.rs): casi lineal desde 0 V, curvándose a partir de unos 2750 mV (donde las propias mediciones de Espressif muestran que la S3 pierde linealidad) más allá del rango efectivo de 2900 mV, y saturando en 4095 desde unos 3.1 V. Así, un potenciómetro entre los 3.3 V del riel alcanza 4095 un poco antes del final de su recorrido, y la mitad del riel (1.65 V) lee unos 2220. La calibración eFuse de una unidad mueve eso unos pocos puntos porcentuales, lo cual no se modela. analogReadMilliVolts invierte la misma curva. Un canal sin nada en su pin vaga, como lo hace una entrada flotante (docs/uno.md sección 1).

Faltan el ADC2, el controlador digital, el DMA, las eFuses de calibración y el sensor de temperatura.

3.7 LEDC (0x6001_9000)

Ocho canales y cuatro temporizadores, todos de una sola clase de velocidad: el LEDC completo del S3.

offset registro bits
0x00 + 0x14n LEDC_CHn_CONF0_REG bits 0..1 TIMER_SEL, bit 2 SIG_OUT_EN, bit 3 IDLE_LV, bit 4 PARA_UP (solo escritura)
0x04 + 0x14n LEDC_CHn_HPOINT_REG bits 0..13 HPOINT
0x08 + 0x14n LEDC_CHn_DUTY_REG bits 0..18 el ciclo útil en dieciseisavos de una cuenta
0x0C + 0x14n LEDC_CHn_CONF1_REG el hardware de desvanecimiento: almacenado, no desvanece nada
0x10 + 0x14n LEDC_CHn_DUTY_R_REG el ciclo útil vigente, solo lectura
0xA0 + 8n LEDC_TIMERn_CONF_REG bits 0..3 DUTY_RES, bits 4..21 CLK_DIV (Q10.8), bit 22 PAUSE, bit 23 RST (se activa al reiniciar), bit 25 PARA_UP (solo escritura)
0xA4 + 8n LEDC_TIMERn_VALUE_REG el contador
0xC0 LEDC_INT_RAW_REG bit n = el temporizador n se desbordó
0xC4 LEDC_INT_ST_REG
0xC8 LEDC_INT_ENA_REG se guarda; ninguna línea llega al núcleo
0xCC LEDC_INT_CLR_REG
0xD0 LEDC_CONF_REG bits 0..1 APB_CLK_SEL (1, el reloj APB, es la única fuente modelada), bit 31 CLK_EN
0xFC LEDC_DATE_REG lee 0x1907_2601

Verificado: la base, cada desplazamiento y cada bit de la tabla (resumen de registros 35.4 y registros 35.1 a 35.13). Esto es un cambio real respecto del modelo clásico del ESP32, cuya disposición del LEDC es presumida.

Un temporizador cuenta 2^DUTY_RES cuentas a 80 MHz dividido entre CLK_DIV: f = 80e6 / ((CLK_DIV / 256) * 2^DUTY_RES). La salida de un canal está en alto desde HPOINT durante DUTY >> 4 cuentas.

Nada surte efecto sin su bit de actualización. Los campos CLK_DIV y DUTY_RES de un temporizador esperan a TIMERn_PARA_UP, y los campos HPOINT, SIG_OUT_EN, TIMER_SEL y el ciclo útil de un canal esperan a PARA_UP_CHn (las listas bajo los registros 35.1 y 35.7). El modelo mantiene aparte lo que se escribió de lo que está vigente, así que un firmware que olvida un bit de actualización no obtiene PWM, como en un escritorio real. PAUSE, RST y IDLE_LV actúan de inmediato. El ciclo útil figura bajo DUTY_START; el modelo lo carga con PARA_UP_CHn esté o no activado DUTY_START, lo cual se presume que es lo que hace un simple cambio de ciclo útil con el hardware de desvanecimiento inactivo.

Un canal llega a un pad a través de la matriz GPIO en OUT_SEL 73 + n (sección 3.1). El contador es una función de forma cerrada del tiempo simulado, así que un núcleo detenido en waiti no cuesta nada mientras corre un PWM; runtime.rs mide el período del ejemplo fade contra el 1 ms de 1 kHz con un margen de 5 us.

El reloj del LEDC está apagado al reiniciar (sección 3.9): hasta que se activa SYSTEM_LEDC_CLK_EN el bloque no responde.

No modelado: el hardware de desvanecimiento del ciclo útil, el contador de desbordamiento, las fuentes de reloj distintas de APB, y la línea del LEDC hacia la matriz de interrupciones.

3.8 RMT (0x6001_6000)

Los cuatro canales de transmisión del periférico de control remoto: lo que maneja el LED RGB.

offset registro bits
0x00 + 4n RMT_CHnDATA_REG escritura: introduce una palabra en la RAM del canal n a través del FIFO del APB
0x20 + 4n RMT_CHnCONF0_REG bit 0 TX_START, bit 1 MEM_RD_RST, bit 2 APB_MEM_RST, bit 3 TX_CONTI_MODE, bit 4 MEM_TX_WRAP_EN, bit 5 IDLE_OUT_LV, bit 6 IDLE_OUT_EN, bit 7 TX_STOP, bits 8..15 DIV_CNT, bits 16..19 MEM_SIZE, bit 20 CARRIER_EFF_EN, bit 21 CARRIER_EN, bit 22 CARRIER_OUT_LV, bit 24 CONF_UPDATE
0x50 + 4n RMT_CHnSTATUS_REG bits 0..9 la dirección de lectura, bits 11..20 la dirección de escritura del APB, bits 22..24 el estado, bit 25 MEM_EMPTY, bit 26 APB_MEM_WR_ERR
0x70 RMT_INT_RAW_REG bit n TX_END, bit 4+n ERR, bit 8+n TX_THR_EVENT, bit 12+n TX_LOOP
0x74 RMT_INT_ST_REG
0x78 RMT_INT_ENA_REG
0x7C RMT_INT_CLR_REG
0x80 + 4n RMT_CHnCARRIER_DUTY_REG bits 0..15 en bajo, bits 16..31 en alto, 0x40 cada uno al reiniciar
0xA0 + 4n RMT_CHn_TX_LIM_REG bits 0..8 TX_LIM, bits 9..18 TX_LOOP_NUM, bit 19 TX_LOOP_CNT_EN, bit 20 LOOP_COUNT_RESET, bit 21 LOOP_STOP_EN
0xC0 RMT_SYS_CONF_REG bit 0 APB_FIFO_MASK, bits 4..11 SCLK_DIV_NUM, bits 24..25 SCLK_SEL, bit 26 SCLK_ACTIVE, bit 31 CLK_EN
0xCC RMT_DATE_REG lee 0x0210_1181
0x800 a 0xDFF la RAM 384 palabras

Los registros de los canales de recepción (0x30 a 0x4C, 0x60 a 0x6C, 0x90 a 0x9C, 0xB0 a 0xBC) se almacenan, se leen de vuelta y no reciben nada.

Verificado: la base, cada desplazamiento y bit de la tabla (resumen de registros 37.5, registros 37.1 a 37.19), el tamaño de la RAM y su inicio NONFIFO en "RMT base address + 0x800", el formato del código de pulso (período en los bits 0..14 y 16..30, nivel en los bits 15 y 31, "el valor mínimo del período es cero y se interpreta como un marcador de fin de transmisión"), el reloj del canal (rmt_sclk dividido entre DIV_CNT, "el valor 0 representa el divisor 256", y rmt_sclk la fuente dividida entre SCLK_DIV_NUM + 1 + A/B), los valores de reinicio (portadora activada, MEM_SIZE 1, DIV_CNT 2), y la lista de campos que esperan a CONF_UPDATE (tabla 37.3-1).

Believed: the manual gives transmit channel n's NONFIFO start as "RMT base address + 0x800 + n x 48", and the model reads the 48 as words, so channel n's block starts at 0x800 + 192n: the only reading under which the eight 48-word blocks of section 37.3.2 fit the 384 words. The manual's receive-channel start, "0x8c0 + m x 48", does not settle it either way, and the receive channels are not modeled.

Lo que hace una transmisión, según la sección 37.3.4: TX_START transmite desde el inicio del bloque del canal, y cada código mantiene su nivel durante period tics del reloj del canal; ante un marcador de fin el canal se detiene, activa TX_END y mantiene el nivel del marcador de fin, o IDLE_OUT_LV si IDLE_OUT_EN está activado; agotar el final de sus bloques de MEM_SIZE sin marcador de fin lo detiene con MEM_EMPTY y ERR, salvo que el modo de envolvimiento lo haga volver a empezar, en cuyo caso TX_THR_EVENT se activa cada vez que salen TX_LIM palabras más; el modo continuo vuelve a empezar en cada marcador de fin, contando ciclos cuando se le pide. TX_STOP detiene de inmediato.

Actualización de configuración. DIV_CNT, IDLE_OUT_EN, IDLE_OUT_LV, TX_CONTI_MODE, TX_STOP, los campos de la portadora y los tres campos de TX_LIM surten efecto solo con CONF_UPDATE (tabla 37.3-1); el modelo los mantiene aparte hasta entonces. MEM_SIZE, el modo de envolvimiento y TX_START actúan de inmediato.

The carrier is on at reset. A code whose level matches CARRIER_OUT_LV becomes a square wave high for CARRIER_HIGH + 1 and low for CARRIER_LOW + 1 cycles of rmt_sclk. The model starts that wave high at the start of each code, which is believed, and does not modulate the idle level when CARRIER_EFF_EN is clear. A WS2812 needs the carrier off, and the runtime clears CARRIER_EN; the model counts transmissions made with it on, and the runtime tests check the count is zero.

La salida es una función de forma cerrada del tiempo entre los límites de los códigos, así que cada flanco cae en su picosegundo y un núcleo detenido no cuesta nada mientras sale una trama. runtime.rs decodifica las tramas de los ejemplos blink y rainbow en GPIO48 y comprueba cada tiempo en alto y en bajo contra las ventanas de la hoja de datos del WS2812B.

El reloj del RMT está apagado al reiniciar (sección 3.9).

No modelado: los canales de recepción, el DMA en el canal 3, el arranque simultáneo, la propiedad y la alimentación de la RAM, y las reglas de período mínimo (fórmulas 37.1 y 37.3).

3.9 SYSTEM (0x600C_0000) y la matriz de interrupciones (0x600C_2000)

offset registro
0x10 SYSTEM_CPU_PER_CONF_REG, almacenado
0x18 SYSTEM_PERIP_CLK_EN0_REG
0x1C SYSTEM_PERIP_CLK_EN1_REG, almacenado
0x20 SYSTEM_PERIP_RST_EN0_REG
0x24 SYSTEM_PERIP_RST_EN1_REG, almacenado

Verified: the offsets and reset values (registers 17.3 to 17.7). LEDC (bit 11) and RMT (bit 9) are gated off at reset in SYSTEM_PERIP_CLK_EN0_REG. Here, a write to either block while its clock bit is clear, or while its bit in SYSTEM_PERIP_RST_EN0_REG holds it in reset, is dropped and counted, and a read returns 0; holding one in reset puts it back to power-on. The runtime sets both clock bits before anything else. The other blocks here are clocked at reset and are not gated in the model.

La matriz de interrupciones: el registro de mapeo de la fuente n para el núcleo 0 está en 0x600C_2000 + 4n, y sus cinco bits bajos nombran la interrupción de CPU que la fuente genera. Verificado contra la tabla 9.3-1 y el resumen de registros 9.4, al igual que los cuatro números de fuente que este modelo enruta:

fuente número
GPIO_INTERRUPT_CPU 16
UART_INTR 27
RMT_INTR 40
USB_DEVICE_INT 96

Una fuente mapeada a una de las interrupciones internas del núcleo (6, 7, 11, 15, 16 o 29) no llega a nada, que es como el manual indica deshabilitar una fuente (sección 9.3.3.3). Todos los demás registros de mapeo se almacenan, se leen de vuelta y no enrutan nada.

3.10 Buzón de red de Mokxi (0x6FFF_E000)

Este bloque no es del ESP32-S3. Todas las demás direcciones de este documento son del chip. Este es propio de Mokxi: la red simulada de crates/net, en una dirección que el S3 deja sin mapear. El manual ubica los periféricos en "0x6000_0000~0x600D_0FFF" y la memoria RTC FAST termina en 0x600F_FFFF, así que una imagen que use este bloque falla en el silicio en lugar de leer el registro de otro periférico. Esa falla es la respuesta honesta, porque lo que hay detrás de este bloque no existe en el chip. Es la misma dirección que usan los modelos del ESP32-C3 y C6, porque los tres chips dejan el mismo hueco.

El bloque no genera ninguna interrupción. Todas las demás fuentes de aquí llegan al núcleo a través de la matriz de interrupciones de la sección 3.9, y un número de fuente de la matriz es del chip; no hay un número honesto que darle a un periférico que el chip no tiene, así que el buzón no recibe ninguno. NET_INT_RAW_REG se puede leer igualmente, el firmware hace sondeo, y un núcleo detenido en waiti se despierta cuando la red tiene algo que decir, de la misma forma en que se despierta por un flanco de PWM.

Aquí no hay radio, no hay 802.11 ni internet real. Nada en el modelo transmite, escanea, asocia, cifra ni abre un socket: una contraseña se compara como cadena, un nombre que no está bajo .mokxi no se resuelve, y los orígenes que la red sirve son funciones en crates/net/src/http.rs. El buzón tiene la forma de la costura real en lugar de una ficción sobre una MAC: en un ESP32-S3 real el hardware WiFi está detrás de un blob binario cerrado con una interfaz de comandos, y el WiFi.h de Arduino termina al otro lado de uno de estos. docs/wifi.md es el contrato de lo que hay detrás; esta sección son solo los registros.

Un registro de comandos, un registro de estado, un anillo de 4096 bytes en cada sentido y un bit de interrupción. Escribir NET_CMD_REG ejecuta el comando; un comando que tarda tiempo simulado activa BUSY y lo limpia, con DONE en NET_INT_RAW_REG, cuando termina.

offset nombre bits
0x00 NET_ID_REG lee 0x494B4F4D, y nada más lo hace. Un sketch que quiera saber si está en Mokxi lee esto; en silicio el acceso falla
0x04 NET_CMD_REG escribe un código de comando (tabla abajo); la escritura lo ejecuta
0x08 NET_ARG_REG una palabra de argumento, leída de vuelta: el puerto para LISTEN, el estado para REPLY
0x0C NET_STATUS_REG bit 0 BUSY, bit 1 ERR, bit 2 RX_READY, bit 3 LINK, bit 4 SERVE, bits 8..11 STATE
0x10 NET_RESULT_REG lo que respondió el último comando
0x14 NET_INT_RAW_REG bit 0 DONE, bit 1 EVENT
0x18 NET_INT_ENA_REG los mismos dos bits
0x1C NET_INT_CLR_REG escribe 1 para limpiar, los mismos dos bits
0x20 NET_TX_LEN_REG bytes preparados en el anillo de salida
0x24 NET_TX_DATA_REG escritura: empuja un byte (bits 0..7) al anillo de salida
0x28 NET_RX_LEN_REG bytes en espera en el anillo de entrada
0x2C NET_RX_DATA_REG lectura: saca un byte del anillo de entrada, 0 cuando está vacío
0x30 NET_RING_LEN_REG capacidad de cada anillo en bytes, para que el firmware no tenga que fijar 4096 a mano
0x40 NET_BT_CMD_REG Bluetooth: escribe un código de comando de Bluetooth (docs/bluetooth.md); la escritura lo ejecuta
0x44 NET_BT_ARG_REG Bluetooth: una palabra de argumento, leída de vuelta; un evento deja aquí su número
0x48 NET_BT_RESULT_REG Bluetooth: lo que respondió el último comando de Bluetooth
0x4C NET_BT_STATUS_REG bit 0 CLASSIC_ON, bit 1 CLASSIC_LINK, bit 2 EVENT, bit 3 BLE_ADV, bit 4 BLE_LINK, bit 5 BT_ERR, bit 8 HAS_CLASSIC, bit 9 HAS_BLE
0x50 NET_BT_TX_LEN_REG Bluetooth: bytes preparados en su propio anillo de salida
0x54 NET_BT_TX_DATA_REG Bluetooth: escritura: empuja un byte a ese anillo
0x58 NET_BT_RX_LEN_REG Bluetooth: bytes en espera en su propio anillo de entrada
0x5C NET_BT_RX_DATA_REG Bluetooth: lectura: saca un byte, 0 cuando está vacío

Los ocho registros NET_BT_ son la mitad Bluetooth del bloque, con anillos propios: solo Bluetooth LE, como en el chip real, así que los comandos de Classic ponen BT_ERR. Tampoco hay una radio detrás de ellos; docs/bluetooth.md es su contrato.

STATE es dónde está la estación: 0 inactiva, 1 iniciando, 2 conectando, 3 conectada, 4 falló, 5 no existe esa red. NET_CMD_STATUS convierte lo mismo en el código wl_status_t de Arduino que un sketch lee de WiFi.status().

NET_CMD_REG nombre qué hace
0 NOP nada
1 RESET desconecta, descarta ambos anillos, descarta cualquier solicitud
2 CONNECT el anillo de salida contiene ssid\0password; activa BUSY de uno a tres segundos
3 DISCONNECT descarta la asociación y la dirección
4 STATUS NET_RESULT_REG = el código wl_status_t
5 IP NET_RESULT_REG = la dirección asignada, primer octeto en el byte bajo
6 RSSI NET_RESULT_REG = la señal en dBm, con signo extendido
7 SSID el anillo de entrada recibe el nombre del punto de acceso
8 MAC el anillo de entrada recibe los seis bytes MAC de la placa
9 REQUEST el anillo de salida contiene method\0url\0headers\0body; activa BUSY
10 POLL NET_RESULT_REG = 0 mientras está en curso, luego el estado HTTP, o un error negativo con ERR arriba; el cuerpo llega al anillo de entrada
11 LISTEN escucha en el puerto de NET_ARG_REG
12 ACCEPT NET_RESULT_REG = 1 y el anillo de entrada contiene method\0path\0query\0body, o 0 cuando no hay nada en espera
13 REPLY responde la solicitud aceptada con el estado en NET_ARG_REG; el anillo de salida contiene content-type\0body
14 STOP deja de escuchar
15 WL_GPIO_SET maneja los GPIO propios del componente inalámbrico desde NET_ARG_REG. No esta placa: la radio de este componente no tiene tal pin, así que pone ERR y no maneja nada. Es la ruta que sigue el LED integrado de una Pico W (docs/picow.md sección 3.8)
16 WL_GPIO_GET se leen de vuelta, y el mismo ERR aquí
17 BLYNK una operación en el servidor Blynk simulado, la operación en NET_ARG_REG y sus campos en el anillo de salida; se responde de inmediato en NET_RESULT_REG, con ERR arriba sin pasar por la red (docs/wifi.md, "Blynk")
19 ETH Ethernet por cable (firmware/include/ETH.h), la operación en NET_ARG_REG: 1 levanta el enlace por un cable simulado, sin SSID y sin contraseña, y se une 1.5 s después con el mismo contrato de arrendamiento; 2 pone 1 en NET_RESULT_REG cuando el enlace es (o fue por última vez) el cableado. Hay un solo enlace: STATUS, IP y cada petición lo leen sin importar cómo se levantó
20 SOFTAP el AP por software (crates/net/src/softap.rs, docs/wifi.md), la operación en NET_ARG_REG: 1 lo levanta (el anillo de salida ssid\0password\0 y el byte de canal; NET_RESULT_REG 1, o 0 con ERR por un nombre vacío o una contraseña de uno a siete caracteres), 2 lo baja, 3 lo configura (dirección, puerta de enlace y máscara de red, cuatro bytes cada una), 4 su dirección (0 mientras está inactivo), 5 las estaciones conectadas, 6 las conexiones, desconexiones y el bit de actividad que el entorno de ejecución convierte en eventos, 7 y 8 el servidor DNS del portal cautivo iniciándose (el nombre, un byte cero, la dirección) y deteniéndose, 9 su nombre hacia el anillo de entrada, 10 la dirección del celular, 11 el Host de la petición que se atiende hacia el anillo de entrada. La única estación es el celular del panel Web

Los códigos negativos de POLL: -1 el nombre no se resuelve, -2 la estación no está asociada, -3 https:// y TLS no se simula, -4 un cuerpo más largo que el anillo, -5 una URL que esta red no puede analizar, -6 ya hay una petición en curso. firmware/include/HTTPClient.h los convierte en los códigos con forma de Arduino con los que un sketch se compara, y docs/wifi.md lista la correspondencia.

Tiempos, todos propios de este modelo y todos indicados en docs/wifi.md: una asociación tarda entre uno y tres segundos, decididos a partir del SSID para que una lección tarde lo mismo las dos veces; una contraseña errónea se convierte en WL_CONNECT_FAILED a los cinco segundos; una petición a un origen simulado regresa 60 ms después; una petición al propio servidor del sketch que el sketch nunca responde la cierra la red con un 504 a los diez segundos.

3.11 Los watchdogs de los grupos de timers, los reinicios de RTC_CNTL y el monitor de pila

Igual que en el C3 (sección 3.9 de docs/esp32c3.md), con el diseño del S3: no hay WDT_CONF_UPDATE_EN (una escritura surte efecto de inmediato), el bit de interrupción del watchdog es el bit 2, llega al núcleo a través de la matriz de interrupciones (fuentes 52 y 55; el runtime mapea 52 a la interrupción 17 de la CPU), los registros de almacenamiento están en 0x50..0x5C y 0xC0..0xCC, y el SP_MIN de ASSIST_DEBUG está un registro más adelante (0x3C). El monitor de pila revisa ENTRY, donde el código con ventanas mueve la pila en cada llamada; una falla contra límites que desde entonces se ampliaron se reintenta en lugar de reportarse.

El entorno de ejecución corre el watchdog de tareas de ESP-IDF sobre el watchdog del grupo de timers 0, como lo hace ESP-IDF (firmware/src/main.cpp): tics de 500 µs, la etapa 0 una interrupción al agotarse el tiempo y la etapa 1 un reinicio del sistema al doble, iniciado antes de setup() a 5 s con un pánico, vigilando la tarea de reposo del núcleo 0. El sketch corre en el núcleo 1, cuya tarea de reposo no se vigila a menos que lo pida (enableCore1WDT()), así que un bucle que nunca cede sigue corriendo, como en la placa. La interrupción imprime las líneas de ESP-IDF ("E (…) task_wdt: Task watchdog got triggered. …", las tareas, "Aborting.", la línea de aborto y "Rebooting..."), deja la pista ESP_RST_TASK_WDT de ESP-IDF en el registro de almacenamiento del RTC y reinicia la CPU mediante el reinicio por software, así que esp_reset_reason() devuelve 6 después. esp_task_wdt_*, enableLoopWDT() y enable/disableCore0WDT() actúan sobre él. El watchdog del grupo de timers 1 se modela igual y nada en el entorno de ejecución lo arma: el watchdog de interrupciones no se simula.

4. El núcleo: el LX7, qué ABI, y cómo llega una interrupción

The S3's two cores are Xtensa LX7s, and this model runs one of them on crates/xtensa-core, the interpreter the classic ESP32 and the ESP8266 already use, in a third configuration, Model::LX7.

Para todo lo que emite el compilador, el LX7 de aquí es el LX6. Los headers de configuración de las dos cadenas de herramientas (core-isa.h en xtensa-esp32-elf y xtensa-esp32s3-elf) coinciden en cada opción de enteros que decide qué código emite un compilador: sesenta y cuatro registros de dirección y la ventana de registros, el bucle sin sobrecosto, la multiplicación de 32 bits y su mitad alta, el divisor, MIN/MAX, SEXT, CLAMPS, S32C1I, MAC16, los booleanos y la FPU de precisión simple. Y la evidencia es más fuerte que los headers: crates/xtensa-core/tests/programs.rs contiene la compilación del programa de prueba hecha por el compilador del S3, que también compiló el compilador del ESP32 clásico, y ambas salieron idénticas byte por byte. Así que el S3 usa la ABI windowed, exactamente como el ESP32 clásico, con ENTRY, RETW, ROTW, MOVSP, L32E/S32E y las excepciones de ventana a través de sus propios vectores (la sección 4 de docs/esp32.md tiene la tabla de vectores, y es la del ISA, no la del chip).

Lo que el LX7 añade en este chip es la extensión vectorial del S3, las instrucciones EE.* para trabajo de IA y DSP, que el ensamblador codifica en el espacio op0 = 4 que el LX6 da a MAC16. Ninguna de las dos está modelada, y ambas fallan como instrucciones ilegales (crates/xtensa-core/tests/encoding.rs contiene dos codificaciones del ensamblador del S3). GCC no las emite desde C ordinario.

Interrupciones. INTENABLE enmascara; PS.INTLEVEL controla el paso. Solo se modela el nivel 1. En el S3 las interrupciones de nivel 1 son 0 a 10, 12, 13, 17 y 18, con máscara 0x0006_37FF, y 19 a 21 son de nivel 2: verificado contra la tabla 9.3-2 del manual. Los tres comparadores de CCOMPARE levantan las interrupciones 6, 15 y 16 de la CPU, según la misma tabla. El runtime enruta GPIO a la interrupción 13 de la CPU, una interrupción de periférico de nivel 1, y toma su tick de retardo de CCOMPARE0 en la interrupción 6 de la CPU.

PRID lee 0xCDCD, como en el modelo clásico: se cree correcto. Lo que importa es que el bit 13 esté en cero, que es como el software distingue el núcleo 0 del núcleo 1.

El resto es la sección 4 del ESP32 clásico sin cambios: CCOUNT es el conteo de ciclos; un WSR a un CCOMPARE lo arma y limpia su interrupción; "igualado o superado" en lugar de "igual"; un plazo ya vencido no se arma; MOVSP nunca levanta Alloca; y la FPU de precisión simple funciona, como en el ESP32 clásico (sección 4 de docs/esp32.md), así que un float compilado por firmware/esp32s3/build.sh da la respuesta correcta. Un sketch compilado en el navegador sigue siendo soft float (-Xclang -target-feature -Xclang -fp, con llamadas a mokxi_float.c).

5. Modelo de tiempo, sonda, poke y el canal del host

La CPU corre a 240 MHz, una instrucción por ciclo. El tiempo se recalcula a partir del conteo de ciclos, así que una porción de 2400 instrucciones dura exactamente 10 us. Dentro de una porción el conteo de instrucciones es el reloj: una lectura de un temporizador, un byte serie, un cambio de pin y un flanco de RMT caen todos en la instrucción que los causó. Un núcleo estacionado en WAITI no cuesta nada: la placa pide que se le despierte en lo más temprano entre su próximo vencimiento de CCOMPARE, su próximo flanco de LEDC o RMT, un byte serie y la red, y un cambio de pin o un byte del host también la despierta. Una lectura de GPIO_IN_REG después de que una escritura movió un pad en la misma porción termina la porción antes de la lectura, de modo que ve lo que el circuito hizo con la escritura, exactamente como en el ESP32 clásico (docs/esp32.md sección 5). delayMicroseconds() por debajo de 50 us cuenta CCOUNT y nunca dura menos de lo pedido.

probe es una máscara de bits con el color del LED:

bits significado
0 en ejecución
1 estacionado en waiti, o detenido por el depurador
2..19 el color del LED RGB tal como capturó el último cuadro, seis bits por canal: rojo en 14..19, verde en 8..13, azul en 2..7

El LED es decodificado por el componente de la placa a partir de los flancos que el SoC reporta en el pad del LED (GPIO48, o GPIO38 en la v1.1), con las ventanas del componente ws2812: un pulso alto menor a 125 ns es un glitch, hasta 600 ns es un 0, hasta 950 ns es un 1, cualquier cosa más larga rompe el cuadro, un nivel bajo más corto de lo que el bit permite también lo rompe, y 50 us de nivel bajo capturan los primeros 24 bits, verde primero. El LED conserva su color tras un reinicio del chip, como lo hace un WS2812, porque recibe energía de la placa. Los dos bits bajos del color por canal no caben en una sonda y se descartan.

poke: 1 mantiene BOOT (GPIO0 en bajo), 0 lo libera; 2 mantiene RST, 3 lo libera.

El canal del host transporta ambos puertos serie de la placa. Una DevKitC-1 real tiene dos conectores: "UART", a través de un puente USB a UART hacia UART0, y "USB", el propio controlador USB Serial/JTAG del chip. Aquí el monitor serie está conectado a ambos a la vez: host_read entrega los bytes que salieron de UART0 y los bytes que entregó el puerto USB, en el orden en que llegaron, y host_write pone lo que se escribe tanto en el FIFO de recepción de UART0 como en la cola del host del puerto USB. El puente en sí no está modelado, y tampoco lo está el reinicio automático por DTR y RTS.

Falla. 1000 trampas consecutivas sin progreso y el núcleo se declara en fallo y se detiene, con el lugar donde murió registrado y reportado en el canal del host.

6. De lo que este modelo está seguro, y de lo que no

Verificado contra el manual, la hoja de datos o la guía del usuario

Las ventanas de memoria (tabla 4.3-1) y cada base de periférico (tabla 4.3-3). Cada desplazamiento de registro y cada bit nombrado en la sección 3, bloque por bloque: GPIO (6.14 a 6.20), IO MUX (6.36 y tabla 6.12-1, incluido el valor de reinicio de cada pad y la función 1 siendo GPIO en cada pin), UART0 (26.6 a 26.19), USB Serial/JTAG (33.2 a 33.9 y el comportamiento en 33.3.3), SYSTIMER (11.1 a 11.5 y el reloj de 16 MHz), SENS (39.10 a 39.13), LEDC (35.1 a 35.13 y las listas de PARA_UP), RMT (37.1 a 37.19, el tamaño de la RAM, el formato del código de pulsos, la fórmula del reloj y la tabla 37.3-1), SYSTEM (17.3 a 17.7, incluido que LEDC y RMT quedan deshabilitados al reiniciar) y la matriz de interrupciones (tabla 9.3-1 y resumen 9.4). Los números de señal de la matriz GPIO 73 a 80 para LEDC y 81 a 84 para RMT (tabla 6.11-1), y que las habilitaciones de salida de ambos periféricos están fijas en alto. Los niveles de interrupción de la CPU y los números de interrupción de los comparadores (tabla 9.3-2). El mapa de canales del ADC1 y los rangos efectivos de las cuatro atenuaciones (hoja de datos). El orden de los headers, el GPIO del LED RGB en cada revisión, y las dimensiones de la placa (guía del usuario y plano de dimensiones). Las opciones del ISA de enteros (el core-isa.h de las toolchains, y la salida del compilador del S3 byte por byte).

Se cree, pero no está verificado

  • SCLK_DIV_NUM + 1 como el divisor de reloj del núcleo de UART0 (sección 3.3). El runtime escribe 0 ahí, que es 1 bajo esta lectura; la fórmula impresa en el manual no lleva el más uno.
  • La disposición de la RAM del RMT por canal, 0x800 + 192n (sección 3.8).
  • La fase de la portadora: primero alto, desde el inicio de cada código (sección 3.8).
  • La carga del ciclo útil en PARA_UP_CHn sin DUTY_START (sección 3.7).
  • El tiempo de los paquetes USB: 12 Mbit/s más trece bytes, y sin retardo de calendarización del host (sección 3.4).
  • PRID = 0xCDCD (sección 4).

Cada número del que depende el runtime está nombrado en un solo lugar (firmware/esp32s3/include/esp32s3.h), y crates/esp32s3/tests/contract.rs verifica que ese header y crates/esp32s3/src/map.rs coincidan en los mismos números.

Modelado, pero no con los números exactos del chip

  • El ADC con ATTEN3 es la curva de un componente típico, no la de esta unidad (sección 3.6): la saturación en unos 3.1 V y el doblez arriba de 2.75 V sí están, pero la variación entre unidades que corrige la calibración de eFuse no lo está. Las otras atenuaciones son líneas rectas hasta el tope de sus rangos efectivos.
  • Una conversión tarda exactamente 5 us, y un flanco de LEDC o de RMT cae en el picosegundo exacto.
  • GPIO_STRAP_REG es una constante, no un estado retenido de los pines al reiniciarse.
  • RST es solo una pull-up de 10 k; el capacitor de encendido no está modelado.
  • No hay ROM de arranque ni árbol de relojes. El núcleo está a 240 MHz y el reloj APB a 80 MHz desde la primera instrucción, y SYSTEM_CPU_PER_CONF_REG se guarda pero no cambia nada.
  • Los pads de USB no se toman. GPIO19 y GPIO20 siguen siendo pines ordinarios y el puerto USB sigue funcionando aunque un sketch los controle.
  • U0TXD mantiene un nivel alto constante mientras el UART lo posee; los bits del UART son el canal hacia el host, no una forma de onda en GPIO43.
  • CCOMPARE compara con "alcanzado o superado", y MOVSP nunca genera Alloca (sección 4).

Ausentes a propósito

  • El segundo núcleo. Solo corre el núcleo 0; no hay interrupción entre núcleos ni FreeRTOS, así que cualquier cosa que inicie una tarea en el núcleo 1 no se ejecutará.
  • La extensión de vectores. Toda codificación EE.* genera una falla (sección 4). La FPU sí está modelada.
  • SRAM0, la caché, la MMU, la flash y la PSRAM. El código corre desde SRAM1.
  • Las radios WiFi y Bluetooth, en todas sus formas. El WiFi al que llega un sketch es la red simulada de la sección 3.10.
  • El RTC, sus memorias, los coprocesadores ULP, el sueño profundo y la unidad de gestión de energía.
  • ADC2, el controlador ADC digital, el DMA, los eFuse de calibración, el sensor de temperatura y el sensor táctil.
  • Los temporizadores de los grupos de temporizadores, el watchdog del RTC y el watchdog de interrupciones (los watchdogs de los grupos de temporizadores son los de la sección 3.11).
  • UART1 y UART2, los controladores de I2C y SPI, I2S, el controlador de cámara y LCD, TWAI, el host de SD, el contador de pulsos, el PWM de motor, el controlador USB OTG, GDMA y los aceleradores criptográficos. Los Wire y SPI del runtime son por software en pines ordinarios (SDA 8 y SCL 9, SCK 12, MISO 13, MOSI 11 y SS 10, los valores predeterminados del núcleo Arduino para esta placa), igual que en cualquier otra placa de aquí, porque ningún modelo de placa de aquí tiene esos controladores.
  • Los canales de recepción del RMT y el resto de la lista de la sección 3.8, y el hardware de fundido del LEDC.
  • La matriz de interrupciones más allá de cuatro fuentes, y todo nivel de interrupción de CPU por arriba de uno.

Por eso los binarios de ESP-IDF del fabricante y de Arduino-core no funcionan aquí, y sí el firmware compilado para este documento.

Las imágenes de las tres placas Xtensa no son intercambiables. Las cadenas de program del catálogo difieren (elf32 xtensa lx7 esp32s3 aquí, elf32 xtensa lx6 esp32 en el DevKit clásico, elf32 xtensa lx106 esp8266 en el NodeMCU), y la diferencia es real: una imagen para el ESP32 clásico ejecuta las mismas instrucciones pero se carga en direcciones que este chip no tiene, así que el cargador la rechaza.

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

Un entorno de ejecución con forma de Arduino: setup() y loop(), pinMode, digitalWrite, digitalRead, shiftOut, analogRead (con analogReadResolution, analogSetAttenuation y analogSetPinAttenuation), analogWrite y la familia ledcAttach/ledcWrite/ledcRead, rgbLedWrite y neopixelWrite, millis, micros, micros64, delay, delayMicroseconds, attachInterrupt, Serial, USBSerial, map, random. Sin núcleo de Arduino, sin ESP-IDF, sin libc. WiFi.h, HTTPClient.h y WebServer.h son el entorno de red simulada compartida de docs/wifi.md.

LED_BUILTIN and RGB_BUILTIN are the Arduino core's number for the RGB LED: the GPIO count plus the LED's pin, 49 + 48. digitalWrite(LED_BUILTIN, HIGH) sends the LED one WS2812 frame, white at RGB_BRIGHTNESS (64 of 255), and LOW sends black, which is what the Arduino core does. rgbLedWrite(pin, r, g, b) takes the GPIO number or RGB_BUILTIN. Both use RMT channel 0 at 100 ns a tick: a 0 is 400 ns high and 800 ns low, a 1 is 800 ns high and 400 ns low, both inside the WS2812B datasheet's windows, with the carrier switched off. The core has no BOOT_BUTTON: the BOOT button is GPIO 0, so sketches use 0. A0 to A9 are GPIO 1 to 10.

mokxi_init, antes de los constructores estáticos, activa las compuertas de reloj de LEDC y RMT, cambia UART0 al reloj APB a 115200 y enruta la fuente de interrupción de GPIO. Toda escritura que cambia una salida de LEDC termina con su bit de actualización.

Serial es UART0. USBSerial es el puerto USB Serial/JTAG: los bytes entran en su búfer de 64 bytes y el driver escribe WR_DONE en cada salto de línea y en flush(), esperando a que el búfer se libere en lugar de perder un byte.

crt0.S y support64.c son los del ESP32 clásico, compilados de nuevo para esta placa en vez de copiados: los manejadores de ventanas, la tabla de vectores y la entrada de excepciones son del ISA y no del chip. Otros seis archivos son los del ESP32-C3, como en el ESP32 clásico.

Compilado con el GCC de Espressif para el S3. deploy/fetch-xtensa.sh esp32s3 coloca xtensa-esp32s3-elf-gcc 8.4.0 (esp-2021r2-patch5) en tools/xtensa/, que está en gitignore. GCC es GPL, y nada de lo que compila aquí se enlaza contra libgcc ni ninguna otra parte del toolchain (el entorno de ejecución es -nostdlib con su propio código de soporte), así que ningún código GPL llega a un ELF distribuido. docs/compile.md tiene el relato completo.

Enlazado contra firmware/esp32s3/link.ld: .text en la dirección de bus de instrucciones de SRAM1, las secciones de datos en la dirección de bus de datos del primer byte después de esta, la pila en la parte alta de SRAM2. La compilación rechaza una imagen con más de 64 KB cargables, y elfcheck.py rechaza una cuyo código y datos compartirían RAM.

Once ejemplos, cada uno con un sketch que la interfaz muestra: blink (el LED RGB en blanco y un LED cableado en GPIO2), rainbow (el LED RGB recorriendo la rueda de color), button (un interruptor a tierra en GPIO21 con la pull-up del propio pad, encendiendo el LED en GPIO2), serial (un tic por segundo en UART0, y un eco), usbserial (lo mismo en el puerto USB), fade (un LED en GPIO2 por LEDC, ocho bits a 1 kHz), knob (un potenciómetro en GPIO4, canal 3 de ADC1, atenuando el LED en GPIO2 con la lectura cruda impresa), y los cuatro ejemplos de WiFi: wificonnect, wifiweather, wifiapi y wifilamp.

crates/esp32s3/tests/runtime.rs arranca esos ELF y mide: el medio periodo de blink a no más de 5 ms de 500, las tramas WS2812 en GPIO48 decodificadas y cada bit con su tiempo en alto y en bajo dentro de las ventanas de la hoja de datos, los colores que rainbow envía en orden verde primero, el periodo de LEDC a no más de 5 us de 1 ms, millis() a no más de 60 ms del reloj del kernel a lo largo de cinco segundos, ningún par de bytes de UART0 más cerca que un tiempo de byte a 115200, y una línea USB que llega como un solo paquete. crates/esp32s3/tests/wifi.rs ejecuta los ejemplos de WiFi contra la red simulada. Cada prueba se omite sola cuando las imágenes no están compiladas.