Mikroprocesor STM32F407VG

Mikroprocesor lze definovat jako sekvenční automat vyrobený technologií VLSI (Very Large Scale Integration) — tedy integrovaný obvod s miliardami tranzistorů na jednom křemíkovém čipu. Tvoří ho tři základní součásti: řadič, ALU a pracovní registry. Samotný mikroprocesor není schopen provozu bez podpůrných obvodů — paměti, oscilátoru, vstupně-výstupních bloků. Teprve rozšířen o tyto součásti tvoří mikropočítač, a ten doplněný o periferie umožňující interakci s uživatelem se nazývá mikropočítačový systém.

Následující diagram ukazuje hierarchii: mikroprocesor (řadič + ALU + registr instrukce) tvoří jádro mikropočítače. K němu se přidává paměť a I/O bloky. Celý systém je pak obklopen periferiemi — monitorem, klávesnicí, vnější pamětí.

Výpočetní systém si lze představit jako člověka sedícího u stolu. Člověk je řadič — ovládá kalkulačku (ALU), jejíž ovládání je dáno programem (instrukcemi). Vstupní data zadává přes klávesnici (vstupní jednotka), výsledky vidí na displeji (výstupní jednotka). Na stole jsou položeny hodiny — každou minutu je proveden další příkaz. Příkazy na papíru jsou zpracovávány sekvenčně — od prvního k poslednímu, výjimkou jsou skokové instrukce. Ukazatel aktuálního příkazu je Program Counter (PC).

Každá instrukce prochází třemi fázemi: Fetch — řadič čte binární kód instrukce z paměti na adrese, kam ukazuje registr PC. Decode — dekodér zjistí typ operace (ADD, MOV, BEQ...) a připraví operandy. Execute — ALU instrukci vykoná a výsledek uloží. Procesor bez pipeline dokončí každou instrukci celým cyklem, moderní procesory s pipeline zpracovávají více instrukcí najednou — každý takt dokončí jednu.

Základem dnešních výpočetních strojů (od roku 1945) je Von Neumannova architektura. Klíčový princip: instrukce i data jsou členěny do slov/slabik stejného formátu, uloženy ve společné paměti a nijak speciálně nerozlišeny. Zpracování je sekvenční — instrukce za instrukcí. Struktura výpočetního stroje je nezávislá na řešeném problému — program uložený v paměti definuje, co stroj dělá. Paměť je rozdělena na buňky stejné velikosti, přistupuje se k nim pomocí adresy.

Nevýhodou je Von Neumannův bottleneck: CPU a paměť jsou propojeny jedinou sběrnicí — instrukce i data musí sdílet stejný kanál, procesor nemůže současně číst instrukci a přistupovat k datům. Instrukce a data jsou binárně zakódována a vzájemně nerozeznatelná (záměna instrukcí a dat je technicky možná — self-modifying code).

Harvardská architektura odděluje paměť pro data a program — fyzicky jsou to dvě samostatné paměti se dvěma oddělenými sběrnicemi. Díky tomu lze instrukci a data načítat souběžně, bez vzájemného blokování. Paměti nemusí mít stejné parametry (Flash pro program, SRAM pro data). Nevýhodou je, že nevyužitou část jedné paměti nelze přidělit druhé. Nenastane situace vlastního přepsání (program nemůže přepsat sám sebe přes datovou sběrnici). Řízení CPU je odděleno od řízení V/V jednotek — nejsou napojeny přímo na ALU. Příklady: Atmel 8051, ARM (v modifikované podobě).

ARM Cortex-M4 používá modifikovanou Harvardskou architekturu: uvnitř jádra jsou fyzicky odděleny instrukční sběrnice (I-BUS) a datová sběrnice (D-BUS), takže fetch a datový přístup probíhají paralelně. Z pohledu programátora je však adresový prostor unifikovaný — Flash, RAM i periferie leží v jednom lineárním adresovém prostoru 0x00000000–0xFFFFFFFF. Výsledek: výkon Harvardské architektury + flexibilita Von Neumannovy architektury.

CISC (Complex Instruction Set Computer) — instrukce jsou komplexní, každá může provést více operací. Proměnná délka instrukcí (1–15 B u x86). Program je kratší, ale dekódování složité. Příklady: Intel x86/x64.

RISC (Reduced Instruction Set Computer) — instrukce jsou jednoduché, pevná délka (2 nebo 4 B), typicky 1 cyklus. Přirozená pipeline. Program je delší, ale každá instrukce je rychlá. Příklady: ARM, MIPS, RISC-V, AVR.

ARM Cortex-M4 používá Thumb-2 — hybridní instrukční sada kombinující 16bitové Thumb instrukce (kompaktní kód) a 32bitové ARM instrukce (výkon). Historicky: první ARM procesor vyrobila firma Acorn Computers, ARM = Acorn Risc Machine, dnes Advanced RISC Machine. ARM Holdings (britská společnost, zal. 1990 firmami Acorn, Apple a VLSI Technology) architekturu vyvíjí a licencuje — samotné čipy vyrábí až výrobci jako ST, Apple, Qualcomm, Samsung, Nvidia. Ročně se vyrobí přes 50 miliard ARM čipů.

Procesory se dělí nejen na RISC/CISC, ale i podle šířky operandu a použití:

• MCU (Microcontroller Unit) — nejjednodušší skupina, mikrořadiče. Malé rozměry, nízká cena a spotřeba, slabší výkon. Vyráběny pro přesně určenou specifickou činnost s minimální možností rozšíření. Příklad: STM32, AVR.
• CPU (Central Processing Unit) — základní řídicí jednotka PC. Mnohem vyšší výkon, větší rozměry, větší spotřeba. Jednodušší a širší možnost rozšíření — otevřená architektura, velké množství pinů/signálů. Příklad: Intel Core, AMD Ryzen.
• DSP (Digital Signal Processing) — kompromis mezi MCU a CPU. Návrh optimalizovaný pro algoritmy zpracování digitálních signálů. Vysoký výkon v oblasti zpracování velkého objemu dat v reálném čase. Využití v měřicí technice, zvukových kartách, mobilech.
• GPU (Graphics Processing Unit) — speciální procesory pro grafické karty. Řídí zpracování obrazových dat a výpočty fyzikálního modelu 3D scény.
• APU (Accelerated Processing Unit) — v jednom pouzdře CPU i GPU, moderní procesory.
• NPU (Network Processing Unit) — součást přepínačů, směrovačů a síťových zařízení.

Procesory se dělí také podle šířky slova: 4, 8, 16, 32, 64 bit. Šířka určuje, jak velká čísla procesor zpracuje v jednom kroku a jak velké jsou jeho registry.

Sběrnice (bus) je sdílené komunikační médium. Každá sběrnice se skládá ze tří skupin vodičů: adresová sběrnice (CPU vysílá adresu — 32bit = 4 GB adresovatelného prostoru), datová sběrnice (přenáší data — 8/16/32/64 bit šířka) a řídicí sběrnice (R/W, CS, CLK, IRQ). V STM32F407 jsou sběrnice hierarchicky organizovány: AHB (168 MHz, jádro + paměti + DMA), APB2 (84 MHz, ADC, TIM1/8, USART1/6) a APB1 (42 MHz, TIM2–7, USART2–5, SPI2/3, I2C).

Řadič je ta část mikroprocesoru, která čte instrukce a koordinuje ostatní části. Obsahuje: registr instrukce (uchovává právě načtenou instrukci), registr adresy (adresa příští instrukce = Program Counter), dekodér instrukce (rozpozná typ operace) a generátor řídících impulzů (vydává řídicí signály pro ALU a paměť). Řadič sám nic nepočítá — pouze orchestruje.

ALU je kombinační obvod — bezpaměťová "kalkulačka" procesoru. Provádí: sčítání, odčítání, logický AND/OR/XOR/NOT, bitový posun (shift), porovnání. Nastavuje stavové příznaky (flags): N (Negative), Z (Zero), C (Carry), V (Overflow). Tyto příznaky využívají podmíněné instrukce (BEQ, BNE, BGT...) pro větvení programu — základ if/else a smyček v C. Cortex-M4 navíc obsahuje FPU (Floating Point Unit) pro hardwarové operace s float čísly dle IEEE 754.

Mikroprocesor (MPU) je pouze výpočetní motor — CPU jádro (řadič + ALU + registry). Bez podpůrných obvodů není schopen provozu. Potřebuje externí: RAM, Flash/ROM, hodinový oscilátor, řadiče sběrnic, I/O expandéry. Příklad: Intel Core i7, 8086.

Mikrokontrolér (MCU) má vše integrováno na jednom čipu: CPU jádro + Flash paměť pro program + SRAM pro data + periferie (GPIO, timery, ADC, DAC, UART, SPI, I2C, USB...). Stačí přidat napájení, oscilátor a program — systém funguje.

Náš STM32F407VG je mikrokontrolér — na jediném čipu nese 32bitové ARM Cortex-M4 jádro, 1 MB Flash, 192 KB RAM a desítky periferií. ARM jako součást SoC (System on Chip) integruje: grafické jádro, operační paměť, síťový čip, I/O rozhraní, modem... Výhody SoC: levnější výroba, nižší spotřeba, vysoká integrace. Nevýhoda: malá možnost HW konfigurace.

Cortex-M4 patří do rodiny ARMv7E-M — 32bitová RISC architektura. Označení jader jsou Cortex, označení architektur ARMvX: Cortex-M4 → ARMv7, Cortex-A55 → ARMv8.2. Klíčové vlastnosti jádra:

• 32bitová datová šířka — operace s 32bitovými čísly jsou nativní.
• Modifikovaná Harvardská architektura — I-BUS, D-BUS a S-BUS uvnitř jádra.
• 5-stupňový pipeline (Fetch → Decode → Register Read → Execute → Write-back).
• Thumb-2 instrukční sada — 16bitové i 32bitové instrukce.
• Hardwarová násobička (1 cyklus) a dělička (2–12 cyklů).
• DSP rozšíření — SIMD, MAC (Multiply-Accumulate) instrukce.
• FPU (Floating Point Unit) — single-precision float dle IEEE 754.
• MPU (Memory Protection Unit) — volitelná ochrana paměťových regionů.
• NVIC (Nested Vectored Interrupt Controller) — integrovaný řadič přerušení.

STM32F407 mapuje vše do jednoho 32bitového adresního prostoru (0x00000000–0xFFFFFFFF). Na Discovery kitu je k dispozici: 1 MB Flash, 112 KB SRAM1, 16 KB SRAM2, 64 KB CCM RAM, 4 KB Backup SRAM. Celkem 192+4 KB RAM. Podporované externí paměti: Compact Flash, NAND, NOR Flash, SRAM, PSRAM.

STM32F407VGTx (pouzdro LQFP100) má 140 I/O pinů, porty A–K (pro uživatele A–E), 14 časovačů (16/32bit), 3× 12bit ADC, 2× 12bit DAC, 4× USART, 3× I2C, 3× SPI, USB 2.0, Ethernet 10/100 Mb/s, generátor náhodných čísel. CLK až 168 MHz, interní 16 MHz RC nebo 32 kHz. Debug: ST-LINK/V2 (SWD).

Cortex-M4 má 16 hlavních registrů + speciální: R0–R12 (obecné, R0–R3 = parametry funkcí a návratová hodnota), R13/SP (Stack Pointer — zásobník roste dolů, MSP pro privilegovaný kód, PSP pro RTOS vlákno), R14/LR (Link Register — návratová adresa při volání funkcí), R15/PC (Program Counter — adresa příští instrukce), APSR (Application PSR — příznaky N,Z,C,V), CONTROL (privilegovaný/neprivilegovaný režim), PRIMASK/FAULTMASK/BASEPRI (maskování přerušení — základ __disable_irq() / __enable_irq()).

Celý MCU potřebuje hodinový signál. Modul RCC (Reset and Clock Control) řídí všechny hodinové signály. Na Discovery kitu: interní HSI oscilátor 16 MHz. Pomocí PLL lze dosáhnout až 168 MHz. Sběrnice mají předděličky: AHB (max 168 MHz), APB2 (max 84 MHz), APB1 (max 42 MHz). Klíčové: každá periferie musí mít povolen hodinový signál zápisem do RCC registrů — bez toho jsou registry periferie nedostupné.

GPIO (General Purpose Input/Output) — 140 I/O pinů organizovaných do portů A–I, každý port má až 16 pinů. Každý port má vlastní sadu registrů. Před použitím je nutné vždy povolit hodinový signál pro daný port zápisem do RCC→AHB1ENR.

Každý pin je konfigurován 2 bity v registru MODER: 00 = vstup (reset state), 01 = výstup (GPIO output), 10 = alternativní funkce (AF), 11 = analogový mód.

Registr BSRR (Bit Set/Reset Register) umožňuje atomicky nastavit nebo resetovat piny jedním zápisem: dolních 16 bitů = set, horních 16 bitů = reset. Toto zabraňuje nekonzistentním stavům při přerušení uprostřed read-modify-write operace na ODR.

Piny mohou být přepojeny na interní periferie (UART, SPI, I2C, timery...) pomocí registru AFR[0/1] (4 bity na pin, hodnoty AF0–AF15). Například PA2 = TX USART2 = AF7, PA3 = RX USART2 = AF7. Nejprve je nutné nastavit MODER na 10 (alternativní funkce), poté zapsat číslo AF do AFR.

// Příklad: inicializace PA2 jako TX USART2 (AF7)
pin_enable(PA2);               // RCC->AHB1ENR |= GPIOAEN
pin_mode(PA2, PIN_MODE_AF);    // MODER |= (0b10 << 2*2)
pin_af(PA2, PIN_AF7);          // AFR[0] |= (7 << 4*2)

// Příklad: interní LED PD12 jako výstup
pin_enable(LED_IN_0);          // Hodinový signál pro port D
pin_mode(LED_IN_0, PIN_MODE_OUTPUT); // MODER: pin 12 = 01 (výstup)
io_set(LED_IN_0, 1);           // BSRR: nastavit PD12 = 1 -> LED svítí

Nejjednodušší časovač je SysTick — jednoduchý interní systémový časovač, součást jádra Cortex. Při podtečení (od nastavené hodnoty dolů na 0) vyvolá přerušení. Periodicky odčítá jedničku od uživatelem definované hodnoty. Využití: pravidelná kontrola sériového kanálu, klávesnice, tlačítek; časování pro LCD driver; blikání LED. Funkce delay_ms() a delay_us() v knihovně jsou implementovány právě přes SysTick.

TIM6 a TIM7 jsou 16bitové základní časovače (respektive vzestupné čítače s možností auto-reload). Součástí je 16bitový programovatelný prescaler — využívaný jako dělička frekvence. Při přetečení nebo dosažení hodnoty auto-reload může být generováno přerušení nebo signál pro DMA. Lze je využít i pro řízení DAC.

// POLLING --- procesor aktivně čeká na přetečení:
TIM6->CR1 |= TIM_CR1_CEN;          // Start časovače
while (1) {
    if (TIM6->SR & TIM_SR_UIF) {   // Přeteklo? (UIF = Update Interrupt Flag)
        TIM6->SR &= ~TIM_SR_UIF;   // Smazat příznak --- POVINNÉ!
        TIM6->CNT = TIMx_CNT;      // Reset počítadla
        io_set(LED_IN_0, !io_get(LED_IN_0)); // Akce
    }
}

Přerušení (interrupt) je mechanismus, kterým periferie nebo výjimečná situace upozorní procesor, že nastal důležitý event. Analogie: místo neustálého chodění ke dveřím a kontroly (polling), nainstalujete zvonek (interrupt). Periférie vysílá žádost IRQ (Interrupt Request) → řadič přerušení ji přijme (může jich přijít více najednou) → pošle signál INT procesoru → procesor odpoví INTA (interrupt acknowledge) → řadič sdělí typ přerušení → procesor podle tabulky vektorů přerušení skočí na příslušný podprogram (ISR).

Cortex-M4 má integrovaný NVIC (Nested Vectored Interrupt Controller). Klíčové vlastnosti: vektorová tabulka v paměti Flash na adrese 0x08000000 (ukazatele na ISR), vnořená přerušení (vyšší priorita přeruší obsluhu nižší), až 240 externích přerušení + 16 systémových výjimek (NMI, HardFault, SysTick...), programovatelné priority (0–15, nižší číslo = vyšší priorita), tail-chaining (přechod mezi ISR trvá jen 6 cyklů), late-arrival (vyšší priorita vyhraje nad rozestavěnou nižší).

Při příchodu přerušení HW automaticky za 12 cyklů: uloží R0–R3, R12, LR, PC, xPSR na zásobník → načte adresu ISR z vektoru → skočí na ISR → po návratu (BX LR) obnoví registry a pokračuje. Programátor musí v ISR smazat příznak přerušení, jinak se ISR volá znovu donekonečna. Např. pro TIM6: TIM6->SR &= ~TIM_SR_UIF;

Pro přerušení od GPIO pinů slouží EXTI (External Interrupt/Event Controller). 16 linek (EXTI0–EXTI15), každá obsluhuje pin _n ze všech portů. Na jednu linku lze připojit jen jeden port najednou (volba přes SYSCFG_EXTICR). Přerušení lze spouštět na náběžnou hranu (0→1), sestupnou hranu (1→0) nebo obě. Tlačítko USER_BUTTON (PA0) → EXTI0, náběžná hrana.

Při inicializaci periferií se používá vzor __disable_irq() ... __enable_irq(). Toto dočasně zakáže všechna maskovaná přerušení zápisem do registru PRIMASK. Důvod: inicializace GPIO trvá více kroků a přerušení uprostřed by mohlo vidět polovičně inicializovanou periferii — zakázáním IRQ zajistíme atomičnost víceregistrové operace.

Školní kit je deska STM32F4-Discovery (STM32F407VGTx) od STMicroelectronics. Obsahuje MCU, programátor ST-Link/V2, krystal 8 MHz. Školní přípravek rozšiřuje základní desku o: LCD 8×2, klávesnici 4×3, 4× externí LED (aktivní LOW na portu E), COM port, fotorezistor 10 kΩ, reproduktor.

Na desce jsou 4 uživatelské LED na portu D (PD12–PD15) a 2 tlačítka (modré PA0 = USER_BUTTON, černé = RESET). Interní LED jsou aktivní HIGH — svítí při log. 1.

Vnější LED na portu E (PE12–PE15) jsou aktivní LOW — svítí při log. 0. Proto je LED_setup() zhasíná zápisem io_set(LED_EX_x, 1).

LED_setup();               // Inicializace: int. výstup HIGH, ext. výstup HIGH (zhasnuté)
io_set(LED_IN_0, 1);       // PD12 = 1 → zelená LED svítí
io_set(LED_EX_0, 0);       // PE12 = 0 → červená ext. LED svítí
TOGGLE_BIT(GPIOD->ODR, 12); // XOR bit 12 → přepnutí stavu LED

Alfanumerický LCD 8×2 (8 sloupců, 2 řádky) s řadičem HD44780. Komunikuje přes 4bitové paralelní rozhraní: datové vodiče DB4–DB7 + řídicí RS, R/W, EN.

8bitový příkaz nebo ASCII kód znaku se posílá ve dvou nibblech (4 bity najednou): nejprve horní 4 bity, poté dolní 4 bity. Každý nibble je odeslán pulzem na EN vodiči. RS=0 → příkaz, RS=1 → data (znak).

LCD_setup();           // Inicializace LCD
LCD_set(LCD_CLR);      // Smazat displej (0x01)
LCD_set(LCD_LINE1);    // Přejít na řádek 1 (0x80)
LCD_print("Hello!");   // Vypsat řetězec
LCD_set(LCD_LINE2);    // Přejít na řádek 2 (0xC0)
LCD_goto(3, 2);        // Pozice sloupec 3, řádek 2
LCD_symbol('X');       // Vypsat jeden znak

Školní klávesnice je maticová 3×4. Fyzicky jsou spínače zapojeny v matici — každý na průsečíku řádku a sloupce. Stačí tak 3+4 = 7 pinů místo 12.

Zapojení na kitu: COL0–COL2 → PD0–PD2 (vstup + pull-up), ROW0–ROW3 → PD6–PD9 (výstup push-pull). Princip čtení — row scanning:

• 1. Aktivujeme řádek n (ROW_n = 0, ostatní = 1).
• 2. Přečteme stav sloupců (IDR).
• 3. Pokud COL_m = 0, je stisknuta klávesa na průsečíku ROW_n × COL_m.
• 4. Vrátíme KBD_MAP[n][m] — ASCII kód klávesy.

static uint8_t KBD_MAP[KEYPAD_ROWS][KEYPAD_COLS] = {
    {'1','2','3'}, {'4','5','6'}, {'7','8','9'}, {'*','0','#'}
};
KBD_setup();               // Sloupce=vstup+pull-up, řádky=výstup
uint8_t key = KBD_read();  // Vrátí ASCII nebo 0 (nic nestisknuto)
if (key) LCD_symbol(key);  // Zobrazit na LCD

UART (Universal Asynchronous Receiver-Transmitter) — sériový protokol bez hodinového signálu. Dva vodiče: TX (vysílání) a RX (příjem). Frame: 1 start bit + 8 datových bitů + 1 stop bit. Školní kit: USART2 na PA2(TX)/PA3(RX), AF7, 9600 Bd. Výpočet BRR: USARTDIV = f_PCLK / (16 × BaudRate) = 16 000 000 / (16 × 9600) = 104,167 → mantissa=104, fraction=3 → BRR=0x0683.

UART_setup();              // Init USART2 @ 9600 Bd, PA2/PA3 AF7
UART_putc('A');            // Odeslat jeden znak (blokující)
UART_write("Hello
", 7); // Odeslat řetězec
uint8_t c = UART_getc();   // Přijmout znak (blokující)
char buf[32];
UART_read(buf, sizeof(buf)); // Přijmout řetězec do 
 nebo 

Keil µVision5 je profesionální IDE pro vývoj embedded systémů na ARM procesorech. Obsahuje editor, kompilátor (ARM Compiler 5/6), linker, debugger a simulátor. Výběr čipu: STMicroelectronics → STM32F4 Series → STM32F407 → STM32F407VGTx. Preprocessor definice: STM32_TYPE=407.

Klíčové kroky projektu: Build (F7) → Download/Flash (F8) → Debug (F5). V debuggeru: breakpointy (F9), krokování (F10/F11), Watch okno pro proměnné, Peripherals → System Viewer pro zobrazení všech registrů MCU v reálném čase (MODER, IDR, ODR, TIM6→SR...).

#include "stm32_kit.h"
#include "stm32_kit/led.h"
#include "stm32_kit/lcd.h"
#include "stm32_kit/keypad.h"
#include "stm32_kit/uart.h"
#include "stm32_kit/timers.h"

#define TIMx_PSC 159
#define TIMx_ARR 19999
#define TIMx_CNT 0

static uint8_t KBD_MAP[KEYPAD_ROWS][KEYPAD_COLS] = {
    {'1','2','3'}, {'4','5','6'}, {'7','8','9'}, {'*','0','#'}
};

BOARD_SETUP void setup(void) {  // Voláno automaticky před main()
    LED_setup();
    LCD_setup();
    KBD_setup();
    UART_setup();
    TIM6_setup();
}

int main(void) {
    TIM6_config();
    TIM6->CR1 |= TIM_CR1_CEN;
    LCD_set(LCD_CLR);
    LCD_print("STM32F407 Ready");
    while (1) {
        if (TIM6->SR & TIM_SR_UIF) {
            TIM6->SR &= ~TIM_SR_UIF;
            io_set(LED_IN_0, !io_get(LED_IN_0));
        }
        uint8_t key = KBD_read();
        if (key) { LCD_set(LCD_LINE2); LCD_symbol(key); UART_putc(key); }
    }
}