O mnePortfolioBlogKurzyKontakt
Zpět na osnovu kurzu
Lekce 16 z 25 · 🔌 Fáze 4

Co je mikrokontrolér

Mikrokontrolér (MCU, čti „em-cí-jů") je maličký počítač na jednom čipu. Vysvětlíme si ho analogiemi: CPU = mozek, Flash = knihovna, SRAM = pracovní stůl, EEPROM = zápisník, clock = tep srdce. A potom rozsvítíš svoji první LED.
⏱ 2 h
(1 h teorie + 1 h praxe)
Začátečník

Část 1 — Teorie

Co je uvnitř čipu — s analogiemi na mozek, knihovnu a pracovní stůl

⏱ Čas na studium: přibližně 1 hodina

🧠 16.1 Co je mikrokontrolér a proč existuje?

Představ si malinký počítač velikosti nehtu, který stojí pár korun, nemá obrazovku, nemá klávesnici, ale umí přemýšlet a ovládat věci kolem sebe. Pračka, mikrovlnka, dálkový ovladač, kávovar, elektrický zubní kartáček, Bluetooth sluchátka, termostat — všechno v sobě má mikrokontrolér.

Mikrokontrolér (zkratka MCU, čti „em-cí-jů" — z anglického Micro Controller Unit) je celý počítač na jednom kousku křemíku:

  • Procesor (CPU) — umí počítat a rozhodovat
  • Paměti — pamatuje si program a data
  • Periferie — „nohy" k okolnímu světu (piny, ADC, UART, …)

Všechno v jednom balíčku. Zapojíš napájení a je to — žije.

💬 Co to znamená: MCU vs. CPU vs. mikroprocesor?

Tři slova, která znějí podobně, ale znamenají něco jiného. Tohle si zapamatuj — často se to plete.

  • CPU (čti „cé-pé-jů", Central Processing Unit) = samotný mozek. Malinký kousek, co umí sčítat, odčítat, porovnávat. Sám o sobě ale nic moc nedělá — potřebuje paměť a „ruce".
  • Mikroprocesor (např. Intel Core i7 v tvém notebooku) = CPU na čipu, ale paměť a periferie jsou venku. Potřebuje kolem sebe desku plnou součástek (základní deska PC).
  • Mikrokontrolér (MCU) = CPU + paměti + periferie všechno uvnitř jednoho čipu. Stačí napájení a ono to funguje.

Analogie: CPU = samotný mozek v laboratoři. Mikroprocesor = mozek v hlavě, ale bez těla (potřebuje externí srdce, plíce, žaludek). MCU = celý člověk — malý, ale kompletní.

Proč mě to zajímá? Když si někde přečteš „čip XY" a chceš vědět, co to je — podívej se, jestli má uvnitř paměť a piny. Má? → MCU. Nemá? → jen CPU/procesor.

💡 Kde všude je MCU? V běžné domácnosti máš 20–50 mikrokontrolérů, aniž bys to tušil. V autě okolo 100. Roční světová produkce je cca 30 miliard kusů — 4× víc než lidí na planetě.

🏛️ 16.2 Uvnitř čipu — mozek, knihovna, stůl, zápisník

MCU obsahuje několik bloků, které spolu spolupracují. Každý má jasnou roli. Projdeme je postupně, pokaždé s analogií.

MCU Clock 16 MHz tep CPU jádro · vykonává kód vnitřní sběrnice (bus) Flashprogram SRAMproměnné GPIOpiny ADC / PWManalog Timery,UART/SPI/I²C
Uvnitř jednoho čipu: CPU (jádro) řízené clockem, propojené sběrnicí s pamětí (Flash + SRAM) a periferiemi (GPIO, ADC/PWM, časovače, komunikace). Proto se mu říká „celý počítač na jednom čipu".

🧠 Co to znamená: CPU (procesor)?

CPU je mozek celého čipu. Jeho práce je jednoduchá a nudná: pořád dokola čte instrukce z paměti a provádí je. „Přičti 5", „porovnej tyhle dvě čísla", „skoč o 10 řádků zpět".

  • Analogie: CPU = tvůj mozek, když počítáš na papíře. Přečteš zadání, vezmeš tužku, napíšeš výsledek, pokračuješ dál. Nic si dlouhodobě nepamatuješ — všechno si musíš psát.
  • Konkrétní čísla: Arduino Uno má CPU ATmega328P s rychlostí 16 MHz = 16 milionů instrukcí za sekundu. ESP32 má dvě CPU běžící na 240 MHz — 30× rychlejší.
  • Proč mě to zajímá? Rychlost CPU = kolik věcí stihne za sekundu. Blikat LEDkou? Stačí 1 MHz. Zpracovávat zvuk? Potřebuješ 100 MHz+. Dělat video? 500 MHz+.

📚 Co to znamená: Flash (program memory)?

Flash je velká paměť uvnitř MCU, kde je uložený tvůj program. Přežije vypnutí napájení. Při zapnutí CPU začne číst od prvního bajtu Flash a provádí instrukci po instrukci.

  • Analogie: Flash = knihovna s knihami. Knihy po zavření dveří nezmizí, ale psát do nich je pomalé (knihovníce musí otevřít a ručně opravit). Čtení je rychlé.
  • Konkrétní čísla: Arduino Uno má 32 kB Flash (= asi 8 000 řádků kódu). ESP32 má 4 MB = 1 000 000 řádků, dost na celý operační systém.
  • Přežije vypnutí? ANO. Tomu se říká „non-volatile" (ne-prchavá). Program nahraješ jednou a zůstane tam navždy (nebo do dalšího nahrání).
  • Omezení životnosti: Flash lze přepsat „jen" ~10 000× (někdy 100 000×). Pro tebe to nic neznamená — program nahráváš pár desítek krát za život desky.

🪑 Co to znamená: SRAM (pracovní paměť)?

SRAM (čti „es-rám", Static RAM) je pracovní paměť, kam si CPU odkládá dočasné hodnoty během výpočtu. Proměnné v kódu (int counter = 0;), stav výpočtu, „poznámky pro sebe".

  • Analogie: SRAM = pracovní stůl. Když sedíš a počítáš, máš po stole rozložené papíry, tužky, kalkulačku. Všechno okamžitě po ruce. Ale jakmile odejdeš a zhasneš, papíry ze stolu spadnou (ztratí se).
  • Konkrétní čísla: Arduino Uno má 2 kB SRAM (jen 2048 bajtů! — 500 proměnných typu float). ESP32 má 520 kB = 250× víc.
  • Přežije vypnutí? NE. Tomu se říká „volatile" (prchavá). Po resetu je všechno nula.
  • Proč mě to zajímá? Když se tvůj Arduino program chová zmateně a restartuje se sám, velmi často jsi vyčerpal SRAM. Velká pole (např. char text[3000]) se na Uno prostě nevejdou.

📓 Co to znamená: EEPROM (zápisník)?

EEPROM (čti „í-í-prom", Electrically Erasable Programmable ROM) je malá paměť, která přežije vypnutí — ale na rozdíl od Flash do ní můžeš zapisovat z běžícího programu.

  • Analogie: EEPROM = zápisník do kapsy. Malý, ale můžeš do něj kdykoliv škrtnout tužkou a poznámka tam zůstane i po cestě domů. Knihovnu (Flash) si domů nepřineseš — tu doplňují jen profesionálové.
  • K čemu to použiješ? Uložit nastavení uživatele (jazyk, jas displeje, hodnotu termostatu). Po vypnutí MCU se nezapomene.
  • Konkrétní čísla: Uno má 1 kB EEPROM (1024 bajtů — stačí na pár set nastavení). ESP32 EEPROM nemá, ale emuluje ji ve Flash.
  • Omezení: EEPROM se dá přepsat ~100 000× na jednu buňku. Proto nezapisuj do ní každou milisekundu — spálíš ji za pár hodin. Zápis cca 1× za minutu nebo jen při změně.

👖 Co to znamená: registr?

Registr je maličká (8 nebo 16 bitů) velmi rychlá paměť uvnitř CPU. CPU má jich jen pár desítek, ale je do nich okamžitý přístup — bez jediného taktu zpoždění.

  • Analogie: registr = kapsa u nohavice. Když ti podám 5 Kč, uložíš je do kapsy, ne do kufru v autě. Je to nejblíž ruce. SRAM = kufr v autě (musíš dojít), EEPROM = zápisník doma (musíš domů).
  • Hierarchie rychlosti: registr (1 takt) → SRAM (2–3 takty) → Flash (několik taktů, čte se po blocích) → EEPROM (tisíce taktů).
  • Proč mě to zajímá? V Arduinu se tím nemusíš trápit — kompilátor to řeší za tebe. Ale když čteš datasheet (např. „nastav registr PORTB na 0xFF"), víš, že je to pin-control paměť uvnitř CPU.
💡 Celé shrnutí analogiemi: CPU = tvůj mozek. Flash = knihovna (program, velká, čtení rychlé, psaní těžké). SRAM = pracovní stůl (proměnné, rychlé, po vypnutí zmizí). EEPROM = zápisník (malá, nastavení, přežije). Registr = kapsa u kalhot (nejrychlejší, nejmenší).
PaměťKapacita (Uno)Přežije reset?Analogie
Flash32 kB✅ AnoKnihovna (program)
SRAM2 kB❌ NePracovní stůl
EEPROM1 kB✅ AnoZápisník
Registr~32 × 8 bit❌ NeKapsa u nohavice

💓 16.3 Clock — tep srdce MCU

CPU neběhá tempem, jak zrovna chce — potřebuje metronom, který udává rytmus. Tomu metronomu se říká clock (čti „klok"), česky hodinový signál. Na každém „tik" clocku CPU vykoná jednu drobnou práci (část instrukce).

💓 Co to znamená: clock (F_CPU, hodinový kmitočet)?

Pravidelný obdélníkový signál 0-1-0-1-0-1… uvnitř čipu. Jeho kmitočet (frekvence) udává, kolik instrukcí CPU stihne za sekundu.

  • Analogie: clock = tep tvého srdce. Každý tep = 1 akce. 60 tepů/minuta (1 Hz) = spíš klidný člověk. 16 MHz (Arduino Uno) = 16 milionů tepů/sekundu — neuvěřitelně rychle.
  • Jednotky: MHz = megahertz = milion tepů/s. GHz = gigahertz = miliarda tepů/s. Arduino Uno: 16 MHz. ESP32: 240 MHz. Raspberry Pi: 1 500 MHz (1,5 GHz).
  • Proč mě to zajímá? Rychlejší clock = víc práce za sekundu, ale také víc spotřeby (baterie vydrží kratší dobu) a víc tepla. U hodinek s baterií chceš pomalý clock (~1 MHz). U Wi-Fi rádia rychlý (80+ MHz).
  • V Arduinu ho najdeš jako: konstantu F_CPU (čti „ef-cé-pé-jů"). Na Uno = 16 000 000. Funkce delay(1000) přesně odpočítá 1 000 × F_CPU/1000 taktů = 1 sekundu.

⚡ Co to znamená: krystal vs. RC oscilátor?

Clock není magie — někdo ho musí fyzicky vyrábět. Jsou dvě možnosti:

  • Krystal (křemenný, quartz crystal) = přesná malá součástka. Rozkmitá se na přesné frekvenci (např. 16 MHz). Přesnost 20 ppm = chyba 1 sekunda za 14 hodin. Analogie: švýcarské náramkové hodinky.
  • RC oscilátor (uvnitř čipu) = levné řešení z rezistoru a kondenzátoru. Přesnost ±1,5 % při pokojové teplotě, ±10 % při mrazu. Analogie: levné nástěnné hodiny, co se zpožďují o minutu denně.
  • Kdy co? Přesné časování (UART, hodiny reálného času) → krystal. Jednoduché blikání LED → stačí interní RC.
  • ppm = „parts per million", dílů v milionu. 1 ppm = 0,0001 %. 20 ppm znamená, že na každou sekundu je chyba maximálně 20 mikrosekund.
Délka jednoho taktu
T = 1 / F_CPU
Okamžitý příklad
Arduino Uno běží na 16 MHz. Jak dlouho trvá jeden takt? A kolik taktů potřebuje jednoduchá instrukce (třeba „přičti 1 k proměnné")?
T = 1 / 16 000 000 Hz = 62,5 nanosekundy (nanosekunda = miliardtina sekundy). Jednoduchá AVR instrukce typu „add" trvá 1 takt = 62,5 ns. Složitější, např. násobení, 2 takty = 125 ns. Za 1 sekundu tedy CPU vykoná až 16 milionů jednoduchých instrukcí. Pro blikání LED každou sekundu tedy 99,9 % času CPU jen čeká v delay().

🔄 16.4 Reset a napájení — jak MCU „nabootuje"

Když MCU zapneš (přivedeš napájení), není okamžitě připravený. Má bootovací sekvenci — pár milisekund, během kterých čeká na ustálení napětí, nastaví si clock, vynuluje SRAM a teprve pak začne provádět tvůj program.

🔌 Co to znamená: napájení (VCC, GND, 3,3 V vs. 5 V)?

MCU potřebuje elektřinu, jako všechno jiné. Má dva hlavní piny:

  • VCC (někdy VDD) = „plus", kladné napájecí napětí. Typicky 3,3 V (ESP32, STM32) nebo 5 V (Arduino Uno).
  • GND (Ground) = „mínus", zem. Referenční úroveň 0 V. Všechna napětí se počítají vůči ní.
  • Analogie: VCC a GND jsou jako dva konce baterie. MCU je spotřebič mezi nimi.
  • Pozor na úrovně: 3,3 V MCU nesnese 5 V na svých vstupech — spálí se. Proto se ESP32 s 5 V senzorem propojuje přes level shifter. Arduino Uno (5 V) snese 3,3 V signál, ale nezvedne ho plně.
  • Proud: Uno dává z pinu max 20 mA (miliampér). ESP32 max 12 mA. Motor nebo relé musíš spínat přes tranzistor, viz L12/L13.

🔁 Co to znamená: reset?

Reset znamená „začni znovu od začátku". CPU přestane to, co dělal, nastaví si program counter (ukazatel na řádek kódu) na 0, a začne znovu číst program od prvního bajtu Flash.

  • Co způsobí reset? (1) Zapnutí napájení (power-on reset). (2) Stisk reset tlačítka. (3) Watchdog timer (program zamrzl). (4) Brown-out (napětí klesne pod bezpečnou úroveň).
  • Analogie: reset = když se PC zasekne a ty ho vypneš a znovu zapneš. SRAM se vynuluje (všechno zapomenuto), Flash zůstane (program je pořád tam).
  • Watchdog timer = „hlídací pes". Speciální časovač, který MCU automaticky resetuje, pokud program „nehlásí, že žije" (neladí speciální registr). Používá se v kritických aplikacích (pračka, průmysl), aby zamrznutí netrvalo hodiny.
  • Brown-out detektor = „když napájení klesne pod 2,7 V, radši resetuj". Ochrana proti chování v podvýživě, kdy by CPU mohlo dělat nesmyslné věci.

⚠️ SRAM po resetu je nula — neplň si iluze

Globální proměnné v C/C++ se po resetu vynulují. int counter; bez inicializace bude 0. To je normální. Ale pokud čekáš, že stav z předchozího běhu přežije reset — nepřežije. Chceš-li perzistenci, použij EEPROM.

🏗️ 16.5 Rodiny MCU — AVR, ESP32, STM32, RP2040

MCU na trhu jsou stovky typů. Pro začátečníka jsou zajímavé čtyři „rodiny" — čtyři populární řady od různých výrobců. Každá má svůj charakter:

RodinaTypický členClockFlash / SRAMPro co
AVR (Atmel/Microchip)ATmega328P (Arduino Uno)16 MHz32 kB / 2 kBÚplný začátek, jednoduché projekty
ESP32 (Espressif)ESP32-WROOM-32240 MHz, 2 jádra4 MB / 520 kBWi-Fi, Bluetooth, IoT projekty
STM32 (ST Microelectronics)STM32F103 („Blue Pill")72 MHz64–1024 kB / 20–320 kBPrůmysl, auto, vážnější projekty
RP2040 (Raspberry Pi)Raspberry Pi Pico133 MHz, 2 jádra2 MB / 264 kBHobby, robotika, USB projekty

🧰 Co to znamená: Arduino (ne čip, ale ekosystém)?

Arduino není čip — je to ekosystém desek + vývojového prostředí + knihoven. Samotný mikrokontrolér na Arduino Uno je ATmega328P (AVR rodina). Arduino jen přidává:

  • Desku se součástkami kolem čipu (krystal, USB převodník, regulátor napětí, pin header). Ušetří ti týden pájení.
  • Arduino IDE — jednoduché vývojové prostředí, kde napíšeš program a jedním tlačítkem nahraješ do čipu.
  • Knihovny — funkce jako digitalWrite(13, HIGH), které schovávají složité registry. Místo „nastav bit 5 v registru PORTB" napíšeš prostě „rozsviť pin 13".

Analogie: Arduino vs. holý AVR čip = Lego vs. samotné plastové kousky. S Legem postavíš hrad za odpoledne. Z plastových granulí bys ho vyráběl týdny.

Proč mě to zajímá? Dneska je 90 % hobby projektů postavené na Arduinu — protože je to jednoduché a všechno „jen funguje". S pokrokem přejdeš na PlatformIO (lepší IDE) a pak pro vážnější projekty na čistý C/STM32 HAL.

💡 Která rodina je pro tebe? Začínáš → Arduino Uno (AVR, 5 €). Chceš Wi-Fi → ESP32 (~5 €). Chceš výkon → RP2040 (Pi Pico) (~5 €). Chceš seriózně → STM32 (STM32 „Blue Pill" ~3 €, ale složitější setup).

🛠️ 16.6 Vývojová cesta — od myšlenky k blikající LED

Krátký přehled, jak se v praxi dostaneš od „chci blikat LED" k tomu, že to opravdu bliká:

  1. Koupit desku (Arduino Uno, 5 €) a USB kabel.
  2. Nainstalovat Arduino IDE (arduino.cc, zdarma).
  3. Připojit desku USB kabelem k PC. Ovladač se většinou nainstaluje sám.
  4. Otevřít příklad File → Examples → Basics → Blink.
  5. Vybrat desku Tools → Board → Arduino Uno.
  6. Vybrat port Tools → Port → COM3 (nebo podobně).
  7. Kliknout Upload (ikona šipky → nahoře). Program se zkompiluje, nahraje, a LED na desce začne blikat.

To je celé. Za 15 minut máš funkční embedded systém.

📝 Co to znamená: setup() a loop()?

Každý Arduino program má přesně dvě funkce, které musíš napsat:

  • setup() — „příprava". Běží jen jednou, hned po resetu. Tady nastavíš piny, zapneš UART, inicializuješ displej.
  • loop() — „hlavní cyklus". Arduino ho volá pořád dokola, nekonečně. Co je uvnitř, to se vykoná, pak se zavolá znovu. A znovu. A znovu. Milionkrát za sekundu.

Analogie: setup() = ranní rituál (vstaneš, oholíš se, nasnídáš se — jen jednou denně). loop() = tvůj pracovní den, který se opakuje každých 24 hodin.

Skrytý main(): Arduino IDE ti za zády dopíše funkci main() (klasika v C), která vypadá zhruba: int main() { setup(); while(1) { loop(); } }. Proto setup() 1×, loop() nekonečno-krát.

🎯 Minimální Arduino „blink" se třemi řádky kódu

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);    // pin 13 = žárovka na desce
}
void loop() {
  digitalWrite(LED_BUILTIN, HIGH); // rozsviť (+5 V)
  delay(500);                     // čekej 500 ms
  digitalWrite(LED_BUILTIN, LOW);  // zhasni (0 V)
  delay(500);                     // čekej 500 ms
}

Tohle je celý program. LED na desce (zabudovaná na pinu 13) bliká 1× za sekundu. Víc do L17 (GPIO piny).

Část 2 — Praktické příklady

Tři věci, co si můžeš osahat rovnou

⏱ Čas na studium: přibližně 1 hodina

Příklad 1: První blink — rozblikej LED na Arduino Uno

Co uděláme: Rozblikáme zabudovanou LED (pin 13) na Arduino Uno. Bez dalších součástek — LED je přímo na desce.

Hardware: Arduino Uno + USB kabel. Celkem ~5 €.

Krok 1 — instalace: Stáhni Arduino IDE z arduino.cc, nainstaluj. Spusť.
Krok 2 — propojení: Zasuň USB-B kabel do Arduina, USB-A do PC. Na desce se rozsvítí zelená LED ON (napájení).
Krok 3 — volba desky a portu: Tools → Board → Arduino Uno. Tools → Port → vyber COM port, co se objevil po zapojení (typicky COM3 nebo COM4 na Windows, /dev/ttyACM0 na Linuxu).
Krok 4 — kód:
const int LED = 13;  // LED_BUILTIN na pinu 13

void setup() {
  pinMode(LED, OUTPUT);     // pin 13 bude výstup (tlačí napětí)
  Serial.begin(115200);     // zapni UART pro debug výpisy
  Serial.println("Blink starting...");
}

void loop() {
  digitalWrite(LED, HIGH);  // pin 13 = +5 V → LED svítí
  delay(500);
  digitalWrite(LED, LOW);   // pin 13 = 0 V → LED zhasne
  delay(500);
}
Krok 5 — upload: Klikni šipku „Upload" (vpravo od ikony „verify"). Počkej pár sekund — status lišta ukazuje průběh. Na desce bliká TX/RX LEDka (data tečou po UART).
Krok 6 — výsledek: Oranžová LEDka L na desce začne blikat 1× za sekundu. Pokud otevřeš Tools → Serial Monitor (115200 baud), uvidíš zprávu „Blink starting…".
Co se stalo pod kapotou: IDE zkompiloval tvůj C++ kód do bajtkódu (~900 bajtů Flash). Uploadem se bajtkód nahrál do Flash. Po automatickém resetu začal CPU číst Flash od řádku 0 — nejprve spustil setup(), pak donekonečna loop(). V loop() přepíná pin 13 mezi HIGH a LOW a čeká 500 ms mezi přepnutími.
Máš funkční MCU. CPU běží 16 MHz, tvůj program žije ve 32 kB Flash, proměnné v 2 kB SRAM. Je to celý počítač za 5 €. Všechno ostatní v tomhle kurzu je jen „o co ho rozšířit, aby dělal něco užitečnějšího".

Příklad 2: Počítadlo resetů v EEPROM (přežije vypnutí)

Co uděláme: Pokaždé když Arduino spustíš (nebo stiskneš reset tlačítko), zvýší se počítadlo v EEPROM o 1 a vypíše se na Serial Monitor. I po odpojení USB hodnota zůstane.

Hardware: jen Arduino Uno.

Kód:
#include <EEPROM.h>

void setup() {
  Serial.begin(115200);
  delay(500);                           // počkej na PC

  // Přečti 2-bajtové celé číslo z adresy 0 v EEPROM
  uint16_t bootCount;
  EEPROM.get(0, bootCount);

  bootCount++;                           // zvyš o 1

  // Zapiš zpět (přežije vypnutí napájení)
  EEPROM.put(0, bootCount);

  Serial.print("Spusteno uz ");
  Serial.print(bootCount);
  Serial.println("-krat.");
}
void loop() {}
Test: Otevři Serial Monitor (115200 baud). Každý reset (tlačítko RESET na desce) zvýší číslo o 1. Odpoj USB, znovu zapoj — číslo pokračuje, kde skončilo.
Pozor! EEPROM snese ~100 000 zápisů na adresu. Proto nepiš do ní v loop() každý průchod — spálil bys ji za hodinu. Tady píšeme jen 1× na reset, takže máš rezervu na 100 000 bootů (víc než život desky).
První spuštění: Nová EEPROM bajtu obsahuje 0xFF. Program přečte 0xFFFF (65535), zvýší na 0 (přeteče). Pokud ti to vadí, nulování udělej jednou: if (bootCount == 65535) bootCount = 0;
Tvůj první perzistentní stav. MCU po vypnutí nic nezapomene. Tohle je přesně mechanismus, kterým termostat pamatuje tvou nastavenou teplotu, mikrovlnka pamatuje, kolik sekund nechat, a pračka pamatuje, který program jsi zvolil.

Příklad 3: Spočítej, kolik SRAM ti ještě zbývá

Co uděláme: Napíšeme funkci, která spočítá volnou SRAM v Arduinu. Tohle je nepostradatelný debug nástroj — když se program chová zmateně, často je příčina vyčerpaná SRAM.

Kód (pro AVR Arduino Uno):
extern int __heap_start, *__brkval;

int freeRAM() {
  int v;
  return (int) &v - (__brkval == 0
    ? (int) &__heap_start
    : (int) __brkval);
}

void setup() {
  Serial.begin(115200);
  Serial.print("Volna SRAM: ");
  Serial.print(freeRAM());
  Serial.println(" bajtu");
}
void loop() {}
Co uvidíš: Něco jako „Volna SRAM: 1856 bajtu" (z celkových 2048). Prázdný program má ~200 B overhead (systémové věci, zásobník).
Zkus to rozšířit: Přidej pole char buffer[500]; jako globální proměnnou. Znovu spusť. Uvidíš zhruba 500 B méně volné paměti.
Tohle je nejčastější dotaz začátečníků: „Proč se mi program zasekává?" Odpověď: zkontroluj volnou SRAM. Pokud jde pod 100 B, Arduino začne pracovat divně — stack a heap kolidují.

Část 3 — Shrnutí a test

Klíčové pojmy, pravidla a kvíz pro ověření

📋

Shrnutí lekce 16

Klíčové pojmy jednou větou

📝

Test z lekce 16

5 otázek · 5–10 minut

🔁

Opakovací test — lekce 1–16

10 otázek napříč kurzem