Tasker - "multitasking" na Arduinu

Poměrně rychle jsem přijal programovací styl navrhovaný Arduino IDE, tj. dvě hlavní funkce - setup() a loop(). Do setup() dám inicializační věci a do loop() dám samotné jádro programu, které provádí nějakou periodickou činnost. Dokud jde jen o jednu činnost, například blikání LEDkou v sekundovém rytmu, je to jednoduché: rozsvítím LED, počkám půl sekundy díky volání funkce delay(500), zhasnu, počkám další půlsekundu dík dalšímu volání delay(500) a je to:

void loop() {
    digitalWrite(13, HIGH);
    delay(500);
    digitalWrite(13, LOW);
    delay(500);
}

Bezva, ale co když potřebuji vykonávat činnosti dvě a navíc různé? Třeba během blikání LED chci ještě číst teploty z čidel. Anebo kreslit na displej. Anebo odpovídat na požadavky web klientů. Anebo tisíc jiných věcí. Co pak? Jak během delay(), kdy program stojí a čeká, vykonávat jinou činnost?

Když jsem pracoval na řídicím programu pro můj vytuněný domácí termostat, docela mě zarazilo, kolik chvílemi až protichůdných požadavků musí zvládat vyřizovat v podstatě naráz:

• měřit teploty z obou větví digitálních čidel DS18B20, třeba jednou za tři sekundy
• měřit teplotu a vlhkost z čidla DHT11, nesmí častěji než jednou za sekundu
• podle teplot a dalších údajů spínat kotel, stačí jednou za pět sekund
• řídit podsvícení displeje, to je potřeba nejméně dvakrát za sekundu
• kontrolovat, jestli se někdo nedotkl displeje, to je potřeba co nejčastěji, aspoň 10x za sekundu
• překreslovat displej, nejlépe přesně jednou za sekundu, pokud se ho někdo nedotkl, jinak dřív
• sledovat požadavky na interní webserver, to stačí tak 2-3x za sekundu
• občas ujistit watchdog, že ještě žiju a nemá mě zresetovat (aspoň jednou za 4 sekundy)

Mimochodem, stejné problémy vyvstanou třeba při řízení robotického auta (což mám se synem taky v řešení) - tam je potřeba číst údaje z různých snímačů (vzdálenosti, světla, rychlosti), poslouchat dálkové ovládání a zároveň neustále řídit motory, do toho sem-tam blikat blinkry, svítit světly, přehrávat hlasy či muziku a podobně.

Na tohle všechno by byl ideální nějaký multitasking/multithreading, ne? Po více než dvaceti letech strávených v multitáskových operačních systémech to k němu člověka tak nějak táhne.  Ono se to všechno sice dá nacpat do té funkce loop(), ale je potřeba u toho moooc přemýšlet a hlavně - nikdy nevolat delay()!

Takže můj termostat měl všechny výše uvedené činnosti napsané za sebou v loop() cyklu jednu za druhou, ale zároveň jsem si musel definovat hromadu proměnných, které si pamatují, kterou z těch výše popsaných událostí jsem kdy zavolal a pak je nutné kontrolovat, jestli už je čas ji zavolat znovu - a pokud ještě není, tak ji nevolat a pokračovat v cyklu dál.

Nemusím vysvětlovat, že zdrojový kód ty dodatečné podmínky a přeskoky docela znepřehledňují. Navíc čtení z digitálních čidel DS18B20 napájených parazitně je potřeba provádět vlastně nadvakrát - nejdřív je nutno požádat o změření teploty, pak počkat 750 milisekund (pro 12bitovou přesnost) a pak teprve přečíst samotné teploty z čidel. To je další komplikace.

A když jsem teď začal znovu rozvíjet ten můj termostat a chtěl jsem tam přidat další funkci, která by na definovaný interval, třeba 30 minut, změnila nějaké nastavení a po uplynutí času ho zase sama vrátila zpět (ano, jde o větrání), uvědomil jsem si, že už to dál nechci takto plácat. A začal jsem hledat nějakou knihovnu, která by toto spouštění úloh v čase řešila za mě.

Poměrně brzy jsem našel celou řadu hotových řešení přímo pro Arduino (či pro nejbližší ATMEL procesory), které všechny slibovaly modré z nebe a světový mír. Vlastně je tu všechny můžu vypsat, ať ušetřím jiným hledačům čas:

• https://sourceforge.net/projects/abavr/
• https://github.com/ivanseidel/ArduinoThread
• http://playground.arduino.cc/Code/TaskScheduler
• http://playground.arduino.cc/Code/TimerScheduler
• https://github.com/lewisd32/Tasker
• https://github.com/Zuph/AVRQueue/
• https://github.com/chrispbarlow/TTduino
• https://github.com/blanboom/Arduino-Task-Scheduler/
• http://blog.protoneer.co.nz/arduino-task-scheduler/
• https://github.com/cyphar/sched
• https://code.google.com/p/arduino-scoop-cooperative-scheduler-arm-avr/ 

No, strávil jsem docela dost času procházením těch existujících řešení, našel v nich chyby v návrhu i implementaci a nakonec jsem se rozhodl: napíšu si vlastní!

Upřímně řečeno, většinou lidi znovuvynalézající kolo nepovažuju za nejmoudřejší, ale v tomto případě jsem si byl docela jistý, že žádné z 11 dostupných řešení nefunguje tak, jak potřebuju, a že tedy bude OK věnovat část mé životní energie na řešení dvanácté, napsané mně na míru. Stanovil jsem si přitom následující zásady:

1. co nejjednodušší použití (NE C++ třídám, dědičnosti, složitému API, mnoha parametrům)
2. co nejkratší implementace (aby bylo na první pohled zřejmé, že to funguje správně)
3. co nejúspornější provoz (malá zabraná jak flash tak RAM paměť)
4. co nejpružnější a nejmocnější vlastnosti (předávání parametrů do volaných funkcí, ideálně dynamické vytváření úkolů za běhu)
5. 100% kompatibila s Arduinem (žádný vlastní časovač či přerušení)
6. a samozřejmě bez chyb přetečení časovače po 49 dnech

Nakonec bylo napsání vlastního řešení rychlejší, než jsem čekal. Výsledný kód implementace se vejde na jednu obrazovku monitoru, pro použití stačí zavolat jednu jedinou funkci s navíc intuitivním jménem i parametry, v RAM zabírá jedna úloha jen 14 bajtů včetně parametru předávaného do volané funkce a dokonce je možné vytvářet další úlohy dynamicky za běhu!

Výsledek jsem nazval Tasker pro Arduino a ihned ho použil v mém termostatu. Špagetový kód z funkce loop() jsem rozdělil na jednotlivé malé funkce a volám je jako samostatné úlohy v jejich pravý čas. Zdrojový kód termostatu se tím krásně pročistil a výsledek funguje díky prioritám implementovaným v Taskeru mnohem lépe, než dříve (například vyhodnocení dotykové vrstvy má teď jednu z nejvyšších priorit, aby reakce na dotyk byla okamžitá - tohle mi dřív trochu zlobilo). Super!

Můj Tasker jsem s radostí uvolnil pro všechny na GitHubu: https://github.com/joysfera/arduino-tasker

Nechci zde opisovat či překládat anglicky psaný manuál viditelný hned na tom URL uvedeném výše, ale pár ukázek elegantního řešení typických problémů s mým Taskerem si neodpustím. Pro začátek obligátní blikání LEDkou - na čtyři řádky a bez delay():

Tasker tasker;
void blik(int) { digitalWrite(13, !digitalRead(13)); }
void setup() { tasker.setInterval(blik, 500); }
void loop() { tasker.loop(); }

A ještě třeba nekompletní ukázka možnosti čtení těch DS18B20 periodicky každé tři sekundy, a to bez jakéhokoliv čekání na cokoliv, postaveném na zřetězení úkolů díky možnosti dynamického přidávání nových úkolů za běhu:

Tasker tasker;

OneWire oneWire(4);
DallasTemperature sensor(&oneWire);
float g_teplota;

void ctiSensor(int) {
    g_teplota = sensor.getTempC(0);
}

void ctiTeplotu(int) {
    sensor.requestTemperatures();
    tasker.setTimeout(ctiSensor, 750);
}

void setup() {

    sensor.begin();

    sensor.setWaitForConversion(false);
    tasker.setInterval(ctiTeplotu, 3000);
    tasker.run();
}

void loop() { }

To mi připomíná, že bych měl vyvézt na GitHub i mé úpravy v knihovně DallasTemperature... Snad někdy brzy.

Lepší ukázka využití Taskeru a kompletní popis API je na URL výše. A samozřejmě nejlepší dokumentací je samotný zdrojový kód, o kterém si troufám tvrdit, že je přehledný a dobře čitelný. Tak si to užijte! :)

EDIT 2017/01/27:
Na přání jsem doplnil klíčový řádek do příkladu se čtením čidel od Dallasu, takže už to nebude blokovat. A víte co? Rovnou jsem tam doplnil i tři další řádky, aby ten program byl celý funkční.
Tento příklad najdete i v mém git repozitáři jako druhý example vedle MultiBlink.