Esta é a referência de engenharia do modelo: o que ele implementa, registrador por registrador, para quem escreve firmware para ele. Para usar a placa no editor, comece por A ESP32-S3-DevKitC-1 e página da placa.
A ESP32-S3-DevKitC-1 é a própria placa da Espressif para o ESP32-S3: um módulo ESP32-S3-WROOM-1, dois núcleos Xtensa LX7 a 240 MHz, dois soquetes micro-USB e um LED RGB endereçável. Um componente do kernel (esp32s3 em crates/parts) envolve um modelo de SoC ESP32-S3 (crates/esp32s3) no mesmo interpretador Xtensa que o ESP32 clássico e o ESP8266 usam (crates/xtensa-core). Este documento é o contrato, e ele prevalece sobre qualquer comentário no código.
O tipo no catálogo é esp32s3. A string program do catálogo é elf32 xtensa lx7 esp32s3.
Leia a seção 6 primeiro se você vai levar uma versão daqui para o silício real. Diferentemente do contrato do ESP32 clássico, quase todo número aqui foi verificado contra uma página do ESP32-S3 Technical Reference Manual (versão 1.8), do ESP32-S3 Series Datasheet e do guia do usuário e do desenho de dimensões da DevKitC-1 da Espressif. A seção 6 lista os poucos que não foram, e tudo o que não é modelado de forma alguma: o segundo núcleo, a extensão de vetores, o cache, a flash, a PSRAM e os dois rádios, entre outros.
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. Pinos da placa (ordem do catálogo)
Vista de cima, os dois soquetes micro-USB embaixo, o módulo WROOM-1 e sua antena em cima. O desenho de dimensões da Espressif dá a placa como 62,74 x 25,40 mm com cada fileira de header a 1,27 mm da borda, então os dois headers de 22 pinos ficam a 22,86 mm (0,9 polegada) de distância e a placa encaixa numa protoboard deixando uma fileira de furos livre de cada lado. O visual a desenha nesse tamanho.
J1, o conector esquerdo, pino 1 no topo (22 furos): 3V3, 3V3b, RST, 4, 5, 6, 7, 15, 16, 17, 18, 8, 3, 46, 9, 10, 11, 12, 13, 14, 5V, G.
J3, o conector direito, pino 1 no topo (22 furos): Gb, TX, RX, 1, 2, 42, 41, 40, 39, 38, 37, 36, 35, 0, 45, 48, 47, 21, 20, 19, Gc, Gd.
44 pinos. Um número é a GPIO n. TX e RX são as GPIO43 e GPIO44, UART0. RST é o chip enable. 5V é o trilho de 5 V do USB. G é o terra. Nomes duplicados ganham uma letra, porque os nomes de pinos do catálogo são únicos; a serigrafia não a imprime.
Verificado: a ordem de ambos os conectores, pino por pino, contra as tabelas J1 e J3 do guia do usuário (os guias v1.0 e v1.1 dão a mesma ordem), e a posição das fileiras contra o desenho de dimensões.
GPIO 26 a 32 não estão em nenhum dos conectores. Eles são a flash SPI. GPIO 22 a 25 não existem no componente de jeito nenhum (a tabela de funções do IO MUX não tem linha para eles). GPIO 33 e 34 também não estão no conector. crates/parts/src/parts/esp32s3.rs tem um teste que cobre tudo isso.
GPIO 35, 36 e 37 estão no conector e, nas variantes com PSRAM octal (o DevKitC-1-N8R8 que a maioria compra), eles pertencem à PSRAM e não devem ser usados. Este modelo não tem PSRAM, então aqui eles são pinos comuns, e a nota do guia do usuário está repetida na página de ajuda.
GPIO 19 e 20 são o USB D- e D+ do chip, aos quais o soquete "USB" da placa está ligado. Aqui eles continuam sendo pads comuns e a porta USB serial continua funcionando mesmo quando um sketch os aciona, o que uma placa real não faria (seção 3.4).
Coisas na 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
revisionproperty picks which,1.0or1.1, and defaults to1.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 é o GPIO0, ativo em nível baixo; clicar nele na placa liga o pino ao terra. Ele também está no J3 como
0. - RST reseta o chip.
- Um LED vermelho de alimentação de 3,3 V, desenhado aceso, porque a placa aqui está sempre no USB.
Elétrico: cada GPIO aciona push-pull a 3,3 V através de R_STRONG, fica em alta impedância, ou faz pull-up ou pull-down através de 45 k. Uma entrada lê nível alto a 1,65 V (metade da alimentação de E/S); um nó em disputa (Desconhecido) lê 0, e um nó flutuante lê ruído, como no Uno (docs/uno.md seção 1). GPIO0 lê nível alto quando nada o segura, por causa do pull-up da placa ao lado do botão BOOT. 3V3 fornece 3,3 V através de R_SUPPLY, 5V fornece 5 V, G fornece 0 V. RST tem um pull-up de 10 k para 3,3 V e puxá-lo abaixo de 1,65 V mantém o núcleo em reset. O capacitor ao lado desse resistor, o reset de energização da placa, não é modelado.
2. Mapa de memória
| SRAM1, barramento de instruções | 416 KB em 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 e SRAM2, barramento de dados | 480 KB em 0x3FC8_8000 a 0x3FCF_FFFF |
| topo da pilha | 0x3FD0_0000 |
| UART0 | 0x6000_0000, seção 3.3 |
| matriz de GPIO | 0x6000_4000, seção 3.1 |
| SENS | 0x6000_8800, seção 3.6 |
| IO MUX | 0x6000_9000, seção 3.2 |
| RMT | 0x6001_6000, seção 3.8 |
| LEDC | 0x6001_9000, seção 3.7 |
| SYSTIMER | 0x6002_3000, seção 3.5 |
| USB Serial/JTAG | 0x6003_8000, seção 3.4 |
| SYSTEM | 0x600C_0000, seção 3.9 |
| Matriz de interrupções | 0x600C_2000, seção 3.9 |
Cada bloco de periférico tem 4 KB aqui, exceto o SENS, que são os 2 KB superiores do bloco de gerenciamento de baixa energia.
Verificado: cada endereço da tabela, contra as tabelas 4.3-1 (memória interna) e 4.3-3 (periféricos) do manual. SENS é "o endereço base do Low Power Management + 0x800" no resumo de registradores 39.6.2 do manual.
Uma SRAM, duas janelas, e o modelo tem as duas. O manual diz que a SRAM1 é "endereçada pela CPU através do barramento de dados ou do barramento de instruções na mesma ordem": o byte em 0x4037_8000 + n é o byte em 0x3FC8_8000 + n. O modelo mantém um buffer só para a janela de dados e mapeia a janela de instruções sobre seus primeiros 416 KB, então um programa pode ler o próprio código pelo barramento de dados e receber os bytes certos, algo que o modelo do ESP32 clássico não consegue oferecer. A SRAM2 está só no barramento de dados, logo depois da SRAM1. firmware/esp32s3/link.ld coloca o código no endereço de instruções e começa as seções de dados no endereço do barramento de dados do primeiro byte depois do código, então os dois nunca dividem a RAM, e elfcheck.py recusa uma imagem em que isso aconteceria.
A SRAM0, os 32 KB em 0x4037_0000 que o cache de instruções pode ocupar, não é modelada; um acesso a ela é uma falha.
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.
O núcleo reseta com o pc no ponto de entrada do ELF e todo registrador de endereço em zero. Não há boot ROM aqui: o carregador de primeiro estágio, as leituras de flash, a árvore de clock e a configuração do cache estão todos ausentes, e o runtime deixa explícito o estado que quer.
3. Registradores de periféricos
Apenas o subconjunto abaixo está implementado. Qualquer outra coisa dentro de um bloco mapeado lê 0 e conta como acesso perdido; qualquer coisa fora de todos os blocos é uma falha de acesso.
3.1 Matriz de GPIO (0x6000_4000)
Os números de GPIO vão de 0 a 48, então todo registrador com um bit por pino vem em duas metades: a simples cobre GPIO 0 a 31 e a com 1 cobre GPIO 32 a 48 em seus dezessete bits baixos.
| offset | registrador |
|---|---|
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, armazenado |
0x554 + 4n |
GPIO_FUNCn_OUT_SEL_CFG_REG |
As formas W1TS dos registradores de status, GPIO_CPU_INT_REG/GPIO_CPU_INT1_REG (lidas como o status), GPIO_BT_SELECT_REG, GPIO_SDIO_SELECT_REG e GPIO_CLOCK_GATE_REG também recebem resposta.
Verificado: a base e cada offset, contra o resumo de registradores 6.14.
GPIO_PINn_REG (registrador 6.18): o bit 2 PAD_DRIVER torna o pad open drain; os bits 7..9 INT_TYPE escolhem o que levanta a interrupção do pino (0 desligado, 1 borda de subida, 2 borda de descida, 3 qualquer borda, 4 nível baixo, 5 nível alto); o bit 13 é a habilitação de interrupção da 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 lê 0x08: bit 3 (GPIO0) alto, bits 2, 4 e 5 (GPIO46, GPIO45, GPIO3) baixos, o que é um boot comum a partir da flash de 3,3 V. A atribuição dos bits é a do registrador 6.15; o valor aqui é uma constante, não uma captura do que os pinos fizeram no reset.
3.2 IO MUX (0x6000_9000)
IO_MUX_PIN_CTRL_REG em 0x00, depois um registrador por GPIO em 0x04 + 4n. Ao contrário do ESP32 clássico, o IO MUX do S3 está em ordem de GPIO. Bit 7 FUN_WPD, bit 8 FUN_WPU, bit 9 FUN_IE, bits 10..11 FUN_DRV (armazenado), bits 12..14 MCU_SEL. Um pad só chega a GPIO_IN_REG com seu buffer de entrada habilitado.
Verificado: a base, os offsets e os bits, contra o registrador 6.36; a tabela de funções e os valores de reset contra a tabela 6.12-1.
MCU_SEL escolhe uma de até cinco funções. A função 1 é a matriz de GPIO em todos os pinos. Na maioria dos pinos a função 0 também é a matriz de GPIO, mas nos pinos 26 a 32 é a flash, nos 39 a 42 os pinos JTAG, nos 43 e 44 a UART0 e nos 47 e 48 o par de clock da flash, então um programa que queira um desses como GPIO precisa definir MCU_SEL como 1. O pinMode do runtime sempre faz isso. O LED RGB no GPIO48 é um deles: até que algo defina seu MCU_SEL, nada que um programa escreva na matriz chega a esse pad.
Cada pad inicia no valor de reset do manual. Coluna "RST" da tabela 6.12-1: GPIO0 e os pinos de flash com seus pull-ups, GPIO45 e GPIO46 com seus pull-downs, a maioria dos pinos apenas com o buffer de entrada ligado, e os GPIO 4 a 8, 15, 16 e 19 a 21 sem nem isso, então digitalRead em um desses lê 0 até o buffer ser ligado. MTCK, GPIO39, inicia com pull-up, que é o que a tabela diz para um componente cujos pads JTAG não foram desativados por eFuse. GPIO43, U0TXD, inicia com a saída habilitada na UART; a forma de onda da UART em si não é modelada (seção 3.3), então esse pad mantém o nível alto de repouso da linha até um programa assumi-lo.
3.3 UART0 (0x6000_0000)
| offset | registrador |
|---|---|
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: a base e todos os offsets (resumo de registradores 26.6) e os bits abaixo.
Duas FIFOs de 128 bytes. Os bits 0..9 de UART_STATUS_REG são RXFIFO_CNT e os bits 16..25 são TXFIFO_CNT. O bit 17 de UART_CONF0_REG, RXFIFO_RST, e o bit 18, TXFIFO_RST, as esvaziam (registrador 26.9; no modelo do ESP32 clássico esses dois estão invertidos, seção 6). UART_CONF1_REG guarda os dois limiares de FIFO, dez bits cada, 96 no reset. Os bits 0..11 de UART_CLKDIV_REG são a parte inteira do divisor e os bits 20..23 os dezesseis avos, 694 no reset.
O divisor divide o clock do núcleo da UART, que os bits 20..21 de UART_CLK_CONF_REG, SCLK_SEL, escolhem: 1 o clock APB de 80 MHz, 3 o cristal de 40 MHz, e o cristal é o valor de reset (registrador 26.18). O 2, o oscilador RC_FAST, não é modelado e é tratado como o cristal. SCLK_DIV_NUM (bits 12..19) divide o clock do núcleo por SCLK_DIV_NUM + 1, o que se acredita: o manual chama o campo de "parte integral do divisor de frequência" e imprime o divisor sem o um, e no reset o campo é 1. O runtime define SCLK_SEL como 1 e SCLK_DIV_NUM como 0, e então 694 dá 115 274 baud. As partes fracionárias SCLK_DIV_A/SCLK_DIV_B não são modeladas.
Os bytes saem da FIFO de transmissão na taxa de baud, não instantaneamente, então uma porta a 115 200 baud carrega 11 520 bytes por segundo aqui como numa bancada; crates/esp32s3/tests/runtime.rs verifica que nenhum par de bytes do exemplo serial está mais perto do que o tempo de um byte.
UART1 e UART2 não são modeladas. A forma de onda do pino U0TXD também não é modelada: os bytes são o canal do host, não bits no GPIO43.
3.4 USB Serial/JTAG (0x6003_8000)
A metade serial do controlador: a porta CDC-ACM que o soquete "USB" da placa carrega, que um sketch alcança como USBSerial.
| offset | registrador |
|---|---|
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, armazenado |
Verificado: a base, os offsets (resumo de registradores 33.5) e os bits: EP1_CONF bit 0 WR_DONE, bit 1 SERIAL_IN_EP_DATA_FREE, bit 2 SERIAL_OUT_EP_DATA_AVAIL (registrador 33.2); INT_* bit 2 SERIAL_OUT_RECV_PKT_INT e bit 3 SERIAL_IN_EMPTY_INT, que está definido no reset (registrador 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.
A temporização é própria deste modelo. O manual diz que o host "verificará periodicamente". Aqui o host sempre tem um terminal aberto e coleta um pacote descarregado assim que ele poderia atravessar um barramento de 12 Mbit/s: o pacote mais treze bytes de token, handshake e enquadramento, então 51.3 us para 64 bytes. Um host real adiciona até um quadro (1 ms) de agendamento; isso não é modelado.
Não modelado: a metade JTAG, a enumeração, as interrupções de erro de barramento, os pedidos de reset e modo de download por RTS/DTR, e a suspensão. O host está sempre conectado.
3.5 SYSTIMER (0x6002_3000)
Unidade 0: o contador de 52 bits por trás de micros() e millis().
| offset | registrador |
|---|---|
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: a base, os offsets (resumo de registradores 11.5), os bits (CONF bit 30 TIMER_UNIT0_WORK_EN, definido no reset; OP bit 30 UPDATE, bit 29 VALUE_VALID) e o clock de contagem de 16 MHz ("XTAL_CLK/2.5, que é 16 MHz", seção 11.4).
Ler é travar-e-ler: escreva UPDATE, espere VALUE_VALID, leia VALUE_HI e VALUE_LO. O contador não é contado: ele é o tempo simulado dividido por 62.5 ns, mais o que um load tenha posto lá, então não há nada contra o que ele possa derivar. A unidade 1, os três comparadores e seus alarmes não são modelados; o tick do runtime é o próprio CCOMPARE0 do núcleo (seção 4).
3.6 SENS: ADC1, uma conversão (0x6000_8800)
A conversão iniciada por software do controlador RTC ADC1.
| offset | registrador | bits |
|---|---|---|
0x00 |
SENS_SAR_READER1_CTRL_REG |
armazenado |
0x0C |
SENS_SAR_MEAS1_CTRL2_REG |
bits 0..15 MEAS1_DATA_SAR (somente leitura), bit 16 MEAS1_DONE_SAR, bit 17 MEAS1_START_SAR, bit 18 MEAS1_START_FORCE, bits 19..30 SAR1_EN_PAD (um 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: a base, os três offsets e todos os bits, contra os registradores 39.10 a 39.13.
Uma conversão: ponha a atenuação em ATTEN1, defina START_FORCE e EN_PAD_FORCE, ponha o bit do canal em SAR1_EN_PAD, levante MEAS1_START_SAR, espere MEAS1_DONE_SAR, leia o dado. Uma conversão leva 5 us fixos de tempo simulado, valor próprio do modelo.
Dez canais, e o canal n é o GPIO n + 1: ADC1_CH0 é o GPIO1 e ADC1_CH9 GPIO10 (as tabelas de pinos do guia do usuário, pino por pino).
O resultado são doze bits da tensão do nó no momento em que a conversão começou. Em ATTEN0 para ATTEN2 é round(4095 x Vin / Vtop), com corte, onde Vtop é o topo da "faixa efetiva de medição" do datasheet: 850 mV, 1100 mV e 1600 mV. ATTEN3 (12 dB), a atenuação de reset e o padrão do core do Arduino, segue a curva bruta de um componente típico (CURVE_ATTEN3 em crates/esp32s3/src/adc.rs): quase linear a partir de 0 V, curvando a partir de cerca de 2750 mV (onde as próprias medições da Espressif mostram o S3 perder linearidade) além da faixa efetiva de 2900 mV, e saturando em 4095 a partir de cerca de 3.1 V. Assim um potenciômetro ligado ao trilho de 3.3 V atinge 4095 um pouco antes do fim do curso, e metade do trilho (1.65 V) lê cerca de 2220. A calibração de eFuse de uma unidade move isso alguns por cento, o que não é modelado. analogReadMilliVolts inverte a mesma curva. Um canal sem nada no seu pino oscila, como faz uma entrada flutuante (docs/uno.md seção 1).
O ADC2, o controlador digital, o DMA, os eFuses de calibração e o sensor de temperatura estão ausentes.
3.7 LEDC (0x6001_9000)
Oito canais e quatro temporizadores, todos de uma única classe de velocidade: o LEDC inteiro do S3.
| offset | registrador | 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 (somente escrita) |
0x04 + 0x14n |
LEDC_CHn_HPOINT_REG |
bits 0..13 HPOINT |
0x08 + 0x14n |
LEDC_CHn_DUTY_REG |
bits 0..18 o duty em dezesseis avos de um contador |
0x0C + 0x14n |
LEDC_CHn_CONF1_REG |
o hardware de fade: armazenado, não faz nenhum fade |
0x10 + 0x14n |
LEDC_CHn_DUTY_R_REG |
o duty em vigor, somente leitura |
0xA0 + 8n |
LEDC_TIMERn_CONF_REG |
bits 0..3 DUTY_RES, bits 4..21 CLK_DIV (Q10.8), bit 22 PAUSE, bit 23 RST (definido no reset), bit 25 PARA_UP (somente escrita) |
0xA4 + 8n |
LEDC_TIMERn_VALUE_REG |
o contador |
0xC0 |
LEDC_INT_RAW_REG |
bit n = o timer n fez overflow |
0xC4 |
LEDC_INT_ST_REG |
|
0xC8 |
LEDC_INT_ENA_REG |
armazenado; nenhuma linha chega ao core |
0xCC |
LEDC_INT_CLR_REG |
|
0xD0 |
LEDC_CONF_REG |
bits 0..1 APB_CLK_SEL (1, o clock APB, é a única fonte modelada), bit 31 CLK_EN |
0xFC |
LEDC_DATE_REG |
lê 0x1907_2601 |
Verificado: a base, cada offset e cada bit da tabela (resumo de registradores 35.4 e registradores 35.1 a 35.13). Isso é uma mudança real em relação ao modelo do ESP32 clássico, cujo layout de LEDC é presumido.
Um temporizador conta 2^DUTY_RES contagens a 80 MHz dividido por CLK_DIV: f = 80e6 / ((CLK_DIV / 256) * 2^DUTY_RES). A saída de um canal fica alta a partir de HPOINT por DUTY >> 4 contagens.
Nada entra em vigor sem o bit de atualização correspondente. O CLK_DIV e o DUTY_RES de um timer esperam por TIMERn_PARA_UP, e o HPOINT, SIG_OUT_EN, TIMER_SEL e o duty de um canal esperam por PARA_UP_CHn (as listas nos registradores 35.1 e 35.7). O modelo mantém separado o que foi escrito do que está em vigor, então um firmware que esquece um bit de atualização não gera PWM, como numa bancada real. PAUSE, RST e IDLE_LV agem imediatamente. O duty está listado em DUTY_START; o modelo o carrega em PARA_UP_CHn, esteja DUTY_START definido ou não, o que se acredita ser o que uma simples mudança de duty faz com o hardware de fade em repouso.
Um canal alcança um pad pela matriz GPIO em OUT_SEL 73 + n (seção 3.1). O contador é uma função fechada do tempo simulado, então um núcleo parado em waiti não custa nada enquanto um PWM roda; runtime.rs mede o período do exemplo fade contra os 1 ms de 1 kHz dentro de 5 us.
O clock do LEDC está desligado no reset (seção 3.9): até SYSTEM_LEDC_CLK_EN ser definido, o bloco não responde.
Não modelado: o hardware de duty-fade, o contador de overflow, fontes de clock que não a APB e a linha do LEDC para a matriz de interrupções.
3.8 RMT (0x6001_6000)
Os quatro canais de transmissão do periférico de controle remoto: o que aciona o LED RGB.
| offset | registrador | bits |
|---|---|---|
0x00 + 4n |
RMT_CHnDATA_REG |
escrita: empurra uma palavra para a RAM do canal n pelo FIFO da 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 o endereço de leitura, bits 11..20 o endereço de escrita da APB, bits 22..24 o 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 baixo, bits 16..31 alto, 0x40 cada no reset |
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 |
lê 0x0210_1181 |
0x800 a 0xDFF |
a RAM | 384 palavras |
Os registradores dos canais de recepção (0x30 a 0x4C, 0x60 a 0x6C, 0x90 a 0x9C, 0xB0 a 0xBC) são armazenados, lidos de volta e não recebem nada.
Verificado: a base, cada offset e bit da tabela (resumo de registradores 37.5, registradores 37.1 a 37.19), o tamanho da RAM e seu início NONFIFO em "endereço base do RMT + 0x800", o formato do código de pulso (período nos bits 0..14 e 16..30, nível nos bits 15 e 31, "o valor mínimo para o período é zero e é interpretado como um marcador de fim de transmissão"), o clock do canal (rmt_sclk dividido por DIV_CNT, "o valor 0 representa o divisor 256", e rmt_sclk a fonte dividida por SCLK_DIV_NUM + 1 + A/B), os valores de reset (carrier ligado, MEM_SIZE 1, DIV_CNT 2) e a lista de campos que esperam por CONF_UPDATE (tabela 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.
O que uma transmissão faz, da seção 37.3.4: TX_START envia a partir do início do bloco do canal, cada código mantendo seu nível por period pulsos do clock do canal; em um marcador de fim o canal para, levanta TX_END e mantém o nível do marcador de fim, ou IDLE_OUT_LV se IDLE_OUT_EN estiver definido; chegar ao fim de seus blocos de MEM_SIZE sem um marcador de fim o para com MEM_EMPTY e ERR, a menos que o modo wrap o mande de volta, caso em que TX_THR_EVENT sobe cada vez que mais TX_LIM palavras passarem; o modo contínuo recomeça a cada marcador de fim, contando loops quando solicitado. TX_STOP para de imediato.
Atualização de configuração. DIV_CNT, IDLE_OUT_EN, IDLE_OUT_LV, TX_CONTI_MODE, TX_STOP, os campos do carrier e os três campos de TX_LIM só entram em vigor em CONF_UPDATE (tabela 37.3-1); o modelo os mantém separados até lá. MEM_SIZE, o modo wrap e TX_START agem de imediato.
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.
A saída é uma função fechada do tempo entre fronteiras de código, então cada borda cai no seu picossegundo e um núcleo parado não custa nada enquanto um quadro sai. runtime.rs decodifica os quadros dos exemplos blink e rainbow no GPIO48 e verifica cada tempo alto e baixo contra as janelas do datasheet do WS2812B.
O clock do RMT está desligado no reset (seção 3.9).
Não modelado: os canais de recepção, DMA no canal 3, início simultâneo, propriedade e energia da RAM e as regras de período mínimo (fórmulas 37.1 e 37.3).
3.9 SYSTEM (0x600C_0000) e a matriz de interrupção (0x600C_2000)
| offset | registrador |
|---|---|
0x10 |
SYSTEM_CPU_PER_CONF_REG, armazenado |
0x18 |
SYSTEM_PERIP_CLK_EN0_REG |
0x1C |
SYSTEM_PERIP_CLK_EN1_REG, armazenado |
0x20 |
SYSTEM_PERIP_RST_EN0_REG |
0x24 |
SYSTEM_PERIP_RST_EN1_REG, armazenado |
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.
A matriz de interrupção: o registrador de mapeamento da fonte n para o core 0 está em 0x600C_2000 + 4n, e seus cinco bits baixos nomeiam a interrupção de CPU que a fonte gera. Verificado contra a tabela 9.3-1 e o resumo de registradores 9.4, assim como os quatro números de fonte que este modelo roteia:
| fonte | número |
|---|---|
GPIO_INTERRUPT_CPU |
16 |
UART_INTR |
27 |
RMT_INTR |
40 |
USB_DEVICE_INT |
96 |
Uma fonte mapeada para uma das interrupções internas do core (6, 7, 11, 15, 16 ou 29) não alcança nada, que é como o manual diz para desabilitar uma fonte (seção 9.3.3.3). Todos os outros registradores de mapeamento são armazenados, lidos de volta e não roteiam nada.
3.10 Mailbox de rede do Mokxi (0x6FFF_E000)
Este bloco não é do ESP32-S3. Todos os outros endereços neste documento são do chip. Este é do próprio Mokxi: a rede simulada de crates/net, num endereço que o S3 deixa sem mapear. O manual coloca os periféricos em "0x6000_0000~0x600D_0FFF" e a memória RTC FAST termina em 0x600F_FFFF, então uma imagem que use este bloco falha no silício em vez de ler o registrador de outro periférico. Essa falha é a resposta honesta, porque a coisa por trás deste bloco não existe no chip. É o mesmo endereço que os modelos do ESP32-C3 e do C6 usam, porque os três chips deixam a mesma lacuna.
O bloco não levanta nenhuma interrupção. Todas as outras fontes daqui chegam ao core pela matriz de interrupção da seção 3.9, e um número de fonte da matriz é do chip; não há um número honesto para dar a um periférico que o chip não tem, então o mailbox não recebe nenhum. NET_INT_RAW_REG ainda pode ser lido, o firmware faz polling, e um core parado em waiti ainda é acordado quando a rede tem algo a dizer, do mesmo jeito que é acordado por uma borda de PWM.
Aqui não há rádio, nem 802.11, nem internet de verdade. Nada no modelo transmite, escaneia, associa, criptografa ou abre um socket: uma senha é comparada como string, um nome que não esteja sob .mokxi não resolve, e as origens que a rede serve são funções em crates/net/src/http.rs. O mailbox tem a forma da costura real em vez de uma ficção sobre um MAC: num ESP32-S3 de verdade o hardware de WiFi fica atrás de um blob binário fechado com uma interface de comandos, e o WiFi.h do Arduino acaba do outro lado de um destes. docs/wifi.md é o contrato do que está atrás dele; esta seção é só os registradores.
Um registrador de comando, um registrador de status, um anel de 4096 bytes em cada sentido e um bit de interrupção. Escrever em NET_CMD_REG executa o comando; um comando que leva tempo simulado levanta BUSY e o limpa, com DONE em NET_INT_RAW_REG, quando termina.
| offset | nome | bits |
|---|---|---|
0x00 |
NET_ID_REG |
lê 0x494B4F4D, e nada mais o faz. Um sketch que quer saber se está no Mokxi lê isto; no silício o acesso falha |
0x04 |
NET_CMD_REG |
escreva um código de comando (tabela abaixo); a escrita o executa |
0x08 |
NET_ARG_REG |
uma palavra de argumento, lida de volta: a porta para LISTEN, o status 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 |
o que o último comando respondeu |
0x14 |
NET_INT_RAW_REG |
bit 0 DONE, bit 1 EVENT |
0x18 |
NET_INT_ENA_REG |
os mesmos dois bits |
0x1C |
NET_INT_CLR_REG |
escreva 1 para limpar, os mesmos dois bits |
0x20 |
NET_TX_LEN_REG |
bytes preparados no anel de saída |
0x24 |
NET_TX_DATA_REG |
escrita: empurra um byte (bits 0..7) para o anel de saída |
0x28 |
NET_RX_LEN_REG |
bytes aguardando no anel de entrada |
0x2C |
NET_RX_DATA_REG |
leitura: retira um byte do anel de entrada, 0 quando está vazio |
0x30 |
NET_RING_LEN_REG |
capacidade de cada anel em bytes, para o firmware não precisar fixar 4096 |
0x40 |
NET_BT_CMD_REG |
Bluetooth: escreva um código de comando Bluetooth (docs/bluetooth.md); a escrita o executa |
0x44 |
NET_BT_ARG_REG |
Bluetooth: uma palavra de argumento, lida de volta; um evento deixa seu número aqui |
0x48 |
NET_BT_RESULT_REG |
Bluetooth: o que o último comando Bluetooth respondeu |
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 no seu próprio anel de saída |
0x54 |
NET_BT_TX_DATA_REG |
Bluetooth: escrita: empurra um byte para esse anel |
0x58 |
NET_BT_RX_LEN_REG |
Bluetooth: bytes aguardando no seu próprio anel de entrada |
0x5C |
NET_BT_RX_DATA_REG |
Bluetooth: leitura: retira um byte, 0 quando está vazio |
Os oito registradores NET_BT_ são a metade Bluetooth do bloco, com anéis próprios: só Bluetooth LE, como no chip real, então os comandos do Classic setam BT_ERR. Também não há rádio por trás deles; docs/bluetooth.md é o contrato deles.
STATE é onde está a estação: 0 ociosa, 1 iniciando, 2 conectando, 3 conectada, 4 falhou, 5 rede inexistente. NET_CMD_STATUS transforma a mesma coisa no código wl_status_t do Arduino que um sketch lê de WiFi.status().
NET_CMD_REG |
nome | o que faz |
|---|---|---|
| 0 | NOP |
nada |
| 1 | RESET |
desconecta, zera ambos os anéis, descarta qualquer requisição |
| 2 | CONNECT |
o anel de saída contém ssid\0password; levanta BUSY por um a três segundos |
| 3 | DISCONNECT |
descarta a associação e o endereço |
| 4 | STATUS |
NET_RESULT_REG = o código wl_status_t |
| 5 | IP |
NET_RESULT_REG = o endereço obtido, primeiro octeto no byte menos significativo |
| 6 | RSSI |
NET_RESULT_REG = o sinal em dBm, com sinal estendido |
| 7 | SSID |
o anel de entrada recebe o nome do ponto de acesso |
| 8 | MAC |
o anel de entrada recebe os seis bytes de MAC da placa |
| 9 | REQUEST |
o anel de saída contém method\0url\0headers\0body; levanta BUSY |
| 10 | POLL |
NET_RESULT_REG = 0 em andamento, depois o status HTTP, ou um erro negativo com ERR ativo; o corpo chega no anel de entrada |
| 11 | LISTEN |
escuta na porta em NET_ARG_REG |
| 12 | ACCEPT |
NET_RESULT_REG = 1 e o anel de entrada contém method\0path\0query\0body, ou 0 quando nada está aguardando |
| 13 | REPLY |
responde à requisição aceita com o status em NET_ARG_REG; o anel de saída contém content-type\0body |
| 14 | STOP |
para de escutar |
| 15 | WL_GPIO_SET |
controla os próprios GPIOs do componente sem fio a partir de NET_ARG_REG. Não nesta placa: o rádio deste componente não tem esse pino, então ele define ERR e não controla nada. É o caminho que o LED embutido de um Pico W percorre (docs/picow.md seção 3.8) |
| 16 | WL_GPIO_GET |
lê de volta, e o mesmo ERR aqui |
| 17 | BLYNK |
uma operação no servidor Blynk simulado, a operação em NET_ARG_REG e seus campos no anel de saída; respondida de imediato em NET_RESULT_REG, com ERR ativo, sem passar pela rede (docs/wifi.md, "Blynk") |
| 19 | ETH |
Ethernet com fio (firmware/include/ETH.h), a operação em NET_ARG_REG: 1 levanta o enlace por um cabo simulado, sem SSID e sem senha, conectado 1,5 s depois com o mesmo lease; 2 coloca 1 em NET_RESULT_REG quando o enlace é (ou foi por último) o com fio. Há um único enlace: STATUS, IP e toda requisição o leem de que forma ele tenha subido |
| 20 | SOFTAP |
o soft AP (crates/net/src/softap.rs, docs/wifi.md), a operação em NET_ARG_REG: 1 o levanta (o anel de saída ssid\0password\0 e o byte de canal; NET_RESULT_REG 1, ou 0 com ERR para um nome vazio ou uma senha de um a sete caracteres), 2 o derruba, 3 o configura (endereço, gateway e máscara de rede, quatro bytes cada), 4 seu endereço (0 enquanto estiver derrubado), 5 as estações conectadas, 6 as entradas, saídas e o bit de ativo que o runtime transforma em eventos, 7 e 8 um servidor DNS de portal cativo iniciando (o nome, um byte zero, o endereço) e parando, 9 seu nome no anel de entrada, 10 o endereço do telefone, 11 o Host da requisição sendo servida no anel de entrada. A única estação é o telefone do painel Web |
Os códigos negativos de POLL: -1 o nome não resolve, -2 a estação não está associada, -3 https:// e o TLS não são simulados, -4 um corpo maior que o anel, -5 uma URL que esta rede não consegue interpretar, -6 já há uma requisição em andamento. firmware/include/HTTPClient.h os transforma nos códigos no formato Arduino que um sketch compara, e docs/wifi.md lista o mapeamento.
Temporização, toda ela própria deste modelo e toda declarada em docs/wifi.md: uma associação leva entre um e três segundos, decidida a partir do SSID para que uma aula leve o mesmo tempo nas duas vezes; uma senha errada vira WL_CONNECT_FAILED após cinco segundos; uma requisição a uma origem simulada volta 60 ms depois; uma requisição ao próprio servidor do sketch que o sketch nunca responde é fechada pela rede com um 504 após dez segundos.
3.11 Watchdogs dos grupos de timer, resets do RTC_CNTL e o monitor de pilha
Como no C3 (docs/esp32c3.md seção 3.9), com o layout do S3: sem WDT_CONF_UPDATE_EN (uma escrita tem efeito imediato), o bit de interrupção do watchdog é o bit 2, ele chega ao core pela matriz de interrupção (fontes 52 e 55; o runtime mapeia 52 para a interrupção 17 da CPU), os registradores de armazenamento estão em 0x50..0x5C e 0xC0..0xCC, e o SP_MIN do ASSIST_DEBUG fica um registrador além (0x3C). O monitor de pilha checa ENTRY, onde código em janelas move a pilha a cada chamada; uma falha contra limites que desde então se alargaram é repetida em vez de relatada.
O runtime executa o watchdog de tarefas do ESP-IDF sobre o watchdog do grupo de timers 0, como o ESP-IDF faz (firmware/src/main.cpp): ticks de 500 µs, estágio 0 uma interrupção no timeout e estágio 1 um reset do sistema no dobro dele, iniciado antes de setup() em 5 s com um panic, observando a tarefa de idle do núcleo 0. O sketch roda no núcleo 1, cuja tarefa de idle não é observada a menos que ele peça (enableCore1WDT()), então um loop que nunca cede a execução continua rodando, como na placa. A interrupção imprime as linhas do ESP-IDF ("E (…) task_wdt: Task watchdog got triggered. …", as tarefas, "Aborting.", a linha de abort e "Rebooting..."), deixa a dica ESP_RST_TASK_WDT do ESP-IDF no registrador de armazenamento do RTC e reseta a CPU pelo reset de software, então esp_reset_reason() diz 6 depois. esp_task_wdt_*, enableLoopWDT() e enable/disableCore0WDT() atuam sobre ele. O watchdog do grupo de timers 1 é modelado da mesma forma e nada no runtime o arma: o watchdog de interrupção não é simulado.
4. O core: o LX7, qual ABI, e como uma interrupção chega
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 tudo o que o compilador emite, o LX7 daqui é o LX6. Os cabeçalhos de configuração das duas toolchains (core-isa.h em xtensa-esp32-elf e xtensa-esp32s3-elf) concordam em todas as opções inteiras que decidem qual código um compilador emite: sessenta e quatro registradores de endereço e a janela de registradores, o loop sem overhead, a multiplicação de 32 bits e sua metade alta, o divisor, MIN/MAX, SEXT, CLAMPS, S32C1I, MAC16, os booleanos e a FPU de precisão simples. E a evidência é mais forte que os cabeçalhos: crates/xtensa-core/tests/programs.rs guarda a compilação feita pelo compilador do S3 do programa de teste que o compilador do ESP32 clássico também compilou, e as duas saíram byte a byte idênticas. Então o S3 roda a ABI windowed, exatamente como o ESP32 clássico, com ENTRY, RETW, ROTW, MOVSP, L32E/S32E e as exceções de janela pelos seus próprios vetores (docs/esp32.md seção 4 tem a tabela de vetores, e ela é da ISA, não do chip).
O que o LX7 acrescenta neste chip é a extensão de vetores do S3, as instruções EE.* para trabalho de IA e DSP, que o assembler codifica no espaço op0 = 4 que o LX6 dá ao MAC16. Nenhum dos dois é modelado, e ambos falham como instruções ilegais (crates/xtensa-core/tests/encoding.rs guarda duas codificações do assembler do S3). O GCC não as emite a partir de C comum.
Interrupções. INTENABLE faz a máscara; PS.INTLEVEL faz o gate. Apenas o nível 1 é modelado. No S3, as interrupções de nível 1 são 0 a 10, 12, 13, 17 e 18, máscara 0x0006_37FF, e 19 a 21 são nível 2: verificado contra a tabela 9.3-2 do manual. Os três comparadores CCOMPARE geram as interrupções de CPU 6, 15 e 16, da mesma tabela. O runtime direciona o GPIO para a interrupção de CPU 13, uma interrupção de periférico de nível 1, e tira seu tick de atraso do CCOMPARE0 na interrupção de CPU 6.
PRID lê 0xCDCD, como no modelo clássico: acreditado. O que importa é que o bit 13 está zerado, que é como o software distingue o core 0 do core 1.
O resto é a seção 4 do ESP32 clássico sem mudanças: CCOUNT é a contagem de ciclos; um WSR num CCOMPARE o arma e limpa sua interrupção; "atingiu ou passou" em vez de "igual"; um prazo já passado não é armado; MOVSP nunca levanta Alloca; e a FPU de precisão simples roda, como no ESP32 clássico (docs/esp32.md seção 4), então um float compilado por firmware/esp32s3/build.sh chega à resposta certa. Um sketch compilado no navegador ainda é soft float (-Xclang -target-feature -Xclang -fp, chamadas em mokxi_float.c).
5. Modelo de tempo, probe, poke e o canal do host
A CPU roda a 240 MHz, uma instrução por ciclo. O tempo é recalculado a partir da contagem de ciclos, então uma fatia de 2400 instruções tem exatamente 10 us. Dentro de uma fatia, a contagem de instruções é o relógio: uma leitura de timer, um byte serial, uma mudança de pino e uma borda de RMT caem todas na instrução que as causou. Um núcleo estacionado em WAITI não custa nada: a placa pede para ser acordada no mais cedo entre o próximo prazo de CCOMPARE, a próxima borda de LEDC ou RMT, um byte serial e a rede, e uma mudança de pino ou um byte do host também a acorda. Uma leitura de GPIO_IN_REG depois que uma escrita moveu um pad na mesma fatia encerra a fatia antes da leitura, de modo que ela vê o que o circuito fez da escrita, exatamente como no ESP32 clássico (docs/esp32.md seção 5). delayMicroseconds() abaixo de 50 us conta CCOUNT e nunca é mais curto do que o pedido.
probe é uma máscara de bits com a cor do LED dentro:
| bits | significado |
|---|---|
| 0 | rodando |
| 1 | estacionado em waiti, ou parado pelo depurador |
| 2..19 | a cor do LED RGB como ele registrou o último quadro, seis bits por canal: vermelho em 14..19, verde em 8..13, azul em 2..7 |
O LED é decodificado pelo componente da placa a partir das bordas que o SoC informa no pad do LED (GPIO48, ou GPIO38 na v1.1), com as janelas do componente ws2812: um pulso alto abaixo de 125 ns é um glitch, até 600 ns é um 0, até 950 ns é um 1, qualquer coisa mais longa quebra o quadro, um nível baixo mais curto do que o bit permite também quebra, e 50 us de nível baixo registram os primeiros 24 bits, verde primeiro. O LED mantém sua cor através de um reset do chip, como um WS2812 faz, porque é alimentado pela placa. Os dois bits baixos da cor de cada canal não cabem em uma ponta de prova e são descartados.
poke: 1 mantém BOOT (GPIO0 em nível baixo), 0 libera; 2 mantém RST, 3 solta.
O canal do host carrega as duas portas seriais da placa. Um DevKitC-1 real tem dois soquetes: "UART", através de uma ponte USB para UART, até a UART0, e "USB", o próprio controlador USB Serial/JTAG do chip. Aqui o monitor serial está ligado às duas ao mesmo tempo: host_read devolve os bytes que saíram da UART0 e os bytes que a porta USB entregou, na ordem em que chegaram, e host_write coloca o que é digitado tanto na FIFO de recepção da UART0 quanto na fila do host da porta USB. A ponte em si não é modelada, e o auto-reset via DTR e RTS tampouco.
Travamento. 1000 traps consecutivos sem progresso e o núcleo é declarado travado e parado, com o local onde morreu registrado e informado no canal do host.
6. Do que este modelo tem certeza, e do que não tem
Verificado contra o manual, o datasheet ou o guia do usuário
As janelas de memória (tabela 4.3-1) e a base de cada periférico (tabela 4.3-3). Cada offset de registrador e cada bit citado na seção 3, bloco por bloco: GPIO (6.14 a 6.20), IO MUX (6.36 e tabela 6.12-1, incluindo o valor de reset de cada pad e a função 1 sendo GPIO em cada pino), UART0 (26.6 a 26.19), USB Serial/JTAG (33.2 a 33.9 e o comportamento em 33.3.3), SYSTIMER (11.1 a 11.5 e o clock de 16 MHz), SENS (39.10 a 39.13), LEDC (35.1 a 35.13 e as listas de PARA_UP), RMT (37.1 a 37.19, o tamanho da RAM, o formato do código de pulso, a fórmula do clock e a tabela 37.3-1), SYSTEM (17.3 a 17.7, incluindo LEDC e RMT desligados no reset) e a matriz de interrupções (tabela 9.3-1 e o resumo 9.4). Os números de sinal da matriz GPIO 73 a 80 para LEDC e 81 a 84 para RMT (tabela 6.11-1), e que as habilitações de saída de ambos os periféricos estão presas em nível alto. Os níveis de interrupção da CPU e os números de interrupção dos comparadores (tabela 9.3-2). O mapa de canais do ADC1 e as faixas efetivas das quatro atenuações (datasheet). A ordem dos pinos do cabeçalho, o GPIO do LED RGB em cada revisão e as dimensões da placa (guia do usuário e desenho dimensional). As opções de ISA inteiro (o core-isa.h das toolchains, e a saída do compilador do S3 byte a byte).
Acreditado, não verificado
SCLK_DIV_NUM + 1como o divisor de clock da UART0 (seção 3.3). O runtime escreve 0 aí, que é 1 sob esta leitura; a fórmula impressa no manual não tem o mais um.- O layout da RAM do RMT por canal,
0x800 + 192n(seção 3.8). - A fase da portadora: alta primeiro, a partir do início de cada código (seção 3.8).
- O carregamento do duty em
PARA_UP_CHnsemDUTY_START(seção 3.7). - O tempo dos pacotes USB: 12 Mbit/s mais treze bytes, e nenhum atraso de escalonamento do host (seção 3.4).
PRID=0xCDCD(seção 4).
Cada número do qual o runtime depende está nomeado em um só lugar (firmware/esp32s3/include/esp32s3.h), e crates/esp32s3/tests/contract.rs mantém esse cabeçalho e crates/esp32s3/src/map.rs com os mesmos números.
Modelado, mas não com os números do chip
- O ADC em
ATTEN3é a curva de um componente típico, não a desta unidade (seção 3.6): a saturação em cerca de 3,1 V e a curvatura acima de 2,75 V estão lá, a variação de unidade para unidade que a calibração do eFuse corrige não está. As outras atenuações são linhas retas até o topo de suas faixas efetivas. - Uma conversão leva exatamente 5 us, e uma borda de LEDC ou RMT cai no picossegundo exato.
GPIO_STRAP_REGé uma constante, não uma travagem dos pinos no reset.RSTé apenas um pull-up de 10 k; o capacitor de power-on não é modelado.- Não há ROM de boot nem árvore de clock. O núcleo está a 240 MHz e o clock APB a 80 MHz desde a primeira instrução, e
SYSTEM_CPU_PER_CONF_REGé armazenado e não muda nada. - Os pads USB não são tomados. GPIO19 e GPIO20 continuam pinos comuns e a porta USB continua funcionando mesmo se um sketch os acionar.
- U0TXD mantém um nível alto estável enquanto a UART o controla; os bits da UART são o canal do host, não uma forma de onda em GPIO43.
CCOMPAREcompara "atingiu ou passou", eMOVSPnunca gera Alloca (seção 4).
Ausente de propósito
- O segundo núcleo. Só o núcleo 0 roda; não há interrupção entre núcleos nem FreeRTOS, então qualquer coisa que inicie uma tarefa no núcleo 1 não vai rodar.
- A extensão de vetores. Toda codificação
EE.*gera fault (seção 4). A FPU é modelada. - SRAM0, o cache, a MMU, a flash e a PSRAM. O código roda da SRAM1.
- Os rádios WiFi e Bluetooth, em qualquer forma. O WiFi que um sketch alcança é a rede simulada da seção 3.10.
- O RTC, suas memórias, os coprocessadores ULP, o deep sleep e a unidade de gerenciamento de energia.
- ADC2, o controlador ADC digital, DMA, os eFuses de calibração, o sensor de temperatura e o sensor de toque.
- Os timers dos grupos de timer, o watchdog do RTC e o watchdog de interrupção (os watchdogs dos grupos de timer são os da seção 3.11).
- UART1 e UART2, os controladores I2C e SPI, I2S, o controlador de câmera e LCD, TWAI, o host de SD, o contador de pulsos, o PWM de motor, o controlador USB OTG, GDMA e os aceleradores criptográficos. O
Wiree oSPIdo runtime são software em pinos comuns (SDA 8 e SCL 9, SCK 12, MISO 13, MOSI 11 e SS 10, os padrões do core Arduino para esta placa), exatamente como em toda outra placa daqui, porque nenhum modelo de placa daqui tem esses controladores. - Os canais de recepção do RMT e o resto da lista da seção 3.8, e o hardware de fade do LEDC.
- A matriz de interrupções além de quatro fontes, e todo nível de interrupção da CPU acima de um.
É por isso que binários do ESP-IDF do fabricante e do core do Arduino não rodam aqui, e firmware compilado para este documento roda.
As imagens das três placas Xtensa não são intercambiáveis. As strings de program do catálogo diferem (elf32 xtensa lx7 esp32s3 aqui, elf32 xtensa lx6 esp32 no DevKit clássico, elf32 xtensa lx106 esp8266 no NodeMCU), e a diferença é real: uma imagem para o ESP32 clássico executa as mesmas instruções, mas carrega em endereços que este chip não tem, então o loader a recusa.
7. Runtime do firmware (firmware/esp32s3/)
Um runtime em estilo Arduino: setup() e loop(), pinMode, digitalWrite, digitalRead, shiftOut, analogRead (com analogReadResolution, analogSetAttenuation e analogSetPinAttenuation), analogWrite e a família ledcAttach/ledcWrite/ledcRead, rgbLedWrite e neopixelWrite, millis, micros, micros64, delay, delayMicroseconds, attachInterrupt, Serial, USBSerial, map, random. Sem core do Arduino, sem ESP-IDF, sem libc. WiFi.h, HTTPClient.h e WebServer.h são o runtime de rede simulada compartilhado 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 dos construtores estáticos, liga os portões de clock do LEDC e do RMT, muda a UART0 para o clock APB a 115200 e roteia a fonte de interrupção dos GPIOs. Toda escrita que muda uma saída do LEDC termina com seu bit de atualização.
Serial é a UART0. USBSerial é a porta USB Serial/JTAG: os bytes entram no buffer de 64 bytes e o driver escreve WR_DONE a cada nova linha e em flush(), esperando o buffer ficar livre em vez de perder um byte.
crt0.S e support64.c são os do ESP32 clássico, compilados de novo para esta placa em vez de copiados: os manipuladores de janela, a tabela de vetores e a entrada de exceção são do ISA, e não do chip. Mais seis arquivos são os do ESP32-C3, como no ESP32 clássico.
Compilado pelo GCC da Espressif para o S3. deploy/fetch-xtensa.sh esp32s3 coloca xtensa-esp32s3-elf-gcc 8.4.0 (esp-2021r2-patch5) em tools/xtensa/, que é gitignored. O GCC é GPL, e nada do que ele compila aqui faz link com libgcc ou qualquer outra parte do toolchain (o runtime é -nostdlib com seu próprio código de suporte), então nenhum código GPL chega a um ELF distribuído. docs/compile.md tem o relato completo.
Linkado contra firmware/esp32s3/link.ld: .text no endereço de barramento de instruções da SRAM1, as seções de dados no endereço de barramento de dados do primeiro byte depois dela, a pilha no topo da SRAM2. A compilação recusa uma imagem com mais de 64 KB carregáveis, e elfcheck.py recusa uma cujo código e dados dividiriam a mesma RAM.
Onze exemplos, cada um com um sketch que a interface mostra: blink (o LED RGB em branco e um LED ligado no GPIO2), rainbow (o LED RGB percorrendo o círculo cromático), button (uma chave para o terra no GPIO21 com o pull-up do próprio pad, acendendo o LED no GPIO2), serial (um tick por segundo na UART0, e um echo), usbserial (o mesmo na porta USB), fade (um LED no GPIO2 em LEDC, oito bits a 1 kHz), knob (um potenciômetro no GPIO4, canal 3 do ADC1, controlando o brilho do LED no GPIO2 com a leitura bruta impressa), e os quatro exemplos de WiFi: wificonnect, wifiweather, wifiapi e wifilamp.
crates/esp32s3/tests/runtime.rs inicializa esses ELFs e mede: o meio período do blink a até 5 ms de 500, os quadros WS2812 no GPIO48 decodificados e o tempo em alto e em baixo de cada bit dentro das janelas do datasheet, as cores que rainbow envia na ordem verde primeiro, o período do LEDC a até 5 us de 1 ms, millis() a até 60 ms do clock do kernel ao longo de cinco segundos, nenhum par de bytes da UART0 mais próximo que um tempo de byte a 115200, e uma linha USB chegando como um único pacote. crates/esp32s3/tests/wifi.rs roda os exemplos de WiFi contra a rede simulada. Cada teste pula a si mesmo quando as imagens não estão compiladas.