Sdílejte nás



RSS feeds

Hardwario Tower - rychlá ochutnávkaTisk

pebr0u mi poslal článek o vývojovém setu Hardwario Tower. Za článek děkuji.

Ze schránky vypadla obálka a v ní nová hračka. Na první pohled to vypadá jako stopadesátý klon Arduina - tentokrát s procesorem STM32.



Jenže omyl. Jedná se o prvky stavebnice HARDWARIO TOWER IoT Kit (dříve BigClown) - vpravo na obrázku je Core module a uprostřed je Barometer Tag a vlevo je kompatibilní WiFi modul s ESP8266 od chiptron.cz. A k tomu je potřeba říct základní informaci, kterou si z tohoto článku odnesete:



HARDWARIO TOWER není Arduino! Ano, vzhled desky láká to tak vnímat. Ale TOWER nejsou prototypové desky pro návrh ve stylu Arduina.

Čím se to liší?

HARDWARIO TOWER je modulová stavebnice, ze které můžete své IoT projekty sestavit - a přímo použít v provozu.

OK, ale takových stavebnic je plný Aliexpress. Kde je přínos třeba proti M5Stack?

První rozdíl je v tom, že celá stavebnice je vytvářená s ohledem na spotřebu. Když do sebe zacvaknete Core module, Battery module (nebo Mini battery module) a nějaké senzory, získáte zařízení, které na alkalické články AAA poběží rok či déle.

Druhý rozdíl je v tom, jak je řešena konektivita. Core module nemá energeticky náročné WiFi. Místo toho má vlastní úsporné rádio v pásmu 868 MHz, se šifrovaným provozem a bezpečnostním čipem pro ukládání šifrovacích klíčů. No a k čemu se takovým rádiem připojí? Buď k dalším Core modulům, nebo k bráně připojené na internet, což může být třeba Raspberry Pi se zapojeným Radio Dongle. Standardní implementace tedy vypadá tak, že k internetu je připojená jen brána s Radio Dongle a všechny Core moduly si povídají s ní.

Třetí rozdíl není na první pohled vidět, ale je nejdůležitější. Aby všechno fungovalo správně a spotřeba zařízení byla minimální, HARDWARIO TOWER má vlastní vývojový toolchain postavený výrazně odlišně, než jsme zvyklí z prostředí Arduina.

Když programujete mikrokontrolér “arduinovým” přístupem, máte procesor plně pod kontrolou a řešíte kompletní životní cyklus aplikace včetně správy napájení. Najdete knihovny pro všechna zařízení, která máte připojena - a naučíte se je používat, protože každá knihovna se ovládá trochu jinak. A pak píšete aplikaci: probudit periferie, načíst a zpracovat hodnoty, odeslat, nakonfigurovat režim spánku, uspat zařízení. A tak stále dokola.

Ve světě Hardwaria je tomu jinak.

Pokud programujete přímo mikrokontrolér, máte v SDK k dispozici kompletní knihovny na obsluhu všech běžných periferií. Všechny části knihoven se chovají konzistentně, programují se obdobným způsobem. Jednotlivé funkce jsou postavené odlišně, než se běžně dělá v arduino světě - všechny operace, kde to dává smysl, jsou asynchronní. Ke každému zařízení nastavíte callback, který je zavolán při získání hodnoty nebo když periferie nahlásí alert. Stejně tak píšete i jednotlivé funkce vaší aplikace - nastavíte, za jak dlouho se má která akce spustit. I interrupty se skryjí za callbacky a nemusíte je nijak řešit. Pokud vyvíjíte v JavaScriptu, budete se tady cítit jako doma.

Na rozdíl od běžného vývoje ve světě Arduina nemáte přístup k power managementu a neřídíte běžný běh aplikace. Jen reagujete na události tak, jak vám je SDK předává. Knihovny Hardwaria pak samy rozhodnou, kdy se vyplatí procesor či periferie uspat a na jakou dobu. Výsledkem je maximalizace výdrže na baterku.

Proč je zvýrazněno “pokud programujete přímo mikrokontrolér” - ono to jde i jinak?

Ano. Můžete samozřejmě v céčku naprogramovat přímo kód pro mikrokontrolér - v terminologii stavebnice TOWER jde o vytvoření firmware. Ale nemusíte.
Pro spoustu základních použití je již firmware připravený. Takže spojíte potřebné moduly, do Core Module nahrajete hotový firmware a “mobilní” část řešení je hotová. Výstupy jsou přes rádio předané do brány s Radio Dongle … a tam běží druhá polovina softwarového stacku, Hardwario Playground, což je MQTT server a Node-RED, ve kterém se jednoduše nakliká reakce na jednotlivé zprávy ze zařízení. Tak jednoduše, že Hardwario má přímo celou sekci hotových jednoduchých projektů pro výuku dětí. Bez programování.

Dobře, ale já bych chtěl programovat, ne klikat v GUI. Jak je to složité?

Tak si to předvedeme. Není to složité.

Programování firmware pro HARDWARIO TOWER


Instalace vývojového toolchainu je popsána zde a je jednoduchá:
- Nainstalujete si Visual Studio Code, které se používá jako editor
- Nainstalujete si Hardwario Toolchain. Hardwario Toolchain je sada commandline nástrojů a hlavně nakonfigurovaný shell se správnou konfigurací.

Vytvoření, sestavení a nahrání aplikace do Core Module jde také rychle:
- Vytvoříte si prázdný adresář.
- Spustíte shell Hardwario Toolchainu, přejdete do vytvořeného prázdného adresáře a napíšete
bcf create my_project

- Toolchain vytvoří adresář my_project a v něm nainicializuje nový projekt - vytvoří kostru aplikace a z GITu stáhne SDK.
- Přejdete do adresáře projektu a spustíte VS Code:
cd my_project
code .


- Ve VSCode upravíte aplikaci.
- Sestavení aplikace provedete pomocí Ctrl-Shift-B.
- Vzniklou aplikaci nahrajete do zařízení přes USB kabel příkazem
bcf flash

Visual Studio Code s aplikací a výstupem sestavení:


Nahrání aplikace do zařízení:


Na následujícím snímku je vidět struktura aplikace na disku. Vaše zdrojové soubory jsou v adresáři app, knihovny hardwaria jsou vloženy jako GIT submodul do adresáře sdk. Makefile je připraven už z toolchainu, není potřeba na něj sahat. Sestavená aplikace je v souboru firmware.bin.



Aplikace pro TOWER má dvě funkce - na první pohled podobné jako v Arduinu:
- void application_init(void) je volána při startu aplikace,
- void application_task(void) je základní akce aplikace. Nicméně nejde o ekvivalent loop() v Arduinu, protože není volána opakovaně, pokud si o to sama neřekne.

Pro začátek si zkusíme obsloužit akcelerometr vestavěný v Core Module. Ukázka předvede jak běžné periodické načítání hodnoty z periferie, tak zpracování alertů.

Dokumentace k akcelerometru je zde.

Nejprve si nadefinujeme objekt akcelerometru a objekt pro nastavení alarmu akcelerometru:
twr_lis2dh12_t a;
twr_lis2dh12_alarm_t alarm1;


Ve funkci application_init() nastavíme, že se chceme používat akcelerometr, chceme snímat hodnoty periodicky každých 10 sekund a chceme se okamžitě dozvědět o situaci, kdy zrychlení v ose X překročí 1.5 g.
Výstupy budeme posílat na sériový port.


void application_init(void)
{
     // nastaveni logovani na seriovy port
     twr_log_init(TWR_LOG_LEVEL_DUMP, TWR_LOG_TIMESTAMP_ABS);
     // zapneme I2C
     twr_i2c_init( TWR_I2C_I2C0, TWR_I2C_SPEED_400_KHZ );
     // nastaveni akcelerometru na I2C sbernici 0
     twr_lis2dh12_init(&a, TWR_I2C_I2C0, 0x19);
     // chceme dostat alarm v pripade zrychleni nad 1.5 g v ose X
     alarm1.x_high = true;
     alarm1.threshold = 1.5;
     twr_lis2dh12_set_alarm(&a, &alarm1);
     // pokud se neco stane, zavolá se funkce lis2_event_handler()
     twr_lis2dh12_set_event_handler(&a, lis2_event_handler, NULL);
     // a chceme dostat hodnotu jednou za 10 sekund
     twr_lis2dh12_set_update_interval(&a, 10000);
}



Tím je inicializace hotová. No a teď zbývá už jen funkce pro příjem callbacků z akcelerometru:


void lis2_event_handler (twr_lis2dh12_t *self, twr_lis2dh12_event_t event, void *event_param)
{
     twr_lis2dh12_result_g_t a_result;
     if (event == TWR_LIS2DH12_EVENT_ALARM ) {
         twr_log_info("alarm akcelerometru!" );
     }
     if (event == TWR_LIS2DH12_EVENT_UPDATE || event == TWR_LIS2DH12_EVENT_ALARM ) {
         twr_lis2dh12_get_result_g(self, &a_result);
         twr_log_info("acc: X: %f Y: %f Z: %f", a_result.x_axis, a_result.y_axis, a_result.z_axis);
     }
}


Když nám akcelerometr bude chtít něco říct, zavolá funkci lis2_event_handler. Jako parametry nám SDK předá odkaz na objekt akcelerometru, typ události a případně náš identifikátor předaný jako poslední parametr do twr_lis2dh12_set_event_handler().

Pokud jde o událost typu ALARM, vypíšeme informaci, že jde o alarm.
V případě, že jde o výsledek vyžádaného měření (UPDATE), a také v případě alarmu, vyžádáme z objektu akcelerometru naměřené hodnoty a vypíšeme je.

Aplikaci sestavíme a nahrajeme do zařízení.

Součástí Hardwario Toolchainu není sériový monitor. Pokud žádný nemáte, stáhněte si Hercules. Otevřete sériový port v konfiguraci 115200 bps/8/N.

Na následujícím screenshotu je ukázka výstupu. Je vidět periodické načítání hodnot po každých deseti sekundách (udáván je čas od startu zařízení). V čase 74 sekund jsem Core modulem několikrát klepnul o stůl. Okamžitě přišla událost alarmu, následovaná událostí update. (Hodnota načtená z akcelerometru 1.5 g nepřesahuje, protože úder o stůl je velmi krátký a když se dostanu k načtení hodnoty, už odeznívá.)




Dalšími periferiemi, které vyzkoušíme, budou teploměr (opět vestavěný v Core modulu) a Barometer tag. Zapojení pinů Barometer tagu je stejné, jako zapojení pinů Core modulu, pro propojení tak nejsou potřeba žádné drátové spojky.



A teď přijde na řadu software. Ovládání každého zařízení vypadá podobně, to je základní kouzlo SDK Hardwaria. Takže stejně jako pro akcelerometr stačí jen:
- nadefinovat objekty pro jednotlivé periferie
- ve funkci application_init() je nastavit
- a připravit callback funkci

Takže přidáme definici:
twr_tmp112_t temp;
twr_tag_barometer_t barometer;

Rozšíříme inicializaci o dvě nová zařízení a požádáme o jejich čtení každých 10 sekund:


void application_init(void)
{
     twr_log_init(TWR_LOG_LEVEL_DUMP, TWR_LOG_TIMESTAMP_ABS);
     twr_i2c_init( TWR_I2C_I2C0, TWR_I2C_SPEED_400_KHZ );

     twr_lis2dh12_init(&a, TWR_I2C_I2C0, 0x19);
     alarm1.x_high = true;
     alarm1.threshold = 1.5;
     twr_lis2dh12_set_alarm(&a, &alarm1);
     twr_lis2dh12_set_event_handler(&a, lis2_event_handler, NULL);
     twr_lis2dh12_set_update_interval(&a, 10000);

     // teplomer
     twr_tmp112_init(&temp, TWR_I2C_I2C0, 0x49);
     twr_tmp112_set_event_handler(&temp, tmp112_event_handler, NULL);
     twr_tmp112_set_update_interval(&temp, 10000);

     // barometr
     twr_tag_barometer_init( &barometer, TWR_I2C_I2C0 );
     twr_tag_barometer_set_event_handler(&barometer, barometer_event_handler, NULL );
     twr_tag_barometer_set_update_interval (&barometer, 10000 );

}


a přidáme dvě nové callback funkce:


void barometer_event_handler(twr_tag_barometer_t * barometer,
twr_tag_barometer_event_t event ,
void * event_param )
{
     if( event == TWR_TAG_BAROMETER_EVENT_UPDATE ) {
          float pascalVal = 0;
          bool rc = twr_tag_barometer_get_pressure_pascal (barometer, &pascalVal );
          twr_log_info("APP: Barometer rc= %s", rc ? "OK" : "ERR" );
          twr_log_info("APP: Barometer %f hPa", pascalVal/100.0 );

          float meterVal;
          twr_tag_barometer_get_altitude_meter (barometer, &meterVal );
          twr_log_info("APP: Barometer rc= %s", rc ? "OK" : "ERR" );
          twr_log_info("APP: Barometer %f m", meterVal );
     }
}

void tmp112_event_handler(twr_tmp112_t *self, twr_tmp112_event_t event, void *event_param)
{
     if (event == TWR_TMP112_EVENT_UPDATE)
     {
          float temperature = 0.0;
          twr_tmp112_get_temperature_celsius(self, &temperature);
          twr_log_info("APP: Temp %.4f °C", temperature );
     }
}



Poznámka: SDK dokumentace pro teploměr je zde. Dokumentaci pro barometr jsem v základních popisech nenašel, ale alespoň hlavičky funkcí jsou v detailním docu - a protože je ovládání všech periferií obdobné, nebyl problém barometr obsloužit.

Sestavíme a nahrajeme aplikaci a můžeme se kochat. Každých 10 sec dostaneme teplotu, stav akcelerometru i barometru (tlak i nadmořskou výšku).



Poznámka: Funkce pro tlakoměr nemají kalibraci. Pro použití ve funkci meteostanice je tedy potřeba přepočítávat tlak na hladinu moře; pokud chcete barometr použít jako výškoměr, musíte si udělat počáteční kalibraci výšky.

Jak vidíte, programování je jednoduché a unifikované, se stejným přístupem ke všem periferiím. Ta systematičnost se mi líbí.

Pokud vás stavebnice Hardwario Tower zaujala, pak se koukněte na seznam dostupných modulů a tagů. Pro rozumné experimentování dává smysl kombinace Core Module + Battery Module + Radio Dongle, abyste mohli vytvořit zařízení nezávislé na drátovém napájení a předávat data do internetu. Na počítači, do kterého připojíte Radio Dongle, spustte Hardwario Playground a začněte tím, že vyzkoušíte jeden z připravených projektů.

Pod čarou:

1) Tvůrci nedávno přejmenovali tuto stavebnici z BigClown na TOWER. A proběhlo i přejmenování funkcí a konstant v SDK - co se dříve jmenovalo bc_*, nyní se jmenuje twr_*. V dokumentaci SDK to ještě není zcela promítnuté. Takže když kopírujete samply z dokumentace, je potřeba vše přejmenovávat.

2) Existují dvě verze Core modulu - 1 a 2. Ukázky výše jsou pro verzi 2. Verze 1 se složitěji programuje (musíte mačkat tlačítko) a nemá z počítače jednoduše dostupný UART (nemá konverzi UARTu na sériový port). Samply pro v1 v dokumentaci SDK používají pro komunikaci s počítačem příkazy jako bc_usb_cdc_write.

3) Ne vždy se mi podařilo poslat aplikaci do modulu napoprvé. Pokud dostanete chybu při programování, zkuste to znovu - nebo modul odpojte, znovu připojte a pak to zkuste znovu.



4) Hardwario Toolchain nelze nainstalovat na počítač s antivirem Sophos - heuristice antiviru se nelíbí kód kompilátoru.

Upozornění

Administrátor těchto stránek ani autor článků neručí za správnost a funkčnost zde uvedených materiálů.
Administrátor těchto stránek se zříká jakékoli odpovědnosti za případné ublížení na zdraví či poškození nebo zničení majetku v důsledku elektrického proudu, chybnosti schémat nebo i teoretické výuky. Je zakázané používat zařízení, která jsou v rozporu s právními předpisy ČR či EU.
Předkládané informace a zapojení jsou zveřejněny bez ohledu na případné patenty třetích osob. Nároky na odškodnění na základě změn, chyb nebo vynechání jsou zásadně vyloučeny. Všechny registrované nebo jiné obchodní známky zde použité jsou majetkem jejich vlastníků. Uvedením nejsou zpochybněna z toho vyplývající vlastnická práva.
Nezodpovídáme za pravost předkládaných materiálů třetími osobami a jejich původ.
6,214,049 návštěv