The Interrupts

Riešenie pôvodného problému s doručením pizze je však veľmi jednoduché - keď doručovateľ s pizzou dorazí, zazvoní alebo zaklope na dvere zákazníka. Poprípade ho pred príchodom upozorní telefonátom. Ten sa teda nemusí starať o to, či uplynula doba doručenia alebo či náhodou neprišiel skôr. Môže sa venovať svojim dôležitejším povinnostiam a na vznik udalosti doručenia bude automaticky a hlavne včas upozornený.

Tento mechanizmus sa v svete informačných technológií nazýva prerušenie (z angl. interrupt). Koncept prerušení je vo svete mikrokontrolérov veľmi dôležitý.

Prerušenie je mechanizmus, ktorým dá prostredie mikrokontroléru vedieť, že sa práve stalo niečo dôležité. Vo všeobecnosti je možné povedať, že prerušenie je špeciálny signál pre mikrokontrolér, ktorý poslal softvér alebo hardvér a vyžaduje si okamžitú pozornosť.

Výhodou takéhoto prístupu je vo všeobecnosti zníženie zaťaženia mikrokontroléra, ktorý nemusí stále dookola testovať, či k udalosti došlo alebo ešte nie (viď polling). V porovnaní s polling-om má prerušenie lepší reakčný čas, pretože reaguje na udalosť okamžite.

Princíp prerušenia sa využíva aj v architektúre riadenej udalosťami (a zngl. event driven architecture) alebo v programovaní riadenom udalosťami (z angl. event driven programming). V objektovom programovaní je zasa tento prístup opísaný pomocou návrhového vzoru pozorovateľ (z angl. observer).

Podobne, ako keď donášková služba volá priamo zákazníkovi, aby ho informovala o tom, že je donáška pripravená, aj požiadavku o prerušenie dostane od zariadenia priamo mikrokontrolér Tým pádom môže prísť požiadavka o prerušenie kedykoľvek a prerušenie predstavuje asynchrónny spôsob komunikácie.

Hlavný rozdiel medzi polling-om a prerušením je v tom, či sa softvér sám opýta alebo hardvér sám oznámi, či došlo k predmetnej udalosti.

Interrupt Service Routine

Inštrukcie programu, ktorý beží v mikrokontroléri, sa (obyčajne) vykonávajú sekvenčne. To znamená, že po vykonaní jednej inštrukcie sa vykoná nasledujúca inštrukcia v poradí. Akonáhle však mikrokontrolér dostane požiadavku na prerušenie, pozastaví sa vykonávanie inštrukcií programu mikrokontroléra a ten spustí špeciálnu funkciu na spracovanie prerušenia, ktorá sa označuje ISR (z angli. Interrupt Service Routine). Po jej skončení sa obnoví vykonávanie prerušeného programu vykonaním ďalšej inštrukcie v poradí.

ISR funkcie nevracajú žiadnu hodnotu a nemajú žiadny parameter. Ak je teda potrebné vo vnútri ISR funkcie zmeniť stav správania aplikácie, je na to možné použiť globálne premenné. Je to vlastne jediný spôsob, pomocou ktorého je možné prenášať údaje medzi ISR a hlavným programom.

Pri tvorbe ISR je dobré dodržiavať niekoľko odporúčaní:

• ISR majú byť čo najkratšie a čo najrýchlejšie, aby zbytočne nebrzdili hlavný program alebo prípadne ďalšie prerušenia, ktoré môžu nastať.
• Je potrebné sa vo vnútri ISR vyhnúť použitiu funkcie delay()!
• Nepoužívať sériovú komunikáciu!
• Ak programujete v jazyku C, tak globálne premenné, ktoré používate na zdieľanie údajov medzi ISR a programom, označte pomocou kvalifikátora volatile! Tým poviete prekladaču, že táto premenná môže byť použiteľná kdekoľvek v kóde a prekladač jej obsah vždy pri použití znovu načíta a nebude sa spoliehať na jej kópiu v registri. Zabránite tak aj prípadným optimalizáciám prekladača, vďaka ktorým by ju mohol napr. vyhodiť, pretože sa nepoužíva (v hlavnom programe).
• Nevypínať ani nezapínať podporu prerušení vo vnútri ISR. V tomto prípade však existujú výnimky, ktoré budú opísané neskôr v kapitole.

Reasons to use Interrupts

Existuje veľa dôvodov, prečo prerušenia používať . Niektoré z nich sú tieto:

• To detect pin changes (eg. rotary encoders, button presses)
• Watchdog timer (eg. if nothing happens after 8 seconds, interrupt me)
• Timer interrupts - used for comparing/overflowing timers
• SPI data transfers
• I2C data transfers
• USART data transfers
• ADC conversions (analog to digital)
• EEPROM ready for use
• Flash memory ready

Types of Interrupts

Pri práci s mikrokontrolérmi je možné prerušenia rozdeliť do dvoch skupín:

1. hardvérové prerušenia, známe tiež ako externé prerušenia, alebo tiež pin-change prerušenia, a
2. softvérové prerušenia, ktoré sú známe ako interné prerušenia alebo tiež časovače.

Ako už názov napovedá, signál prerušenia prichádza v prípade hardvérových alebo externých prerušení z externého zariadenia. Toto zariadenie je s mikrokontrolérom priamo prepojené. Keďže sú prerušenia asynchrónne, k prerušeniu môže dôjsť kedykoľvek.

Interné prerušenia zasa referujú na čokoľvek vo vnútri mikrokontroléra, čo dokáže vyvolať prerušenie. Príkladom môžu byť napríklad časovače, pomocou ktorých je možné zabezpečiť, aby k vyvolaniu prerušenia dochádzalo pravidelne napr. každú 1 sekundu.

Interrupt Vectors in ATmega328P

V jednej chvíli môžu byť naraz vyvolané viaceré žiadosti o prerušenie a mikrokontrolér sa musí rozhodnúť, ktorá z nich bude ošetrená ako prvá. Je teda potrebné, aby mikrokontrolér vedel povedať, ktoré prerušenia majú prednosť pred inými.

Mikrokontrolér obsahuje tzv. tabuľku vektorov prerušení (viď. tabuľka XXX). Táto tabuľka sa nachádza na začiatku programovej flash pamäti a obsahuje adresy ISR funkcií jednotlivých prerušení. V ich poradí je však aj priorita - čím má prerušenie nižšiu adresu, resp. vektor prerušenia má nižšie číslo, tým má vyššiu prioritu. Z tabuľky je teda možné vidieť, že najvyššiu prioritu má prerušenie od zdroja RESET a najnižšiu prioritu od zdroja SPM READY.

: Reset and Interrupt Vectors in ATmega328 and ATmega328P

Handling the External Interrupts with Arduino

Vrátime sa teda k predchádzajúcemu zdrojovému kódu, kedy sme na detekciu pohybu využili metódu polling-u. Tentokrát sa problém pokúsime vyriešiť pomocou prerušenia. Konkrétne sa bude jednať o externé prerušenie, keďže prerušenie vyvolá PIR senzor tým, že pošle signál do mikrokontroléra vtedy, keď bude detekovať pohyb.

Ošetrenie prerušenia sa inicializuje pomocou funkcie attachInterrupt(). Inicializácia môže prebehnúť kdekoľvek v programe, ale pokiaľ sa ošetrenie prerušenia v programe nemení, je ideálne ho inicializovať vo funkcii setup(). Táto funkcia má tri parametre, ktoré hovoria o tom, čo všetko je potrebné vedieť pri ošetrovaní prerušenia:

1. číslo prerušenia, ktoré je potrebné ošetriť,
2. názov (resp. adresu) ISR funkcie, ktorá sa zavolá na jeho ošetrenie, a
3. režim prerušenia, ktorý definuje, aké správanie na pin-e vyvolá prerušenie.

[!NOTE]

Miesto čísla prerušenia, ktoré má byť ošetrené, je vhodnejšie použiť číslo pin-u, na ktorom je toto prerušenie sledované. To je možné dosiahnuť pomocou funkcie digitalPinToInterrupt(pin), ktorá automaticky prevedie číslo pin-u na číslo prerušenia. Týmto spôsobom je tiež možné zabezpečiť prenositeľnosť medzi viacerými platformami.

Pozrime sa najprv na to, aké správanie na pin-e vyvolá prerušenie. Prototypovacia doska Arduino UNO pozná tieto štyri režimy prerušenia:

1. LOW - Prerušenie je vyvolané vtedy, keď sa na pine nachádza úroveň LOW. Tento proces sa deje napríklad vtedy, ak je tlačidlo pripojené k digitálnemu pinu v režime INPUT_PULLUP a po jeho stlačení sa na pin privedie úroveň LOW.

2. CHANGE - Prerušenie je vyvolané vtedy, keď dôjde k zmene úrovne pinu buď z HIGH na LOW alebo z LOW na HIGH. Tento proces sa deje napríklad pri stláčaní prepínača.

3. RISING - Prerušenie je vyvolané vtedy, keď dôjde k zmene úrovne z LOW na HIGH. Tento proces sa deje napríklad pri stlačení tlačidla.

4. FALLING - Prerušenie je vyvolané vtedy, keď dôjde k zmene úrovne z HIGH na LOW. Tento proces sa deje napríklad pri uvoľnení stlačeného tlačidla.

[!NOTE]

Prototypovacie dosky Arduino Due, Zero a MKR1000 majú navyše režim HIGH. K tomuto prerušeniu dôjde vždy vtedy, keď sa na pine bude nachádzať úroveň HIGH.

Princíp jednotlivých režimov je ilustrovaný na nasledujúcom obrázku:

Na základe uvedených režimov prerušenia mikrokontroléra sa je možné stretnúť ešte s nasledujúcim rozdelením externých prerušení:

• Level Interrupts - Prerušenie je vyvolané zakaždým, keď sa na vstupe objaví signál konkrétnej úrovne (HIGH alebo LOW). Pri tomto type prerušenia je dobré dať pozor na to, že pri nezmenenom signále môže k prerušeniu dochádzať opakovane aj počas ošetrovania predchádzajúceho prerušenia.

• Edge Interrupts - Prerušenie je vyvolané vtedy, keď dôjde k zmene jednej úrovne signálu na druhú (napr. ak dôjde k zmene úrovne z HIGH na LOW alebo z LOW na HIGH).

Každý mikrokontrolér je špecifický tým, že na zachytenie externého prerušenia z pripojeného zariadenia nie je možné použiť každý digitálny pin. Vždy je preto potrebné overiť si možnosti mikrokontroléra v jeho dokumentácii. V prípade mikrokontrolérov Arduino sa je možné orientovať pomocou tabuľky XXX.

V porovnaní s mikrokontrolérom ESP8266 je na tom ATmega 328P horšie, pretože je možné použiť piny GPIO0 až GPIO15. To umožňuje naraz sledovať až 16 rozličných prerušení.

PIR senzor je aktuálne v IoT zariadení na detekciu pohybu pripojený k pin-u č. 2. Ten podľa uvedenej tabuľky je možné použiť na zachytávanie externých prerušení.

Následne je potrebné už len poznať názvy ISR funkcií. V predchádzajúcom prípade sme používali funkcie dve a to alarm() a idle(). Funkcia alarm() bola zavolaná vtedy, keď došlo k zisteniu pohybu (na výstupnom pine PIR senzoru došlo k prechodu z úrovne LOW do úrovne HIGH). Funkcia idle() bola zasa vyvolaná vtedy, keď tento pohyb pominul (na výstupnom pine PIR senzoru došlo k prechodu z úrovne HIGH na úroveň LOW).

Vzhľadom na uvedené správanie vieme presne určiť, v akom režime prerušenia má byť zavolaná funkcia alarm() a v akom funkcia idle():

• alarm() sa bude volať v režime RISING
• idle() sa bude volať v režime FALLING

V kóde funkcie setup() to teda bude vyzerať nasledovne:

attachInterrupt (digitalPinToInterrupt(PIN_PIR), alarm, RISING);
attachInterrupt (digitalPinToInterrupt(PIN_PIR), idle, FALLING);

Tu však pozor! Každý mikrokontrolér obsahuje tabuľku vektorov prerušení (viď tabuľka XXX). Každý riadok v tejto tabuľke obsahuje informáciu o tom, ktorá ISR funkcia sa použije na ošetrenie ktorého zdroja prerušenia. To znamená, že na ošetrenie prerušenia na jednom vstupe sa použije len jedna ISR funkcia. V zázname sa nenachádza informácia o tom, v akom režime môže k prerušeniu dôjsť. Ak sme teda v našom prípade na jeden pin namapovali pomocou funkcie attachInterrupt() dve ISR funkcie, tak sme vlastne prepísali ošetrenie prerušenia prvou funkciou pomocou druhej funkcie. Kód sa úspešne preloží, aj sa spustí, ale k ošetreniu prerušenia dôjde len pomocou ISR funkcie idle() v režime FALLING.

Aj napriek tomu je však možné prekonfigurovať ošetrenie prerušenia neskôr v programe. Akonáhle teda k prerušeniu dôjde a vyvolá sa ISR funkcia, jej súčasťou bude volanie funkcie attachInterrupt() na nastavenie nového ošetrenia prerušenia za iných podmienok. Týmto spôsobom si budú jednotlivé ISR funkcie prehadzovať ošetrenie prerušenia navzájom.

Aby všetko pracovalo správne, je potrebné aplikovať tieto informácie a refaktorovať funkciu setup() z predchádzajúceho riešenia. Globálnu premennú isMovement je potrebné označiť kľúčovým slovom volatile a zadefinovať ošetrenie prerušenia pomocou ISR funkcie alarm() v režime RISING (zistenie pohybu). Aktualizovaný kód funkcie setup() sa nachádza vo výpise XXX.

#include <Arduino.h>

#define PIN_LED 8
#define PIN_PIR 2

volatile bool isMovement;

void idle();
void alarm();

void setup(){
    // setup serial
    Serial.begin(9600);
    while(!Serial);

    // set pin modes
    pinMode(PIN_LED, OUTPUT);
    pinMode(PIN_PIR, INPUT);

    // initial state
    isMovement = false;

    // enter idle state
    idle();
}

Následne je potrebné upraviť ISR funkcie alarm() a idle(). Okrem pôvodného správania v každej z nich predefinujeme ošetrenie prerušenia:

• v prípade ISR funkcie alarm() predefinujeme ošetrenie prerušenia pomocou funkcie idle() v režime FALLING (zo stavu ALARM zariadenie prejde do stavu IDLE, ak na pine dôjde k prechodu z úrovne HIGH na úroveň LOW)

• v prípade ISR funkcie idle() predefinujeme ošetrenie prerušenia pomocou funkcie alarm() v režime RISIGN (zo stavu IDLE zariadenie prejde do stavu ALARM, ak na pine dôjde k prechodu z úrovne LOW na úroveň HIGH)

Po úprave budú tieto funkcie vyzerať takto:

void idle(){
    Serial.println("> Idle State");

    // update state
    isMovement = false;
    digitalWrite(PIN_LED, LOW);

    // (re)atach interrupt
    attachInterrupt(digitalPinToInterrupt(PIN_PIR), alarm, RISING);
}

void alarm(){
    Serial.println("> Alarm State");

    // update state
    isMovement = true;
    digitalWrite(PIN_LED, HIGH);

    // (re)atach interrupt
    attachInterrupt(digitalPinToInterrupt(PIN_PIR), idle, FALLING);
}

Nakoniec už zostáva len funkcia loop(), ktorá bude v tomto prípade prázdna. Celý kód, ktorý bol použitý v prípade riešenia pomocou metódy pooling bol totiž presunutý do ISR funkcií. Týmto sme využili všetky výhody, ktoré ponúka mechanizmus prerušení a odstránili sme všetky nedostatky, ktoré ponúka polling. Vo funkcii loop() teda zostáva priestor na vlastný ḱód, ktorý môže na základe globálnej premennej isMovement vykonávať ďalšie operácie.

void loop(){
    // nothing to do :-/
}

Kompletný výpis kódu sa nachádza vo výpise XXX.

#include <Arduino.h>

#define PIN_LED 8
#define PIN_PIR 2

bool isMovement;

void idle();
void alarm();

void idle(){
    Serial.println("> Idle State");

    // update state
    isMovement = false;
    digitalWrite(PIN_LED, LOW);

    // (re)atach interrupt
    attachInterrupt(digitalPinToInterrupt(PIN_PIR), alarm, RISING);
}

void alarm(){
    Serial.println("> Alarm State");

    // update state
    isMovement = true;
    digitalWrite(PIN_LED, HIGH);

    // (re)atach interrupt
    attachInterrupt(digitalPinToInterrupt(PIN_PIR), idle, FALLING);
}

void setup(){
    // setup serial
    Serial.begin(9600);
    while(!Serial);

    // set pin modes
    pinMode(PIN_LED, OUTPUT);
    pinMode(PIN_PIR, INPUT);

    // initial state
    isMovement = false;

    // enter idle state
    idle();
}

void loop(){
    // nothing to do :-(
}

[!NOTE]

Sériová komunikácia vo vnútri ISR.

Toto riešenie je možné ešte zjednodušiť a vrátiť sa tak k pôvodnému konceptu, kedy boli prerušenia RISING a FALLING zadefinované naraz. Upravíme zapojenie tak, že výstup z PIR senzoru pripojíme naraz ku pinu 2 aj 3. na pine 2 bude mikrokontrolér sledovať prerušenie typu RISING a na pine 3 prerušenie typu FALLING.

Upravená schéma zapojenia sa nachádza na obrázku XXX a aktualizovaná podoba kódu riešenia sa nachádza vo výpise XXX.

#include <Arduino.h>

#define PIN_LED 8
#define PIN_IDLE 2
#define PIN_ALARM 3

bool isMovement;

void alarm();

void idle(){
    Serial.println("> Idle State");

    // update state
    isMovement = false;
    digitalWrite(PIN_LED, LOW);
}

void alarm(){
    Serial.println("> Alarm State");

    // update state
    isMovement = true;
    digitalWrite(PIN_LED, HIGH);
}

void setup(){
    // setup serial
    Serial.begin(9600);
    while(!Serial);

    // set pin modes
    pinMode(PIN_LED, OUTPUT);
    pinMode(PIN_ALARM, INPUT);
    pinMode(PIN_IDLE, INPUT);

    // initial state
    isMovement = false;

    // atach interrupt
    attachInterrupt(digitalPinToInterrupt(PIN_ALARM), alarm, RISING);
    attachInterrupt(digitalPinToInterrupt(PIN_IDLE), idle, FALLING);
}

void loop(){
    // nothing to do :-(
}

Týmto prístupom sa síce sprehľadnil a zjednodušil kód, ale stratila sa možnosť využiť druhý pin pre možnosť sledovania prerušení z ďalšieho zariadenia. Preto je vždy dobré takýto prístup zvážiť.

Turning Interrupts On and Off

Ošetrovanie prerušení je po zapnutí mikrokontrolérov ATmega 328P zapnuté. Automaticky sa však vypnú v okamihu, keď dôjde k ošetreniu prerušenia a pomocou ISR funkcie a opät sa automaticky zapnú, keď sa ISR funkcia ukončí.

Existujú však dve makrá, pomocou ktorých je možné ošetrovanie prerušení globálne vypínať a zapínať aj počas vykonávania ISR funkcie. Tieto makrá sú:

• interrupts() - globálne povolí ošetrovanie prerušení

• noInterrupts() - globálne zakáže ošetrovanie prerušení

Nasledujúci fragment kódu ilustruje situáciu, ak by sme chceli opätovne zapnúť prerušenia v ISR funkcii alarm():

void alarm(){
    interrupts();
    isMovement = true;
    digitalWrite(PIN_LED, HIGH);
    attachInterrupt(digitalPinToInterrupt(PIN_PIR), idle, FALLING);
}

[!WARNING]

Tu je však potrebné si dať veľký pozor, pretože ich nesprávnym použitím môžete dosiahnuť nepredvídateľné správanie. Napríklad povolením prerušení v ISR funkcii môžete dosiahnuť rekurzívne vykonávanie ISR funkcie pri ošetrovaní Level prerušení, ak sa úroveň signálu nezmení.

[!NOTE]

Na globálne vypínanie a zapínanie prerušení je možné použiť priamo aj AVR funkcie sei() a cli(). Funkcia sei() globálne prerušenia zapína a funkcia cli() globálne prerušenia vypína. Pri bližšom pohľade do knižnice Arduino.h je možné zistiť, že makrá interrupts() a noInterrupts() volajú práve tieto AVR funkcie:

#define interrupts() sei()
#define noInterrupts() cli()

V texte však budú použité len makrá interrupts() a noInterrupts() kvôli čítateľnejšiemu kódu.

Handling the Internal Interrupts with Arduino

Do kategórie interných prerušení patria časovače. Pomocou nich je možné napríklad presne načasovať spúšťanie časti programu, čo sa častokrát používa aj na vytvorenie dojmu "paralelizácie" vykonávaných úloh.

Mikrokontrolér ATmega328P obsahuje 3 časovače označené ako TIMER0, TIMER1 a TIMER2. TIMER0 a TIMER2 sú 8 bitové, zatiaľ čo TIMER2 je 16 bitový časovač. Ich funkcionalita však závisií od frekvencie mikrokontroléra. V prípade Arduina je použitý externý oscilátor s frekvenciou 16 MHz.

Kažý časovač môže generovať jeden alebo viac prerušení. Tieto sú:

• Compare Match Interrupt - Tento typ prerušenia vznikne v situácii, keď je potrebné, aby sa časovač zastavil pri dosiahnutí konkrétnej hodnoty. Jeho aktuálna hodnota sa porovnáva s požadovanou a keď dôjde k zhode, dôjde k vyvolaniu tohto prerušenia.

• Overflow Interrupt - Každý časovač používa vnútorné počítadlo, ktoré má svoj rozsah v závislosti od veľkosti použitého registra. Hodnota počítadla sa postupne zvyšuje, a keď je dosiahnutá maximálna hodnota a tá sa znova zvýši o jednotku, dôjde k pretečeniu a vyvolaniu tohto typu prerušenia.

• Input Capture Interrupt - Tento typ prerušenia sa používa na zachytenie vzniknutej udalosti na pine. K prerušeniu dôjde vtedy, keď je na pine zaznamenaná konkrétna hrana signálu. Tá môže byť vzostupná, zostupná alebo akákoľvek. Časovač dokáže zaznamenať čas vzniku tejto udalosti.

S použitím týchto časovačov sa je možné stretnúť pri programovaní Arduina bežne. Časovač TIMER0 sa používa pre funkcie pracujúce s časom, ako sú delay(), millis() a micros(). TIMER1 je zasa možné nájsť v knižnici Servo.h a TIMER2 sa používa pri generovaní zvuku pomocou funkcie tone(). Funkcia analogWrite() využíva každý časovač, ale každý pre rozličné piny.

Prehľad vlastností dostupných časovačov na mikrokontroléri ATmega328P sa nachádza v tabuľke XXX.

Osobitným časovačom je Watchdog. Ak sa zariadenie dostane do chybového stavu, je jeho úlohou po uplynutí časového intervalu mikrokontrolér reštartovať. Pre prácu s Watchdog časovačom je k dispozícii knižnica avr/wdt.h.

TimerOne Library

S časovačmi je možné pracovať dvoma spôsobmi: pomocou štandardných AVR knižníc alebo pomocou knižníc tretích strán. A práve knižnica TimerOne ponúka veľmi jednoduché API, ktoré zakryje nízkoúrovňový prístup ponúkaný knižnicami AVR.

Táto knižnica poskytuje kolekciu funkcií na nastavenie 16 bitového časovača označovaného ako TIMER1 (odtiaľ názov knižnice). Pôvodným zámerom bolo vytvoriť jednoduchý a rýchly spôsob na nastavenie periódy PWM. Nakoniec však bol do knižnice zahrnutý aj prerušenie timer overflow a iné vlastnosti.

Na prácu s knižnicou stačí poznať len tieto funkcie:

• Timer1.initialize(microseconds) - Táto funkcia inicializuje prácu s časovačom a musí byť zavolaná ako prvá. Parameter microseconds definuje periódu časovača.
• Timer1.attachInterrupt(function) - Vždy po uplynutí periódy sa spustí ISR funkcia, ktorej názvoj je uvedený v parametri.
• Timer1.detachInterrupt() - Zakáže prerušenie, takže ISR funkcia sa prestane spúšťať.

Pomocou knižnice je však možné ovládať aj už spustený časovač pomocou týchto funkcií:

• Timer1.start() - Spustí časovač a začne novú periódu.
• Timer1.stop() - Zastaví časovač.
• Timer1.restart() - Reštartuje časovač od začiatku novej periódy.

Timers in Motion Detection Scenario

Pre ilustráciu použitia časovačov upravíme scenár vytváraného zariadenia na detekciu pohybu. K existujúcim stavom bude pridaný nový stav s názvom WATCHING. Do neho systém prejde zo stavu IDLE po zistení pohybu. V stave WATCHING sa zasvieti LED dióda a spustí sa časovač. Pokiaľ sa v priebehu najbližších 10 sekúnd pohyb neukončí, systém prejde do stavu ALARM a LED dióda sa rozbliká. Ak sa ale v priebehu týchto 10 sekúnd pohyb stratí, dióda zhasne a systém prejde späť do stavu IDLE. Zo stavu ALARM je možné prejsť do stavu IDLE stlačením tlačidla. Aktualizovaný stavový diagram sa nachádza na obrázku XXX.

Keďže do systému pribudlo tlačidlo, dôjde aj k atualizácii schémy zapojenia. Tá sa nachádza na obrázku XXX.

Zmien sa dočkal aj samotný kód. Vo funkci setup() prebehne štandardná inicializácia, ale rovnako sa v nej inicializuje časovač a nastaví sa jeho perióda na 1 sekundu. Z funkcie sa systém dostane rovno do stavu IDLE.

Novou je funkcia watch(). Tá v premennej countdown nastaví 10 sekundový odpočet a nastaví ISR funkciu tick() pre ošetrenie prerušenia časovača. Tá sa bude volať každú sekundu a zakaždým z premennej countdown odpočíta 1. Pri dosiahnutí hodnoty 0 systém prejde do stavu ALARM.

Kompletný výpis kódu sa nachádza vo výpise XXX.

#include <Arduino.h>
#include <TimerOne.h>

#define PIN_LED 8
#define PIN_PIR 2
#define PIN_BTN 3

volatile bool isMovement;
volatile byte countdown;

void idle();
void watch();
void alarm();

void idle(){
    Serial.println("> Idle State");

    isMovement = false;
    digitalWrite(PIN_LED, LOW);

    // reatach interrupts
    detachInterrupt(digitalPinToInterrupt(PIN_BTN));
    attachInterrupt(digitalPinToInterrupt(PIN_PIR), watch, RISING);
    Timer1.detachInterrupt();
}

void tick(){
    countdown--;
    if(countdown == 0){
        alarm();
    }
}

void watch(){
    Serial.println("> Watch State");

    // update state
    digitalWrite(PIN_LED, HIGH);

    // reatach interrupts
    attachInterrupt(digitalPinToInterrupt(PIN_PIR), idle, FALLING);
    countdown = 10;
    Timer1.attachInterrupt(tick);
    Timer1.restart();
}

void alarm(){
    Serial.println("> Alarm State");

    // update state
    digitalWrite(PIN_LED, HIGH);
    isMovement = true;

    // reatach interrupts
    Timer1.detachInterrupt();
    detachInterrupt(digitalPinToInterrupt(PIN_PIR));
    attachInterrupt(digitalPinToInterrupt(PIN_BTN), idle, LOW);
}

void setup(){
    // set pin modes
    pinMode(PIN_LED, OUTPUT);
    pinMode(LED_BUILTIN, OUTPUT);
    pinMode(PIN_PIR, INPUT);
    pinMode(PIN_BTN, INPUT_PULLUP);

    Serial.begin(9600);
    while(!Serial);

    // setup timer
    Timer1.initialize(1 * 1000000);

    // enter idle state
    idle();
}

void loop(){
    if (isMovement == true){
        digitalWrite(PIN_LED, HIGH);
        delay(1000);
        digitalWrite(PIN_LED, LOW);
        delay(1000);
    }
}

Pros and Cons of Interrupts

Výhody:

• lepší reakčný čas v porovnaní s polling-om
• šetrenie zdrojov

Nevýhody:

• Prerušenia sa výrazne horšie ladia, pretože k prerušeniu môže dôjsť aj počas ladenia programu. A vy zrazu neviete, koľko prerušení bolo vykonaných medzi krokovaním aktuálnej časti programu.

Measuring Power when Using Interrupts

• žiadna zmena