Referencia

Contrato de la placa ESP32-C6 (Fase 9)

La DevKitC-1: treinta y un GPIO, una ventana de SRAM y un relato claro de lo que no está modelado.

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

La ESP32-C6-DevKitC-1 es la segunda placa RISC-V aquí. Un componente del kernel (esp32c6 en crates/parts) envuelve un modelo del SoC ESP32-C6 (crates/esp32c6) en el mismo hart que la C3 (crates/rv32-core). El núcleo se comparte; el chip que lo rodea, no. Este documento es el contrato, y prevalece sobre cualquier comentario en el código.

El tipo de catálogo es esp32c6. Donde una sección dice "como docs/esp32c3.md", ese documento es el contrato para esa parte.

Lee primero la sección 7 si vas a llevar una compilación de aquí a silicio real. Este modelo es más pequeño que la C6, y más de lo habitual está marcado como "creído, no verificado": la sección 7 indica cuáles son esas direcciones y qué falta por completo. Aquí nada se supone en silencio. La sección 3.6, los offsets de registros del ADC SAR, es el único bloque cuyo diseño está en esa lista.

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

Vista superior, los dos conectores USB-C abajo, el módulo ESP32-C6-WROOM-1 y su antena PCB arriba. La placa mide 52.5 x 25.4 mm y sus dos headers de 15 pines están a 22.86 mm (exactamente 0.9 pulgadas) de distancia, así que cabalga el canal central de una protoboard.

El orden es el de la guía de usuario de la ESP32-C6-DevKitC-1 de Espressif, "Header Block", J1 y J3 (placa v1.2). Cada header tiene un decimosexto agujero, NC, que no se lista.

Header izquierdo (J1), de arriba abajo (15 agujeros): 3V3, RST, 4, 5, 6, 7, 0, 1, 8, 10, 11, 2, 3, 5V, GND.

Header derecho (J3), de arriba abajo (15 agujeros): GNDb, TX, RX, 15, 23, 22, 21, 20, 19, 18, 9, GNDd, 13, 12, GNDc.

Luego 14, que no está en ningún header de la placa real (ver abajo).

31 pines. TX y RX son GPIO 16 y 17: la serigrafía los nombra por su función porque son la UART de consola. Los nombres duplicados llevan una letra porque los nombres de pin del catálogo son únicos.

Until late October 2026 the drawing had J3 as GNDb, TX, RX, 9, 12, 13, 14, 21, 20, 19, 18, 15, 23, 22, GNDc and the bottom of J1 as GND, 5V. A diagram saved then is read with the part's header setting at early and keeps that drawing (web/src/parts/header-layout.ts); the catalog keeps GPIO 14's pin for it. On the real order (header: board, the default) the editor draws no 14, and a wire to it is left out of the circuit. The model does not read the setting.

El chip tiene GPIO 0 a 30. GPIO 24 en adelante son la flash SPI en este paquete y no están en ningún header.

Dos pines de la placa no están en ningún header:

  • GPIO 8 tiene un LED RGB direccionable soldado. Un poke no llega a él y el componente de la placa no lo decodifica: una WS2812 es un protocolo, no un nivel. Conecta el componente ws2812 al GPIO 8 y se enciende con los colores que envía el sketch, que es lo que hace el ejemplo rainbow.
  • GPIO 9 es el botón BOOT, activo en bajo. También está en el header derecho, así que se puede conectar; el poke lo lleva a tierra en la placa.

Eléctrico: como la sección 1 de docs/esp32c3.md. Cada GPIO maneja push-pull a 3.3 V a través de R_STRONG, queda en alta impedancia, o tira hacia arriba o hacia abajo a través de 45 k. Una entrada lee alto a 1.65 V; una red en conflicto (Unknown) lee 0, y una flotante lee ruido, como en el Uno (docs/uno.md sección 1). GPIO9 lee alto cuando nada lo mantiene, por la pull-up de la placa junto al botón BOOT. 3V3 maneja 3.3 V a R_SUPPLY, 5V maneja 5 V, las tres tierras manejan 0 V. RST lleva una pull-up de 10 k a 3.3 V, y llevarlo por debajo de 1.65 V mantiene el núcleo en reset.

El orden exacto de la serigrafía de los dos headers es la interpretación de este modelo del pinout de la DevKitC-1. Los números de GPIO son los del chip y son de los que depende el firmware; su posición en el header es de la que depende un diagrama. Si las filas de la placa real están ordenadas de otra forma, un circuito dibujado aquí necesitaría recablearse en el escritorio, y nada más cambiaría.

2. Mapa de memoria

SRAM HP 512 KB en 0x4080_0000 a 0x4087_FFFF
Flash (code and constants) 0x4200_0000, read-only, up to 1,310,720 bytes
tope de la pila 0x4088_0000
UART0 0x6000_0000, sección 3.3
LEDC 0x6000_7000, sección 3.7
SYSTIMER 0x6000_A000, sección 3.4
APB_SARADC 0x6000_E000, sección 3.6 (se cree que los offsets internos son correctos)
IO_MUX 0x6009_0000, sección 3.2
GPIO 0x6009_1000, sección 3.1

Every base address in this table is the ESP32-C6 Technical Reference Manual v1.2, table 5.3-2. An earlier version of this model put APB_SARADC at 0x6000_F000, which that table gives to the USB Serial/JTAG controller.

Flash. A real ESP32-C6 runs almost all of a sketch from flash through the cache, code and const data alike at 0x4200_0000, and the Arduino IDE's default partition ("Default 4MB with spiffs") gives the sketch 1,310,720 bytes of it. That is the room a sketch has here, counted as the IDE counts it (code, constants, startup code and the initial values of the variables), and the number the editor prints after a build. firmware/c6/link.ld keeps the startup code and the trap entry in the HP SRAM and puts every other function and every constant in the flash window, with the variables and the stack in the SRAM from the end of the startup code up. The window is a read-only view of the loaded image, not a cache: no misses, no timing (a fetch from flash costs what one from SRAM costs), and a store to it faults.

Una sola ventana. Es lo primero que difiere de la C3, donde los mismos 400 KB de RAM aparecen dos veces (en 0x4037_C000 para el bus de instrucciones y 0x3FC7_C000 para el bus de datos), y cada acceso tiene que probar ambos. Aquí ambos buses llegan a la SRAM HP en las mismas direcciones, así que una dirección de carga es una dirección de ejecución, .data no necesita copia al reiniciar, y el bus es una sola verificación de rango en lugar de dos.

Cada segmento PT_LOAD debe caer dentro de ese rango; cualquier otra cosa se rechaza con la dirección infractora en el mensaje, y el chip queda sin programa.

3. Registros de periféricos

Solo se implementa el subconjunto de abajo. Cualquier otra cosa dentro de un bloque mapeado de 4 KB lee 0 y cuenta como acceso errante; cualquier cosa fuera de todo bloque es un fallo de acceso.

3.1 GPIO (0x6009_1000)

offset registro
0x04 GPIO_OUT_REG
0x08 GPIO_OUT_W1TS_REG
0x0C GPIO_OUT_W1TC_REG
0x20 GPIO_ENABLE_REG
0x24 GPIO_ENABLE_W1TS_REG
0x28 GPIO_ENABLE_W1TC_REG
0x3C GPIO_IN_REG
0x44 GPIO_STATUS_REG
0x4C GPIO_STATUS_W1TC_REG
0x74 + 4n GPIO_PINn_REG
0x554 + 4n GPIO_FUNCn_OUT_SEL_CFG_REG

Existen los bits 0 a 30; el bit 31 se enmascara en una escritura. El bit 2 PAD_DRIVER de GPIO_PINn_REG pone el pad en drenaje abierto, y los bits 7..9 INT_TYPE eligen qué dispara la interrupción del pin: 0 apagado, 1 flanco de subida, 2 flanco de bajada, 3 cualquier flanco, 4 nivel bajo, 5 nivel alto. GPIO_FUNCn_OUT_SEL_CFG_REG en 128 hace que el pad siga a GPIO_OUT; de 45 a 50 lo entregan a los canales de baja velocidad 0 a 5 de LEDC (sección 3.7, y esos seis índices no están verificados); cualquier otro valor selecciona un periférico que no está modelado, y el modelo lo trata como 128 en lugar de inventar un nivel. Un pad que está manejando un canal de LEDC aún necesita su controlador de salida activado en GPIO_ENABLE_REG.

3.2 IO_MUX (0x6009_0000)

IO_MUX_GPIOn_REG en 0x04 + 4n. Bit 7 FUN_WPD, bit 8 FUN_WPU, bit 9 FUN_IE, bits 12..14 MCU_SEL, de los cuales 1 es GPIO simple. Un pad solo llega a GPIO_IN_REG con su búfer de entrada habilitado, que es lo que hace el hardware. Cada pin arranca en FUN_IE | (1 << 12), así que un programa que solo escriba GPIO_ENABLE y GPIO_OUT se comporta igual en todos los pines.

3.3 UART0 (0x6000_0000)

The C3's offsets, as docs/esp32c3.md section 3.3 gives them: UART_FIFO_REG 0x00, UART_INT_RAW_REG 0x04, UART_INT_ST_REG 0x08, UART_INT_ENA_REG 0x0C, UART_INT_CLR_REG 0x10, UART_CLKDIV_REG 0x14, UART_STATUS_REG 0x1C, UART_CONF0_REG 0x20, UART_CONF1_REG 0x24 (the ESP32-C6 Technical Reference Manual v1.2, section 27 register summary). Two 128-byte FIFOs, and bytes leave the transmit FIFO at the baud rate rather than instantly.

Pero los bits no son los del C3. Verificado contra el mismo manual:

  • UART_CONF0_REG (el UART_CONF0_SYNC_REG del manual, registro 27.9): el bit 22 RXFIFO_RST y el bit 23 TXFIFO_RST vacían los FIFO. Una versión anterior de este modelo usaba los bits 17 y 18 del C3, que en el C6 son otros campos. En el silicio una escritura a un registro _SYNC surte efecto cuando se pone UART_REG_UPDATE (0x98); el modelo lo aplica de inmediato.
  • UART_CONF1_REG (registro 27.10): bits 0..7 RXFIFO_FULL_THRHD y bits 8..15 TXFIFO_EMPTY_THRHD, ambos con reinicio a 96. Una versión anterior de este modelo tenía campos de nueve bits en 0 y 9.
  • UART_STATUS_REG (registro 27.21): bits 0..7 RXFIFO_CNT y bits 16..23 TXFIFO_CNT. El entorno de ejecución los lee con máscaras de ocho bits, como los da el manual. En algún momento leía diez, lo que devolvía los mismos números porque los dos bits sobre cada campo están reservados y leen 0; el header ahora coincide con el manual.

El divisor (bits 0..11 de UART_CLKDIV_REG, con los dieciseisavos en CLKDIV_FRAG, bits 20..23) divide el reloj del núcleo del UART, que en el C6 se elige en PCR y no en el UART: bits 20..21 UART0_SCLK_SEL de PCR_UART0_SCLK_CONF_REG (0x6009_6004, el único registro de PCR modelado) (1 el PLL_F80M_CLK de 80 MHz, 3 el cristal de 40 MHz; 2, RC_FAST, se toma como el cristal) y bits 12..19 UART0_SCLK_DIV_NUM, un preescalador de DIV_NUM + 1. Tras el reinicio eso es el cristal, sin dividir, y UART_CLKDIV se reinicia a 347, que son 115 274 baudios. El entorno de ejecución programa una velocidad como lo hace uart_ll_set_baudrate de ESP-IDF (PLL_F80M, el preescalador más pequeño que deja el divisor por debajo de 4096, y luego UART_REG_UPDATE), así que 1200 y 9600 baudios son exactos en vez de quedarse limitados a un divisor de 4095.

3.4 SYSTIMER (0x6000_A000)

Unit 0 and comparator 0. SYSTIMER_UNIT0_OP_REG 0x04, SYSTIMER_UNIT0_VALUE_HI_REG 0x40, ..._LO_REG 0x44, SYSTIMER_TARGET0_HI_REG 0x1C, ..._LO_REG 0x20, SYSTIMER_TARGET0_CONF_REG 0x34, SYSTIMER_COMP0_LOAD_REG 0x50, SYSTIMER_INT_ENA_REG 0x64, ..._RAW_REG 0x68, ..._CLR_REG 0x6C, ..._ST_REG 0x70. Verified against the ESP32-C6 Technical Reference Manual v1.2, section 13 register summary and registers 13.14 to 13.17. An earlier version of this model put comparator 0 at 0x50 to 0x5C, which on the C6 are the load strobes; the runtime's images were rebuilt when that was corrected.

El contador es un conteo de ticks de 52 bits a 16 MHz derivado del tiempo simulado en lugar de contado, así que nunca se desfasa del resto del circuito. Leerlo es fijar y luego leer: pon UPDATE, espera VALUE_VALID, lee HI y luego LO. Tanto el modo de disparo único como el de período funcionan.

3.5 Interrupciones

Como la sección 3.5 de docs/esp32c3.md. La matriz de interrupciones del C6 no está modelada: GPIO y UART0 comparten la interrupción externa de máquina, mcause 11, y el manejador lee los dos registros de estado para averiguar cuál se disparó; el comparador del SYSTIMER es la interrupción de temporizador de máquina, mcause 7. mstatus.MIE, mie.MTIE y mie.MEIE funcionan; mtvec opera en modo directo.

3.6 APB_SARADC (0x6000_E000)

ADC1 en modo de disparo único, registro por registro como lo describe la sección 3.5 de docs/esp32c3.md: la ruta que toman el controlador adc_oneshot de ESP-IDF y el analogRead del núcleo de Arduino, y nada más. Lo que cambia aquí es la asignación de pines (siete canales, 0 a 6, que en este encapsulado son GPIO 0 a GPIO 6) y la dirección base del bloque.

La dirección base es la del manual (tabla 5.3-2); una versión anterior de este modelo tenía 0x6000_F000, que es el controlador USB Serial/JTAG. Cada desplazamiento de registro de esta sección está sin verificar: son los del C3, que es la distribución de la familia, no una página del manual de referencia técnica del C6 citada textualmente. Un programa que deba ejecutarse en un DevKitC-1 real debería verificarlos primero.

offset nombre bits
0x00 APB_SARADC_CTRL_REG bits 7..14 SAR_CLK_DIV. Se guarda y se lee de vuelta; el tiempo de conversión aquí es fijo
0x04 APB_SARADC_CTRL2_REG se guarda, se lee de vuelta. Las rutas de disparo por temporizador y de DMA no están modeladas
0x0C APB_SARADC_FSM_WAIT_REG se guarda, se lee de vuelta
0x38 APB_SARADC_ONETIME_SAMPLE_REG bits 23..24 ONETIME_ATTEN, bits 25..28 ONETIME_CHANNEL, bit 29 ONETIME_START, bit 30 SAR2_ONETIME_SAMPLE (se guarda, no convierte nada), bit 31 SAR1_ONETIME_SAMPLE
0x44 APB_SARADC_1_DATA_STATUS_REG bits 0..16 ADC1_DATA: la última conversión del ADC1, de doce bits
0x64 APB_SARADC_INT_ENA_REG se guarda; ninguna línea llega al núcleo
0x68 APB_SARADC_INT_RAW_REG bit 31 ADC1_DONE
0x6C APB_SARADC_INT_ST_REG sin máscara y habilitado
0x70 APB_SARADC_INT_CLR_REG escribe 1 para limpiar, el mismo bit
0x78 APB_SARADC_APB_ADC_CLKM_CONF_REG se guarda, se lee de vuelta

Una conversión: escribe ONETIME_SAMPLE con SAR1_ONETIME_SAMPLE, el canal y la atenuación, vuelve a escribirlo con ONETIME_START en alto, espera ADC1_DONE en INT_RAW, lee el registro de datos, limpia la bandera y baja ONETIME_START. Una conversión toma 5 us fijos de tiempo simulado, que el firmware realmente sí espera.

El resultado es de doce bits, round(4095 x Vin / Vfull), acotado, del voltaje de la red en el momento en que empezó la conversión, y ONETIME_ATTEN elige la escala completa según las cifras nominales de la hoja de datos: 0 dB es 1.1 V, 2.5 dB 1.5 V, 6 dB 2.2 V y 11 dB 3.3 V. Un divisor a la mitad del riel de 3.3 V por lo tanto lee alrededor de 2048 a 11 dB. Esa línea recta es correcta para este chip, a diferencia del ESP32 clásico, el S3 y el C3, que se saturan antes de llegar al riel con su atenuación más amplia: la hoja de datos del C6 y las mediciones del propio Espressif le dan un rango útil de 0 a 3300 mV a 12 dB. Un canal sin nada en su pin se mueve erráticamente, como lo hace una entrada flotante (docs/uno.md sección 1).

Faltan el ADC2, la tabla de patrones DMA, el controlador digital, los filtros y monitores de umbral, las eFuses de calibración y el canal interno de temperatura, y ADC1_DONE nunca llega a mip.

3.7 LEDC (0x6000_7000)

El controlador LED PWM, grupo de baja velocidad, que es el único grupo que tiene este chip: cuatro temporizadores y seis canales. Este es el bloque detrás de analogWrite, ledcAttach y ledcWrite. Los bloques de canal y temporizador están donde están los del C3, pero el LEDC del C6 no es registro por registro el del C3: el campo de resolución del temporizador es de cinco bits y llega hasta veinte, HPOINT y DUTY son más anchos, y los registros globales se movieron.

Un temporizador cuenta 2^DUTY_RES cuentas a 80 MHz dividido entre CLK_DIV, un número Q10.8 de relojes de 80 MHz por cuenta, así que f = 80e6 / ((CLK_DIV / 256) * 2^DUTY_RES) y 5 kHz a ocho bits es DUTY_RES 8 con CLK_DIV 16000, exactamente. Un canal elige un temporizador, una cuenta de inicio HPOINT y un ciclo útil, y su salida está en alto desde HPOINT durante DUTY >> 4 cuentas, dando la vuelta al tope del período. Un ciclo útil de 0 es un bajo continuo y un ciclo útil de 2^DUTY_RES un alto continuo, sin ningún flanco.

Verified: the base address (table 5.3-2) and every offset and bit in the table below, against the ESP32-C6 Technical Reference Manual v1.2, section 35.4 (register summary) and registers 35.1, 35.2, 35.8 to 35.14 and 35.23. An earlier version of this model used the C3's LEDC_CONF_REG at 0xD0 and LEDC_DATE_REG at 0xFC, the C3's fourteen-bit HPOINT, nineteen-bit DUTY and fourteen-bit resolution limit, and wrote LEDC_SCLK_SEL = 1, which on the C6 selects RC_FAST_CLK rather than the 80 MHz PLL clock. The C6's event-task, compare, capture and gamma-RAM registers (0x100 to 0x1CC) are not modeled.

offset nombre 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 (se guarda; un ciclo útil escrito aquí surte efecto de inmediato)
0x04 + 0x14n LEDC_CHn_HPOINT_REG bits 0..19 HPOINT: la cuenta en la que empieza el pulso del canal
0x08 + 0x14n LEDC_CHn_DUTY_REG bits 0..24 DUTY: el ancho del pulso en dieciseisavos de cuenta
0x0C + 0x14n LEDC_CHn_CONF1_REG bit 31 DUTY_START, el disparador del fundido de ciclo útil: se guarda, se lee de vuelta y no funde nada
0x10 + 0x14n LEDC_CHn_DUTY_R_REG el ciclo útil tal como está, solo lectura
0xA0 + 8n LEDC_TIMERn_CONF_REG bits 0..4 DUTY_RES (1 a 20; 0 es un temporizador que nadie ha configurado y no cuenta nada), bits 5..22 CLK_DIV, bit 23 PAUSE, bit 24 RST, bit 26 PARA_UP (guardado); el bit 25 está reservado
0xA4 + 8n LEDC_TIMERn_VALUE_REG el contador, solo lectura
0xC0 LEDC_INT_RAW_REG bit n = el temporizador n se desbordó
0xC4 LEDC_INT_ST_REG sin máscara y habilitado
0xC8 LEDC_INT_ENA_REG se guarda; ninguna línea llega al núcleo
0xCC LEDC_INT_CLR_REG escribe 1 para limpiar
0x1F0 LEDC_CONF_REG bits 0..1 SCLK_SEL (0 = el PLL_F80M_CLK de 80 MHz, la única fuente modelada; 1 RC_FAST_CLK, 2 XTAL_CLK; guardado), bits 2..7 las compuertas de reloj de la gamma-RAM (guardadas), bit 31 CLK_EN (guardado)
0x1FC LEDC_DATE_REG un sello de versión, solo lectura: 0x0211_1150

Un canal llega a un pad a través de la matriz GPIO: pon el del pad GPIO_ENABLE y apunta su GPIO_FUNCn_OUT_SEL_CFG_REG en 45 + channel. Esos índices de señal, 45 a 50 para ledc_ls_sig_out0 a ledc_ls_sig_out5, también están sin verificar. Section 3.1's OUT_SEL of 128 still means the pad follows GPIO_OUT, y cualquier valor que no sea ni 128 ni un canal LEDC se trata como 128 en lugar de inventarse.

El contador no avanza paso a paso: es una función de forma cerrada del tiempo simulado y lo mismo pasa con el tiempo de su próximo flanco, así que un núcleo estacionado en wfi no cuesta nada mientras corre un PWM, y la placa se despierta para los flancos y para nada más.

No modelado: el grupo de alta velocidad (este chip no tiene), el hardware de fundido de ciclo útil y gamma, las fuentes de reloj distintas del reloj PLL de 80 MHz, y la línea de interrupción del LEDC hacia la matriz de interrupciones: LEDC_INT_RAW_REG se puede consultar y limpiar pero nunca llega a mip.

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

Este bloque no es el del ESP32-C6. Toda otra dirección en este documento es del chip, creída o citada como lo dispone la sección 7, y una imagen compilada contra él es una imagen para una DevKitC-1. Este es propio de Mokxi: la red simulada de crates/net, mapeada en una dirección que la pieza real deja sin mapear (los periféricos del C6 están en la parte baja de la ventana 0x6000_xxxx y en 0x6009_xxxx, y nada responde en la parte alta), para que una imagen que la use falle en el silicio en lugar de leer el registro de otro periférico. Esa falla es la respuesta honesta, porque lo que está detrás de este bloque no existe en el chip. Es la misma dirección que usa el ESP32-C3, porque ambas piezas dejan vacío el mismo lugar.

Aquí no hay radio, ni 802.11, ni internet real. Nada en el modelo transmite, escanea, asocia, cifra o abre un socket: una contraseña se compara como cadena, un nombre que no esté bajo .mokxi no se resuelve, y los tres 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 vez de una ficción sobre una MAC: en un ESP32 real el hardware de WiFi es 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.9 Los watchdog de los grupos de temporizadores, los resets y el monitor de pila (0x6000_8000, 0x6000_9000, 0x600B_0400, 0x600B_1000, 0x600C_2000)

As the C3's (docs/esp32c3.md section 3.9), with the C6's addresses: the timer groups at 0x6000_8000 and 0x6000_9000, always on the 40 MHz crystal (their clock select is in PCR, of which only UART0's clock register is modeled), the reset cause in LP_CLKRST_RESET_CAUSE_REG, the store registers LP_AON_STORE0..9, LP_AON_HPSYS_SW_RESET and LP_AON_CPU_CORE0_SW_RESET for the software resets, and ASSIST_DEBUG at 0x600C_2000.

El runtime ejecuta el perro guardián de tareas de ESP-IDF sobre el perro guardián del grupo de temporizadores 0, como lo hace ESP-IDF (firmware/src/main.cpp): tics de 500 µs, etapa 0 una interrupción al agotarse el tiempo y etapa 1 un reinicio del sistema al doble, iniciado antes de setup() a 5 s con un pánico, vigilando la tarea idle del núcleo 0. 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 perro guardián del grupo de temporizadores 1 está modelado igual y nada en el runtime lo arma: el perro guardián de interrupciones no se simula.

4. Canal del host

host_write pone bytes en el FIFO de recepción del UART0; host_read toma los bytes que salieron de su FIFO de transmisión. Eso es Serial en un sketch y el monitor serie en la interfaz. Los bytes son UTF-8 hasta donde importa a la interfaz y opacos para el modelo.

Una DevKitC-1 tiene dos conectores USB-C: uno hacia un puente USB a UART, que es este canal, y uno hacia el USB propio del chip, que no está modelado en absoluto.

5. Modelo de tiempo

Como la sección 5 de docs/esp32c3.md. El núcleo HP corre a 160 MHz, una instrucción por ciclo, así que una instrucción dura exactamente 6250 ps y una porción de 10 us son exactamente 1600 instrucciones. Dentro de una porción el conteo de instrucciones es el reloj: una lectura del SYSTIMER, un byte del UART y un cambio de pin caen todos en la instrucción que los causó.

probe es 1 mientras corre el firmware, 0.5 estacionado en wfi, 0 detenido (sin programa, en reset o caído).

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

6. Entorno de ejecución del firmware (firmware/c6/)

Un runtime con forma de Arduino derivado del del C3: setup() y loop(), pinMode, digitalWrite, digitalRead, analogRead (con analogReadResolution, analogSetAttenuation y analogSetPinAttenuation), analogWrite y el par ledcAttach/ledcWrite, millis, micros, delay, delayMicroseconds, attachInterrupt, Serial. Sin núcleo de Arduino, sin ESP-IDF, sin libc.

analogRead es ADC1 de una sola lectura en GPIO 0 a GPIO 6 (sección 3.6), doce bits a 11 dB por defecto, así que firmware/lib/mokxi_joystick.h compila y funciona aquí igual que en la C3. analogWrite(pin, 0..255) es de ocho bits a 1 kHz en cualquier GPIO y adjunta un canal LEDC libre la primera vez que se llama; ledcAttach(pin, frequency, bits) es lo que un sketch necesita cuando la frecuencia importa, y los canales que piden la misma frecuencia y resolución comparten uno de los cuatro temporizadores.

Compilado con clang --target=riscv32-unknown-elf -march=rv32imc -mabi=ilp32, enlazado contra firmware/c6/link.ld. Tres de los archivos del runtime son los de la C3, compilados de nuevo para esta placa en lugar de copiados: el formato de números, las funciones matemáticas y el floor independiente, además de Print y main. Los propios de esta placa son el header de registros, la cantidad de pines, el código de arranque, el script del enlazador y los controladores de GPIO, ADC, PWM, tiempo, UART e interrupciones.

La cadena program del catálogo es elf32 riscv32imc esp32c6. Difiere de la de la C3 porque el ELF realmente lo hace: mismo conjunto de instrucciones, distinto mapa de memoria, y una imagen enlazada para una no funcionará en la otra.

LED_BUILTIN es 8, que en esta placa es el LED RGB direccionable. Ponerlo en alto y en bajo sigue haciendo lo útil en una protoboard; el ejemplo rainbow es para lo que el pin está pensado de verdad.

Seis ejemplos: blink, button (el botón BOOT en GPIO 9), serial, fade (un LED en GPIO 10 respirando con PWM por hardware), stick (un KY-023 en los canales 0 y 1 de ADC1, con el brillo de dos LEDs saliendo de vuelta por LEDC) y rainbow (una rueda de tonos bit-bang hacia el LED RGB y siete más en GPIO 8). Un ejemplo tiene un presupuesto de 16 KB.

7. Lo que este modelo sabe con certeza, y lo que no

Tres grupos. Esta sección existe porque un modelo de placa que adivina silenciosamente una dirección es peor que uno que dice que no lo sabía.

Taken from the technical reference manual. Every base address in section 2 (the ESP32-C6 Technical Reference Manual v1.2, table 5.3-2): UART0_BASE = 0x6000_0000, LEDC_BASE = 0x6000_7000, SYSTIMER_BASE = 0x6000_A000, APB_SARADC_BASE = 0x6000_E000, IOMUX_BASE = 0x6009_0000 and GPIO_BASE = 0x6009_1000. Every register offset inside the UART, GPIO and IO_MUX blocks. The UART's FIFO-reset bits and CONF1 thresholds (registers 27.9 and 27.10), the SYSTIMER comparator (chapter 13) and every LEDC register in section 3.7 (chapter 35), all checked against that manual while the ESP32-S3 was being added; the C6 differs from the C3 in each of them, and each was wrong here before that check and has been corrected, with the runtime's images rebuilt. The GPIO range, 0 to 30. The HP SRAM's 512 KB at 0x4080_0000, and the fact that it is one window rather than two. The RGB LED on GPIO 8 and the BOOT button on GPIO 9. ADC1's channel map: channel n is GPIO n for n in 0 to 6.

Believed, not verified. The register offsets inside APB_SARADC, which are the C3's (section 3.6), and the GPIO matrix signal indices 45 to 50 for ledc_ls_sig_out0 to ledc_ls_sig_out5. Both are named in one place, firmware/c6/include/esp32c6.h, so an image being taken to real silicon has a short list of #defines to check. Firmware built here agrees with the model whether or not it agrees with silicon.

Ausentes a propósito. Cada uno se omitió en lugar de inventarse, porque su disposición de registros no es algo que este modelo pueda reproducir con honestidad:

  • Los temporizadores de los grupos de temporizadores (TIMG0 y TIMG1). Sus watchdogs son los de la sección 3.9. El tiempo aquí viene de SYSTIMER, que es suficiente para millis, micros y un delay en espera.
  • RMT, que es lo que normalmente manejaría el LED RGB. El ejemplo rainbow lo hace con bit-bang en su lugar, y no es un atajo: es la única manera aquí.
  • El núcleo LP y sus periféricos, incluidos LP_UART y LP_I2C. El dominio de baja potencia de la C6 es la mitad de lo que hace interesante al componente y nada de eso está aquí.
  • La matriz de interrupciones, el enrutado con forma de PLIC que decide qué periférico llega a qué mcause. La sección 3.5 dice qué ocupa su lugar.
  • ADC2, el DMA y el controlador digital del SAR ADC, sus filtros y monitores de umbral y sus eFuses de calibración. La sección 3.6 es ADC1 de una sola lectura y nada más.
  • El hardware de duty-fade del LEDC y su línea de interrupción: la sección 3.7 son los temporizadores, los canales y la salida, y LEDC_INT_RAW_REG se consulta por sondeo en lugar de entregarse.
  • La PMU y el árbol de relojes, la caché, la ROM, la flash, SPI, I2C, I2S, USB Serial/JTAG, WiFi 6, Bluetooth LE y 802.15.4.

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