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 STM32F411 Black Pill e página da placa.
O terceiro microcontrolador, e a primeira placa Cortex-M. Um componente do kernel (stm32f411 em crates/parts) encapsula um modelo de SoC STM32F411CEU6 (crates/stm32f411) construído sobre o núcleo ARMv7-M (crates/cortexm-core, comprovado em proofs/cortexm/REPORT.md). O firmware é um ELF ARM Thumb comum que conversa com os periféricos abaixo nos seus endereços reais do STM32F411, tirados do RM0383 (o manual de referência do STM32F411xC/E) e do DS10314 (o datasheet), de modo que um programa compilado para o Mokxi também roda em uma WeAct Black Pill real.
O tipo no catálogo é stm32f411 (WeAct MiniF4 "Black Pill" v3.x, STM32F411CEU6). Uma segunda placa, nucleof411re (a Nucleo-F411RE da ST, o mesmo die do STM32F411RET6), é o mesmo modelo de SoC com uma configuração de placa própria: seu clock, seu USART do host, seus pinos e seu build de runtime. A seção 8 é essa placa; todo o resto aqui vale para ambas, salvo indicação em contrário. Três agentes compilam com base neste arquivo: o SoC e o componente (Rust), o runtime de firmware e os exemplos (C/C++, clang), o visual da placa (TypeScript). Altere-o somente editando primeiro este arquivo. Tudo em docs/esp32c3.md sobre como um componente de placa se comporta (slices, canal do host, reset, linha de crash) e tudo em docs/uno.md sobre como uma placa se encaixa em um circuito vale aqui, salvo se este arquivo disser o contrário.
Rodar binários do fornecedor (STM32Cube HAL, libopencm3, o core STM32duino) não é um objetivo da Fase 4. Esses precisam da árvore de clocks levantada a partir do HSI, da latência e do prefetch da flash, de DMA e USB, e nada disso é modelado. O que é objetivo é que cada registrador que um programa bare-metal toca para piscar um pino, imprimir em uma UART, ler um botão e acionar uma saída PWM esteja no seu endereço real com seus bits reais, de modo que o mesmo código-fonte compilado de forma cruzada contra cabeçalhos CMSIS funcionaria no silício.
1. Pinos da placa (ordem do catálogo)
A placa tem 2x20 pinos em passo de 0,1 polegada mais um cabeçalho SWD de 4 pinos ao longo da borda inferior, USB-C no topo, na ordem do próprio diagrama de pinout da WeAct para as placas STM32F4x1 v2.0+. A ordem do catálogo é o cabeçalho esquerdo de cima a baixo, depois o cabeçalho direito de cima a baixo, depois o cabeçalho SWD da esquerda para a direita.
Cabeçalho esquerdo: PB12, PB13, PB14, PB15, PA8, PA9, PA10, PA11, PA12, PA15, PB3, PB4, PB5, PB6, PB7, PB8, PB9, 5V, GND, 3V3
Cabeçalho direito: 5Vb, GNDc, 3V3b, PB10, PB2, PB1, PB0, PA7, PA6, PA5, PA4, PA3, PA2, PA1, PA0, NRST, PC15, PC14, PC13, VBAT
Cabeçalho SWD: 3V3c, PA13 (SWDIO), PA14 (SWCLK), GNDb
44 pinos. PB11 está ausente: o STM32F411CEU6 é um componente de 48 pinos e não o expõe, então PB0..PB15 é "como populado": quinze pinos, não dezesseis. Os trilhos aparecem mais de uma vez (três de 3,3 V, dois de 5 V, três terras) e carregam uma letra porque os nomes de pinos do catálogo são únicos. Os pinos SWD não encaixam na protoboard em que a placa está (plug: false em web/src/parts/stm32f411.ts).
Until late October 2026 the drawing had the board end for end (VBAT at the
USB end) with the SWD header folded into the VBAT row as PA13, PA14 and
GNDb, and no second 5 V or 3.3 V pins. 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 model does not read the setting.
The silkscreen prints the short forms (VB, C13, R, A0, B9, G); the
catalog uses the full port names because a netlist pin reference has to be
unambiguous.
Elétrico:
3V3fornece 3,3 V emR_SUPPLY;5Vfornece 5 V emR_SUPPLY;GNDeGNDbfornecem 0 V. A placa está sempre alimentada (USB-C). Ela é uma fonte para o resto do circuito.VBATé uma entrada que a placa ignora: aqui ela é sempre alimentada pelo trilho de 3,3 V.NRSTé uma entrada com um pull-up interno de 40 k para 3,3 V (o RM0383 diz de 30 k a 50 k); levada abaixo de 1,65 V, mantém a CPU em reset; soltá-la reinicia o programa a partir do vetor de reset.- Cada
PAn,PBnePCn(e, na Nucleo,PD2) é uma GPIO inout. Saída (MODER= 01 ou 10): push-pull a 3,3 V ou 0 V através deR_STRONG, ou dreno aberto (OTYPERbit definido), em que um nível alto é alta impedância. Entrada ou analógico (MODER= 00 ou 11): alta impedância, mais um pull-up de 40 k para 3,3 V quandoPUPDR= 01 ou um pull-down de 40 k quandoPUPDR= 10. A entrada compara a tensão do nó com 1,65 V (metade de 3,3 V); Unknown lê 0, e uma entrada flutuante lê ruído, como no Uno (docs/uno.mdseção 1). PC13carrega o LED azul da placa, anodo ao 3,3 V através de 470 R, cátodo no pino: o LED acende quandoPC13é levado a nível baixo. Ele é uma carga no pino, e o visual o mostra a partir de um bit de ponta de prova (seção 5).PA0também carrega o botãoKEY, que ligaPA0ao terra enquanto pressionado. Não há pull-up externo: o firmware usa o interno. O botão é acessado porpoke(seção 5), não por um pino.PA9/PA10são USART1 TX/RX na placa real e aqui; os bytes da USART vão para o canal do host (seção 4), e os dois pinos permanecem GPIO no nó, de modo que um osciloscópio neles mostra o que o bloco GPIO estiver fazendo.PA11/PA12são USB D-/D+ na placa real e aqui são GPIO comuns.PA13/PA14saem do reset em modo de função alternativa para o SWD, exatamente como o componente faz, o que significa que ficam em alta impedância até o firmware reprogramarMODER.
2. Mapa de memória (endereços reais do STM32F411CE)
| região | endereço | tamanho | notas |
|---|---|---|---|
| flash | 0x0800_0000 |
512 KB | a flash do STM32F411CE; escritas são ignoradas (não há interface de programação de flash) |
| alias da flash | 0x0000_0000 |
512 KB | os mesmos bytes, porque BOOT0 está baixo e a área de boot mapeia a flash principal para 0 |
| SRAM | 0x2000_0000 |
128 KB | |
| APB1 | 0x4000_0000 |
32 KB | TIM2..TIM5 e USART2, seção 3 |
| APB2 | 0x4001_0000 |
32 KB | TIM1, USART1, ADC1, SYSCFG, EXTI, TIM10, seção 3 |
| AHB1 | 0x4002_0000 |
64 KB | GPIOA..GPIOD e RCC, seção 3 |
| SCS | 0xE000_E000 |
4 KB | SysTick, NVIC e o SCB, respondidos dentro de cortexm-core e nunca vistos no barramento |
Qualquer outro endereço é uma falha de acesso: o núcleo recebe um BusFault, que com o SHCSR de reset escala para HardFault. Registradores não mapeados dentro de um bloco de periférico mapeado leem 0 e ignoram escritas, com um contador para diagnóstico.
ELF de firmware: loadProgram aceita um executável ELF32 little-endian ARM (e_machine 40). Todo segmento PT_LOAD precisa cair dentro da flash (por qualquer uma das duas visões) ou da SRAM. O reset é o arquitetural, não um salto para o ponto de entrada: MSP vem da palavra na base da tabela de vetores e PC da segunda palavra, com o bit baixo zerado, então uma imagem de firmware é uma tabela de vetores de verdade e não um simples ponto de entrada. VTOR reseta para 0, que é o alias da flash. Um carregamento durante a execução reseta a placa.
O núcleo é Profile::V7M com Cpu::set_priority_bits(4); a família STM32F4 implementa os quatro bits superiores de cada campo de prioridade de 8 bits, então NVIC_IPR se comporta como um NVIC_SetPriority do CMSIS espera. Não há FPU: CPACR é armazenado e nunca usado, e toda instrução VFP e DSP gera UNDEFINSTR. Compile o firmware com -mfloat-abi=soft.
3. Registradores de periféricos (subconjunto, offsets reais, posições de bits reais)
Os registradores têm 32 bits e são alinhados por palavra. Acesso por byte e halfword funciona e atinge a palavra que o contém, que é o que as pontes AHB/APB fazem para os registradores modelados aqui.
3.1 RCC (0x4002_3800)
A árvore de clock é modelada a partir dos registradores, com uma concessão às imagens que o Mokxi traz: até o firmware mexer na configuração de clock o componente roda no clock de boot da sua placa (SYSCLK = HCLK = 84 MHz no Black Pill, 100 MHz na Nucleo, APB1 na metade), porque o runtime do Arduino nunca programa o PLL. A primeira escrita em RCC_CR ou RCC_PLLCFGR, ou uma escrita em RCC_CFGR que mude SW, entrega o clock aos registradores: a partir daí SYSCLK é o HSI (16 MHz), o HSE (cristal de 25 MHz no Black Pill, os 8 MHz do ST-LINK na Nucleo) ou o PLL (src / PLLM * PLLN / PLLP) conforme SWS indicar, HCLK é SYSCLK / HPRE, PCLK1 e PCLK2 são HCLK / PPRE1 e PPRE2, e os clocks dos timers são PCLK (prescaler 1) ou 2 x PCLK, ou com DCKCFGR.TIMPRE HCLK até uma divisão por 4. O núcleo, o SysTick, os timers, os baud rates da USART, o clock do ADC e a conversão de ciclos para tempo acompanham tudo, inclusive quando o clock muda durante a execução. O HCLK é arredondado para MHz inteiros na conversão de tempo. Um reset devolve o clock de boot. A latência da flash continua armazenada e ignorada.
| offset | nome | comportamento |
|---|---|---|
0x00 |
RCC_CR |
stored; HSIRDY (1), HSERDY (17) and PLLRDY (25) read back set whenever their ON bit is set, so a spin on "ready" terminates immediately (oscillators and the PLL start at once) |
0x04 |
RCC_PLLCFGR |
armazenado, lido de volta; reset 0x2400_3010 |
0x08 |
RCC_CFGR |
armazenado; SWS[3:2] segue SW[1:0] imediatamente quando a fonte que SW indica está ligada em RCC_CR, e permanece parado caso contrário. HPRE, PPRE1, PPRE2 definem os clocks dos barramentos como acima |
0x0C |
RCC_CIR |
armazenado, lido de volta |
0x10 0x20 0x24 |
RCC_AHB1RSTR RCC_APB1RSTR RCC_APB2RSTR |
um 1 escrito no bit de um periférico reseta os registradores desse periférico; o próprio registrador lê 0 |
0x30 |
RCC_AHB1ENR |
bit 0 GPIOAEN, 1 GPIOBEN, 2 GPIOCEN, 3 GPIODEN, 4 GPIOEEN, 7 GPIOHEN, 12 CRCEN, 21 DMA1EN, 22 DMA2EN |
0x34 |
RCC_AHB2ENR |
armazenado, lido de volta |
0x40 |
RCC_APB1ENR |
bit 0 TIM2EN, 1 TIM3EN, 2 TIM4EN, 3 TIM5EN, 11 WWDGEN, 14 SPI2EN, 15 SPI3EN, 17 USART2EN, 21 I2C1EN, 22 I2C2EN, 23 I2C3EN, 28 PWREN |
0x44 |
RCC_APB2ENR |
bit 0 TIM1EN, 4 USART1EN, 5 USART6EN, 8 ADC1EN, 11 SDIOEN, 12 SPI1EN, 13 SPI4EN, 14 SYSCFGEN, 16 TIM9EN, 17 TIM10EN, 18 TIM11EN |
0x50 0x54 0x60 0x64 |
os quatro registradores LPENR |
armazenado, lido de volta |
0x70 |
RCC_BDCR |
armazenado; LSERDY (1) segue LSEON (0) |
0x74 |
RCC_CSR |
armazenado; LSIRDY (1) segue LSION (0); PINRSTF (26) definido após um reset de NRST, PORRSTF (27) e BORRSTF (25) após energização; uma escrita com RMVF (24) limpa as flags |
Um bit de habilitação de clock é um gate real: um periférico cujo bit de habilitação está zerado lê 0 e ignora escritas, e um contador de acessos perdidos registra o acesso. Esse é o erro bare-metal STM32 mais comum de todos, e escondê-lo o tornaria invisível aqui.
3.2 GPIOA, GPIOB, GPIOC, GPIOD (0x4002_0000, 0x4002_0400, 0x4002_0800, 0x4002_0C00)
Port D is on the die in both packages; the 48-pin F411CE bonds out none of it
and the 64-pin F411RE only PD2. Its reset values are all zero. The clock
enable is RCC_AHB1ENR bit 3, GPIODEN.
| offset | nome | bits |
|---|---|---|
0x00 |
MODER |
2 bits per pin: 00 input, 01 output, 10 alternate function, 11 analog |
0x04 |
OTYPER |
1 bit per pin: 0 push-pull, 1 open-drain |
0x08 |
OSPEEDR |
2 bits per pin; stored, read back, no effect on edge timing |
0x0C |
PUPDR |
2 bits per pin: 00 none, 01 pull-up, 10 pull-down |
0x10 |
IDR |
somente leitura, bits 0..15: os níveis dos pinos |
0x14 |
ODR |
bits 0..15: o latch de saída |
0x18 |
BSRR |
somente escrita: bits 0..15 definem o bit correspondente do ODR, bits 16..31 o zeram; um reset vence uma definição na mesma escrita. Lê 0 |
0x1C |
LCKR |
armazenado, lido de volta; a sequência de trava não é imposta |
0x20 0x24 |
AFRL AFRH |
4 bits por pino, pinos 0..7 e 8..15 |
Os valores de reset são os do próprio componente, o que importa porque são eles que deixam os pinos SWD em paz: GPIOA_MODER = 0xA800_0000, GPIOA_OSPEEDR = 0x0C00_0000, GPIOA_PUPDR = 0x6400_0000; GPIOB_MODER = 0x0000_0280, GPIOB_OSPEEDR = 0x0000_00C0, GPIOB_PUPDR = 0x0000_0100; todo o resto é 0.
IDR lê o que este chip está colocando num pino que ele dirige, e o que a placa amostrou do nó num pino que ele não dirige, exatamente como o PINx faz no Uno.
Função alternada: com MODER = 10 o pad é dirigido pelo periférico que AFRL/AFRH selecionar para aquele pino, do subconjunto das seções 3.3 e 3.4. Uma seleção de função alternada que este modelo não implementa deixa o pad em alta impedância e conta uma conexão perdida. Os mapeamentos modelados (tabela 9 do DS10314):
| AF | pinos |
|---|---|
AF1 TIM2 |
PA0 CH1, PA1 CH2, PA2 CH3, PA3 CH4, PA5 CH1, PA15 CH1, PB3 CH2, PB10 CH3 |
AF1 TIM1 |
PA8 CH1, PA9 CH2, PA10 CH3, PA11 CH4; complementares PA7, PB13 CH1N, PB0, PB14 CH2N, PB1, PB15 CH3N |
AF2 TIM3 |
PA6 CH1, PA7 CH2, PB0 CH3, PB1 CH4, PB4 CH1, PB5 CH2, PC6 CH1, PC7 CH2, PC8 CH3, PC9 CH4 |
AF3 TIM10 |
PB8 CH1 |
AF2 TIM4 |
PB6 CH1, PB7 CH2, PB8 CH3, PB9 CH4 |
AF2 TIM5 |
PA0 CH1, PA1 CH2, PA2 CH3, PA3 CH4 |
AF7 USART1 |
PA9 TX, PA10 RX, PB6 TX, PB7 RX |
AF7 USART2 |
PA2 TX, PA3 RX |
3.3 TIM2, TIM3, TIM4, TIM5 (0x4000_0000, 0x4000_0400, 0x4000_0800, 0x4000_0C00)
TIM2 e TIM5 têm CNT, ARR e CCRx de 32 bits; TIM3 e TIM4 são de 16 bits. Os quatro são clockados a 84 MHz (seção 5).
| offset | nome | bits |
|---|---|---|
0x00 |
CR1 |
CEN 0, UDIS 1, URS 2, OPM 3, DIR 4, CMS 5..6, ARPE 7, CKD 8..9 |
0x04 |
CR2 |
armazenado, lido de volta |
0x08 |
SMCR |
armazenado, lido de volta; os modos slave e trigger não são modelados |
0x0C |
DIER |
UIE 0, CC1IE 1, CC2IE 2, CC3IE 3, CC4IE 4, TIE 6; os habilitadores de DMA são armazenados |
0x10 |
SR |
UIF 0, CC1IF 1..CC4IF 4, TIF 6, CC1OF 9..CC4OF 12. Escreva 0 num bit para limpá-lo, 1 o deixa (rc_w0, como diz o manual) |
0x14 |
EGR |
somente escrita: UG 0 recarrega o prescaler e o contador e ativa UIF, CC1G 1..CC4G 4 ativam os flags de captura/comparação, TG 6 ativa TIF |
0x18 |
CCMR1 |
modo de saída: CC1S 0..1, OC1FE 2, OC1PE 3, OC1M 4..6, OC1CE 7, CC2S 8..9, OC2FE 10, OC2PE 11, OC2M 12..14, OC2CE 15 |
0x1C |
CCMR2 |
o mesmo para os canais 3 e 4 |
0x20 |
CCER |
CC1E 0, CC1P 1, CC2E 4, CC2P 5, CC3E 8, CC3P 9, CC4E 12, CC4P 13 |
0x24 |
CNT |
|
0x28 |
PSC |
16 bits; o contador avança a 84 MHz / (PSC + 1) |
0x2C |
ARR |
valor de recarga; o período é ARR + 1 ticks contando para cima |
0x34 0x38 0x3C 0x40 |
CCR1 CCR2 CCR3 CCR4 |
|
0x48 0x4C |
DCR DMAR |
armazenado, lido de volta |
0x50 |
TIM2_OR / TIM5_OR |
armazenado, lido de volta |
Contagem: para cima (DIR = 0), para baixo (DIR = 1) e alinhada ao centro (CMS != 0) estão todas modeladas, cada uma com o evento de atualização onde o manual o coloca. ARPE faz buffer de ARR e OCxPE faz buffer de CCRx até o evento de atualização, que é o que torna uma mudança de ciclo ativo sem glitches.
Modos de comparação de saída (OCxM): 0 congelado, 1 ativo na correspondência, 2 inativo na correspondência, 3 alternância, 4 força inativo, 5 força ativo, 6 modo PWM 1 (ativo enquanto CNT < CCRx contando para cima), 7 modo PWM 2 (o inverso). CCxP inverte a polaridade da saída. O pino só se move enquanto CCxE está ativo e o pad está no modo de função alternada com aquele timer selecionado (seção 3.2).
A captura de entrada não é modelada: CCxS != 0 armazena e conta uma conexão perdida.
Linhas do NVIC: TIM2 = 28, TIM3 = 29, TIM4 = 30, TIM5 = 50. Cada uma se mantém ativa enquanto qualquer um dos flags de SR estiver ativo com o habilitador correspondente em DIER, mantida como nível. O handler limpa o flag, como no silício.
3.3a TIM1 (0x4001_0000) e TIM10 (0x4001_4400)
TIM1 is the advanced-control timer: the registers of section 3.3, 16 bits wide,
plus RCR (0x30, stored; the repetition counter is not acted on) and BDTR
(0x44). BDTR.MOE (bit 15) gates every TIM1 output: with it clear none of
them drives a pin. CCER adds CCxNE (bit 4n+2) and CCxNP (bit 4n+3)
for channels 1 to 3: the complementary output alone is the channel's reference
level with CCxNP as its polarity, and with CCxE on as well it is the
reference's complement (RM0383 table 56 with no dead time; dead time and the
break input are stored and not modeled). Clock enable RCC_APB2ENR bit 0.
TIM10 é um timer de 16 bits com um canal, modelado com os registradores da seção 3.3; os que faltam no silício são lidos como armazenados. Habilitação de clock: RCC_APB2ENR bit 17.
Ambos contam no clock de timer do APB2, que é o HCLK nas duas placas. Linhas do NVIC: TIM1_UP_TIM10 = 25 (atualização do TIM1, ou qualquer interrupção do TIM10), TIM1_TRG_COM_TIM11 = 26 (trigger do TIM1), TIM1_CC = 27 (flags de comparação do TIM1).
3.4 USART1 (0x4001_1000) e USART2 (0x4000_4400)
| offset | nome | bits |
|---|---|---|
0x00 |
SR |
PE 0, FE 1, NE 2, ORE 3, IDLE 4, RXNE 5, TC 6, TXE 7, LBD 8, CTS 9. RXNE, TC e LBD/CTS são limpos escrevendo 0; TC e ORE também são limpos na sequência ler-SR-depois-ler-DR, como diz o manual |
0x04 |
DR |
escrita: transmite; leitura: o byte recebido e limpa RXNE |
0x08 |
BRR |
DIV_Fraction 0..3, DIV_Mantissa 4..15; baud = f_PCLK / (8 x (2 - OVER8) x USARTDIV) |
0x0C |
CR1 |
SBK 0, RWU 1, RE 2, TE 3, IDLEIE 4, RXNEIE 5, TCIE 6, TXEIE 7, PEIE 8, PS 9, PCE 10, WAKE 11, M 12, UE 13, OVER8 15 |
0x10 |
CR2 |
armazenado, lido de volta; STOP 12..13 é armazenado e 8N1 é assumido para o ritmo |
0x14 |
CR3 |
armazenado, lido de volta |
0x18 |
GTPR |
armazenado, lido de volta |
f_PCLK é o HCLK para a USART1 (APB2) e HCLK / 2 para a USART2 (APB1), seção 5: 84 e 42 MHz no Black Pill, 100 e 50 MHz na Nucleo.
USART1 é o canal do host na Black Pill; na Nucleo é a USART2, que essa placa liga à porta COM virtual do ST-LINK, e a USART1 é a porta cujos bytes não vão a lugar nenhum. A transmissão é o buffer único do próprio componente mais o registrador de deslocamento: uma escrita em DR com TXE ativado limpa TXE, o registrador de deslocamento pega o byte e TXE volta logo em seguida, e o byte chega ao host um tempo de quadro depois (10 tempos de bit no baud configurado), quando TC é ativado. Recepção: os bytes do host entram em uma FIFO do tamanho do registrador de recepção real de um byte mais uma fila de espera de 256 bytes no lado do host, para o texto digitado não se perder; RXNE fica ativado enquanto um byte espera; ler DR o retira, e um byte que chega com RXNE já ativado ativa ORE.
A outra USART é uma segunda, idêntica, cujos bytes transmitidos não vão para lugar nenhum (eles são contados, então um teste pode vê-los) e cujo receptor nunca tem nada para ler. Ela existe para que firmwares escritos para duas portas liguem e rodem.
Linhas do NVIC: USART1 = 37, USART2 = 38. Cada uma se ativa enquanto RXNE & RXNEIE, TXE & TXEIE, TC & TCIE ou IDLE & IDLEIE valerem. Essas são condições, não flags de borda, então entrar no handler não limpa nada. Um handler de TXE sem nada mais para enviar precisa se desligar, como no chip.
3.5 SYSCFG (0x4001_3800) e EXTI (0x4001_3C00)
| offset | nome | bits |
|---|---|---|
SYSCFG 0x00 |
MEMRMP |
armazenado, lido de volta; o remap de boot é fixo na flash principal |
SYSCFG 0x04 |
PMC |
armazenado, lido de volta |
SYSCFG 0x08..0x14 |
EXTICR1..EXTICR4 |
4 bits por linha: 0 = porta A, 1 = porta B, 2 = porta C, 3 = porta D. A linha n observa o pino n da porta selecionada |
SYSCFG 0x20 |
CMPCR |
lê 0 |
EXTI 0x00 |
IMR |
máscara de interrupção, um bit por linha 0..15 (as linhas 16..22 são armazenadas e nunca disparam) |
EXTI 0x04 |
EMR |
máscara de evento; armazenada, e uma linha mascarada acorda o núcleo de WFE |
EXTI 0x08 |
RTSR |
seleção de trigger de subida |
EXTI 0x0C |
FTSR |
seleção de trigger de descida |
EXTI 0x10 |
SWIER |
writing 1 sets the matching PR bit |
EXTI 0x14 |
PR |
pendente; escreva 1 para limpar |
NVIC lines: EXTI0 = 6, EXTI1 = 7, EXTI2 = 8, EXTI3 = 9, EXTI4 = 10, EXTI9_5 =
23, EXTI15_10 = 40. A line asserts its NVIC input while its PR bit is set and
its IMR bit is set; the handler clears PR, as on silicon.
3.6 SysTick e o NVIC
Both are inside cortexm-core at the architectural addresses in the System
Control Space and never reach the bus (proofs/cortexm/REPORT.md section 5).
SYST_CALIB is programmed to 10500 with SKEW and NOREF clear: the board's
external reference is HCLK/8 = 10.5 MHz, so a 10 ms tick is 105,000 of them,
which does not fit 24 bits: the part's own answer, and the reason CMSIS
SysTick_Config uses the processor clock. With CLKSOURCE clear the model
still counts processor cycles; the /8 divider is not modeled and is called out
here rather than hidden.
stm32f411.h também tem as grafias do CMSIS, para código escrito contra os cabeçalhos da ST: os nomes SysTick_CTRL_*_Msk e _Pos, SysTick_LOAD_RELOAD_Msk e SysTick_VAL_CURRENT_Msk, SystemCoreClock (84.000.000, uma variável como no CMSIS) e um SystemCoreClockUpdate() vazio. O millis() do runtime roda no SysTick, então um sketch que o reprograma altera millis() e delay().
3.6a ADC1 (0x4001_2000, registradores comuns em 0x4001_2300)
Um grupo regular, iniciado por SWSTART (bit 30 do CR2) com ADON definido, em modo simples ou contínuo, com SCAN percorrendo a sequência e deixando o último resultado em DR, que é o que um componente sem DMA faz. Não há início com "escreva ADON duas vezes" nesta família. SR: EOC (1) é definido quando uma conversão termina e limpo quando DR é lido; STRT (4) é definido quando uma começa; ambos são rc_w0. CR1.RES (bits 24..25) escolhe 12, 10, 8 ou 6 bits; CR2.ALIGN alinha à esquerda; CR1.EOCIE levanta a linha 18 do NVIC (ADC). ADC_CCR.ADCPRE (bits 16..17) divide PCLK2 por 2, 4, 6 ou 8 para o clock do ADC, e uma conversão leva o tempo de amostragem do canal em SMPRx (3, 15, 28, 56, 84, 112, 144 ou 480 clocks do ADC) mais um clock por bit (RM0383 11.5): EOC não sai nem cedo nem tarde.
Channels 0..7 are PA0..PA7, 8 and 9 PB0 and PB1, 10..15 PC0..PC5
(DS10314 table 8). The board hands each one the voltage on its net as a
twelve-bit count against 3.3 V; a floating pin reads noise. Channel 17
(VREFINT, 1.21 V, count 1502) and 18 (the temperature sensor at 25 C, 0.76 V,
count 943) read their nominal values while ADC_CCR.TSVREFE (bit 23) is set,
and 0 otherwise. Not modeled: the injected group, the analog watchdog,
external triggers, DMA and the overrun flag. Clock enable RCC_APB2ENR bit 8.
3.7 O que não é modelado
A árvore de clock e a latência da flash, DMA, USB, I2C, SPI, SDIO, o RTC, os watchdogs, TIM9 e TIM11, a unidade de CRC, os modos de baixo consumo do controlador de energia, os option bytes e a programação da flash. Os registradores deles não estão mapeados (falta de acesso), exceto onde um bloco está listado acima; nesse caso, um offset não implementado lê 0, ignora escritas e conta como acesso estranho. WFI e WFE pausam o núcleo; SLEEPDEEP é armazenado e se comporta como sleep normal.
4. Canal do host
host = "bytes utf-8 na USART1" ("bytes utf-8 na USART2" na Nucleo). readHost devolve os bytes TX da USART do host conforme terminam de sair no fio; writeHost empurra bytes para sua fila de recepção (overflow descarta e define ORE, como no chip). O monitor serial mostra os bytes como texto, decodificando UTF-8 e tratando \n como fim de linha (\r ignorado).
5. Modelo de tempo e o componente
84 MHz no Black Pill, um ciclo por 1/84 us (100 MHz na Nucleo, um ciclo por exatamente 10 ns, e uma fatia de 1000 ciclos; o resto desta seção dá os números do Black Pill). As contagens de ciclos vêm do core (Cpu::run devolve ciclos; o contador de ciclos do core é o relógio). Um ciclo não é um número inteiro de picossegundos, então o tempo é derivado como ps = cycles * 1_000_000 / 84, exatamente, nunca acumulado, sempre recalculado a partir da contagem de ciclos, então nunca pode derivar. Uma fatia de 10 us é exatamente 840 ciclos, e 840 ciclos são exatamente 10.000.000 ps, então os limites de fatia são exatos.
Clocks no boot (a seção 3.1 diz como o firmware os muda; todo número aqui passa então a seguir HCLK):
| domínio | Black Pill | Nucleo |
|---|---|---|
| SYSCLK, HCLK, CPU | 84 MHz | 100 MHz |
| clock de periférico APB1 (USART2) | 42 MHz | 50 MHz |
| clock de timer APB1 (TIM2..TIM5) | 84 MHz | 100 MHz |
| APB2 (USART1, ADC1) e seus timers (TIM1, TIM10) | 84 MHz | 100 MHz |
Dentro de uma fatia o core é avançado de modo que cada escrita em periférico carregue o ciclo da CPU em que aconteceu: uma mudança de pad se torna um drive_after naquele deslocamento a partir do início da fatia, então duas escritas em BSRR separadas por quatro ciclos estão realmente a 48 ns de distância no nó. Os timers são avançados analiticamente. O próximo evento de cada timer (um compare match, um update, um overflow) é calculado a partir da sua contagem, prescaler, ARR e modo, o core é rodado até aquele ciclo, o evento é aplicado e a rodagem continua, então uma borda de PWM cai no ciclo exato em vez de no fim de uma fatia. Leituras de IDR veem os níveis dos pinos no início da fatia mais qualquer mudança que o próprio programa fez na fatia.
WFI (and WFE with the event register clear) parks the core: the part stops
slicing and schedules one wake at the earliest of the SysTick reload, the next
timer event that can raise an enabled interrupt, and the next USART event; a pin
change or a host byte wakes it immediately. This is the whole idle story.
proofs/cortexm/REPORT.md measures the core at 1.02x of a real STM32F411 in
Chromium and says plainly that there is no headroom, so a sketch that busy-waits
through a delay() will not hold real time. delay() in the runtime therefore
parks on WFI and is woken by SysTick, and an idle board costs the kernel a
handful of events a simulated second instead of 84 million cycles.
Probe: bit 0 = executando (1 durante a execução, 0 em reset ou parado), bit 1 = dormindo (estacionado em WFI/WFE), bit 2 = o LED da placa (PC13 em nível baixo), bit 3 = atividade de TX nos últimos 20 ms, bit 4 = atividade de RX nos últimos 20 ms. Então probe é uma pequena máscara de bits, 0 sem programa.
Poke: 0 = soltar KEY, 1 = pressionar KEY (liga PA0 ao terra enquanto estiver pressionado), 2 = segurar NRST, 3 = soltar NRST.
Tratamento de falhas como em docs/esp32c3.md seção 5: o núcleo relata um Trap, e o componente para e imprime uma linha no canal do host, por exemplo firmware crashed at pc=0x08000412, HardFault (CFSR 0x00000100). Um lockup, uma instrução indefinida, um BKPT e uma tabela de vetores fora do mapeamento chegam todos como traps. O componente então para de pedir despertares.
6. Runtime do firmware (firmware/stm32/)
Um runtime em C e C++ standalone para o STM32F411, compilado com clang 18 (--target=thumbv7em-none-eabi -mfloat-abi=soft -mcpu=cortex-m4 -Os) e lld, sem newlib, sem CMSIS, sem HAL, nada de GPL:
crt0.S: the 16 system vectors plus the 85 IRQ vectors at the head of flash,_start(setMSP, which the core has already done from vector 0; copy.datafrom its load address in flash, clear.bss, run the C++ static constructors, callmain), and a default handler that stops.link.ld: flash em0x0800_0000com 512 KB, SRAM em0x2000_0000com 128 KB, pilha no topo da SRAM, com um assert de que os dados estáticos deixam espaço para ela.stm32f411.h: cada registro da seção 3 como uma macro volatile com o nome real da ST (GPIOC->ODR,RCC->AHB1ENR,TIM3->CCR1,USART1->DR), além das constantes de bits e dos números de IRQ.arduino.h: a mesma interface de sketch do runtime do Uno, nos pinos deste componente:pinMode,digitalWrite,digitalRead,analogWrite,delay,delayMicroseconds,millis,micros,Serial,attachInterrupt,shiftOut,map,random. Os números dos pinos são os nomes das portas:PA0,PB9,PC13são constantes, eLED_BUILTINéPC13.
millis() vem do SysTick a 1 kHz (reload 83.999). micros() vem do TIM2, um contador de 32 bits em livre execução a 1 MHz (PSC = 83, ARR = 0xFFFFFFFF), então tem resolução de 1 us e reinicia a cada 71.6 minutos. delay() estaciona o núcleo em WFI até a contagem do SysTick atingir o prazo; delayMicroseconds() faz espera ocupada no TIM2.
analogWrite(pin, 0..255) gera PWM a 1 kHz, como o STM32duino faz (PWM_FREQUENCY 1000: PSC = 1, um tick de 42 MHz, e ARR = 41.999, ou seja 84 MHz / 2 / 42.000), com CCRx = 42.000 x valor / 255, o escalonamento do setCaptureCompare do core, em doze pinos:
| temporizador | canal 1 | canal 2 | canal 3 | canal 4 |
|---|---|---|---|---|
| TIM5 | PA0 |
PA1 |
PA2 |
PA3 |
| TIM3 | PA6 |
PA7 |
PB0 |
PB1 |
| TIM4 | PB6 |
PB7 |
PB8 |
PB9 |
0 e 255 não são PWM: eles desconectam a saída de comparação e levam o pino a nível baixo ou alto, então analogWrite(pin, 0) é de fato desligado. Um digitalWrite em um pino de PWM retoma o pino, como o core do Arduino faz.
analogRead(pin) converte no ADC1 (seção 3.6a) como o STM32duino faz: o pino em modo analógico, ADCPRE PCLK2 / 4, 15 ciclos de amostragem, SWSTART e uma espera em EOC, e o resultado em dez bits por padrão (ADC_RESOLUTION 10). analogReadResolution(bits) escolhe a resolução mais próxima do conversor (6, 8, 10 ou 12) e mapeia para os bits pedidos com o mapResolution do core. Um número abaixo da quantidade de entradas analógicas da placa é uma entrada analógica (analogRead(0) é A0), como no STM32duino; na Black Pill A0 a A9 são PA0 a PA7, PB0 e PB1.
Serial é a USART1 em PA9/PA10, 8N1, recepção dirigida por interrupção para um buffer circular de 64 bytes, transmissão por um buffer circular de 64 bytes esvaziado pela interrupção de TXE, como o HardwareSerial do STM32duino faz (SERIAL_TX_BUFFER_SIZE 64): um print que cabe retorna imediatamente e os bytes saem na taxa de baud, um mais longo espera por espaço, e availableForWrite() é o espaço restante (63 quando vazio). attachInterrupt(pin, fn, mode) usa SYSCFG e EXTI: um handler por linha, CHANGE, RISING e FALLING.
Exemplos em firmware/stm32/examples/<name>/sketch.ino, compilados para web/public/firmware/stm32/<name>.elf com web/public/firmware/stm32/index.json no mesmo formato do índice do Uno, cada entrada contendo "program": "elf32 arm stm32f411":
blink:PC13a 1 Hz, ativo em nível baixo,delay(500)estacionado emWFI.button: o botãoKEYemPA0comINPUT_PULLUPacendePC13.serial: imprimemillis()uma vez por segundo e ecoa o que recebe.fade:analogWriteemPA0fazendo um LED respirar, comPC13acompanhando.
A interface escolhe a lista de firmware pela string program do catálogo do componente (docs/sim-api.md seção 3): "elf32 riscv32imc" lê /firmware/index.json, "elf32 avr atmega328p" lê /firmware/uno/index.json, "elf32 arm stm32f411" lê /firmware/stm32/index.json e "elf32 arm stm32f411 nucleo" lê /firmware/nucleof411re/index.json.
7. O que este modelo sabe com certeza, e o que não sabe
Três grupos, a mesma ordenação que a seção 7 de docs/esp32c6.md usa. Ela existe porque um modelo de placa que adivinha silenciosamente um endereço é pior do que um que diz que não sabia.
Tirado do manual de referência e executado por firmware de verdade. Cada endereço base, deslocamento de registrador e posição de bit nas seções 2 e 3 vem do manual de referência do STM32F4 (RM0383) e da folha de dados do STM32F411CE: RCC em 0x4002_3800, GPIOA/B/C em 0x4002_0000/0400/0800, TIM2 a TIM5 em 0x4000_0000/0400/0800/0C00, USART1 em 0x4001_1000 e USART2 em 0x4000_4400, SYSCFG em 0x4001_3800 e EXTI em 0x4001_3C00, SysTick e o NVIC nos seus endereços ARM, 128 KB de SRAM em 0x2000_0000 e 512 KB de flash em 0x0800_0000; GPIOD em 0x4002_0C00, TIM1 em 0x4001_0000, ADC1 em 0x4001_2000 e TIM10 em 0x4001_4400, com os campos de bit e os tempos do ADC do capítulo 11 do RM0383. crates/stm32f411/tests/firmware.rs e tests/nucleo.rs carregam ELFs de verdade e acionam GPIO, os timers, as duas USARTs, o ADC, o SysTick e o EXTI através deles. A ordem dos pinos do WeAct Black Pill e o seu LED em PC13 são da própria placa.
Modelado, mas sem seguir os números do manual de referência. Comportamentos, e não endereços:
- O clock de inicialização é a velocidade máxima da placa (84 MHz, ou 100 na Nucleo). Uma placa real que nunca configura o PLL roda a 16 MHz no HSI; aqui, um programa que nunca mexe nos registradores de clock roda no clock da placa, que é o que o runtime Arduino do Mokxi assume. Depois que um programa escreve nos registradores de clock, o PLL, os osciladores e os prescalers passam a ser seguidos (seção 3.1); a latência do flash, não.
- A fatia tem duas marchas, e a primeira escrita depois de um período calmo sai adiantada. O núcleo roda em lotes grosseiros até uma escrita cair num registrador de GPIO, timer ou USART, e então passa a executar uma instrução por vez por um tempo. Tudo dentro de uma rajada é exato; a primeira escrita de uma rajada é cronometrada no início do lote em que ela aconteceu, o que pode adiantar em até 6.1 us.
- Os pads são três estados e um limiar. Push-pull a 3.3 V, dreno aberto, alta impedância, ou um pull interno de 40 kΩ (a folha de dados dá de 30 kΩ a 50 kΩ), leitura comparada com metade da alimentação, sem histerese, sem ajuste de velocidade, sem tempo de subida e sem limite de corrente. O LED da placa é um LED atrás de 470 Ω em
PC13, com o anodo no trilho, então um nível baixo o acende. - The board is an ideal supply: 3V3 and 5V at rail impedance for ever, so nothing
browns out and the regulator is not there.
VBATis a pin and no more. Startup is a microsecond, with no option bytes and no boot pins.
Ausentes de propósito, como a seção 3.7 lista: a árvore de clock e a latência do flash, DMA, USB (portanto o soquete USB da placa não carrega nada; Serial chega ao monitor pelo canal do host e PA11/PA12 continuam GPIO comum), I2C, SPI, I2S, SDIO, o RTC, os watchdogs, TIM9 e TIM11, CRC, a FPU e seus registradores, e a programação do flash. A ausência da FPU custa tempo, e não resultados: o runtime é compilado para o ABI de soft-float, então um float é calculado em software e dá o mesmo resultado, em mais ciclos do que a FPU do chip levaria.
8. A Nucleo-F411RE (nucleof411re)
A NUCLEO-F411RE da ST (MB1136, UM1724): o STM32F411RET6, o mesmo die no encapsulamento de 64 pinos, numa placa com ST-LINK. O componente é o mesmo adaptador do Black Pill (crates/parts/src/parts/stm32f411.rs) com a configuração de placa stm32f411::NUCLEO_F411RE; o runtime é firmware/stm32/ compilado com -DMOKXI_BOARD_NUCLEO_F411RE (firmware/nucleof411re/build.sh). Catálogo program = "elf32 arm stm32f411 nucleo", que lê /firmware/nucleof411re/index.json; host = "utf-8 bytes on USART2".
Clock. 100 MHz, o clock que a variante NUCLEO_F411RE do STM32duino programa (HSE bypass a partir dos 8 MHz do ST-LINK, PLLM 4, PLLN 100, PLLP 2; APB1 / 2, APB2 / 1), então um ciclo dura exatamente 10 ns e uma fatia de 10 us, 1000 ciclos. O núcleo custa ao host o mesmo por ciclo que no Black Pill, e há 19 % mais ciclos por segundo, então um sketch que faz espera ocupada precisa de 19 % a mais da máquina para manter o tempo real; um que dorme em delay() não custa nada em nenhum caso.
Pinos (ordem do catálogo): os cabeçalhos Arduino CN6 IOREF, NRST, 3V3, 5V, GND, GNDb, VIN; CN8 A0..A5; CN5 D15, D14, AVDD, GNDc, D13..D8; CN9 D7..D2; depois os pinos que só os cabeçalhos morpho expõem, CN7 PC10, PC11, PC12, PD2, VDD, E5V, BOOT0, GNDd, PA13, PA14, PA15, PB7, PC13, VBAT, PC2, PC3 e CN10 PC9, PC8, PC6, PC5, U5V, GNDe, PA12, PA11, PB12, PB2, PB1, PB15, PB14, PB13, AGND, PC4, PA2, PA3 (63 pinos). Um pad que está tanto num cabeçalho Arduino quanto num cabeçalho morpho é um único pino, com o nome Arduino:
| Arduino | D2 |
D3 |
D4 |
D5 |
D6 |
D7 |
D8 |
D9 |
D10 |
D11 |
D12 |
D13 |
D14 |
D15 |
A0 |
A1 |
A2 |
A3 |
A4 |
A5 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| pad | PA10 |
PB3 |
PB5 |
PB4 |
PB10 |
PA8 |
PA9 |
PC7 |
PB6 |
PA7 |
PA6 |
PA5 |
PB9 |
PB8 |
PA0 |
PA1 |
PA4 |
PB0 |
PC1 |
PC0 |
Deixados de fora porque a placa, como vem de fábrica, não os conecta (UM1724 6.8, 6.12): D0/D1 (SB62/SB63 abertos; PA3/PA2 vão para o ST-LINK e estão no cabeçalho morpho), PC14/PC15 (o cristal LSE) e PH0/PH1 (o MCO do ST-LINK). VIN, E5V e BOOT0 são entradas que a placa ignora; IOREF, VDD, AVDD e VBAT (ligado ao VDD nesta placa) estão a 3.3 V; U5V está a 5 V.
Na placa. LD2, verde, do PA5 através de 510 ohms até o terra: fica acesa enquanto o pino direciona nível alto, e somente enquanto ele é uma saída (bit 2 da ponta de prova). B1, o botão azul USER, liga o PC13 ao terra (um toque em 1 mantém pressionado, 0 solta), e R30, 4.7 k do PC13 para 3.3 V, está sempre no pino, então uma entrada lê nível alto quando solto. B2 é NRST (toque em 2, 3). Os bits da ponta de prova são os do Black Pill; os bits 3 e 4 são o COM do LD1 do ST-LINK.
Runtime. Numeração NUCLEO_F411RE do STM32duino: 0..15 são D0..D15, 16..51 seguem a ordem morfo da variante, PIN_A0..PIN_A15 = 192..207 são suas entradas analógicas, e todo nome de porta é definido como um desses números (PA5 é PIN_A15, que é o pino digital 13), então 13, D13, PA5 e LED_BUILTIN são o mesmo pino. USER_BTN é PC13. Serial é a USART2 em PA2/PA3 (SERIAL_UART_INSTANCE 2), também chamada Serial2; não existe Serial1. analogWrite usa o primeiro timer que o PinMap_TIM da variante lista para cada pino, a 1 kHz (PSC 1, ARR 49.999): TIM2 em PA0..PA3, PA5, PA15, PB3, PB10; TIM3 em PA6, PB4, PB5, PC6..PC9; TIM4 em PB6..PB9; TIM1 em PA8..PA11 e, como CH1N..CH3N, PA7, PB0, PB1, PB13.. PB15. Assim, micros() roda no TIM5 aqui, e tone() no TIM10, o TIMER_TONE da variante. Wire usa por padrão D14/D15, e SPI usa D13, D12, D11, D10. Exemplos em firmware/nucleof411re/examples/: blink, button, serial, fade (D9) e analog (A0).