Referência

Contrato da placa STM32 "Blue Pill" F103 (Fase 9)

A F103 no nosso núcleo Cortex-M3, com GPIO por CRL e CRH, TIM1 a TIM4, USART1 e um ADC de doze bits.

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 STM32 Blue Pill e página da placa.

O quinto microcontrolador e a segunda placa Cortex-M. Um componente do kernel (bluepill em crates/parts) envolve um modelo do SoC STM32F103C8T6 (crates/stm32f103) construído sobre o mesmo núcleo ARMv7-M da Black Pill (crates/cortexm-core, comprovado em proofs/cortexm/REPORT.md). O firmware é um ELF ARM Thumb comum que conversa com os periféricos abaixo nos endereços reais do STM32F103, tirados do RM0008 (o manual de referência do STM32F101/102/103/105/107) e do datasheet do STM32F103x8/xB, então um programa compilado para o Mokxi também roda em uma Blue Pill real.

O tipo do catálogo é bluepill (STM32F103C8T6, LQFP de 48 pinos, a placa que todo mundo chama de Blue Pill). Tudo o que docs/esp32c3.md diz sobre como um componente de placa se comporta (fatias, canal do host, reset, linha de crash) e tudo o que docs/uno.md diz sobre como uma placa se encaixa num circuito vale aqui, a menos que este arquivo diga o contrário.

Por que este não é o Black Pill com números diferentes

docs/stm32f411.md é o irmão deste documento, e a tentação é ler um como o outro. Não faça isso. O F1 é uma geração diferente da família e as diferenças são exatamente as que um programa consegue ver:

F411 (Black Pill) F103 (Blue Pill)
núcleo Cortex-M4, sem FPU Cortex-M3
clock 84 MHz 72 MHz
flash / SRAM 512 KB / 128 KB 64 KB / 20 KB
configuração de pino MODER, OTYPER, PUPDR, AFRL/AFRH um campo de quatro bits em CRL/CRH
direção do pull de entrada PUPDR o bit ODR daquele pino
limpar um pino metade alta do BSRR metade alta do BSRR, ou BRR
porta de clock do GPIO RCC_AHB1ENR RCC_APB2ENR
função alternativa um número por pino em AFR fixa por periférico, remapeada em AFIO_MAPR
seleção de porta do EXTI SYSCFG_EXTICR AFIO_EXTICR
base do RCC 0x4002_3800 0x4002_1000
timers TIM2 e TIM5 são de 32 bits todo contador é de 16 bits
ADC não modelado ADC1, conversão única
pinos de debug no reset PA13, PA14, PA15, PB4 com pull os mesmos cinco, liberados por SWJ_CFG

Nenhum endereço é compartilhado. Os dois crates do SoC são irmãos, não um modelo e uma cópia.

Rodar binários do fabricante (STM32Cube HAL, libopencm3, o core STM32duino) não é um objetivo. Eles precisam da árvore de clock levantada a partir do HSI, da latência e do prefetch do flash, de DMA e USB, nada do qual é modelado. O que é um objetivo é que todo registrador que um programa bare-metal toca para piscar um pino, imprimir numa UART, ler um botão, ler uma tensão e acionar uma saída PWM esteja no endereço real com seus bits reais, de modo que o mesmo código-fonte compilado de forma cruzada contra os cabeçalhos CMSIS funcionaria no silício.

1. Pinos da placa (ordem do catálogo)

The board is 2x20 pins on a 0.1 inch pitch, 53 x 23 mm, with the micro-USB socket at the top. Catalog order is the left header top to bottom, then the right header top to bottom.

Conector esquerdo: VBAT, PC13, PC14, PC15, PA0, PA1, PA2, PA3, PA4, PA5, PA6, PA7, PB0, PB1, PB10, PB11, NRST, 3V3, GND, 5V

Conector direito: GNDb, GNDc, 3V3b, PB12, PB13, PB14, PB15, PA8, PA9, PA10, PA11, PA12, PA15, PB3, PB4, PB5, PB6, PB7, PB8, PB9

40 pinos: 32 de E/S, três terras, dois de 3,3 V, um de 5 V, VBAT e NRST. A serigrafia imprime as formas curtas (VB, C13, R, A0, B9, G, 3.3); o catálogo usa os nomes completos de porta porque uma referência de pino na netlist precisa ser inequívoca, e adiciona sufixos às repetições (GNDb, GNDc, 3V3b) porque dois pinos de um componente não podem compartilhar um nome.

Três pinos do chip não estão num conector: PA13 e PA14 são o conector SWD separado de quatro pinos ao longo da borda inferior, e PB2 é o jumper BOOT1 no topo. Eles existem no modelo do chip (têm de existir, porque a porta de debug os mantém), mas nenhum fio consegue alcançá-los aqui, exatamente como na placa.

Elétrico:

  • 3V3 e 3V3b fornecem 3,3 V em R_SUPPLY; 5V fornece 5 V em R_SUPPLY; GND, GNDb e GNDc fornecem 0 V. A placa está sempre alimentada (USB). 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 datasheet dá de 30 k a 50 k); abaixo de 1,65 V ela mantém a CPU em reset; soltá-la reinicia o programa a partir do vetor de reset.
  • Cada PAn, PBn e PCn é uma GPIO inout. Saída (MODE != 00): push-pull a 3,3 V ou 0 V através de R_STRONG, ou dreno aberto (CNF = 01 ou 11), em que um nível alto é high-Z sem nenhum pull, porque uma saída do F1 não tem nenhum. Entrada (MODE = 00): high-Z para flutuante (CNF = 01) e analógico (CNF = 00), ou um pull de 40 k cuja direção é o bit ODR daquele pino para CNF = 10. A entrada lê a tensão do nó contra 1,65 V (metade de 3,3 V); Unknown lê 0, e uma entrada flutuante lê ruído, como no Uno (docs/uno.md seção 1).
  • PC13 carrega o LED verde da placa, ânodo no 3,3 V através de 1 k, cátodo no pino: o LED acende quando PC13 é 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). 1 k em vez dos 470 R do Black Pill, razão pela qual o LED de um Blue Pill é o mais fraco dos dois. A nota do próprio datasheet da ST vale aqui também: PC13, PC14 e PC15 estão no domínio de energia de backup e só conseguem drenar 3 mA, então eles acionam um indicador e pouco mais.
  • Não há botão do usuário. O único botão do Blue Pill é o RESET, que é alcançado pelo poke (seção 5). Um sketch que precisa de um botão tem de colocar um na protoboard, razão pela qual tantos tutoriais de Blue Pill começam ligando um.
  • PA9/PA10 são USART1 TX/RX na placa real e aqui; os bytes da USART vão para o canal do host (seção 4). PA11/PA12 são USB D-/D+ na placa real e GPIO comum aqui.
  • PA15, PB3 e PB4 estão no conector, mas a porta de debug SWJ os mantém fora do reset: PA15 e PB4 com pull-up, PB3 flutuante. O firmware os recupera escrevendo SWJ_CFG em AFIO_MAPR (seção 3.5). Esta é a surpresa mais comum nesta placa, e o modelo a reproduz em vez de escondê-la.

2. Mapa de memória (endereços reais do STM32F103C8)

região endereço tamanho notas
flash 0x0800_0000 64 KB flash do STM32F103C8; escritas são ignoradas (sem interface de programação de flash)
alias da flash 0x0000_0000 64 KB os mesmos bytes, porque BOOT0 está baixo e a área de boot mapeia a flash principal para 0
SRAM 0x2000_0000 20 KB
APB1 0x4000_0000 32 KB TIM2..TIM4, USART2, USART3, seção 3
APB2 0x4001_0000 32 KB AFIO, EXTI, GPIOA..GPIOC, ADC1, TIM1, USART1, seção 3
AHB 0x4002_0000 RCC em 0x4002_1000, 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.

Muitas placas C8 têm de fato 128 KB de flash, porque o die é um CB com metade dele sem teste. 64 KB é o que o número do componente promete, então 64 KB é o que este modelo oferece e o que o firmware pode assumir; o script de link verifica isso.

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 STM32F1 implementa os quatro bits superiores de cada campo de prioridade de 8 bits, como a F4, então NVIC_IPR se comporta como um NVIC_SetPriority do CMSIS espera. Um Cortex-M3 é ARMv7-M sem a extensão DSP do M4 e sem FPU, exatamente o que cortexm-core implementa e recusa: toda codificação VFP e SIMD saturante levanta UNDEFINSTR. Nenhum recurso precisou ser desligado para este componente; os extras do M4 nunca estiveram lá. Compile o firmware com -mcpu=cortex-m3 -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. O acesso por byte e meia palavra funciona e atinge a palavra que os contém, que é o que a ponte APB faz para os registradores modelados aqui.

3.1 RCC (0x4002_1000)

A árvore de clock é modelada a partir dos registradores, com uma concessão às imagens que o Mokxi distribui: até o firmware mexer na configuração do clock o componente roda no clock de boot, SYSCLK = HCLK = 72 MHz (o cristal HSE vezes nove), APB1 na metade e o ADC em PCLK2 / 6, porque o runtime do Arduino nunca programa o PLL. A primeira escrita em RCC_CR, ou uma escrita em RCC_CFGR que mude SW, PLLSRC, PLLXTPRE ou PLLMUL, entrega o clock aos registradores: a partir daí SYSCLK é o HSI (8 MHz), o HSE (8 MHz) ou o PLL (HSI / 2, ou HSE dividido pela metade por PLLXTPRE, vezes PLLMUL + 2, no máximo 16) conforme SWS disser, HCLK é SYSCLK / HPRE, PCLK1 e PCLK2 são HCLK / PPRE1 e PPRE2, os clocks dos timers são PCLK (prescaler 1) ou 2 x PCLK, e o clock do ADC é PCLK2 / ADCPRE. O núcleo, o SysTick, os timers, os baud rates do USART, o 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 do 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. Reset 0x0000_0083
0x04 RCC_CFGR armazenado; SWS[3:2] segue SW[1:0] imediatamente quando a fonte que SW indica está ligada em RCC_CR, e fica parado caso contrário. HPRE, PPRE1, PPRE2, PLLMUL, PLLSRC, PLLXTPRE e ADCPRE definem os clocks como acima
0x08 RCC_CIR armazenado, lido de volta
0x0C RCC_APB2RSTR um 1 escrito no bit de um periférico reseta os registradores desse periférico; o próprio registrador lê 0
0x10 RCC_APB1RSTR o mesmo para os periféricos da APB1
0x14 RCC_AHBENR armazenado, lido de volta; reset 0x0000_0014 (SRAMEN, FLITFEN)
0x18 RCC_APB2ENR bit 0 AFIOEN, 2 IOPAEN, 3 IOPBEN, 4 IOPCEN, 5 IOPDEN, 6 IOPEEN, 9 ADC1EN, 10 ADC2EN, 11 TIM1EN, 12 SPI1EN, 14 USART1EN
0x1C RCC_APB1ENR bit 0 TIM2EN, 1 TIM3EN, 2 TIM4EN, 11 WWDGEN, 14 SPI2EN, 17 USART2EN, 18 USART3EN, 21 I2C1EN, 22 I2C2EN, 23 USBEN, 25 CANEN, 27 BKPEN, 28 PWREN
0x20 RCC_BDCR armazenado; LSERDY (1) segue LSEON (0)
0x24 RCC_CSR stored; LSIRDY (1) follows LSION (0); PINRSTF (26) set after an NRST reset, PORRSTF (27) after power-on, SFTRSTF (28) after AIRCR.SYSRESETREQ; a write with RMVF (24) clears the flags. There is no BORRSTF: this family has no brown-out reset flag, and bit 25 is reserved

O GPIO é habilitado a partir de APB2ENR, e não de um registrador do AHB. Essa única linha é a diferença entre um sketch de Blue Pill que funciona e um em que toda escrita em pino some, e é onde um hábito da F4 falha primeiro.

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 (0x4001_0800, 0x4001_0C00, 0x4001_1000)

offset nome bits
0x00 CRL 4 bits por pino, pinos 0..7: MODE em 0..1, CNF em 2..3
0x04 CRH o mesmo para os pinos 8..15
0x08 IDR somente leitura, bits 0..15: os níveis dos pinos
0x0C ODR bits 0..15: o latch de saída, e a direção do pull-up/pull-down de uma entrada com pull
0x10 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
0x14 BRR write-only: bits 0..15 clear the matching ODR bit. The F4 has no such register
0x18 LCKR armazenado, lido de volta; a sequência de trava não é imposta

MODE: 00 entrada, 01 saída a 10 MHz, 10 saída a 2 MHz, 11 saída a 50 MHz. As três taxas de saída são armazenadas e não afetam o tempo de subida aqui, o que é dito claramente em vez de escondido.

CNF while MODE is 00: 00 analog, 01 floating, 10 pulled (e a direção do pull é o bit de ODR daquele pino, 1 para cima e 0 para baixo), 11 reservado.

CNF enquanto MODE não é 00: 00 push-pull de uso geral, 01 open drain de uso geral, 10 push-pull de função alternativa, 11 open drain de função alternativa.

O valor de reset de CRL e CRH é 0x4444_4444: todo pino uma entrada flutuante. ODR reseta para 0.

IDR lê o que este chip está colocando num pino que ele dirige em push-pull, e o que a placa amostrou do nó em qualquer outro pino, exatamente como PINx faz no Uno. Uma saída open drain, portanto, lê o pino e não o latch, que é o que faz um barramento one-wire funcionar.

A porta de debug SWJ mantém cinco pinos após o reset, aconteça o que CRL/CRH disserem (RM0008 9.3.5): PA13 (JTMS/SWDIO) com pull-up, PA14 (JTCK/SWCLK) com pull-down, PA15 (JTDI) com pull-up, PB3 (JTDO) flutuante, PB4 (NJTRST) com pull-up. AFIO_MAPR.SWJ_CFG decide quais ele mantém: 000 todos os cinco, 001 todos menos PB4, 010 apenas PA13/PA14 (SWD, e a escolha usual), 100 nenhum. Um pino mantido pela porta de debug ignora o bloco GPIO completamente.

3.3 TIM1, TIM2, TIM3, TIM4 (0x4001_2C00, 0x4000_0000, 0x4000_0400, 0x4000_0800)

Todo contador deste componente é de 16 bits. Os quatro são clockados a 72 MHz (seção 5). O TIM1 é o timer avançado; os outros três são de uso geral.

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. Escreva 0 num bit para limpá-lo, 1 o deixa como está (rc_w0, como diz o manual)
0x14 EGR write-only: UG 0 reloads the prescaler, counter and repetition counter and sets UIF, CC1G 1..CC4G 4 set the capture/compare flags, TG 6 sets TIF
0x18 CCMR1 modo de saída: CC1S 0..1, OC1FE 2, OC1PE 3, OC1M 4..6, OC1CE 7, e os mesmos oito bits para o canal 2
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 16 bits
0x28 PSC 16 bits; o contador incrementa a 72 MHz / (PSC + 1)
0x2C ARR valor de recarga; o período é ARR + 1 ticks contando para cima
0x30 RCR somente no TIM1, 8 bits: o evento de atualização acontece a cada RCR + 1 overflows. Reservado nos outros três, e uma escrita lá conta como valor perdido
0x34 0x38 0x3C 0x40 CCR1 CCR2 CCR3 CCR4 16 bits
0x44 BDTR somente no TIM1: apenas MOE (15) tem efeito, e sem ele os canais não chegam a nenhum pino. O dead time, a entrada de break e as saídas complementares são armazenados e não modelados
0x48 0x4C DCR DMAR 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.

Output compare modes (OCxM): 0 frozen, 1 active on match, 2 inactive on match, 3 toggle, 4 force inactive, 5 force active, 6 PWM mode 1 (active while CNT < CCRx up-counting), 7 PWM mode 2 (the inverse). CCxP inverts the output polarity. The pin only moves while CCxE is set (and, on TIM1, BDTR.MOE as well) and the pad's CNF says alternate function (section 3.2), and AFIO_MAPR has that channel on that pin (section 3.5).

A captura de entrada não é modelada: CCxS != 0 armazena e conta uma conexão perdida.

NVIC lines: TIM1 splits its flags across TIM1_UP = 25 (the update flag) and TIM1_CC = 27 (the four compare flags and the trigger); TIM2 = 28, TIM3 = 29, TIM4 = 30 each carry all of theirs. Each asserts while any of its SR flags is set with the matching DIER enable, held as a level. The handler clears the flag, as on silicon.

3.4 USART1 (0x4001_3800), USART2 (0x4000_4400), USART3 (0x4000_4800)

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
0x04 DR escrita: transmite; leitura: o byte recebido e limpa RXNE
0x08 BRR DIV_Fraction 0..3, DIV_Mantissa 4..15; baud = f_PCLK / (16 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. O bit 15 é reservado: não há OVER8 neste componente, e a sobreamostragem é sempre por dezesseis
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 é 72 MHz para a USART1 (APB2) e 36 MHz para a USART2 e a USART3 (APB1), seção 5. A 72 MHz e 115200 baud, USARTDIV é exatamente 39.0625, então BRR = 0x271 e a taxa é exata; esse é um dos motivos pelos quais 72 MHz é o número que todos escolhem para este componente.

A USART1 é o canal do host. A transmissão é o buffer único do próprio componente mais o registrador de deslocamento: uma escrita em DR com TXE definido limpa TXE, o registrador de deslocamento recebe o byte e TXE volta imediatamente, e o byte chega ao host um tempo de quadro depois (10 tempos de bit no baud configurado), quando TC é definido. Recepção: os bytes do host entram em uma FIFO do tamanho do registrador real de recepção de um byte mais um acúmulo de 256 bytes no lado do host, para que o texto digitado não se perca; RXNE fica definido enquanto um byte espera; ler DR o remove, e um byte chegando com a fila cheia define ORE.

A USART2 e a USART3 são USARTs idênticas cujos bytes transmitidos não vão a lugar algum (eles são contados, então um teste pode vê-los) e cujos receptores nunca têm nada para ler. Elas existem para que firmware escrito para mais de uma porta compile e rode.

Linhas do NVIC: USART1 = 37, USART2 = 38, USART3 = 39. Cada uma se ativa enquanto RXNE & RXNEIE, TXE & TXEIE, TC & TCIE ou IDLE & IDLEIE se mantiver. 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 a enviar precisa desligar a si mesmo, como no chip.

3.5 AFIO (0x4001_0000) e EXTI (0x4001_0400)

offset nome bits
AFIO 0x00 EVCR armazenado, lido de volta
AFIO 0x04 MAPR os remaps abaixo, mais SWJ_CFG em 24..26
AFIO 0x08..0x14 EXTICR1..EXTICR4 4 bits por linha: 0 = porta A, 1 = porta B, 2 = porta C. A linha n observa o pino n da porta selecionada
AFIO 0x1C MAPR2 armazenado, lido de volta
EXTI 0x00 IMR máscara de interrupção, um bit por linha 0..15 (as linhas 16..18 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

Não há AFRL/AFRH neste componente: os pinos de um periférico são fixos, e AFIO_MAPR move alguns deles em bloco. Os mapeamentos modelados:

campo do MAPR valor canal 1 / TX 2 3 4
TIM1_REMAP 6..7 00, 01 PA8 PA9 PA10 PA11
11 porta E, não modelada
TIM2_REMAP 8..9 00 PA0 PA1 PA2 PA3
01 PA15 PB3 PA2 PA3
10 PA0 PA1 PB10 PB11
11 PA15 PB3 PB10 PB11
TIM3_REMAP 10..11 00 PA6 PA7 PB0 PB1
10 PB4 PB5 PB0 PB1
11 PC6 PC7 PC8 PC9
TIM4_REMAP 12 0 PB6 PB7 PB8 PB9
1 porta D, não modelada
USART1_REMAP 2 0 / 1 PA9 / PB6 TX
USART2_REMAP 3 0 PA2 TX (1 é a porta D, não modelada)
USART3_REMAP 4..5 00 / 01 PB10 / PC10 TX

Um remap para uma porta que este modelo não tem (D ou E) deixa os pinos como estão em vez de inventá-los. Um pino pode ser função alternativa de dois periféricos (PA9 é USART1 TX e canal 2 do TIM1), o que no silício é um erro de configuração; o modelo resolve isso em um só lugar, USART antes do temporizador, de modo que cada pad tenha exatamente um dono e nenhum periférico possa empurrar outro para fora de um pino pelas costas.

SWJ_CFG (24..26) é o que libera os pinos de depuração; veja a seção 3.2.

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 ADC1 (0x4001_2400)

A twelve-bit successive-approximation converter, clocked at PCLK2 / 6 = 12 MHz (section 5), which is the only divider that keeps a 72 MHz APB2 inside the part's 14 MHz limit. One ADC clock is six CPU cycles.

offset nome bits
0x00 SR AWD 0, EOC 1, JEOC 2, JSTRT 3, STRT 4; escreva 0 para limpar
0x04 CR1 EOCIE 5, SCAN 8; o restante é armazenado
0x08 CR2 ADON 0, CONT 1, CAL 2, RSTCAL 3, ALIGN 11, EXTSEL 17..19, EXTTRIG 20, SWSTART 22
0x0C 0x10 SMPR1 SMPR2 3 bits por canal: 1.5, 7.5, 13.5, 28.5, 41.5, 55.5, 71.5, 239.5 clocks do ADC. SMPR2 contém os canais 0..9
0x14..0x20 JOFR1..JOFR4 armazenado, lido de volta
0x24 0x28 HTR LTR armazenado, lido de volta; o watchdog analógico não é modelado
0x2C SQR1 L 20..23, o tamanho do grupo menos um, e as conversões 13..16
0x30 0x34 SQR2 SQR3 cinco bits por conversão; SQR3[4:0] é o primeiro
0x38 JSQR armazenado, lido de volta; o grupo injetado não é modelado
0x3C..0x48 JDR1..JDR4 lê 0
0x4C DR a última conversão regular concluída; lê-lo limpa EOC

Uma conversão leva tempo de amostragem + 12,5 ciclos de ADC, e o resultado não é entregue antes do tempo: o firmware realmente espera em EOC. Com a amostragem padrão de 1,5 ciclos, são 14 ciclos de ADC (84 ciclos de CPU, 1,17 us); com os 55,5 que o runtime usa, 68 ciclos (408 ciclos, 5,7 us).

Iniciar uma conversão: escrever ADON quando ele já está em 1 inicia uma, que é a própria expressão idiomática do componente, e o mesmo vale para SWSTART com EXTTRIG definido e EXTSEL = 111. CONT reinicia ao fim de cada uma. CAL e RSTCAL são aceitos e lidos de volta limpos imediatamente (não há nada a calibrar), e nenhum deles inicia uma conversão, porque um conversor em calibração não converte. ALIGN coloca os doze bits em DR[15:4].

SCAN percorre o grupo regular e deixa o último resultado em DR, que é exatamente o que faz um componente sem DMA, e a razão pela qual SCAN sem DMA é uma armadilha.

Canais: 0..7 são PA0..PA7 e 8..9 são PB0..PB1. Os canais 10..15 estão em pinos da porta C que um componente de 48 pinos não tem. O canal 16 é o sensor de temperatura, fixado em sua leitura de 25 C de 1,43 V (1775 contagens), e o canal 17 é o VREFINT, fixado em 1,20 V (1489 contagens). O componente da placa converte a tensão do nó em cada pino analógico em uma contagem com base no trilho de 3,3 V; um nó em contenção lê 0, e um flutuante vagueia, como acontece no Uno.

Linha do NVIC: ADC1_2 = 18, ativada enquanto EOC & EOCIE se mantém. O ADC2 não é modelado.

3.7 SysTick e o NVIC

Ambos estão dentro de cortexm-core, nos endereços arquiteturais do System Control Space, e nunca chegam ao barramento (proofs/cortexm/REPORT.md seção 5). SYST_CALIB é 90.000 com SKEW e NOREF limpos: a referência externa é HCLK/8 = 9 MHz, então um tick de 10 ms é exatamente 90.000 deles e o campo é exato, ao contrário do Black Pill, onde não cabe. Com CLKSOURCE limpo, o modelo ainda conta ciclos do processador; o divisor por 8 não é modelado e é declarado aqui em vez de escondido.

stm32f103.h também tem as grafias da 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 (72.000.000, uma variável como na CMSIS) e um SystemCoreClockUpdate() vazio. O millis() do runtime roda no SysTick, então um sketch que o reprograma altera millis() e delay(), como aconteceria sob a HAL do STM32duino.

3.8 O que não é modelado

A árvore de clock e a latência de flash, DMA, USB, CAN, I2C, SPI, o RTC e os registradores de backup, os watchdogs, o ADC2, o grupo injetado e o watchdog analógico do ADC, a entrada de break e as saídas complementares do TIM1, o input capture, os modos de baixo consumo do controlador de energia, os option bytes e a programação de flash. Seus registradores não estão mapeados (falha de acesso), exceto onde um bloco é listado acima; nesse caso, um offset não implementado lê 0, ignora escritas e conta uma escrita perdida. WFI e WFE estacionam o núcleo; SLEEPDEEP é armazenado e se comporta como sono comum.

4. Canal do host

host = "bytes utf-8 na USART1". readHost retorna os bytes de TX da USART1 conforme eles terminam de sair no fio; writeHost empurra bytes para a fila de recepção da USART1 (o estouro 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

72 MHz, um ciclo por 1/72 us. As contagens de ciclos vêm do núcleo (Cpu::run retorna ciclos; o contador de ciclos do núcleo é o clock). Um ciclo não é um número inteiro de picossegundos, então o tempo é derivado como ps = ciclos * 1_000_000 / 72, exatamente, nunca acumulado, sempre recomputado a partir da contagem de ciclos, então nunca pode divergir. Uma fatia de 10 us é exatamente 720 ciclos, e 720 ciclos são exatamente 10.000.000 ps, então os limites das fatias 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 frequência
SYSCLK, HCLK, CPU 72 MHz
Clock de periféricos da APB1 (USART2, USART3) 36 MHz
Clock de timers da APB1 (TIM2..TIM4) 72 MHz
APB2 (USART1, TIM1, entrada do prescaler do ADC) 72 MHz
ADC 12 MHz

Dentro de uma fatia, o núcleo é avançado de modo que cada escrita em periférico carregue o ciclo de CPU em que aconteceu: uma mudança de pino vira um drive_after naquele deslocamento a partir do início da fatia, então duas escritas em BSRR a quatro ciclos de distância realmente ficam 55 ns afastadas 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 de sua contagem, prescaler, ARR e modo, o núcleo roda até aquele ciclo, o evento é aplicado e a execução 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 (e WFE com o registrador de evento limpo) estaciona o núcleo: o componente para de fatiar e agenda um único despertar no mais próximo entre o reload do SysTick, o próximo evento de timer que possa levantar uma interrupção habilitada, o próximo evento de USART e o fim de uma conversão do ADC; uma mudança de pino ou um byte do host o desperta imediatamente. Essa é toda a história do repouso. proofs/cortexm/REPORT.md mede o núcleo a cerca de tempo real no Chromium e afirma claramente que não há margem, então um sketch que faz espera ocupada em um delay() não vai manter tempo real. Por isso o delay() do runtime estaciona em WFI e é despertado pelo SysTick, e uma placa ociosa custa ao kernel um punhado de eventos por segundo simulado em vez de 72 milhões de ciclos.

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 RESET, 1 = segurar RESET. Não há um segundo botão para poke nesta placa.

Tratamento de falhas como em docs/esp32c3.md seção 5: o núcleo relata uma Trap, e o componente para e imprime uma linha no canal do host, por exemplo firmware crashed at pc=0x08000412, BKPT #0 (CFSR 0x00000000, HFSR 0x40000000). Um lockup, uma instrução indefinida, um BKPT e uma tabela de vetores não mapeada chegam todos como traps. O componente então para de pedir despertares.

6. Runtime do firmware (firmware/bluepill/)

Um runtime freestanding de C e C++ para o STM32F103, compilado com clang 18 (--target=thumbv7m-none-eabi -mcpu=cortex-m3 -mfloat-abi=soft -Os) e lld, sem newlib, sem CMSIS, sem HAL, nada de GPL:

  • crt0.S: the 16 system vectors plus the 60 IRQ vectors at the head of flash, reset entry (copy .data from its load address in flash, clear .bss, run the C++ static constructors, call main; the core has already loaded MSP from vector 0), and a default handler that executes BKPT so a stray interrupt becomes one line on the serial monitor rather than a silent spin.
  • link.ld: flash em 0x0800_0000 com 64 KB, SRAM em 0x2000_0000 com 20 KB, pilha a partir do topo da SRAM, com um assert de que os dados estáticos deixam 2 KB para ela.
  • stm32f103.h: todos os registradores da seção 3 como macros volatile com o nome real da ST (GPIOC->ODR, RCC->APB2ENR, TIM3->CCR1, USART1->DR, ADC1->SQR3), além das constantes de bits e dos números de IRQ.
  • arduino.h: a mesma interface de sketch dos runtimes do Uno e da Black Pill, nos pinos deste componente: pinMode, digitalWrite, digitalRead, analogRead, analogWrite, delay, delayMicroseconds, millis, micros, Serial, attachInterrupt, shiftOut, map, random. Os números dos pinos são os nomes das portas: PA0, PB9, PC13 são constantes, e LED_BUILTIN é PC13. Há um pinMode extra, INPUT_ANALOG, porque o conversor do F1 só pode amostrar um pino cujo CNF indicar isso.

millis() vem do SysTick a 1 kHz (reload 71,999). micros() vem do TIM2 a 1 MHz (PSC = 71, ARR = 0xFFFF) estendido para 32 bits em software: todo contador deste componente tem dezesseis bits, então o TIM2 transborda a cada 65,536 ms e sua interrupção de atualização carrega a metade de cima. micros() lê as duas partes com uma proteção contra um transbordo cair entre elas, e incorpora um transbordo cujo tratador ainda não rodou, que é o que noInterrupts() em volta de uma chamada de micros() significa. Quinze interrupções por segundo é nada perto das mil do SysTick. delay() estaciona o núcleo em WFI até a contagem do SysTick atingir o prazo; delayMicroseconds() espera ocupado em micros().

analogRead(pin) devolve os próprios doze bits do conversor, 0 em 0 V e 4095 em 3,3 V, e não os dez de um Arduino: o ADC deste componente é realmente de doze bits, e arredondá-lo para baixo para parecer um AVR jogaria fora dois bits à toa. A primeira chamada liga o ADC1, define ADCPRE como /6 e executa a sequência de reset e calibração. Os dez pinos são PA0..PA7, PB0 e PB1; qualquer outro devolve 0.

analogWrite(pin, 0..255) gera PWM a 1 kHz, como o STM32duino faz (PWM_FREQUENCY 1000: PSC = 1, um tick de 36 MHz, e ARR = 35.999, ou seja, 72 MHz / 2 / 36.000), com CCRx = 36.000 x valor / 255, a escala do setCaptureCompare do core, em dez pinos:

temporizador canal 1 canal 2 canal 3 canal 4
TIM3 PA6 PA7 PB0 PB1
TIM4 PB6 PB7 PB8 PB9
TIM1 PA8 nenhum nenhum PA11

PA0..PA3 are not PWM pins here, unlike on the Black Pill: TIM2 is the microsecond counter and it needs a whole timer to itself. TIM1's channels 2 and 3 are PA9 and PA10, which are Serial, so they are left out too. TIM1 needs BDTR.MOE, which the runtime sets when it starts that timer.

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.

Serial é a USART1 em PA9/PA10, 8N1, recepção por interrupção num anel de 64 bytes, transmissão por um anel de 64 bytes esvaziado pela interrupção TXE, como faz o HardwareSerial do STM32duino (SERIAL_TX_BUFFER_SIZE 64): um print que cabe retorna imediatamente e os bytes saem na taxa de baud, um maior espera por espaço, e availableForWrite() é o espaço restante (63 quando vazio). attachInterrupt(pin, fn, mode) usa AFIO e EXTI: um tratador por linha, CHANGE, RISING e FALLING.

Exemplos em firmware/bluepill/examples/<name>/sketch.ino, compilados para web/public/firmware/bluepill/<name>.elf com web/public/firmware/bluepill/index.json no mesmo formato do índice do Uno, cada entrada carregando "program": "elf32 arm stm32f103":

  • blink: PC13 a 1 Hz, ativo em nível baixo, delay(500) estacionado em WFI.
  • button: um botão em PB0 com INPUT_PULLUP acende PC13.
  • serial: imprime millis() e um analogRead(PA0) uma vez por segundo, e ecoa o que recebe.
  • fade: analogWrite em PA6 fazendo um LED respirar pelo TIM3, com PC13 acompanhando.

A interface escolhe a lista de firmwares pela string program do componente no catálogo (docs/sim-api.md seção 3): "elf32 arm stm32f411" lê /firmware/stm32/index.json e "elf32 arm stm32f103" lê /firmware/bluepill/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 percorrido por firmware real. Todo endereço base, deslocamento de registrador e posição de bit das seções 2 e 3 vem do manual de referência do STM32F1 (RM0008) e da folha de dados do STM32F103C8: RCC em 0x4002_1000, GPIOA/B/C em 0x4001_0800/0C00/1000 com os nibbles de configuração de quatro bits CRL/CRH próprios do F1, TIM1 a TIM4, USART1 a USART3, AFIO em 0x4001_0000, EXTI em 0x4001_0400 e ADC1 em 0x4001_2400, com 20 KB de SRAM e 64 KB de flash. crates/stm32f103/tests/firmware.rs carrega ELFs reais e aciona GPIO, os timers, USART1, ADC1, SysTick e EXTI através deles. A ordem do cabeçalho de quarenta pinos do Blue Pill, seu LED em PC13 ligado com o anodo no trilho, e o fato de PA15, PB3 e PB4 subirem como pinos JTAG 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 boot é 72 MHz. Um Blue Pill real que nunca configura o PLL roda a 8 MHz no HSI; aqui um programa que nunca toca nos registradores de clock roda a 72 MHz, 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 são seguidos (seção 3.1); a latência da flash não.
  • A fatia tem duas marchas, e o primeiro acesso depois de um período quieto é adiantado, em até 7,1 us. Tudo dentro de uma rajada é exato. O raciocínio é o mesmo da seção 7 de docs/stm32f411.md.
  • O ADC1 não tem erro nenhum. Uma conversão é a reta contra VREF+ = 3,3 V, amostrada no instante em que começou, sem sample-and-hold, sem impedância de entrada, sem não linearidade, sem ruído e sem nenhum dos desvios que o ADC de um F103 real precisa de calibração (o bit CAL do ADC_CR2 é aceito e não faz nada aqui).
  • 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á 30 kΩ a 50 kΩ), lidos contra metade da alimentação, sem histerese, sem ajuste de velocidade, sem tempo de subida e sem limite de corrente.
  • A placa é uma fonte ideal: 3V3 e 5V na impedância do trilho para sempre, então nada sofre brown out e o regulador (que num Blue Pill clone costuma ser o componente errado e o motivo de a placa morrer) não está lá. A inicialização é um microssegundo, sem pinos de boot e sem option bytes.
  • Não há botão de usuário, porque a placa não tem nenhum; o único botão mantém NRST em nível baixo e chega pelo poke.

Ausentes de propósito, como a seção 3.8 lista: a árvore de clock e a latência da flash, DMA, USB (então Serial chega ao monitor pelo canal do host e PA11/PA12 ficam como GPIO comum), CAN, I2C, SPI, o RTC e os registradores de backup, os watchdogs, a entrada de break e as saídas complementares do TIM1, o ADC2, o grupo injetado e o watchdog analógico do ADC, e a programação da flash.

8. Enviar para uma placa real

"Upload para a placa" grava um sketch em uma Blue Pill real pelo bootloader de memória de sistema do F103 na USART1, como descreve o AN3155 da ST (web/src/hardware/stm32-serial.ts, o cartão em stm32-upload-dialog.ts).

  • Compilação. A compilação para hardware é o runtime do simulador mais firmware/bluepill/hardware/clocks.c sob -DMOKXI_HARDWARE (hardwareBundle em web/src/compile/bundles.ts). O chip real sai do reset no HSI de 8 MHz; mokxi_hw_init() inicia o cristal de 8 MHz, define dois wait states de flash e o prefetch buffer, APB1 /2, APB2 /1, ADC /6, e roda o SYSCLK a partir do PLL a 72 MHz. Esse é exatamente o F_CPU, F_APB1, F_APB2 e F_TIM que stm32f103.h assume. Sem cristal, ele fica no HSI. O endereço de link é o mesmo (0x08000000), então o script de link é compartilhado. Os ELFs do simulador estão fixados em hardware-build.test.ts.
  • Ligação. Um adaptador serial USB a 3,3 V: TX no A10, RX no A9, GND no G. BOOT0 em 1, depois RESET, inicia o loader da ROM. Após o upload, BOOT0 de volta a 0.
  • Protocolo. 115200 baud, 8E1. Sincronismo com 0x7F, Get, Get ID (0x410 em um F103C8), Erase (0x43) ou Extended Erase (0x44) conforme a versão do loader, Write Memory em blocos de 256 bytes, Read Memory para verificar cada um, e então Go para 0x08000000. Um NACK no erase significa que a proteção de leitura está ativa, e o cartão diz como limpá-la.
  • Ainda não testado em uma placa real. O flasher foi testado apenas contra um loader falso (testing/fake-stm32.ts).