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
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ý.
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 (čti „polink", z angl. „to poll" = dotazovat se) je metoda, kdy čip v kruhu pořád znovu čte, jestli se něco nestalo.
loop() — tisíckrát za sekundu zavolá digitalRead(button) a zkouší, jestli není stisknuté.loop() nestihl přečíst).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.
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.
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.
void onPress() { // tohle je ISR flag = true; // uvnitř jen rychlé věci! } attachInterrupt(0, onPress, FALLING); // registruj ISR na pin
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.
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".loop() označ volatile.volatile bool pressed = false; // ✓ ISR i loop ji vidí čerstvou bool pressed = false; // ✗ nefunguje — loop uvidí jen starou hodnotu
loop() nereaguje na flag — skoro vždycky chybí volatile.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.
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
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.delay(), Serial.print(), síťové volání. Blokovalo by to CPU a mohlo by to zablokovat samo sebe.volatile. Jinak kompilátor tě zradí.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().
Čip nereaguje na „tlačítko je stisknuté" — reaguje na moment stisknutí. Tomuhle momentu se v elektronice říká 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é.
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í.
volatile unsigned long lastIrq = 0; void onPress() { unsigned long now = millis(); if (now - lastIrq > 50) { // ignoruj opakování < 50 ms lastIrq = now; pressFlag = true; } }
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.
Historicky byly IRQ piny drahé na hardware, takže se šetřily.
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é.
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.
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.
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.millis() a delay(). Timer1 (16-bit, přesný) a Timer2 jsou tvoje.delay(). Tvůj program pak může dělat další věci zároveň.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.
#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ší.
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.
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í.
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.
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).
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.
#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.
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ánku | Vzorkování ADC, PWM, bliknutí LED, watchdog |
| Arduino API | attachInterrupt() | Timer1.attachInterrupt() (TimerOne) |
| Analogie | 🔔 zvonek u dveří | ⏱️ kuchyňský minutník |
millis() není dost přesné.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
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:
INPUT_PULLUP (viz L17).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() } }
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 ); }
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 }
loop() dělat cokoliv jiného. Polling by to nezvládl — kdyby loop() zrovna čekal na Serial.print(), stisk by propásl.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 %).
#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! }
delay(1000) v loop() (který má chybu 20–30 s/den kvůli jitteru) je to o řád lepší.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.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í.Klíčové pojmy, pravidla a kvíz pro ověření
Shrnutí lekce 20
Test z lekce 20
Opakovací test — Fáze 1–4 (L1–L20)