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

Zvonek u dveří a kuchyňský minutník

Jak čip reaguje na události v reálném čase. Místo aby pořád koukal z okna, jestli někdo jde (polling), sedí si v klidu a zazní mu zvonek (interrupt) nebo mu začne pípat kuchyňský minutník (timer). Baterka pak vydrží roky místo dnů.
⏱ 2 h
(1 h teorie + 1 h praxe)
Začátečník

Část 1 — Teorie

Jak čip reaguje na události (s analogiemi na zvonek u dveří, kuchyňský minutník a spánek s budíkem)

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

🔔 20.1 Dva způsoby, jak čip reaguje na události

Mikrokontrolér (MCU, viz L16) musí reagovat na události. Někdo stiskne tlačítko, přijde zpráva z Wi-Fi, uplyne 1 sekunda. Jak se o tom čip dozví? Jsou dva způsoby — a rozdíl je dramatický.

  • Polling — čti „polink" — čip se pořád ptá: „už je něco? už je něco? už je něco?" Vypadá to jednoduše, ale spotřebuje 100 % CPU na pouhé koukání.
  • Interrupt — čti „interapt" — čip si dělá svoje (nebo spí), a když se něco stane, hardware ho sám upozorní. CPU může většinu času nic nedělat a šetřit baterku.

Obojí se hodí někdy. Ale interrupt je mnohem efektivnější a dnes je to default pro cokoliv, co má vydržet na baterce nebo reagovat rychle.

⚡ POLLING CPU 100 % INTERRUPT CPU ~0 % (spánek) ISR → spánek t
Stejná událost (⚡ tlačítko), dvě reakce. Polling: CPU jede celou dobu na 100 % a pořád se ptá → baterka vydrží dny. Interrupt: CPU spí (~0 %), hardware ho probudí jen na okamžik do ISR a zase usne → baterka vydrží roky.

💬 Co to znamená: polling?

Polling (čti „polink", z angl. „to poll" = dotazovat se) je metoda, kdy čip v kruhu pořád znovu čte, jestli se něco nestalo.

  • Analogie: čekáš na kamaráda, a každou minutu jdeš koukat z okna, jestli už přichází. Celou hodinu nic jiného neděláš, jen chodíš k oknu a zpět.
  • Jak to vypadá v kódu: v Arduinu klasický loop() — tisíckrát za sekundu zavolá digitalRead(button) a zkouší, jestli není stisknuté.
  • Kdy je to OK? Pomalý, jednoduchý kód, napájený z USB, kde je jedno, že CPU běží na 100 %. Arduino tutoriály to tak dělají.
  • Kdy už ne? Když běžíš na baterce, nebo potřebuješ zachytit krátkou událost (třeba impulz rotačního enkodéru trvá 100 µs — to by loop() nestihl přečíst).

🔔 Co to znamená: interrupt (přerušení)?

Interrupt (čti „interapt") je automatické upozornění od hardwaru. Čip si dělá svoje — a když se něco stane, hardware ho na chvilku zastaví, řekne mu „stalo se tohle", a pak ho zase pustí, kam skončil.

  • Analogie: máš zvonek u dveří. Celý den si čteš knížku. Nemusíš každou minutu otvírat dveře a koukat, kdo tam je — když někdo přijde, zvonek zazvoní. Ty se zvedneš, otevřeš, poděkuješ a vrátíš se k knížce.
  • Česky se říká „přerušení" — přerušilo se to, co jsi dělal, na chvilku.
  • Proč mě to zajímá? Bez interruptu by tvůj MCU musel každou ms kontrolovat tlačítko = 99 % času zbytečné. S interruptem může spát a probudit se jen když tlačítko stiskneš → baterka vydrží roky místo dnů.
  • Jiné slovo: „IRQ" — čti „aj-kjů-ár", zkratka z Interrupt ReQuest (žádost o přerušení). Stejná věc, jen technický žargon.
💡 Shrnutí dvou přístupů: Polling = chodím každou minutu koukat z okna. Interrupt = mám zvonek, který mě upozorní, až někdo opravdu přijde. První je vyčerpávající a nepřesný. Druhý je klidný a spolehlivý. 99 % moderní elektroniky používá interrupty.

📜 20.2 Kdo otevře dveře? — ISR (funkce u zvonku)

Když zvonek zazvoní, někdo musí jít otevřít. V čipu tu „osobu" tvoří funkce, kterou předem napíšeš ty. Hardware si ji pamatuje a když přijde event, automaticky ji zavolá. Téhle funkci se říká ISR.

💬 Co to znamená: ISR?

ISR (čti „aj-es-ar") je zkratka Interrupt Service Routine — doslova „obslužná funkce přerušení". Je to kus kódu, který se spustí automaticky, když hardware zaznamená událost.

  • Analogie: ISR je jako recepční v hotelu. Když zazní zvonek, recepční vstane, vyřídí hosta a sedne si zpět. Nesmí se rozkecat — další hosté by čekali.
  • Jak to vypadá v Arduinu:
    void onPress() {    // tohle je ISR
      flag = true;       // uvnitř jen rychlé věci!
    }
    attachInterrupt(0, onPress, FALLING);  // registruj ISR na pin
  • Proč to má tak tajemné jméno? Je to historie ze 70. let, kdy „service routine" znamenalo „funkce, která něco obsluhuje". Dnes by se to asi jmenovalo „event handler", ale ISR zůstalo.

💬 Co to znamená: volatile?

Když ISR a hlavní smyčka loop() sdílejí proměnnou (třeba flag „bylo stisknuto"), musíš ji napsat s klíčovým slovem volatile (čti „volatajl", anglicky „těkavý, proměnlivý"). Jinak kompilátor zoptimalizuje tvůj kód a hlavní smyčka nikdy neuvidí změny z ISR.

  • Analogie: lednička vs. zápisník. Bez volatile si kompilátor myslí: „hodnotu promnné už jednou přečetl, v registru ji mám, nebudu ji číst z RAM znovu" — jako kdyby ti někdo řekl, kolik je mléka v lednici, a ty bys pak 10× pil podle té staré informace, aniž bys do lednice znova koukl. S volatile kompilátor pochopí: „tohle se může změnit kdykoliv, vždycky otevři ledničku znova".
  • Pravidlo: každou proměnnou sdílenou mezi ISR a loop() označ volatile.
  • Jak to vypadá:
    volatile bool pressed = false;   // ✓ ISR i loop ji vidí čerstvou
    bool pressed = false;            // ✗ nefunguje — loop uvidí jen starou hodnotu
  • Proč mě to zajímá? Tohle je TOP 1 chyba začátečníků. Když ti ISR „nefunguje" a loop() nereaguje na flag — skoro vždycky chybí volatile.

💬 Co to znamená: atomic (nedělitelné)?

Když máš větší proměnnou (např. uint32_t, 4 byty) na malém MCU (Arduino Uno je 8-bit = 1 bajt najednou), čtení trvá několik kroků. Kdyby ISR přerušila hlavní kód mezi kroky, dostaneš poloviční staré, poloviční nové data — nesmysl.

  • Analogie: představ si, že přenášíš 4 sklenice vody z kuchyně do pokoje. Kdyby tě někdo uprostřed cesty „přerušil" a vyměnil ti sklenice za jiné, přineseš mix 2 starých + 2 nových → voda se rozlije. Musíš celou cestu udělat naráz — žádné přerušení uprostřed.
  • „Atomic" (čti „atomik", z řeckého atomos = nedělitelný) znamená „operace, která proběhne celá najednou a nedá se přerušit uprostřed".
  • Řešení v Arduinu:
    noInterrupts();           // dočasně zakáže všechny ISR
    uint32_t snap = counter;  // teď celé 4 bajty přečtu bez rušení
    interrupts();             // povolí ISR zpět
  • Proč mě to zajímá? Na ESP32 (32-bit) je čtení uint32_t už atomické samo, nepotřebuješ to. Na Arduinu Uno ano. Tohle je typický „funguje mi to na jedné desce, nefunguje na druhé" bug.

⚠️ 4 pravidla psaní ISR (musíš si je vtlouct do hlavy)

  1. KRÁTKÁ. Max. desítky µs. Dobrá ISR má 1–3 řádky. Špatná ISR má 20 a víc.
  2. Žádné delay(), Serial.print(), síťové volání. Blokovalo by to CPU a mohlo by to zablokovat samo sebe.
  3. Sdílené proměnné = volatile. Jinak kompilátor tě zradí.
  4. Větší proměnné čti s noInterrupts(). Jinak dostaneš poloviční hodnotu.

Zlatý pattern: ISR jen zaznamená událost (nastaví flag). Skutečnou práci (vypsat něco, poslat e-mail, rozsvítit LED) dělá loop().

⚡ 20.3 Hrana signálu — moment, kdy se „něco stane"

Čip nereaguje na „tlačítko je stisknuté" — reaguje na moment stisknutí. Tomuhle momentu se v elektronice říká hrana (edge).

💬 Co to znamená: hrana (edge)?

Digitální signál je buď 0 (LOW, třeba 0 V) nebo 1 (HIGH, třeba 3,3 V). Hrana je ten zlomek sekundy, kdy signál přechází z jedné hodnoty do druhé.

  • Analogie: světlo v místnosti. Když svítí, je to „1". Když nesvítí, „0". Hrana je ten moment cvaknutí vypínače, ne celý stav svícení.
  • Stoupající hrana (RISING) = z 0 do 1. Vypínač se rozsvítil. Typicky „někdo stiskl tlačítko" (když používáš pull-down rezistor).
  • Klesající hrana (FALLING) = z 1 do 0. Vypínač zhasl. Typicky „někdo stiskl tlačítko" u INPUT_PULLUP (stisk táhne pin k zemi — viz L17).
  • Proč je důležité to rozlišovat? Kdyby čip reagoval na „pin je 0", spustil by ISR tisíckrát za sekundu po celou dobu, kdy tlačítko držíš. Chceš reakci jen jednou, v okamžiku stisku = detekce hrany.

💬 Co to znamená: debounce (odstranění zákmitu)?

Mechanické tlačítko nepřepne jednou — dupe. Mezi „nestisknuto" a „stisknuto" pin 1–3 ms poskakuje mezi 0 a 1 (kovové kontakty se „odrazí"). Bez ošetření by tvoje ISR jedním stiskem zaznamenala 5–10 událostí.

  • Analogie: mechanický zvonek na dveřích — 1 stisk, a zvonek třikrát cingrlingrling. Jeden host, tři cingrlingy.
  • Anglicky „bounce" = odrážet. Debounce = „odbounce", odstranit odrazy.
  • Nejjednodušší řešení v kódu: zapamatuj si čas poslední ISR. Pokud přijde další do 50 ms, ignoruj ji.
    volatile unsigned long lastIrq = 0;
    void onPress() {
      unsigned long now = millis();
      if (now - lastIrq > 50) {   // ignoruj opakování < 50 ms
        lastIrq = now;
        pressFlag = true;
      }
    }
  • Proč zrovna 50 ms? Zákmity trvají 1–3 ms. 50 ms je bezpečná rezerva a zároveň je to rychleji, než člověk zvládne stisknout podruhé (nejrychlejší dvojstisk ~150 ms). Pro super-rychlá tlačítka (herní) se dává 10 ms.
💡 Trik, který chápeš intuitivně: hrana = okamžik změny, ne stav. Když ti někdo zavolá, reaguješ na zazvonění (moment), ne na „telefon existuje" (stav). Debounce = filtruj zvonek, aby jedno zazvonění nebylo počítáno třikrát kvůli odrazům pružiny.

🔌 20.4 External interrupt — zvonek na GPIO pinu

External interrupt (čti „extérnl interapt", vnější přerušení) je nejběžnější typ — hardware sleduje GPIO pin (viz L17) a když na něm zaznamená hranu, zavolá tvoji ISR.

Použití v praxi: tlačítka, rotační enkodéry, senzory pohybu (PIR), signalizace „data hotová" z jiného čipu, buzení z hlubokého spánku.

💬 Ne všechny piny umí interrupt — zkontroluj desku!

Historicky byly IRQ piny drahé na hardware, takže se šetřily.

  • Arduino Uno (ATmega328P): pouze 2 piny — pin 2 (INT0) a pin 3 (INT1). Ostatní ne.
  • Arduino Mega: 6 pinů.
  • ESP32: každý GPIO umí interrupt. Moderní, pohoda.
  • STM32 (Bluepill atd.): každý pin, ale se skupinami (pin 0 z portu A, B, C sdílí jednu linku).
  • Záchrana na Arduinu Uno: existuje PCINT (Pin Change Interrupt, čti „pí-cé-int") — umí IRQ na všech pinech, ale 1 ISR na skupinu 8 pinů — sám si v ISR musíš přečíst, který pin to byl. Komplikace, ale funguje.

💡 Nejkratší možný interrupt kód (Arduino)

const uint8_t BTN = 2;
volatile bool pressed = false;

void onPress() {     // ISR — 1 řádek
  pressed = true;
}

void setup() {
  pinMode(BTN, INPUT_PULLUP);                    // tlačítko na GND
  attachInterrupt(
    digitalPinToInterrupt(BTN),                // pin → číslo INT linky
    onPress,                                      // funkce k zavolání
    FALLING                                       // na klesající hranu
  );
}

void loop() {
  if (pressed) {
    pressed = false;
    Serial.println("Stisknuto!");
  }
}

Co se děje: Pin 2 má INPUT_PULLUP — v klidu 3,3 V (HIGH). Když stiskneš tlačítko propojené s GND, pin půjde na 0 V (LOW). Toho okamžiku (HIGH → LOW = klesající hrana) si hardware všimne a zavolá onPress(). Funkce nastaví flag. loop() ho při další iteraci zpracuje a vytiskne „Stisknuto!". Žádné pollování, CPU zbývajících 99,99 % času volné.

⏱️ 20.5 Timer — kuchyňský minutník uvnitř čipu

Druhý velký zdroj interruptů je timer — malý hardwarový čítač uvnitř čipu, který sám sebe pořád inkrementuje a každých N kroků spustí ISR. Je to v podstatě kuchyňský minutník, který sám upéká sebe znovu a znovu.

💬 Co to znamená: timer?

Timer je hardwarové počítadlo. V každém taktu hlavních hodin (FCPU) se zvětší o 1. Když dosáhne nastavené hodnoty, vyvolá interrupt a začne počítat znova od 0.

  • Analogie: kuchyňský minutník na špagety. Natáhneš ho na 10 minut, on tiká (tik, tik, tik), a po 10 minutách pípne. U mikrokontroléru je to úplně to samé, jen místo minut jsou to mikrosekundy.
  • Proč je lepší než delay(1000)? delay() zablokuje celý CPU na 1 sekundu — nic jiného neuděláš. Timer běží na pozadí (je to hardware, ne CPU), a když pípne, CPU to jen krátce obslouží (ISR). Mezi tím může CPU dělat cokoliv, klidně spát.
  • Kolik timerů má typický MCU?
    • Arduino Uno (ATmega328P): 3 timery. Timer0 ukradlo samo Arduino pro millis() a delay(). Timer1 (16-bit, přesný) a Timer2 jsou tvoje.
    • ESP32: 4 timery, každý 64-bit (může počítat stovky let).
    • STM32F4: 14+ timerů. Luxus.
  • Proč mě to zajímá? Kdykoliv potřebuješ přesný čas — vzorkovat zvuk, ovládat motor, blikat LEDkou přesně — použij timer místo delay(). Tvůj program pak může dělat další věci zároveň.

💬 Co to znamená: prescaler (předdělič)?

Hlavní hodiny MCU tikají rychle — Arduino Uno tiká na 16 MHz, to je 16 milionů krát za sekundu. Timer je 16-bit (max 65535). Kdyby počítal každý tik, přetekl by za 4 ms. To je málo. Prescaler (čti „prískejler", předdělič) dělí frekvenci hodin dřív, než dojde do timeru.

  • Analogie: převodovka na kole. Ty šlapeš 60× za minutu, ale kolo s velkým převodem se otáčí jen 20× za minutu. Podobně — CPU tiká 16 MHz, timer s prescale 256 tiká jen 62 500× za sekundu. Pomalejší, ale dosáhneš mnohem delších časů.
  • Typické hodnoty: 1, 8, 64, 256, 1024. Volíš z nabídky podle toho, jak dlouhou periodu potřebuješ.
  • Vzorec pro periodu: T = (prescale × (N+1)) / FCPU. Kde N je cílová hodnota timeru.
  • Příklad: chci 1 ms periodu na 16 MHz. Prescale = 64, N = 249 → T = (64 × 250) / 16 000 000 = 1 ms. Ten vzoreček si zapamatovat nemusíš — knihovna TimerOne to spočítá sama.
Perioda timer IRQ
T = (prescale × (N + 1)) / FCPU

💡 „Milisekundový tick" pomocí TimerOne

#include <TimerOne.h>      // knihovna, nainstaluj přes Library Manager

volatile uint32_t ticks = 0;

void onTick() { ticks++; }  // ISR — jeden řádek

void setup() {
  Serial.begin(115200);
  Timer1.initialize(1000);       // 1000 µs = 1 ms perioda
  Timer1.attachInterrupt(onTick);
}

void loop() {
  // tvůj kód běží paralelně, ticks se zvětšuje 1000× za sekundu
}

Timer běží v hardwaru, zcela nezávisle na loop(). Za 1 sekundu spustí ISR přesně 1000×, s jitterem (rozptylem) pod 1 µs. Pro srovnání: millis() má jitter 4 ms (když tě zrovna přerušuje jiný interrupt). Timer je o 4000× přesnější.

🏛️ 20.6 Priority — kdo jde první na pohotovosti?

Co když přijde více interruptů najednou? Třeba stiskneš tlačítko zrovna v momentě, kdy timer pípne. Který se vyřeší první? Moderní čipy (ARM Cortex-M — většina ESP32, STM32, Raspberry Pi Pico) mají priority.

💬 Co to znamená: NVIC?

NVIC (čti „en-ví-aj-sí") znamená Nested Vectored Interrupt Controller — česky „řadič vnořených vektorovaných přerušení". Zní to složitě, ale princip je snadný: NVIC je malý hardware uvnitř ARM čipu, který rozhoduje, kterou ISR spustit jako první.

  • Analogie: pohotovost v nemocnici. Přijdou tři pacienti: jeden s rýmou, druhý se zlomeným prstem, třetí s infarktem. Sestra (NVIC) rozhodne: infarkt jako první (priorita 0, nejvyšší), prst (priorita 3), rýma (priorita 7, nejnižší). Rýma počká.
  • 8 úrovní priority (0–7, 0 je nejvyšší). Přiřadíš každému interruptu jedno číslo.
  • „Nested" (čti „nestid", vnořený) znamená, že vyšší priorita může přerušit nižší. Třeba běží Timer ISR a v tom přijde UART byte (musí se zpracovat hned, jinak se ztratí) — UART přeruší Timer, po návratu se Timer dokončí.
  • Typická priorita: Systick a watchdog 0 (nejvyšší), UART RX 2–3, timery 5–6, user tasks 7.
  • Proč mě to zajímá? Bez priorit by se v komplikovaném systému ztrácely UART byty (přišly, zatímco jiná ISR běžela). NVIC to vyřeší automaticky.
  • Arduino AVR (Uno) NVIC nemá — ISR se spouštějí v pořadí vektorové tabulky, uvnitř ISR jsou všechny další IRQ zakázané. Jednodušší, ale méně flexibilní.

💤 20.7 Sleep — MCU spí, budík ho probudí

Největší superschopnost interruptů: čip může spát. V aktivním režimu spotřebuje 10–100 mA. Ve spánku 1–10 µA — 10 000× méně. A když přijde interrupt, probudí se. Tohle je jediný důvod, proč dnes bateriová elektronika vydrží roky.

💬 Co to znamená: sleep mode (spánkový režim)?

Sleep mode je stav, kdy čip vypne většinu své vnitřní elektroniky, aby šetřil proud. Zůstane zapnutá jen malá část, která čeká na budíka (external interrupt z GPIO, nebo RTC timer).

  • Analogie: člověk spí. Vědomí je vypnuté, srdce bije pomalu, energie se nespotřebovává. Ale uši zůstávají citlivé — budík zazvoní a během ms se probudíš. Mozek je v tomto „úsporném módu", dokud nepřijde podnět.
  • IDLE (lehký spánek) — CPU stojí, ale periferie běží. Probudí cokoliv. Wake-up za 1 takt CPU (~62 ns). Spotřeba ~1 mA.
  • POWER-DOWN / DEEP-SLEEP (hluboký spánek) — všechno včetně hlavních hodin vypnuté. Probudí jen external GPIO nebo RTC timer. Wake-up ~ms. Spotřeba 1–10 µA. Baterka vydrží roky.
  • Konkrétní čísla ESP32:
    • Aktivní s Wi-Fi: 160 mA
    • Light-sleep: 1,3 mA
    • Deep-sleep s RTC budíkem: 10 µA
    • Baterka 2500 mAh v deep-sleep: 28 let (ano, opravdu — praktický limit je samovybíjení baterky)
💡 Proč interrupty + sleep = revoluce: bez interruptů bys musel v loop() polit a CPU by běžel 24/7 na plné páře. S interrupty MCU 99,99 % času spí a chvilkově se probudí na 1 ms, aby něco udělal. To je rozdíl mezi baterkou na 2 dny a baterkou na 2 roky. Všechna moderní senzorová IoT elektronika (LoRa loggery, Bluetooth beacony, chytré zámky) funguje přesně takhle.

💡 „Zámek s baterkou na 3 roky" — pattern

#include <avr/sleep.h>

volatile bool woke = false;
void onButton() { woke = true; }

void setup() {
  attachInterrupt(0, onButton, FALLING);
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
}

void loop() {
  sleep_enable();
  sleep_cpu();           // <<< zde MCU usne, spotřeba ~1 µA
  sleep_disable();       // probudil se (někdo stiskl), pokračujeme zde

  // Udělej, co je potřeba (odemkni, blikni LED, …)
  doUnlock();
  woke = false;
  // …a zase spi v další iteraci loop()
}

Zámek na dveřích: 99,999 % času spí. Když stiskneš tlačítko (FALLING na pin 2), probudí se, odemkne, a zas si jde lehnout. S baterkou CR2032 (225 mAh) vydrží 3+ roky. S 4× AA (2500 mAh) přes 30 let. Přesně tak fungují ovladače ke garáži, chytré zámky a PIR alarmy.

🧭 20.8 Srovnávací tabulka: external IRQ vs. timer IRQ

Dva nejčastější typy interruptů vedle sebe — ať si vybereš, kdy co použít.

 External IRQ (zvonek)Timer IRQ (minutník)
Co spouštíHrana na GPIO pinu (tlačítko, senzor)Uplyne nastavený čas (1 ms, 1 s, …)
Nepravidelné vs. pravidelnéNepravidelné (kdykoli)Pravidelné, přesné
Typické použitíTlačítko, enkodér, PIR senzor, buzení ze spánkuVzorkování ADC, PWM, bliknutí LED, watchdog
Arduino APIattachInterrupt()Timer1.attachInterrupt() (TimerOne)
Analogie🔔 zvonek u dveří⏱️ kuchyňský minutník

🎯 Rozhodovací strom pro začátečníka

  • „Chci reagovat, když někdo stiskne tlačítko." → External IRQ + debounce.
  • „Chci bliknout LED přesně každou 1 sekundu a zároveň dělat jiné věci." → Timer IRQ.
  • „Mám bateriové zařízení, co má vydržet roky." → Sleep + external IRQ (GPIO nebo RTC).
  • „Chci vzorkovat senzor přesně 1000× za sekundu." → Timer IRQ. millis() není dost přesné.
  • „Rotační enkodér kvako 50 impulzů/s." → External IRQ na obou pinech (pollingem se ti ztratí půlka impulzů).

Část 2 — Praktické příklady

Od teorie k tlačítku, které nestisknutím něco nespustí, a LED, co bliká přesně každou sekundu

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

Příklad 1: Tlačítko přes interrupt + debounce

Co uděláme: Tlačítko na pin 2 toggluje LED na pin 13. Místo pollingu v loop() použijeme interrupt. CPU pak může mezi stisky dělat jakoukoli jinou práci (nebo spát). A přidáme debounce — jinak jedno stisknutí udělá 5 toggle.

Hardware:

  • Tlačítko mezi pin 2 a GND. Pull-up rezistor není nutný — použijeme interní INPUT_PULLUP (viz L17).
  • LED + rezistor 220 Ω mezi pin 13 a GND. (Uno má LED na desce, stačí.)
Krok 1 — proměnné a ISR:
const uint8_t BTN = 2, LED = 13;
volatile bool pressFlag = false;
volatile unsigned long lastIrq = 0;
bool ledOn = false;

void onPress() {                    // ISR — musí být krátká!
  unsigned long now = millis();
  if (now - lastIrq > 50) {           // ignoruj zákmity < 50 ms
    lastIrq = now;
    pressFlag = true;                 // jen flag — zbytek udělá loop()
  }
}
Krok 2 — registrace interruptu v setup():
void setup() {
  pinMode(BTN, INPUT_PULLUP);        // pin 2 v klidu HIGH
  pinMode(LED, OUTPUT);
  Serial.begin(115200);
  attachInterrupt(
    digitalPinToInterrupt(BTN),   // přeloží pin 2 na INT0
    onPress,                         // funkce k zavolání
    FALLING                          // stisk = HIGH → LOW
  );
}
Krok 3 — zpracování v loop():
void loop() {
  if (pressFlag) {
    pressFlag = false;           // ← atomicky by bylo lepší, ale bool je 1 bajt, OK
    ledOn = !ledOn;
    digitalWrite(LED, ledOn);
    Serial.println("Stisk zpracován");
  }
  // CPU má tady 99.99 % času — mohli bychom třeba měřit senzor
}
Proč je to lepší než polling: Pin 2 může měnit stav třeba 1000× za sekundu (zákmity), hardware na každou klesající hranu spustí ISR. Ty uvidíš jen jeden stisk (díky debounce 50 ms). A zároveň může loop() dělat cokoliv jiného. Polling by to nezvládl — kdyby loop() zrovna čekal na Serial.print(), stisk by propásl.
Jedno tlačítko, jeden stisk, jedna reakce. CPU 99,99 % volný. Stejný pattern funguje pro 1000 stisků/s (například u herních kontrolérů).

Příklad 2: LED blikající přesně 1× za sekundu (Timer1)

Co uděláme: LED na pin 13 bude blikat přesně 1× za sekundu, ale loop() bude volný pro jiné úlohy. Místo delay(1000) (který by zablokoval CPU) použijeme Timer1 s knihovnou TimerOne. Přesnost 20 ppm (0,002 %).

Hardware: LED + 220 Ω mezi pin 13 a GND. (Nebo jen využij vestavěnou LED na Uno.)
Instalace knihovny: Arduino IDE → Tools → Manage Libraries → hledej „TimerOne" (Paul Stoffregen) → Install.
Kód:
#include <TimerOne.h>

const uint8_t LED = 13;
volatile bool toggle = false;

void onTimer() {          // ISR — spustí se každou 1 s
  toggle = !toggle;         // jen přepni flag
}

void setup() {
  pinMode(LED, OUTPUT);
  Timer1.initialize(1000000);        // 1 000 000 µs = 1 s
  Timer1.attachInterrupt(onTimer);
}

void loop() {
  digitalWrite(LED, toggle);       // zrcadlí flag do LED

  // --- tady můžeš dělat cokoliv jiného ---
  // měřit senzor, reagovat na tlačítka, posílat UART data…
  // LED bliká úplně přesně a nezávisle na tvém kódu!
}
Jak je to přesné: Timer1 běží z CPU krystalu (16 MHz, ±20 ppm). 1 sekunda = 16 000 000 taktů. Timer1 napočítá přesně tolik. Chyba za celý den: ~1,7 sekundy. Oproti delay(1000) v loop() (který má chybu 20–30 s/den kvůli jitteru) je to o řád lepší.
Důležité — flag pattern: ISR nesmí dělat digitalWrite() přímo (občas je to OK, ale zásada je „ISR = flag, zbytek = loop"). Proto ISR jen přepíná toggle a loop() to zrcadlí do pinu.
LED bliká jako hodinky. loop() může zároveň číst senzor, obsluhovat tlačítka, mluvit přes UART. Timer je úplně nezávislý a přesný. Pro jakoukoliv pravidelnou úlohu (vzorkování, motorek, PID regulátor) je timer to správné řešení.

Část 3 — Shrnutí a test

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

📋

Shrnutí lekce 20

Klíčové pojmy jednou větou

📝

Test z lekce 20

5 otázek · 5–10 minut

🔁

Opakovací test — Fáze 1–4 (L1–L20)

10 otázek · kompletní Fáze 4 dokončená!