Náš čtenář, Ing. Miroslav Tesař, nám poslal článek o ovládání sedmisegmentových displejů pomocí obvodu 74HC595. Děkujeme.

Často sa v schémach na ovládanie 7-mi segmentových displejov používa buď priame prepojenie segmentov s Arduinom, alebo dynamické zobrazovanie displejov pomocou tranzistorov.

V prvom prípade priameho prepojenia Arduina so segmentami potrebujeme na každý displej 7 či 8 výstupov (prvé dva obrázky) . Tento variant spotrebováva veľa digitálnych výstupov, čo predurčuje na realizáciu projektu minimálne Arduino UNO. Prakticky je nemožné ovládať viacmiestny 7-mi segmentový displej pomocou tohto zapojenia.

Hrací kostka

Zapojení sedmisegmentového displeje

Určité vylepšenie sa ponúka v dynamickom riadení viacmiestneho 7-mi segmentového displeja. V tomto prípade potrebujeme 8 spoločných výstupov pre všetky segmenty displeja a po jednom riadiacom výstupu na každú pozíciu displeja. Pri viac miestom displeji a nízkej frekvencii zobrazovania pozícií môže dochádzať k stroboskopickému efektu, kedy je možné vidieť ako jednotlivé displeje blikajú. Horšie však je, že na zobrazenie informácie spotrebuje Arduino veľa strojového času. Ako náhle program vykonáva inú činnosť, prejaví sa to zlým zobrazením číslic.

Zapojení více sedmisegmentových displejů – zdroj: https://www.mikrocontroller.net/wikifiles/b/bc/Tut_7_Seg_03.gif

O to horšie by bolo ovládanie napr. maticového displeja.

Podstatne lepšie riešenie riadenia výstupov pre ovládanie LED, 7-mi či viac segmentových displejov je použitie obvodu 74HC595. Ide o 8-bitový posuvný register s paralelným výstupom. Funkcia 74HC595 je popísaná v datasheetu a netreba ju v tomto článku rozoberať.

Vnitřní schéma obvodu 74HC595

Vstup SHCP je taktovací, ktorý posúva bity prichádzajúci na vstup DS naprieč sériovým posuvným registrom, alebo registrami. Pomocou výstupu Q7S, ktorý pripájame na vstup DS ďalšieho obvodu 74HC595 zaistíme, že sériové dáta potečú cez všetky pripojené posuvné registre. Z uvedeného vyplýva, že prvý vyslaný bit sa po ukončení prenosu dostane na 8-mi bit posledného posuvného registra (ako keď tečie voda v rúre). Tento posun sa deje „na pozadí“ a nenarušuje stav paralelného výstupného registra s výstupmi Q0..Q7 – nedochádza k rušivému blikaniu displeja. Informácia sa dostane na výstup obvodu iba v prípade, že táto bude prepísaná na výstup pomocou vstupu STCP. Prepísanie sa deje naraz pre všetky obvody 75HC595. Vstup OE môže poslúžiť pre prípad, kedy chceme výstupy Q0..Q7 odpojiť od displeja. Ak túto možnosť nepotrebujeme, ušetríme jeden výstupný pin Arduina a na vstup OE privedieme mínus pól napájania. Vstup MR resetuje posuvný register (v našom prípade nepoužitý a pripojený na kladný pól napájania).

Pri použití viac LED diód (záťaže) na každom výstupe je vhodné použiť budič ULN2803. Obvod ULN2803 pracuje na výstupoch s napätím až 50V a každý výstup je možné zaťažiť prúdom až 500mA. V takom prípade však odporúčam použiť chladič. Treba ešte podotknúť, že ak použijete ULN2803, na jeho výstupe je inverzné napätia oproti výstupu z 74HC595. Taktiež výstupné LED diódy zapájame tak, že majú spoločnú anódu. Schéma zapojenia je na obrázku.

Zapojení 74HC595, ULN2803 a sedmisegmentových displejů

Ako je vidno na obrázku, na ovládanie n- zobrazovacích obvodov potrebujeme štyri, prípadne iba tri výstupné piny Arduina.

Programové riešenie

/*******************************************************
 * PIN - KONSTANTY PRE 74HC595
 *******************************************************/
 #define clockPin 17    // Vyber vhodnych pinou je na
 #define latchPin 16    // riesitelovi
 #define oePin    15    //      
 #define dataPin  14    // 

 #define dlzkaFronty 14 // Celkovy pocet prenasanych byte

/*******************************************************
 * STRUKTURA FRONTY PRE 7-SEGMENTY
*******************************************************/
 union display_Struct1 {
   struct
   {     
     byte Displ01; //  1. 7-segment
     byte Displ02; //  2. 7-segment
     byte Displ03; //  3. 7-segment
     byte Displ04; //  4. 7-segment
     byte Displ05; //  5. 7-segment
     byte Displ06; //  6. 7-segment
     byte Displ07; //  7. 7-segment
     byte Displ08; //  8. 7-segment
     byte Displ09; //  9. 7-segment
     byte Displ10; // 10. 7-segment
     byte Displ11; // 11. 7-segment
     byte Displ12; // 12. 7-segment
     byte Displ13; // 13. 7-segment
     byte Displ14; // 14. 7-segment
   };
     byte Fronta[dlzkaFronty];
 };

/*******************************************************
 * PREMENNE
 *******************************************************/
byte Export = 0;

Union štruktúra má tú vlastnosť, že Displ01..Displ14 obsadzuje ten istý pamäťový priestor ako pole Fronta (počet byte musí zodpovedať dĺžke poľa Fronta). Takže s výhodou zapíšeme informáciu pre každú pozíciu displeja a Fronta nám poslúži pre výstup do posuvného registra. Treba však rátať s tým, že (v našom príkladu) začína Fronta s pamäťovým priestorom vymedzeným pre Displ14 a končí Displ01.

Ak potrebujeme na displejoch zobraziť aj iné údaje (napr. ich pomocou prepínača zobrazovať bez toho, aby sa prepísali pôvodné dáta v štruktúre), môžeme takých štruktúr vytvoriť viac. Len dávajte pozor, aby bola dĺžka fronty stále rovnaká.

V prípade, že použijeme viac štruktúr, deklarujeme premennú, ktorá určí tú štruktúru, ktorá sa odošle do displejov.

/*******************************************************
 * INSTANCIE
 *******************************************************/
   union display_Struct1      display1;
// union display_Struct2      display2; // Pripad, kedy pouzijeme 
// union display_Struct3      display3; // dalsie struktury

/*******************************************************
 * SAVE FRONTA
 * -----------------------------------------------------
 * Fyzicke odoslanie dat do obvodov 74HCT595
 * Parameter *pole ziskava adresu prvej zlozky Fronta
 * a pomocou shiftout posiela data z adries Fronta
 *******************************************************/

Pre vysielanie dát na obvody 74HC595 použijeme procedúru:

void saveFronta(byte *pole) {        
   for (byte i=0;i<dlzkaFronty;i++) {
     shiftOut(dataPin,clockPin,LSBFIRST,*(pole+i));
   }
   digitalWrite(latchPin,HIGH); // Prepis do displejov po
   digitalWrite(latchPin,LOW ); // zapisu celej fronty
}

A to je všetko! Uvedená procedúra má výhodu, že môže posielať dáta aj z iných štruktúr. Stačí len v daných procedúrach zapísať dáta do štruktúry union a nastaviť premennú Export.

V prípade, že máme len jednu štruktúru union, v hlavnom programe vytvoríme podmienku, za ktorú sa má uskutočniť zápis do posuvných registrov:

void loop(){  // variant s jednou strukturou union
  if (Export == 1){  // pripadne pouzijeme typ bool
    saveFronta(&display1.Fronta[0]);
    Export = 0;
  }
}

V prípade, že máme viac štruktúr union, upravíme hlavný program pre tento variant:

void loop(){ // variant s viacerymi strukturami union
  switch (Export) {
    case 1: saveFronta(&display1.Fronta[0]);
      break;
    case 2: saveFronta(&display2.Fronta[0]);
      break;
    case 3: saveFronta(&display3.Fronta[0]);
      break;
  }
  Export = 0;
}

K aktualizácii displejov príde len vtedy, keď zapíšeme príslušné číslo do premennej Export. Tým šetríme strojový čas Arduina, lebo dáta sa odošlú iba raz za danú udalosť. Celý kód zde.

Riešenie DPS

V DPS som použil smd súčastky. Upozorňujem na to, že keby ste privádzali signál DS, SHCP a STCP pomocou vodičov (Arduino by bolo mimo túto DPS), tak je potrebné vodiče tieniť. Vyhnete sa tým rušeniu a zlým dátam odosielaným do posuvných registrov. Na DPS je dobré si všimnúť, že napájanie ULN2803 je z oboch strán, aby sa predišlo prúdovému preťaženiu vodivej cesty pri veľkom odbere. Prívod napájania pre 74HC595 a Arduino je tiež riešený osobitne, aby prúdové nárazy neovplyvnili činnosť týchto obvodov. Ďalej si všimnite, že na funkciu 14-miestneho displeja postačí najlacnejší variant s Arduino NANO. Samozrejme že Arduino NANO zvládne aj oveľa väčšiu frontu.

Schéma řízení sedmisegmentových displejů s 74HC595 a Arduino Nano

Schéma ve formátu lay6 – zde.

Autor: Ing. Miroslav Tesař, tesar@imt.eu.sk

Děkujeme za zajímavý článek a přejeme spoustu úspěchů.

Máte zajímavý projekt, se kterým se chcete pochlubit? Přečtěte si tento článek a dejte nám o něm vědět.

Robotická ruka CCRH (Coordinates Controled Robotic Hand)

Tuto ruku jsme stavěli s kamarádem jako studentský projekt. Nyní chceme, aby se náš projekt rozšířil mezi lidi, kteří by měli zájem na něm dále pracovat a vylepšovat jej.

Popis projektu

Jedná se o robotickou ruku, kterou jsme navrhli a vytiskli na 3D tiskárně.

Robotická ruka – návrh pro 3D tisk

Robotická ruka – 3D tisk

Dále jsem pro ní vytvořili ovládací prostředí do PC, pomocí kterého můžete ovládat její základní funkce. Tento program jsme psali v prostředí Processing 3, takže dokonale spolupracuje s naší řídicí jednotkou, která je sestavena ze dvou čipů ATmega328p. Jako převodník pro komunikaci s PC využíváme Arduino UNO bez čipu.

Jako pohon využíváme silné digitální servo motory, podrobnosti najdete na konci článku v soupisce materiálů.

Ruka nyní funguje jako malý pomocník, se kterým je zatím víc práce, než dokáže sama udělat. Nyní pracujeme na ovládání pomocí souřadnicového systému (XYZ) tak, že na SD kartu umístíme soubor, který buď ručně napíšeme, nebo jej vytvoříme pomocí našeho programu.

Ruku lze tedy ovládat pomocí softwaru v PC, nebo z SD karty, kterou umístíte do ovládacího panelu, na kterém je umístěna membránová klávesnice a LCD display.

Popis výroby

Začali jsme tím že jsme vytvořili kompletní 3D model, který jsme pak postupně začali tisknout na 3D tiskárně z PLA plastu. Mezitím jsem si připravili desku 80 x 80 cm, na kterou jsme ruku umístili. Pro demonstraci jsme na desku udělali čtverečkovou síť, která slouží jako pomocník pro určování souřadnic.

Po vytištění jsme začali vše montovat dohromady. Některé díly bylo třeba dočistit, takže jsme je dočistili a pak smontovali dohromady. V ruce jsou dvě kuličková ložiska, která jsme taky navrhovali. Jako kuličky do nich jsme použili kuličky do airsoftových zbraní (průměr 6 mm). Tato ložiska jsme pak ještě promazali silikonový olejem. Jako pohon jsme použili několik druhů servo motorů. Nejsilnější serva (60Kg/m) přišla do spodní části ruky.

Robotická ruka – základna

Dále jsme použili už slabší motory (50Kg/m).

Jako řídicí jednotku jsme chtěli původně použít Arduino UNO, ale nakonec jsme se rozhodli že si vyrobíme vlastní. V programu Fritzing jsme navrhli desku PCB, kterou jsme si pak fotocestou i vyrobili. Na této desce jsou umístěné dva řídící čipy ATmega328p, krystaly 16 MHz, několik kondenzátorů, stabilizátor napětí (7805), který napájel celý řídicí obvod. Dále jsou na desce umístěné konektory pro připojení motorů, SD karty, membránové klávesnice atd.

Robotická ruka – PCB

Konec ruky je zakončen jakýmsi “upínacím nástavcem”, kam lze napojit několik možných nástavců. Nástavce které my nyní používáme jsou dva druhy extruderů, např. na palačinkové těsto, dále pak tříbodové úchopové klepeto. Do budoucna máme v plánu i nějaké nástavce s čidly a měřícími systémy.

Robotická ruka – extruder

Pro napájení řídicí desky i ruky samotné jsme použili průmyslový spínaný zdroj 7,4V (20A), který dokáže napájet všechny části ruky, plus je tam i malá rezerva pro připojení něčeho dalšího.

Software

Počítačová část

Pro počítač jsme vytvořili software v prostředí Processing 3. V tomto programu lze ovládat naší ruku pomocí souřadnic. V programu si zvolíte nejprve souřadnice XY (na vodorovné ploše), pak zvolíte hodnotu na ose Z (hodnota na svislé ose). Dále je pak možnost zvolit, co se má stát s nástavcem (uchopit x uvolnit). Nasledují pak dvě možnosti jak do ruky příkaz dostat – buď jej exportujete do souboru a ten pak nahrajete na SD kartu, ze které ho pak spustíte pomocí ovládacího panelu na ruce, nebo PC připojíte k ruce přes USB a posíláte příkazy napřímo.

Řídicí jednotka

Pro řídicí jednotku jsme museli napsat dva programy (pro každý čip zvlášť). K jednomu čipu jsou připojená všechna zařízení z ovládacího terminálu a k druhému jsou připojené všechny motory.

Pro čip, který má na starosti ovládací panel jsme použili několik knihoven a to hlavně pro LCD display (20 x 4), pak pro membránovou klávesnici (4 x 4), také pro SD kartu a operace s ní.

Robotická ruka – ovládací panel

Na druhém čipu je umístěn program, který čte úhly v určitém formátu ze sériové linky a následně je zapisuje do serv, která se do dané pozice otočí. Na sériovou komunikaci (RX, TX) je připojen druhý čip nebo počítač (to záleží na tom, jestli chcete ruku ovládat přes PC, a nebo z SD karty).

Soupis použitých součástek

• 2x Servo motor 60Kg/m
• 1x Servo motor 48Kg/m
• 2x Servo motor 13,56Kg/m
• 1x Robotické servo 17Kg/m
• Průmyslový spínaný zdroj
• Součástky pro osazení PCB řídicí jednotky (čipy ATmega328p)
• Arduino UNO
• LCD display 20 x 4
• Membránová klávesnice 4 x 4
• Modul pro SD karty

      +Vytištěné plastové díly, které najdete ZDE a taky zde naleznete veškeré programy. Pro montáž jsme použili nějaké M3 šroubky a matky různých délek.
      +K uchycení ruky jsem použil M8 x 50 šroub a matky.

V budoucnu bychom na ruku chtěli umístit infračervenou kalibrační sondu, která by pak ruku zkalibrovala pomocí kalibračních bodů na dané podložce. Další naší myšlenkou by bylo ruku předělat na krokové motory, které by měly být daleko přesnější než dosavadní serva.

Pokud by někdo z vás z řad čtenářů měl nějaký nápad, co by se dalo vylepšit, nebo nějaké další využití, či úkol, který by ruka mohla plnit, nebo nějaký zvídavý dotaz, tak budeme rádi když nám je napíšete do komentářů, nebo na arduino.rady@gmail.com. Budeme také rádi, když vás naše práce inspiruje k vytvoření něčeho dalšího, s čím se pak budete moci pochlubit zase na zpět.

CanSat – finále ČR

V minulém příspěvku jsme představili projekt CanSat a také naše řešení projektu s Arduinem. V tomto článku se podíváme na finální technické řešení CanSatu PilSat, ale na začátku nejdříve na průběh samotného finále, které se konalo 30.-31.3.

Průběh finále

První den finále se konal na Letkově. Před odjezdem na Letkov jsme se sešli v Centru Robotiky a dokončovali jsme konečnou verzi našeho CanSatu. Kolem poledne se začali scházet ostatní týmy na předem ustanoveném místě v Plzni, odkud byl následný odjezd do Letkova. Po příjezdu do Letkova se vylosovalo pořadí týmů na vypuštění CanSatu. Náš tým PilSat byl vylosován jako třetí/čtvrtý v pořadí z osmi/devíti.

CanSat – finále – PILSAT

První pokus vypuštění našeho CanSatu se nepovedl, proto jsme museli vzlétnout dvakrát. Druhý pokus vypuštění CanSatu se nám už povedl, ale vyskytl se problém a řízené přistání selhalo.

Po vypuštění všech CanSatů jsme jeli zpátky do Centra Robotiky, kde jsme zpracovávali získaná data pro druhý den finále a připravovali se na prezentaci.

Náplní druhého dne finále byly prezentace týmů a výsledků z předchozího dne. Vše probíhalo před odbornou porotou a ostatními týmy. Po prezentacích a obědě jsme se dozvěděli výsledky. Náš tým PilSat se umístil na 5. místě a dostali jsme ocenění za inovativní řešení mise.

Technický popis našeho CanSatu

Náš CanSat byl rozdělen do dvou na sobě nezávislých elektronických obvodů. První byl určen pro samotné získávání dat v průběhu letu a druhý pak pro řízení letu (drona).

Obvod pro ovládání letu (drona)

Tento obvod nebyl nijak složitý, sestavili jsem ho z desky NAZE32. Tato deska je podobná Arduinu, ale své využití má hlavně pro stavbu dronů. Tato deska už má ve svém základu integrovaný barometr, gyroskop a akcelerometr, takže k vlastnímu letu už je pak jen třeba připojit motory s regulátory a napájecí destičku s baterkou. V našem případě jsme použili motory ROTORAMA s tahem 220 g, což pro náš CanSat mělo být dostačující. Jako napájení jsme použili baterii Li-Po 7,4 V s kapacitou 460 mAh, což nám mělo vystačit asi na 2 minuty letu při maximálním tahu.

Obvod pro získávání dat

Do obvodu pro získávání dat jsem použili Arduino MICRO, které mělo na starosti zaznamenávání dat a jejich odesílání do pozemní stanice. Data (teplotu a tlak) jsme získávali ze senzoru BMP180. Tato data jsme pak odvysílali v pásmu 433 MHz do pozemní stanice pomocí modulu RFM69HW. V pozemní stanci byla data přijata a pomocí Arduino UNO poslána přes sériovou linku do počítače. K výměně dat docházelo přibližně jedenkrát za sekundu.

CanSat – pozemní stanice

Zpracování dat

Data, která jsme přijali, jsme museli zpracovat a odevzdat porotě. Ze získaných dat jsme měli za úkol zjistit výšku shozu. Náš výpočet bral v úvahu jak tlak, tak i teplotu. Díky tomuto vztahu se nám tedy povedlo vypočítat výšku shozu na 235 m nad zemí.

Řízené přistání (sekundární mise)

Jak dopadlo naše řízené přistání ukazuje obrázek.

CanSat – po dopadu

Náš plán byl založen na vysunutí čtyř ramen s motory, které by zbrzdily pád a umožnily přechod do “letu”. Po vypuštění našeho CanSatu však došlo k otevření pouze jednoho ramene, takže místo letu následoval volný pád trvající necelých 7 sekund s dopadovou rychlostí cca 68 m/s. Po dopadu došlo ještě k explozi a následnému požáru naší baterky, takže z našeho CanSatu toho moc nezbylo.

K vyklopení ramen mělo dojít po spuštění motorů, domníváme se, že motory bohužel nenaskočily kvůli tomu, že se CanSat po vypuštění naklonil. Deska NAZE32, stejně jako všechny ostatní řídicí desky pro drony, potřebuje být ke spuštění motorů v rovině.

Na závěr bych chtěl poděkovat celému týmu a pořadatelům za skvělou soutěž. Příště se určitě bude dařit ještě více.

Stejně jako minulý ročník soutěže JedoBot, o kterém jsme psali v tomto článku, byl ten letošní plný zábavy, nadšení, zajímavých robotů a konstrukcí. Takovou událost jsme si samozřejmě nemohli nechat ujít, a tak přináším obrazovou reportáž z této akce.

Soutěž se odehrála tradičně na Jedovnické průmyslovce a pravidla soutěže byla velmi podobná minulému roku. Snad jen s tím rozdílem, že čároví roboti museli letos zdolat ve druhém kole i překážku v podobě černé krychle vložené do tratě. Tohle shrnu jednoduše slovy “no máme co trénovat na příští rok :)”. A teď už k samotné soutěži a pěkně popořádku. Pro vás, co se už nemůžete dočkat jak dopadlo vyhodnocení soutěže o Arduino robota mBot, tak ANO, je to na konci…

Vyplatilo se přivstat si…

Od rána probíhalo v tělocvičně usilovné lazení a tunění robotů všech druhů a kategorií. Největší zájem byl o testování schopnosti robota objet tu zrádnou černou kostku :). Kdo si přivstal, určitě nelitoval.

Příprava na soutěž

Stanoviště měření rychlosti

Přesné měření časů průjezdu čárou zajišťovalo speciální stanoviště měření rychlosti.

Stanoviště měření rychlosti

Skvělé publikum

Nedílnou součástí soutěže bylo to nejlepší publikum, které prožívalo každé robotí klání do posledního robotického kousnutí a škrábnutí.

Skvělé publikum

Tu atmosféru je nejlépe zažít na vlastní kůži, ale následující video ji dobře vystihuje. Počkejte si do konce na nečekaný závěr tohoto robotího souboje…

Stánek Arduino.cz a HWKitchen.cz

Kromě soutěže o Arduino robota mBot jsme měli na stánku k vyzkoušení také robota mBot Ranger v podobě tanku a slepice. Byl k vidění i oblíbený Arduino kit TinyLab nebo růžový mBot. Díky všem co se u nás zastavili!

Stánek Arduino.cz a HWKitchen.cz na JedoBot 2017

Soutěž o Arduino robota mBot – mBot jezdí po čáře

Soutěž o Arduino robota mBot – zájemci o soutěž

Soutěž o Arduino robota mBot – registrace do soutěže

Soutěž o Arduino robota mBot – přehlídka mBotů

Lego čároví roboti

Roboti z LEGO nepatří ve srovnání s kategorií robotů vlastní konstrukcena na čáře k těm nejrychlejším. Některé konstrukce byly ale velmi zajímavé, pokud jde o nápaditost řešení. Roboti si také dokázali poradit obstojně i s vyhýbáním překážce. Dobrá polovina LEGO robotů dokázala kostku objet.

Čárový robot z Lego Mindstorm jede po čáře

Čárový LEGO robot

Čárový robot z LEGO Mindstorm

Čároví roboti vlastní konstrukce s procesorem

Tady se jezdilo o poznání rychleji. Roboti vlastní konstrukce byli oproti robotům z LEGO na čáře až 10x rychlejší! Horší to bylo ale ve druhém kole, kde číhala na trati překážka a ta se stala většině robotů s procesorem v této soutěži osudnou…

Čárový robot s procesorem

Na obrázku je vidět kostka, kterou jsem tu už párkrát nechvalně zmínil. Gratuluji všem robotům, co si s ní poradili. Příště to bude chtít zakomponovat do řešení nějaký vhodný snímač vzdálenosti a do kol enkodéry pro přesné objetí překážky.

Čárový robot s procesorem – tank

Na následujícím videu je Arduino čárový robot HW Kitchen, kterému se podařilo zdolat celou čáru za pouhých 6,26s. Bohužel na objíždění kostky to bylo horší, tohle jsme vůbec nezvládli. Každopádně jsme i tak získali krásné druhé místo a do příště alespoň víme, co zlepšit :).

Sumo zápasníci

Sumo zápasy jsou tradiční disciplínou. Pokud jste viděli video na začátku článku, tak jistě uznáte, že je to i dost napínavá a adrenalinová disciplína.

Sumo klání Lego robotů

Sumo zápas – kdo asi vyhraje?

Sumo zápasy a nadšené publikum

Sláva vítězům, čest poraženým!

Čáry jsou projety a zápasy dobojovány, nezbývá než vyhlásit a odměnit vítěze…

Vyhlášení výsledků soutěže JedoBot

Stupně vítězů na JedoBot 2017

Ukázka robotického ramene firmy Tecnotrade

Vedle soutěže bylo možné shlédnout také inspirativní ukázku robotického ramene firmy Tecnotrade. Pro účastníky závodů to byl dobrý příklad toho, čeho je možné v robotice dosáhnout.

Robotické rameno firmy Tecnotrade

Robotické rameno firmy Tecnotrade – stylová ukázka práce

Výstavka robotů z Lega Mindstorm

Na závěr ještě pár zajímavých robotů z LEGO Mindstorm.

Výstavka robotů z Lega – robot na složení Rubikovy kostky a robot had

Výstavka robotů z Lega – robotický slon

mBot soutěž

A na úplný závěr je tu konečně vyhlášení soutěže o Arduino robota mBot!

Vítězem se stává: Jan Dražil

Vítězi naší soutěže zasíláme modrého robota mBot a gratulujeme k výhře!

Když se někdo rozhodne postavit si kvadrokoptéru, většinou zavítá na web svého oblíbeného prodejce elektronických modulů a koupí si již hotové řešení pro řízení motorů, snímání informací o aktuální poloze apod.

Sedmnáctiletý Nikodem Bartnik se ale rozhodl, že si vše udělá od základu. Vlastnoručně vyrobený klon Arduino Uno použil jako hlavní jednotku pro řízení letu a postavil si také vysílačku pro ovládání kvadrokoptéry. Také se pokusil vytisknout rám, ale po problémech se raději rozhodl tuto část koupit.

Řídicí deska

Zbytek elektroniky tvoří čtyři motory, čtyři moduly pro jejich řízení (ESC), dva rádiové moduly nRF24L01, deska MPU-6050 (gyroskop a akcelerometr), baterie a pár dalších menších komponent.

Více informací o kvadrokoptéře se můžete dočíst na webu Instructables. Dron v letu můžete vidět ve videu níže.

Přeloženo z https://blog.arduino.cc/2017/04/21/teenage-maker-builds-his-own-arduino-drone/ a mírně upraveno.

Pokud vám, někdo řekne, že si postavil robota, který se může volně pohybovat, pravděpodobně si představíte nějaké vozítko s koly čí pásy, nebo robota typu hexapod. Kutil s přezdívkou joesinstructables se ale rozhodl vytvořit něco trochu jiného a sestrojil robota, který se pohybuje plazením. Svůj výtvor nazývá “Mamba z Erijského jezera”.

Autor propojil tucet servomotorů a vytvořil z nich zařízení tvarem i pohyby podobné hadu. Každý článek má vlastní kolečka. Ta ale nemají pohon a slouží pouze pro zvýšení pohyblivosti. Zařízení je řízené deskou Arduino Mega a je schopné se pohybovat v několika módech, které jsou inspirované dvěma způsoby plazení hadů a také pohybem červů.

Robohad

Robohad se skládá ze dvanácti článků. Každý tvoří servo motor, železné konstrukční prvky, svorka na vodiče a pár LEGO koleček. Robota je možné ovládat pomocí dálkového ovládání, ale je také schopný samostatného pohybu díky IR senzoru ve přední části.

Více informací o projektu naleznete na webu insructables.com.

Přeloženo z https://blog.arduino.cc/2017/04/25/the-lake-erie-mamba-is-a-12-servo-snake-robot/ a mírně upraveno.

Předělejte si staré autíčko a ovládejte ho vlastním mobilem!

Asi každý z nás má doma staré již nepoužívané autíčko, a to buď odložené a zapomenuté ještě z dětství, nebo zničené s odpálenou elektronikou v důsledku opravdu aktivního hraní. V mém případě se jedná o druhý uvedený příklad. V tomto článku se budu věnovat postupu, jak si předělat v podstatě jakékoliv autíčko na ovládání smartphonem přes Bluetooth pomocí Arduina. Postup i kód celého projektu jsou velmi jednoduché, a tak jsem přesvědčen, že tento upgrade zvládne vytvořit každý z vás.

Potřebné součásti

1. podvozek nějakého RC auta
2. 1 x Arduino UNO
3. 2 x relé (Arduino friendly)
4. 1 x micro servo
5. Bluetooth modul HC-05 nebo HC-06
6. baterie (zde 12V / 1200mAh),
7. LED (červenou a bílou) a piezo bzučák
8. šrouby M3 (4 x 25 mm a 6 x 15 mm) + matice M3
9. power banka
10. mobil s androidem
11. + ještě pár drobností uvedených v článku

Jdeme na to!

Stáhněte si aplikaci “Arduino Joystick Controller” dostupnou na: https://play.google.com/store/apps/details?id=com.andico.control.joystick

V této apce je mimo jiné 7 tlačítek sloužících na: zapínání světel, klaksonu a řízení serv namontované kamery. Jsou k dispozici také 3 tlačítka (A,B,C) pro libovolné obsazení uživatelem (např. maják, světelná rampa). Ale o těch někdy příště.

Arduino Joystick Controller

Ještě potřebujeme destičku, která bude rozměrově sedět k velikosti auta. Na tuto desku budeme vše montovat a následně ji umístíme na šasi (podvozek) auta. Já používám 2 mm silné plexisklo. Dá se koupit v každém hobby marketu a jedna plotna o velikosti 25 x 50 cm se prodává asi za 80 Kč. Tuto destičku jsem si nařezal na potřebné rozměry pomocí plátku do ruční pilky. Na destičku jsem si přiložil Arduino součástky, relátka a BT modul a fixou jsem si poznačil jejich umístění a přes dírky tenkým fixem označil tečky pro vrtání děr. Součástky, které nemají díru uchytíme pomocí stahovacího pásku. V mém případě jsem pomocí stahovacího pásku uchytil Bluetooth modul.

Na obrázku vidíte namontované komponenty na plexiskle (bez světel a klaksonu).

Arduino Bluetooth auto – zapojené součásti

Vybereme také vhodné místo pro servo, a pomocí šroubů nebo pásků (jako v mém případě) připevníme servo na tyč řízení.

Arduino Bluetooth auto – detail serva

Zapojení

Vše zapojíme dle následujícího schématu. Baterii dáme původní nebo s podobným napětím (baterie na schématu je pouze orientační).

Zapojení Arduino Bluetooth auta

Arduino program

Spustíme si Arduino IDE a stáhneme si zdrojový kód ZDE.

Otevřeme zdrojový kód a zvolíme COM port a vývojovou desku (já mám: ARDUINO UNO na COM5). Zkompiluj a nahraj do Arduina.

Otevři sériový monitor. Objeví se informace, že BT modul není připojen. Znamená to, že program čeká na spárování s telefonem.

Připojení Bluetooth modulu

Po spárování telefonu s modulem se objeví následující:

Spárování Bluetooth modulu s telefonem

Jednotlivé hodnoty nám udávají směr, rychlost, úhel zatočení, příkazy pro světla, klakson a tlačítka.

Určitě jste byli při konstrukci a montování úspěšní a už si vesele jezdíte s vašim novým Arduino autíčkem!

V minulém dílu jsme si ukázali, co všechno deska TinyLab umí a jaké součástky na ní nalezneme. V dalších dílech si postupně jednotlivé součástky představíme. Dnes se budeme zabývat potenciometrem.

Trocha teorie

Potenciometr je součástka, kterou je možné použít jako regulovatelný napěťový dělič. Co to znamená? Nepůjdeme moc do hloubky a budeme se zabývat hlavně důsledkem, který je pro nás nejdůležitější.

Autor: Iainf – Fotografie je vlastním dílem, CC BY 2.5, https://commons.wikimedia.org/w/index.php?curid=1407612

Na jednu krajní nožičku zapojíme zemi (GND), na druhou plus (v našem případě +5V) a čteme napětí na prostřední nožičce. To se může pohybovat mezi 0V a 5V v závislosti na otočení prostředního kolíku. Jako snad všechny elektrotechnické součástky, i potenciometr má vlastní schématickou značku. Nejčastěji se setkáme se dvěma typy značení, které se liší podle použité normy schématických značek.

Schématické značky potenciometru. Zdroj: https://startingelectronics.org/beginners/components/potentiometer/

Potenciometr na TinyLab

Na desce TinyLab naleznete potenciometr v pravém dolním rohu a je připojený na analogovém pinu A0.

Potenciometr

Jednotlivé součástky se k hlavnímu čipu připojují řadou přepínačů kolem pinů na desce Leonardo. Přepneme si proto přepínač označený číslem 6 na levé straně desky Leonardo. Ten připojuje právě analogový pin A0.

Zapnutí analogového pinu A0 na desce TinyLab

Posílání naměřených hodnot z potenciometru

V tomto příkladu si necháme každých 10ms posílat hodnotu z potenciometru. Když si v nabídce Tools (Nástroje) otevřeme Serial Monitor (Sériový monitor), bude nám závratnou rychlostí vypisovat čísla. Pokud vypisuje nesmyslné hodnoty, zkontrolujte, že máte v pravém dolním rohu monitoru vybranou správnou rychlost – v našem případě 9600.

Vypisování hodnot je zajímavé, zajímavější je ale si otevřít ve stejné nabídce Serial Plotter (Sériový plotter), který přijaté hodnoty zobrazí do grafu.

void setup() {
  // zahájíme sériovou komunikaci s rychlostí 9600
  Serial.begin(9600);
}

void loop() {
  // přečteme hodnotu z analogového pinu A0 a uložíme ji do proměnné s názvem hodnota
  int hodnota = analogRead(A0);

  // odešleme naměřenou hodnotu po sériové lince
  Serial.println(hodnota);

  // počkáme 10 milisekund před dalším opakováním
  delay(10);
}

Změna rychlosti blikání LED

Ještě si dnes vyzkoušíme jiný příklad, ve kterém budeme pomocí potenciometru měnit rychlost blikání LED na pinu 13. Pokud si nepamatujete, jak se LEDkou bliká, podívejte se na závěr minulého článku.

byte ledPin = 13;

void setup() {
  // nastavíme pin 13 jako výstup
  pinMode(ledPin, OUTPUT);
}

void loop() {
  int hodnota = analogRead(A0);
  
  digitalWrite(ledPin, HIGH); // zapneme LED
  delay(hodnota); // počkáme tolik ms, kolik je měřená hodnota
  digitalWrite(ledPin, LOW); // vypneme LED
  delay(hodnota); // opět čekáme
}

Když nyní budeme otáčet potenciometrem, bude se měnit rychlost blikání LED.

To by bylo pro dnešek vše. Další v řadě komponent si představíme v příštím dílu.

Už jsme tu měli několik článků, které se věnovaly Arduino kitu TinyLab. Ty ale většinou předpokládaly alespoň základní znalost platformy Arduino, vývojového prostředí apod. Dnešní článek bude věnován těm uživatelům, kteří nemají s programováním žádnou zkušenost a TinyLab si pořídili, protože s programováním chtějí teprve začít. Stručně si kit představíme, ukážeme si, jak se do něj nahrávají programy a také se odkážeme na zdroje k dalšímu studiu.

Co je TinyLab

Popisu TinyLab se věnoval samostatný článek, představíme si proto tuto desku jen ve stručnosti. Jedná se o Arduino Leonardo, ke kterému je ale „přilepeno“ spoustu dalších komponent. Deska Leonardo je na TinyLab symbolicky naznačená bílou linií. Zachované jsou také patice pro zasunutí různých rozšíření – takzvaných shieldů. Zajímavý je také prostor určený pro vložení a nalepení malého nepájivého kontaktního pole pro rychlé prototypování, což se občas dost hodí.

Z komponent na desce můžeme jmenovat například LED, LCD displej, sedmisegmentový displej, potenciometr, snímač teploty nebo osvětlení a další. Aby nebylo Arduino připojenými komponentami „přehlceno“, popřípadě aby tyto komponenty nenarušovaly komunikaci s případnými připojenými shieldy, je možné komponenty pomocí spínačů na desce podle potřeby připojovat a odpojovat (na obrázku jsou spínače červené). Jednotlivé spínače jsou umístěny naproti příslušného signálu. Pokud je daný spínač rozepnut, tak je možné signál využít pro vlastní potřebu (např. pro připojený Arduino Shieldu). Pokud ale chcete využít určitý prvek na desce TinyLab, tak musíte dát daný spínač do polohy ON.

Napájení Arduino desky a všech periferií zajišťuje výkonný spínaný zdroj, který je schopen na napájecím napětí 5 V dodat až 3 A. Desku TinyLab můžete použít i pro napájení dalších periferií nebo hardware. Navíc je zdroj vybaven ochranou proti zkratu, což se pro různé bastlení hodí.

Komponenty

Kam jsou všechny ty periferie připojeny je dobře vidět z blokového diagramu Tinylab. Podrobnosti ohledně zapojení desky TinyLab naleznete ve schématu zapojení.

Příprava prostředí

Arduino se běžně programuje v prostředí Arduino IDE. To je sice některými pokročilejšími uživateli opovrhované řešení, ale pro začátek naprosto dostačující. Arduino IDE je možné stáhnout zde. Poměrně novou možností je online vývojové prostředí. Programování pak probíhá prostřednictvím prohlížeče. Tuto možnost ale nyní nevyužijeme a stáhneme si aplikaci do počítače. Zde nás čeká nepříjemná komplikace, protože některé programy, které TinyLab využívá, nejsou kompatibilní s nejnovější verzí Arduino IDE. Proto zde stáhneme starší verzi IDE 1.6.8. Zvolte verzi podle vašeho operačního systému a stáhněte ji. Poté Arduino IDE spusťte. Mělo by se vám objevit okno, jaké vidíte níže. Hlavní část okna je určená pro psaní kódu. Ve spodní černé části, se zobrazují různé hlášky, například při nahrávání programu do Arduina apod.

Arduino IDE

První připojení

Vezmeme USB kabel, který je v balení, a propojíme jím desku s počítačem. Měla by se rozsvítit žlutá kontrolka vedle USB konektoru na desce.

Indikátor napájení

Nyní v Arduino IDE otevřeme nabídku Tools a v ní menu Boards, ve kterém vybereme desku Arduino Leonardo. V nabídce Tools/Port potom zvolíme port, ke kterému je Arudino připojeno – poznáme ho mimo jiné podle toho, že po odpojení Arduina od USB konektoru port z nabídky zmizí.

Nyní je vše připravené pro nahrání prvního testovacího programu. V něm si zablikáme LEDkou.

Blikáme LEDkou

Arduino IDE obsahuje při stažení řadu ukázkových příkladů. V menu File/Examples/01.Basics vybereme příklad Blink, který slouží právě k blikání LED. Program vypadá následovně:

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);                    
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);                    
}

Nebudeme si ho podrobně rozebírat. Pokud chcete vědět, co která část znamená, odkáži vás na své články o programování Arduina.

Příklad Blink – blikání LED

Před nahráním ještě přepneme přepínač u pinu 13, který je na desce TinyLab označený číslem 5, do polohy ON. Také přepneme všechny tři spínače, které nalezneme pod sedmisegmentovým displejem do polohy To Control LEDs.

Přepínač pro pin 13

Nyní stiskneme tlačítko upload a program se nahraje do desky.

Tlačítko Upload

LED v levém dolním rohu by nyní měla blikat.

Přidání potřebných knihoven

Abychom mohli využít celý potenciál desky TinyLab, musíme nyní prostředí „naučit“ používat různé komponenty.

Například ovládání LCD displeje by nebylo úplně jednoduché. Zároveň se ale jedná o poměrně často využívanou komponentu. Co s tím? Pro takovéto komponenty proto vznikají tzv. knihovny – balíky kódu, které slouží pro jejich snadné ovládání. Některé knihovny jsou již součástí Arduino IDE, ale ne všechny. Ty chybějící si proto nyní doplníme.

TinyLab GitHub

GitHub je zjednodušeně řečeno server, který slouží ke sdílení kódu mezi uživateli. Na něm nalezneme všechen potřebný software pro ovládání komponent na desce TinyLab a také ukázkové příklady. Na GitHub klikněte na tlačítko Clone or download a poté na Download ZIP. Stáhne se ZIP archiv, který obsahuje několik složek. Nyní nás bude zajímat složka libraries. Ta obsahuje další složky, například RF24, Time a další. Tyto složky přesuneme do složky Libraries v místě, které jsme zvolili pro ukládání Arduino programů při instalaci IDE. Tato složka se dá najít také v nastavení Arduino IDE v položce Soubor/Vlastnosti/Nastavení/Umístění projektů. Typicky například C:/Users/jmeno/Documents/Arduino. Knihovny TinyLab tedy kopírujeme do složky Libraries ve složce Arduino.

Do složky Arduino můžeme nahrát také příklady pro Tinylab, tedy služku example_codes. Tyto Arduino příklady slouží pro podrobnější demonstraci práce s jednotlivými periferiemi a jsou rozděleny podle zkušenosti bastlíře na tři další podadresáře (Basic, Medium, Advanced). Dalšími příklady a Arduino programováním se budeme zabývat v pokračování seriálu o Arduino kitu TinyLab.

Testovací program

ZIP archiv obsahuje také složku test_code, ve které nalezneme programy sloužící pro otestování jednotlivých komponent TinyLab. Tento program je také standardně nahrán v nové desce TinyLab. Složku test_code můžete také zkopírovat do složky Arduino. Otevřeme si nyní program test_code/tinylab_test_code a nahrajeme ho do desky (testovací program najdete v položce Soubor/Projekty). Všechny spínače přepneme do polohy ON a desku restartujeme tlačítkem Reset vedle USB portu. Nyní by se měl rozsvítit LCD displej a na něm zobrazit nápis „LCD -> OK“ a „-> S1“.

Pokud nápis nevidíte, je to pravděpodobně způsobeno nevhodně nastaveným kontrastem LCD. Ten je možné upravit pomocí trimru pod LCD displejem, který je označený LCD contrast. Pomocí malého křížového šroubováku zkuste opatrně potenciometrem otáčet a uvidíte, jak se jas mění.

Pokud se vám již nápis zobrazil správně, můžete tlačítkem S1 přepínat mezi testováním jednotlivých komponent a podle pokynů na displeji provádět jednotlivé testy. U SD karty, ESP8266 a NRF se na displeji zobrazí FAILED. To je v pořádku, pokud tyto komponenty nemáte připojené.

Závěr

To by bylo do začátku vše. Pokud se chcete o TinyLab dozvědět více, podívejte se na seriál článků o něm. Pokud vás zajímá programování Arduina, podívejte se sem.

V minulém dílu jsme se zabývali potenciometrem, který nalezneme na desce TinyLab. Dnes se budeme věnovat čtveřici LED ve spodním rohu desky.

Nastavení přepínačů

LED jsou připojené k pinům (zleva) 13, 12, 11, 10. Proto musíme přepnout spínače u těchto pinů na desce Leonardo do polohy ON. Jedná se o přepínače označené čísly 5, 6, 7 a 8. Také přepneme trojici spínačů pod sedmisegmentovým displejem do polohy To Control LEDs.

Nyní už si můžeme ledkami zablikat, třeba pomocí následujícího kódu.

void setup() {
  pinMode(13, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(10, OUTPUT);
}

void loop() {
  digitalWrite(13, HIGH);
  digitalWrite(12, HIGH);
  digitalWrite(11, HIGH);
  digitalWrite(10, HIGH);

  delay(500);
  
  digitalWrite(13, LOW);
  digitalWrite(12, LOW);
  digitalWrite(11, LOW);
  digitalWrite(10, LOW);

  delay(500);
}

Zkrácení pomocí pole

Nyní si celý příklad přepíšeme pomocí pole a cyklů. Čísla pinů LED si uložíme do pole, kterým pak budeme v cyklech procházet.

byte leds[] = {10, 11, 12, 13};

void setup() {
  for(byte i = 0; i < 4; i++){
    pinMode(leds[i], OUTPUT);  
  }
}

void loop() {
  for(byte i = 0; i < 4; i++){
    digitalWrite(leds[i], HIGH);
  }

  delay(500);

  for(byte i = 0; i < 4; i++){
    digitalWrite(leds[i], LOW);
  }

  delay(500);
}

Blikající had

Když už máme piny LED v jednom poli, můžeme jednoduše vytvořit program, který bude pořád dokola diodami blikat jednou po druhé.

byte leds[] = {10, 11, 12, 13};

void setup() {
  for(byte i = 0; i < 4; i++){
    pinMode(leds[i], OUTPUT);  
  }
}

void loop() {
  for(byte i = 0; i < 4; i++){
    digitalWrite(leds[i], HIGH);
    delay(500);
    digitalWrite(leds[i], LOW);
    delay(500);
  }
}

Měníme rychlost pohybu

Budeme dále pokračovat v úpravách předchozího kódu a umožníme měnit rychlost pohybu LED při běhu programu. Využijeme k tomu komponentu z minulého dílu – potenciometr. Nezapomeňte přepnout přepínač u analogového pinu A0 do polohy ON (je označený pouze nulou, jen na levé straně desky Leonardo).

byte leds[] = {10, 11, 12, 13};

void setup() {
  for(byte i = 0; i < 4; i++){
    pinMode(leds[i], OUTPUT);  
  }
}

void loop() {
  for(byte i = 0; i < 4; i++){
    int pot = analogRead(A0);
    
    digitalWrite(leds[i], HIGH);
    delay(pot);
    digitalWrite(leds[i], LOW);
    delay(pot);
  }
}

Dnes to bylo jednoduché, že? Napadne vás další úprava blikání? Podělte se v komentářích, nebo na našem novém fóru arduino-forum.cz.

Tak zase příště u představení další komponenty.

V dalším dílu seriálu věnovaného desce TinyLab si ukážeme, jak se dá využít Piezzo bzučák dostupný na desce.

Co je piezo bzučák

Označení „piezo“ nesou různé součástky, které pro svoji činnost využívají piezzoelektrický jev. O něm Wikipedie uvádí:

Piezoelektrický jev (z řeckého piezein (πιέζειν) – tlačit) je schopnost krystalu generovat elektrické napětí při jeho deformování.

Tedy, že některé krystaly mají speciální vlastnost, že když je zmáčkneme, generují elektrické napětí. Toho se využívá například v zapalovačích, kdy krystal generuje elektrickou jiskru. Piezo články nalezneme také v některých snímačích v kytarách.

Tento jev ale funguje i opačně. V tomto případě se nazývá nepřímý piezoelektrický jev. Přivedeme-li na krystal napětí, dochází k jeho deformaci.  A toho se využívá právě v piezo bzučácích. Přivedením měnícího se napětí na  krystal dochází k jeho střídavému smršťování a rozpínání. Krystal svým pohybem rozpohybovává i okolní částice a vzniká tak zvuková vlna, kterou slyšíme.

Z našeho pohledu to znamená, že musíme pin, ke kterému je bzučák připojen rychle vypínat a zapínat.

Zvuk

Zvuk se prostředím šíří jako kmitání částic. Bzučák svým pohybem částice rozpohybovává, tento pohyb se postupně šíří prostředím, až narazí na bubínek našeho ucha, který je tímto pohybem rozkmitán. A my tyto kmity vnímáme jako zvuk.

U zvuku rozlišujeme několik vlastností. Jsou to například barva, amplituda (hlasitost), frekvence (výška tónu) a další. U piezzo bzučáku na naší desce jsme schopni ovlivnit pouze frekvenci.

Frekvence

Frekvence říká, kolikrát za sekundu dojde ke kmitnutí částic. V našem případě tedy kolikrát za sekundu bzučák zapneme a vypneme.

Jednotkou frekvence je Hz (hertz). Pokud má tón frekvenci 50Hz, znamená to, že se krystal v bzučáku 50x za sekundu roztáhne a smrští.

Právě frekvence od sebe odlišuje různé tóny. Například pro komorní A je stanovena frekvence 440Hz. Tabulku tónů a jejich frekvencí nalezneme například zde.

Generování zvuku na Arduinu

Našim cílem bude přehrát na bzučáku komorní A, tedy tón s frekvencí 440Hz. Prvně musíme zjistit, jak rychle musíme bzučák zapínat a vypínat. Víme, že k zapnutí a vypnutí musí dojít 440x za sekundu. Bzučák stráví v zapnutém a vypnutém stavu vždy stejnou dobu. Dobu mezi jednotlivými zapnutími nazýváme perioda. Tu vypočítáme pomocí následujícího vzorce:

perioda = 1 / frekvence

Nebo také zapsáno fyzikálně:

T = 1 / f

Víme tedy, že v našem případě bude jedna perioda mít přibližně délku

1 / 440  = 0,002272 sekundy = 2272 mikrosekund

Kód bude vypadat tak, že bzučák zapneme, počkáme polovinu periody, bzučák vypneme a počkáme další polovinu periody. A tak pořád dokola.

Velice jednoduchý kód pro generování komorního A by mohl vypadat takto:

#define BZUCAK A1

unsigned int pulPeriody = 1134;

void setup() {
  pinMode(BZUCAK, OUTPUT);
}

void loop() {
  digitalWrite(BZUCAK, HIGH);
  delayMicroseconds(pulPeriody);
  digitalWrite(BZUCAK, LOW);
  delayMicroseconds(pulPeriody);
}

Na TinyLabu je bzučák připojený k pinu A1 (analogový pin 1), takže nesmíme zapomenout zapnout vypínač u tohoto pinu (označený číslem 5).

Popřípadě pokud chceme periodu dopočítávat až v kódu, bude vypadat takto:

#define BZUCAK A1

unsigned int frekvence = 440;
unsigned int perioda = 1000000 / frekvence;    // není v sekundách, ale mikrosekundách, proto 1000000 místo 1

unsigned int pulPeriody = perioda / 2;

void setup() {
  pinMode(BZUCAK, OUTPUT);
}

void loop() {
  digitalWrite(BZUCAK, HIGH);
  delayMicroseconds(pulPeriody);
  digitalWrite(BZUCAK, LOW);
  delayMicroseconds(pulPeriody);
}

Arduino funkce tone

Zapínání a vypínání pinu ručně, jak jsme si předvedli v předchozím příkladu má jednu nevýhodu. Pokud do funkce loop něco přidáme, dojde k jejímu zdržení, perioda se protáhne a místo tónu A máme jiný tón, popřípadě podivný šum.

Naštěstí existuje funkce tone, která za nás generování tónu obstará. Navíc je vytvořena „chytřeji“, než jsme si předvedli, takže ji dlouhotrvající kód v loop nerozhodí.

Funkci tone můžeme použít dvěma způsoby:

• tone(pin, frekvence)
  • hraje tón na pinu o dané frekvenci, dokud jej funkcí noTone(pin) nevypneme
• tone(pin, frekvence, trvání)
  • Pokud funkci zadáme ještě délku přehrávání tónu (v milisekundách), dojde vypnutí přehrávání tónu po uplynulé době.

Ukažme si tedy použití v obou případech.

#define BZUCAK A1

void setup() {
  tone(BZUCAK, 440);
  delay(1000);
  noTone(BZUCAK);
}

void loop() {}

A bez delay:

#define BZUCAK A1

void setup() {
  tone(BZUCAK, 440, 1000);
}

void loop() {}

Přehrávání melodie

V příkladu na závěr si ukážeme, jak se dá přehrát jednoduchá melodie. Abychom si usnadnili situaci, přidáme si k projektu soubor s definicemi tónů a jejich frekvencí.

V Arduino IDE klikneme na šipku dolů v pravé horní části. A zvolíme možnost Add new tab. Vytvoří se nám nová záložka v IDE, kterou nazveme pitches.h a vložíme do ní následující kód:

#define NOTE_B0  31
#define NOTE_C1  33
#define NOTE_CS1 35
#define NOTE_D1  37
#define NOTE_DS1 39
#define NOTE_E1  41
#define NOTE_F1  44
#define NOTE_FS1 46
#define NOTE_G1  49
#define NOTE_GS1 52
#define NOTE_A1  55
#define NOTE_AS1 58
#define NOTE_B1  62
#define NOTE_C2  65
#define NOTE_CS2 69
#define NOTE_D2  73
#define NOTE_DS2 78
#define NOTE_E2  82
#define NOTE_F2  87
#define NOTE_FS2 93
#define NOTE_G2  98
#define NOTE_GS2 104
#define NOTE_A2  110
#define NOTE_AS2 117
#define NOTE_B2  123
#define NOTE_C3  131
#define NOTE_CS3 139
#define NOTE_D3  147
#define NOTE_DS3 156
#define NOTE_E3  165
#define NOTE_F3  175
#define NOTE_FS3 185
#define NOTE_G3  196
#define NOTE_GS3 208
#define NOTE_A3  220
#define NOTE_AS3 233
#define NOTE_B3  247
#define NOTE_C4  262
#define NOTE_CS4 277
#define NOTE_D4  294
#define NOTE_DS4 311
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_FS4 370
#define NOTE_G4  392
#define NOTE_GS4 415
#define NOTE_A4  440
#define NOTE_AS4 466
#define NOTE_B4  494
#define NOTE_C5  523
#define NOTE_CS5 554
#define NOTE_D5  587
#define NOTE_DS5 622
#define NOTE_E5  659
#define NOTE_F5  698
#define NOTE_FS5 740
#define NOTE_G5  784
#define NOTE_GS5 831
#define NOTE_A5  880
#define NOTE_AS5 932
#define NOTE_B5  988
#define NOTE_C6  1047
#define NOTE_CS6 1109
#define NOTE_D6  1175
#define NOTE_DS6 1245
#define NOTE_E6  1319
#define NOTE_F6  1397
#define NOTE_FS6 1480
#define NOTE_G6  1568
#define NOTE_GS6 1661
#define NOTE_A6  1760
#define NOTE_AS6 1865
#define NOTE_B6  1976
#define NOTE_C7  2093
#define NOTE_CS7 2217
#define NOTE_D7  2349
#define NOTE_DS7 2489
#define NOTE_E7  2637
#define NOTE_F7  2794
#define NOTE_FS7 2960
#define NOTE_G7  3136
#define NOTE_GS7 3322
#define NOTE_A7  3520
#define NOTE_AS7 3729
#define NOTE_B7  3951
#define NOTE_C8  4186
#define NOTE_CS8 4435
#define NOTE_D8  4699
#define NOTE_DS8 4978

Tyto konstanty potom můžeme použít v našem programu tak, že na jeho začátek přidáme řádek #include „pitches.h“. Ukážeme si, jak přehrát stupnici. Úpravou programu ale bude možné zahrát libovolnou stupnici.

#include "pitches.h"
#define BZUCAK A1

unsigned int stupnice[] = {NOTE_C4, NOTE_D4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_A4, NOTE_B4, NOTE_C5};

void setup() {
  for(int i = 0; i < 8; i++){
    tone(BZUCAK, stupnice[i]);
    delay(1000);
  }
  
  noTone(BZUCAK);  
}

void loop() {}

Úprav se nabízí celá řada. Třeba umožnit různou délku tónu a další. Hodně zajímavý je třeba Imperial March na bzučák:

Vytvořili jste vlastní kód? Pochlubte se v komentářích, nebo na našem fóru arduino-forum.cz.

V posledním dílu ze seriálu článků o kitu TinyLab jsme se podívali, jak se dá ovládat piezo bzučák. Dnes si ukážeme, jak můžeme využít fotorezistor, který je dostupný na desce.

Co je to rezistor

Ještě před tím, než se podíváme na fotorezistor, si v rychlosti shrneme, co je to rezistor. Rezistor, je součástka, kterou používáme hlavně kvůli jedné její vlastnosti, kterou je odpor (značí se Ω – ohm). Pomocí odporu vyjadřujeme, jak obtížné je pro proud, aby zkoumanou součástkou protékal. Říkáme, že „součástka klade proudu odpor“.

Rezistor, zdroj: https://en.wikipedia.org/wiki/Resistor#/media/File:Resistor.jpg

Každá reálná elektronická součástka nějaký odpor má, ale u nich je většinou odpor nechtěný (vzniká nedokonalými výrobními procesy, opotřebením, …). Naopak je tomu u rezistoru, u kterého přesně známe jeho odpor, který je neměnný a také žádoucí. Používáme ho například při zapojení LED diody, aby nedošlo k jejímu poškození příliš velkým proudem.

Různé způsoby zapojení LED diody.

Ve většině případů si vystačíme s rezistory, jejichž odpor se nemění. Co ale dělat v případě, kdy bychom potřebovali jejich odpor měnit na základně nějakého vstupu? S jedním proměnným rezistorem jsme se už setkali – bylo to ve článku o potenciometru. U něj jsme měnili odpor otáčením středové osy. Existují ale součástky, které mění svůj odpor na základě jiných podnětů – například teploty, nebo osvětlení.

Fotorezistor

Fotorezistor je součástka, která mění svůj odpor podle toho, jak intenzivní záření na ní dopadá. Jeho princip si představíme velice zjednodušeně – použijeme k tomu mravence.

Existuje druh mravenců, který umí stavět mosty. Nejsou to ale mosty ledajaké – mravenci je staví z vlastních těl. Když narazí na nějaký příkop, první mravenci se přichytí za okraj, na ně se chytí další, na ně další a tak dále, dokud příkop nepřekonají. Pokud jich je dostatek, příkop překonají, a můžou se tak dostat dále. Pokud jich je málo, překážku nepřekonají. Čím více jich je, tím pevnější a delší mosty můžou stavět.

Mravenčí most, zdroj: http://zoommagazin.iprima.cz/zajimavosti/video-mravenci-stavi-dokonale-inteligentni-mosty-z-vlastnich-tel

Vraťme se nyní k fotorezistoru. Představme si elektrony jako mravence a fotorezistor jako příkop. Elektrický proud není nic jiného, než pohyb elektronů – mravenců. Pokud fotorezistor není osvětlený, pohybuje se v jeho okolí velice málo mravenců, kteří nejsou schopní most postavit, popřípadě postaví jen velice tenký most, po kterém přejde jen pár mravenců najednou. Situace se mění, když na fotorezistor zasvítíme – z látky, ze které je vyroben, se začnou uvolňovat volné elektrony (mravenci), kteří pak mohou stavět větší a robustnější mosty, po kterých se mohou začít hrnout davy mravenců. Pokud opět na fotorezistor přestaneme svítit, mravenci se z mostu vrátí na svá původní místa a most tak postupně zaniká.

Na této jednoduché ukázce můžeme vidět, jak spolu souvisí intenzita osvícení fotorezistoru a odpor, který tato součástka proudu klade

Čím více fotorezistor osvítíme, tím více se uvolní elektronů a tím menší odpor nakonec klade.

Fotorezistor na TinyLab

Na desce TinyLab nalezneme fotorezistor v pravém dolním rohu, hned vedle potenciometru. Součástka je označená nápisem PHOTORESISTOR a je připojená na analogový pin A2. Abychom měli k fotorezistoru přístup, musíme si přepnout přepínač u pinu A2 do pozice ON.

Přepínač u A2

Měření analogových hodnot

Na Arduinu obecně (tedy i na TinyLabu) slouží k měření analogových hodnot funkce analogRead(). Ta má jeden parametr, a to pin, na kterém chceme hodnotu měřit. Funkce vrací naměřenou hodnotu, která může být v rozsahu 0 až 1023. Jednoduchý program, který nám bude posílat naměřené hodnoty na fotorezistoru, může vypadat třeba takto:

void setup() {
  Serial.begin(9600);
}

void loop() {
  int mereni = analogRead(A2);
  
  Serial.println(mereni);

  delay(1000);
}

Když nyní budeme fotorezistor zakrývat a odkrývat, měla by se hodnota na sériové lince měnit – 0 značí maximální intenzitu světla, 1023 absolutní tmu. Krajních hodnot ale nemusíme dosáhnout, závisí to i na vnitřním zapojení součástek na desce.

Změna tónu podle osvětlení

Pojďme si vytvořit jednoduchý hudební nástroj, který bude hrát tu frekvenci, jaká je zrovna naměřená hodnota na fotorezistoru. Pokud si nevzpomínáte, jak se dá s TinyLab tvořit hudba, přečtěte si článek o piezo bzučáku. Bzučák je připojený na A1, takže nesmíme zapomenout přepnout jeho přepínač do polohy ON.

void setup() {}

void loop() {
  int mereni = analogRead(A2);
  
  tone(A1, mereni);
}

Výsledný zvuk je jako ze špatného sci-fi, ale základní myšlenka je myslím jasná. Nyní nastal čas na vaše experimenty. Zkuste tento příklad libovolně upravit, nebo například vytovřte program, který bude měnit rychlost blikání LED podle osvětlení, přehrávat různé melodie v závislosti na osvětlení a další. Podělte se se svými nápady v komentářích.

V posledním dílu seriálu o desce TinyLab jsme si představili, jak se dá používat fotorezistor. Dnes se podíváme, jak číst teplotu z dostupného teploměru.

Měření teploty

K elektronickému měření teploty můžeme použít různé typy součástek. Tou asi nejjednodušší je termistor. Termistor je součástka, která se změnou teploty mění svůj vnitřní odpor (podobně jako fotorezistor mění vnitřní odpor při změně intenzity osvětlení). Nevýhodou termistorů je jejich nelinearita. Vysvětleme si ji na příkladu:

Když při

• 0°C naměříme odpor 1000Ω
• při 1°C naměříme 2000Ω,

jaký odpor byste čekali při 2°C? 3000Ω? Právě že ne! Termistory mají nelineární průběh, což znesnadňuje přepočet jejich odporu na teplotu.

Z tohoto důvodu vznikly teploměry s lineárním průběhem, u nichž je přepočet na teplotu daleko jednodušší (vystačíme si s operacemi plus, mínus, krát a děleno).

Elektronické teploměry můžeme dále dělit na analogové a digitální. Z analogových teploměrů získáváme analogovou hodnotu, kterou jednoduše přepočteme na stupně. Digitální teploměry nám často posílají už hodnotu vyjádřenou ve stupních. Na desce TinyLab nalezneme analogový teploměr LM35.

Teploměr LM35

LM35 je na TinyLabu připojený na pin A3 Arduina. Fyzicky teploměr nalezneme v levém dolním rohu.

Jelikož je jeho výstupem analogová hodnota, musíme ji měřit pomocí funkce analogRead, podobně, jako jsme to dělali ve článku o potenciometru. V dokumentaci k teploměru uvidíme následující:

Teploměr LM35

Znamená to tedy, že teploměr musíme napájet napětím mezi 4 a 20V (což Arduino s 5V splňuje). Dále také vyčteme, že na výstupu měříme napětí, které se se změnou teploty o jeden stupeň Celsia změní o deset milivoltů (1V = 1000mV). Pro 0°C naměříme 0V, 1°C 10mV, atd.

Arduino a LM35

Jak měřit napětí v Arduinu? Pomocí funkce analogRead!

Funkce analogRead nám vrací hodnoty mezi 0 a 1023. Tato hodnota je přímo úměrná napětí, které na měřený pin přivedeme. Toto napětí se může pohybovat v rozsahu od 0V do napájecího napětí – v našem případě 5V. Když si spojíme tyto dvě informace (rozsah 0-1023, napětí 0-5V), můžeme vyvodit následujícími kroky vzorec pro výpočet teploty ve °C.

Začneme tím, že si rozsah 0-1024 převedeme na rozsah 0 až 1. (Zápis 1024.0 je použit proto, aby nedošlo k zaokrouhlení výsledku na celá čísla – zde potřebujeme desetinná)

analogRead(pin) / 1024.0

Dále tento výsledek přepočteme na milivolty v rozsahu 0-5000mV (5V = 5000mV).

analogRead(pin) / 1024.0 * 5000

Z dokumentace LM35 víme, že 10mV odpovídá 1°C, tedy výslednou teplotu ve stupních celsia získáme následovně:

analogRead(pin) / 1024.0 * 5000 / 10

Výsledný vzoreček může po zkrácení vypadat například takto:

int celsius = analogRead(A3)/ 1024.0 * 500;

Měříme teplotu

S těmito vědomostmi už se můžeme pustit do programování. Začneme tím, že si vypíšeme změřenou teplotu po sériové lince. Nezapomeňte si zapnout přepínač u analogového pinu A3.

void setup() {
  Serial.begin(9600);
}

void loop() {
  int celsius = analogRead(A3) / 1024.0 * 500;

  Serial.println(celsius);

  delay(1000);
}

Hlídač teploty

V druhém příkladu si ukážeme, jak hlídat teplotu a v případě jejího překročení spustit bzučák.

int hranice = 26;

void setup() {
  Serial.begin(9600);
}

void loop() {
  int celsius = analogRead(A3) / 1024.0 * 500;
  Serial.println(celsius);

  if(celsius >= hranice){
    tone(A1, 440, 500);
    delay(500);
    tone(A1, 600, 500);
    delay(500);  
  }
}

Napadá vás nějaké další zajímavé použití teploměru? Třeba pro jednoduchou meteostanici? Nebo pro spouštění větráku při překročení určité teploty? Podělte se s námi v komentářích.

Náš čtenář, pan Miroslav Kubín, nám poslal článek o stavbě robotického tanku. Děkujeme

Dobrý den,

Je tomu již dva roky co jsem si stáhl Váš e-book a začal jsem se zajímat o elektroniku, jenom podotknu, že nejsem vzdělaný v žádném technickém oboru a díky vašemu e-booku jsem byl schopný rozchodit již i složitější projekty za dva roky. Proto Vám skládám poklonu, protože to pochopil i naprostý laik.

Hotový tank

Ale zpět k tématu. Navrhl, upravil a vytiskl jsem robota, kterého jsem od samého počátku směřoval k tomu, aby se co nejvíce podobal robotům, kteří  jsou v dnešní době používáni na zneškodňování výbušných zařízení (například TALON 2). Robot je ovládaný pouze mobilní aplikací přes bluetooth. Nemá ale sílu na zdvihání těžkých břemen, také není schopen jezdit v obtížném terénu apod. Jedná se pouze o hračku, ačkoli plně funkční.

Požadavky na robota

Jaké byly tedy požadavky na mého robota? V první řadě jsem se ho snažil navrhnout tak, aby se dal ovládat pomocí aplikace přes bluetooth v mobilním telefonu, měl pásový podvozek a robotickou ruku na manipulaci v prostoru kolem čelní části robota, dále jsem chtěl kvůli přehledu vyrobit ovládanou robotickou hlavu na které bude hlavně FPV přenos videa přes 5.8GHz, LED přísvit a ultrazvukový měřič vzdálenosti.

Model

Podvozek

V první řadě jsem začal s hledáním podvozku, a vzhledem k tomu že jsem hrdým majitelem 3D tiskárny, bylo jasné, že celý robot bude vytištěn. Proto jsem začal hledat na www.thingiverse.com a po dlouhém hledání jsem našel tento projekt, který mi nejvíce vyhovoval.  Původně byl podvozek konstruován na dva motory, ale po tom, co jsem zjistil, že dostávají dost zabrat, jsem model upravil a přidal další dva motory. Musel jsem vymodelovat prakticky celý střed těla.

Osazení ložisek

Díly pásů

Střed tanku

Střed tanku

Rameno a hlava

Dále jsem se pustil do montování robotického ramene. Opět jsem vycházel z hotového návrhu, který jsem musel trochu upravit pro můj projekt. Ovšem největší problém jsem měl s vytvořením robotické hlavy. Nikde jsem nenašel nic, co by mi vyhovovalo, tak jsem se pustil do modelování vlastní hlavy. Hlava se otáčí o 360° pomocí serva a převodů. Umí se naklánět nahoru a dolů, a tak má veliký záběr. Jak jsem již psal – na robotickou hlavu jsem umístil FPV vysílač, kameru, led přísvit a ultrazvukový modul  na měření vzdálenosti. Vzhledem k tomu že se mi doma válel laserový modul, tak jsem jej tam taky přidal. Jako FPV kameru jsem použil starou bezpečnostní kameru s automatickým zapínáním IR LED přísvitu.

Robotická ruka

Podstavec hlavy

Podstavec hlavy

Elektronika hlavy

Podstavec hlavy

Na stránky thingiverse jsem přidal svůj projekt pro ty, kteří by si chtěli vyrobit a třeba i upravit svůj vlastní tank s .stl soubory potřebné k 3D tisku, schéma zapojení a Arduino program.

Zapojení

Funkce

A teď k tomu jak tedy robot funguje. Srdcem celého robota je Arduino Uno rev.3, pro ovládání a  komunikaci s Androidem používám bluetooth modul HC-06, pro ovládání motorů používám H-můstek L298N který je napájen 8V a otáčky se regulují pomocí PWM vstupů.  Napájení je řešeno trochu složitěji – na napájení používám dva DC-DC konvertory. Jeden jsem nastavil na napětí 8V a napájí motorový driver a FPV systém. Všechny serva jsou napájeny druhým DC-DC konvektorem nastaveným na 5v. Arduino napájím pětivoltovým výstupem z dvojitého H-můstu L298N. Pokud by někoho zajímalo více, jak robot funguje, může se podívat na můj projekt. Najdete tam i detailní obrázek jak je robot zapojen. Celého robota ovládám velice propracovanou Android aplikací, kde si můžete nastavit všechna tlačítka, táhla a ostatní příslušenství, které používáte a přidělit jim vlastní příkazy.

Ovládání tanku

Zdrojový soubor robota

Thingspeak (podklady pro 3D tisk a další zdroje)

S pozdravem Míra

Děkujeme za zajímavý článek! Máte také projekt, se kterým se chcete pochlubit? Přečtěte si tento článek.

Znáte tu atmosféru, kdy se celé město večer zabalí do tmy, přestanou troubit auta a všechno se zklidní a zpomalí. Vzduchem se nese vůně blížících se Vánoc a do ulic mohou vyrazit světlonoši v tajemném průvodu plném světel a barev. Ano, máme tady zrovna dobu lampionových průvodů. Tyto průvody měly v minulosti různé důvody. Třeba takový Arduino lampionový průvod manifestuje krásu hraní a tvoření s Arduinem.

Tak proč si nepostavit lampion přímo s Arduinem a RGB LED páskem? Ovládat to můžeme celé přes Bluetooth z mobilu. To bude Arduino světlonoš. Co vy na to?

Dáme si tam možnost zvolení barvy lampionu, efekt stroboskopu a také barevnou hudbu! Kdo se bude opravdu snažit, přidá si další režimy podle sebe. Vytvoříme si aplikaci pro Android v online grafickém IDE. Se sestavou Arduina, Bluetooth a NeoPixel LED páskem můžeme barevně osvětlit v podstatě cokoliv a řídit to na dálku z mobilního telefonu. Na vánoční stromek to bude také pasovat. Zajímavá je flexibilita takto jednoduchého Arduino projektu, možnost napájení z baterie a kompaktní rozměry. NeoPixel LED se opravdu povedly a dá se s nimi užít hodně zábavy.

Arduino lampion – jdeme na to!

Nejprve zvolíme vhodné komponenty pro stavbu. Jako základ potřebujeme nějaké malé Arduino. Použijeme Arduino NANO, protože je kompaktní a dá se přímo připojit k počítači. Dále potřebujeme Bluetooth modul HC-05 pro bezdrátovou komunikaci s mobilem a RGB LED pásek. Bude se hodit také LiPol baterie 3,7V s modulem pro nabíjení a zvyšujícím měničem pro výrobu napětí 5 V, aby nebyl lampion závislý na napájení ze síťového zdroje. Jako tělo lampiónu použijeme levné stínidlo z IKEA.

Při konstrukci hardwaru šlo vše hladce. Zarazil jsem se až při psaní kódu. Osvěžil jsem si „delay“ bez funkce delay() s použitím Arduino času millis(). Protože nelze používat delay() a sériovou komunikaci, jen pokud je prodleva opravdu malá. Postupoval jsem svou oblíbenou metodou „pokus omyl“. Po chvíli laborování se vše podařilo. A teď se na celý postup podíváme podrobněji.

Rychlokurz ai2.appinventor.mit.edu grafického IDE

Nejprve si vytvořte účet, ideální je použít spárování s Google účtem. Toto online IDE pro tvorbu Android aplikací je vhodné jak pro začátečníky tak pro pokročilé. Tvorba appky je intuitivní. Také je v IDE spousta příkladů, podle kterých se dá jednoduše postupovat ve vlastním projektu. Mně osobně nejvíce vyhovuje jednoduchá inicializace Bluetooth a následná komunikace s Arduinem. Pro téměř každý můj projekt používám toto online IDE jako univerzální ovladač a display pro Arduino. V podstatě nahrazuje tlačítka, potenciometry, displeje, klávesnice. Co se komu hodí. A když někdo vidí, jak ovládáš věci z telefonu, říká „Cože, jak si to udělal?“. Ty odpovíš jen: „Ty ještě neděláš v APP Inventoru“?

Po rozkliknutí odkazu a úspěšném přihlášení do online IDE vidíme design screen. Zde se vytvářejí ovládací prvky aplikace. Vpravo nahoře je tlačítko ‚Blocks‘ to nás přepne do grafického skládání kódu, podobně jako například u Mblock, které znáte od robotů mBot.

APP Inventor – design screen

APP Inventor – design screen

Grafická část skládání bloků kódu

APP Inventor – vkládání bloků

Přikládám na stažení soubor aplikace a také kód aplikace, který otevřetete v online IDE. Kliknutím na ‚projekt‘ ==> ‚import project from my computer‘  vložíte stažené „jmeno souboru“.aia  z odkazu.  

Podrobněji se na online Android IDE zaměříme třeba příště. Zde je odkaz na spoustu užitečných tutoriálů.

Výsledná aplikace vypadá na displeji mobilu nějak takto.

Arduino android lampion app

Nejprve aktivujte komunikaci s Bluetooth modulem HC-05. V aplikaci si můžete vybrat, jestli má nastavení platit pro celý pásek (v celku) a nebo postupně pro jednotlivé LED (horizontálně). Můžete nastavit barvu v barevném kole a aktivovat funkce pro Equalizer a Stroboskop. Equalizer převádí signál z mikrofonu podle jeho intenzity na barevné efekty LED. Stroboskop pak vytvoří světelný efekt, tak jak ho známe z různých tanečních akcí. Ideální je si to vyzkoušet.

Konstrukce Arduino lampionu

Ideální je začít spojovat Arduino a jednotlivé moduly na kontaktním poli, aby se dalo všechno pohodlně odzkoušet.

Schéma pokusného zapojení Arduino lampionu

Na kontaktním poli je vidět Arduino NANO s připojeným Bluetooth a zvukovým modulem. Zapojený je také LED pásek. Není tady zahrnuta LiPol baterie, nabíjecí modul a zvyšující měnič pro napájení.

Arduino lampion – schéma propojení modulů

Na následujícím obrázku vidíme pokusné zapojení pro zkoušení funkčnosti.

Zapojení Arduino lampionu na kontaktním poli

Před nahráním kódu naimportujte do Arduino IDE NeoPixel knihovny. Následující kód zkopírujte do Arduino IDE. Propojení jednotlivých modulů a pinů je na začátku kódu pro Arduino.

/* piny
 * HC-05
 * Tx 2
 * Rx 3
 * Vcc 5V+
 * GND gnd
 *
 * Mikrofon senzor
 * Vcc 5V+
 * GND gnd
 * A0 - A0
 *
 * NeoPixel pásek
 * DIN 6
 * VCC 5V+
 * GND gnd
 */



int blok;           // hodnota registru
const int sampleWindow = 50;  // prodleva dat z mikrofonu
unsigned int sample;

#include <Adafruit_NeoPixel.h> // knihovna neo_pixel pásku

#ifdef __AVR__
#include <avr/power.h>
#endif

#define PIN 6            // din pin LED pásku
Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, PIN, NEO_GRB + NEO_KHZ800);


#include <SoftwareSerial.h> // inport knihovny softwareserial
#include <Wire.h>

SoftwareSerial BT(2, 3); // Bluetooth piny (RX,TX)


// proměné pro dekódování hodnoty barvy
int RED_LED = 13;
String RGB = "";
String RGB_Previous = "255.255.255)";
String ON = "ON";
String OFF = "OFF";
boolean RGB_Completed = false, style = false;
int r, g, b, rh, gh, bh, s;
float cas;


void setup() {
  BT.begin(9600); // inicializace softwareserial na pinech (2,3) s rychlostí 9600
  RGB.reserve(30);
  Serial.begin(9600); // inicializace serial(9600);
#if defined (__AVR_ATtiny85__)
  if (F_CPU == 16000000) clock_prescale_set(clock_div_1); // ověření setup knihovny
#endif
  strip.begin();// start pásku
  strip.show(); // ukaž co máč navolené
  blok = 0;
  r = 255;   // startovní barva je červená
}

void loop() {
  {
    while (BT.available()) { // pokud jsou přijatá nějaká data
      char ReadChar = (char) BT.read();
      if (ReadChar == 'b') { // apka posílá příkazy jako písmena
        blok = 1;                  // pokud se shoduje, blok registr se přiřadí příslušná hodnota a spustí se
      }
      else { // void () se shodným číslem 
        if (ReadChar == 'd' || ReadChar == 'c') {

        }
        else {
          blok = 0;
        }
      }

      if (ReadChar == 'c') {
        style = true;
      }
      if (ReadChar == 'd') {
        style = false;
      }
      if (ReadChar == 'i') {
        blok = 3;
        cas = millis();
      }
      if (ReadChar == ')') {     
        // pokud je natažen znak ) znamená to že RGB kód byl přijat, apka posílá String R.G.B)
        RGB_Completed = true;    // takže červená vypadá takto 255.0.0)
      }
      else {
        RGB += ReadChar;
      }
    }
    //Když je příkazový kód přijat úplně s koncovým znakem ')'
    if (RGB_Completed) {
      if (RGB == ON) {
        digitalWrite(13, HIGH);
        RGB = RGB_Previous;
        Light_RGB_LED();
      }
      else if (RGB == OFF) {
        digitalWrite(13, LOW);
        RGB = "0.0.0)";
        Light_RGB_LED();
      }
      else {
        //zapni barvu podle barevného kódu ze sériového portu Bluetooth
        if (blok == 0) {
          Light_RGB_LED();
        }
        RGB_Previous = RGB;
      }
      RGB = "";
      RGB_Completed = false;
    }
  }
  if (blok == 1) { // rozřazení co uživatel zmáčknul za funkci
    equalizer();
  }
  if (blok == 3) {
    if (style == true) {
      strobo(100);
    }
    else {
      bourka(200);
    }
  }
}

void equalizer()     // void pro equalizer
{
  unsigned long startMillis = millis();
  unsigned int peakToPeak = 0;   // úroveň špiček

  unsigned int signalMax = 0;
  unsigned int signalMin = 1024;
  // sbírej data po 50 mS
  while (millis() - startMillis < sampleWindow) {
    sample = analogRead(0);
    if (sample < 1024) {
      if (sample > signalMax) {
        signalMax = sample;
      } else if (sample < signalMin) {
        signalMin = sample;
      }
    }
  }
  peakToPeak = signalMax - signalMin;  // amplitude
  int volts = (peakToPeak * 500) / 1024;  // TADY JE SOFTWARE nastavení citlivosti
  // přepisuje se hodnota 500 čím vyší hodnota tím je citlivější
  // u mě to jelo výborně s tímto nastavením

  if (style == false)              // equalizer celý
  {
    for (int i = 0; i < volts; i++) {
      if (i < 5){
        strip.setPixelColor(i, 0, 255, 0);
      }
      if (i > 4 && i < 10) {
        strip.setPixelColor(i, 0, 0, 255);
      }
      if (i > 9) {
        strip.setPixelColor(i, 255, 0, 0);
      }
    }
    for (int i = volts; i < 16; i++){
      strip.setPixelColor(i, 0);
    }
    strip.show();
  } else                  // equalizer horizontálně
  {
    for (int i = 0; i < 15; i++) {
      if (volts < 8){
        strip.setPixelColor(i, 0, 255, 0);
      }
      if (volts > 8 && volts < 12){
        strip.setPixelColor(i, 0, 0, 255);
      }
      if (volts > 12){
        strip.setPixelColor(i, 255, 0, 0);
      }
    }
  }
  strip.show();
}

void Light_RGB_LED() {             // dekódování String řetězce do jednotlivých int hodnot
  if (RGB.length() > 5 && RGB.length() < 12) {
    int SP1 = RGB.indexOf('.');
    int SP2 = RGB.indexOf('.', SP1 + 1);
    int SP3 = RGB.indexOf('.', SP2 + 1);
    String R = RGB.substring(0, SP1);
    String G = RGB.substring(SP1 + 1, SP2);
    String B = RGB.substring(SP2 + 1, SP3);
    r = R.toInt();
    g = G.toInt();
    b = B.toInt();

    //vypíše debug info na Serial monitoru
    Serial.print("R=");
    Serial.println(constrain(R.toInt(), 0, 255));
    Serial.print("G=");
    Serial.println(constrain(G.toInt(), 0, 255));
    Serial.print("B=");
    Serial.println(constrain(B.toInt(), 0, 255));

    for (int i = 0; i < 16; i++) { // promítne hodnoty na pásek
      strip.setPixelColor(i, R.toInt(), G.toInt(), B.toInt());
    }                    
      
    strip.show();
  }
}

void strobo(int prodleva) {
  if (millis() > cas - prodleva / 2) {
    for (int i = 0; i < 15; i++) {
      strip.setPixelColor(i, 0, 0, 0);
    }
  }
  if (millis() > cas) {
    for (int i = 0; i < 15; i++){
      strip.setPixelColor(i, 255, 255, 255);
    }
    cas += prodleva;
  }
  strip.show();
}

void bourka(int prodleva) {
  int in[15];
  for (int i = 0; i < 15; i++){
    in[i] = i;
  }
    

  if (millis() < cas - (prodleva / 2)) {
    strip.setPixelColor(in[s], r, g, b);
    strip.show();
  }

  if (millis() > cas - (prodleva / 2)) {
    for (int i = 0; i < 15; i++) {
      strip.setPixelColor(i, 0, 0, 0);
    }
    s = random(0, 14);
    if (millis() > cas)
      cas += prodleva;
    strip.show();
  }
}

Arduino lampion – prototyp

Prototyp lampionu jsem vytvořil na univerzálním plošném spoji, aby byla zajištěna dobrá odolnost proti otřesům. Při vhodném rozmístění modulů je spojení velmi jednoduché a pájení minimální.

Arduino lampion – řídící PCB (Arduino NANO, Bluetooth HC-05, zvukový modul)

Na spodní straně univerzálního plošného spoje jsou vidět zapájené propojky. Ty se dají snadno udělat tak, že teplotu pájecího hrotu nastavím na minimum.

Řídící deska pro Arduino lampion – zespodu

Celý lampion můžeme napájet například z USB Powerbanky, ale proč si nepostavit vlastní řešení s kvalitním LiPol akumulátorem? Celá konstrukce je jednoduchá. LiPol akumulátor je připojený k nabíjecímu modulu. Ten dále napájí zvyšující měnič, který vytváří napájecí napětí 5 V pro Arduino desku.

Arduino lampion – zálohovaný napájecí zdroj

Arduino lampion – střeva (řídící PCB, zálohovaný zdroj, LED pásek)

Vnitřek Arduino lampionu + aplikace pro Android

Součástky použité pro Arduino lampion

• Arduino deska Arduino NANO
• Bluetooth modul HC-05 pro komunikaci s mobilním telefonem
• RGB NeoPixel LED pásek – délka 0,5 m
• Snímač zvuku s vysokou citlivostí pro vytvoření barevné hudby
• Kontaktní pole s propojovacími drátky pro vytvoření prototypu
• Univerzální plošný spoj pro finální řešení lampionu
• Akumulátor LiPol 3,7 V 1800 mAh pro provoz lampionu bez připojení k externímu napájení
• USB nabíječka LiPol s ochranou pro nabíjení akumulátoru
• Měnič napětí z 0,9 V na 5 V USB – zajišťuje výrobu napětí 5 V pro napájení Arduina
• Stínidlo REGOLIT z IKEA

Svůj Arduino lampion můžete samozřejmě dále vylepšovat. Dalo by se připojit více LED pásků pro silnější vizuální efekt, udělat nové barevné funkce nebo například zkusit mezi sebou propojit více lampionů tak, aby barevně ladily a něco zobrazovaly. Fantazii se meze nekladou. Někdo nosí LED pásky i pod oblečením…

No představte si, kdybyste v noci ve městě potkali skupinu takovýchto barevných koulí. To by byla síla.

Tak možná ji jednou potkáte.

1. Arduino lampionový průvod. Jdete do toho, co říkáte?

Proč máme mBota tak rádi?

Arduino robot mBot od firmy Makeblock má v našich srdcích speciální místečko. Za nás jsou v tom už hluboké emoce podpořené praktickými zkušenostmi, ale pár důvodů proč ho máme tak rádi si tu uvést můžeme:

1. mBota lze pořídit za rozumné peníze. Cena vychází cca 100 USD.
2. Sestavení mBota netrvá ani hodinu. Za tu dobu stihnete nainstalovat i software na počítač nebo mobil a s robotem si zajezdit.
3. mBoti jsou skvělým nástrojem pro začátečníky a díky možnosti přidat různé rozšiřující moduly uspokojí i pokročilé uživatele.
4.  Jsou prostě tak roztomilí.
5. A to nejlepší jsme si nechali nakonec: Lze je programovat pomocí SCRATCH i ARDUINO IDE!

Arduino robot mBot hraní

Nemusím říkat (ale i tak to řeknu), že s narůstajícím úsilím naučit naše studenty programovat se z většiny našich žáků stali mini-experti na kódování ve Scratchi. Pokud se stále divíte, proč je takový povyk kolem kódovacího jazyka Scratch založeného na přetahování bloků s instrukcemi od MIT, tak tomu věnujte chvíli a vyzkoušejte Scratch osobně (www.scratch.mit.edu).

Zaměření na Scratch umožnilo našim studentům skvěle ovládnout kódování postavené na událostech. Někteří studenti měli ale stále pocit, že to „kódování“ nebo programování znamená, že jejich zbrusu nové instrukce existují pouze na obrazovce počítače. Díky mBotovi studenti objevili, že kódováním mohou fyzicky ovládat a řídit okolní svět a to je úžasné. Sice nás může znepokojovat představa malé armády třídních robůtků, která nám ze stolu odnáší ranní kávu, je ale důležité si uvědomit, že z našich studentů mohou být technici těch nejmodernějších robotických platforem.

​Bylo by jednoduché zařadit takto roztomilou platformu do kategorie hraček a dál se tím nezabývat. MBoti mají ale na víc. Tyto modré potvůrky totiž mají schopnosti dramaticky inovovat dosavadní učební osnovy!

Příklad programovacích bloků pro Scratch a mBlock

Vazby mBota na učební osnovy

Víme, že existuje mnoho inovativních aplikací, které by vyhovovaly výuce ve třídě. Vazeb na učební osnovy je prostě až příliš mnoho, abychom je všechny vyjmenovali. Zmíníme alespoň ty, které se zdají lákavější než ostatní. Mnoho cenných aktivit a vazeb na učební osnovy se objevuje spontánně během samotné práce studentů s mBoty. Co se týče hodnocení a důkazů, které jsme posbírali z různých rozhovorů se studenty, překvapila by vás propracovanost jazyka, jaký žáci používají, aby se pochlubili kódem co napsali pro své malé mBoty.

Než začneme mluvit o konkrétních výsledcích, zde jsou některé obecné oblasti pojící se s programováním, které jsme vypozorovali:

Hudba: Věřili byste, že mBoti dokáží zahrát osmibitové tóny jednotlivě i v akordu? V rámci softwaru mBlock mohou studenti naprogramovat své mBoty, aby zahráli jejich vlastní ztvárnění osminotových melodií, jako je například „row-row-row your boat“, nebo „Old MacDonald“. Pokud vydržíte poslouchat pronikavý zvuk repráčků, možná pak studenty stejně raději vyzvete, aby pro svého robota vymysleli a napsali vlastní originální melodii.

Jazykové dovednosti: Objevuje se spousta článků, které zmiňují pozitivní vliv výuky kódování na jazykové dovednosti studentů, včetně mluvení, čtení a poslechu. Pozorovali jsme to například, když studenti začali používat podmínkové příkazy typu „if/then“, „and/or“, anebo složitější „if/then/else“. Metakognitivní vzorce myšlení, o kterých mluvíme, když chceme studenty přimět „přemýšlet o myšlení“ se náhle stanou nezbytnými, aby mohli studenti správně překládat své myšlenky do specifických instrukcí pro jejich poloautonomní roboty.

Vědy: Nebudeme tu zmiňovat všechna využití pokročilé fyziky, protože je jich příliš mnoho. Možná by nás ale nenapadlo, že mBoti nabízejí něco jako analogii biologie. Jedním z prvních postřehů, které u studentů slyšíme, když začnou používat mBoty je: „Hele, to vypadá, jako by ti roboti měli oči.“ Samozřejmě, že mají na mysli ultrazvukový snímač vzdálenosti. Jedno z „očí“ vyšle vlnu na vysoké frekvenci, která se odrazí od protilehlého povrchu a vrátí se zpět do vedlejšího přijímacího „oka“. Často krátce po zahájení tohoto objevování a během výkladu o senzorech (což je biologicky relevantní) slyšíme nadšené zvolání studentů: „To je přece echolokace!“ Na toto nezbývá než se pořádně a doširoka usmát.

Matematika: A teď vážně. Když jsou mBoti tak levní, obětujeme některé funkce a prvky složitějších robotických platforem. Díky tomuto obětování se ale v procesu objeví skutečné matematické výpočty. Například: motory, které pohání kolečka mBotů nemohou být naprogramovány na určitý počet otáček nebo stupňů. Proto se musí studenti spoléhat na jedinou zde možnou proměnlivou hodnotu: čas. Studenti si často brzy uvědomí, že k tomu, aby jejich mBot zatočil na dráze o určitý úhel, musejí naprogramovat rychlost každého kolečko zvlášť. Díky zpětné vazbě v reálném čase za pomoci ultrazvukového snímače studenti ve skutečnosti procvičují jeden z nejsložitějších matematických problémů.

Jak začít s robotem mBot?

Následující instrukce jsou krok-za-krokem adaptovány na operační systém Windows 10. MBoti byli ale navrženi tak, aby fungovali i s jinými verzemi Windows a Mac OS X. Pokud se chcete připojit za pomoci iOS, srolujte níže. Software mBlock je k dispozici také jako aplikace pro mobil nebo tablet.

Software a aplikace mBlock je ke stažení zdarma zde:

Odkaz pro stažení prostředí mBlock

Stáhněte si verzi softwaru mBlock vhodnou pro váš operační systém a mBlock nainstalujte do vašeho počítače.

Instalace ovladače pro mBot

Pro správnou funkci komunikace s robotem mBot je potřeba nainstalovat do počítače příslušný ovladač. Je to vlastně USB driver pro komunikaci počítače s Arduinem uvnitř robota. Díky tomu budou moci studenti použít USB port, aby do svých mBotů nahráli své programy, aniž by se museli spoléhat na připojení Bluetooth.

Instalace ovladače pro mBot (Arduino)

Pro instalaci driveru spusťte nově nainstalovanou verzi mBlocku a klikněte na Připojení –> Instalace ovladače pro Arduino. Pokud narazíte na problém, další pokyny najdete zde.

Jak připojit mBota k počítači (verze Bluetooth)

Pro toto připojení je potřeba mít v počítači hardware pro Bluetooth komunikaci. Naprostá většina dnešních notebooků je vybavena Bluetooth. Pro počítače typu desktop je možné zakoupit Bluetooth modul do USB portu. Výhodou mBota s Bluetooth je hlavně to, že se dá připojit k mobilnímu telefonu nebo tabletu a pak je možné na hraní a programování využívat obyčejný mobil. V mBot aplikaci můžete ovládat robota například jen nakláněním mobilu.

1. Spusťte mBlock a klikněte na Připojení –> Bluetooth –> Objevit.

Připojování mBot přes Bluetooth

2. Po prvním pokusu připojit se k mBotovi je možné, že Windows 10 zobrazí vyskakovací okna. Jednoduše klikněte na YES a spustí se párování.

mBot Bluetooth párování

3. Pokud máte více než jednoho mBota s připojením přes Bluetooth, potom je třeba správně vybrat identifikační číslo ID. Bluetooth modul každého mBota má unikátní identifikační číslo. Toto číslo je možné najít na spodní straně Bluetooth modulu, nebo v nastavení Bluetooth na vašem počítači. Jakmile identifikujete příslušného mBota, doporučujeme ho pro další práci označit.

4. Po tom, co jste zvolili příslušné připojení Bluetooth k vašemu mBotovi, můžete spojení ověřit buď kliknutím na Připojení –> Bluetooth –> a objeví se značka hned vedle správného ID, nebo klikněte na zelenou kategorii Roboti, kde uvidíte zelenou tečku (ne červenou), která potvrzuje připojení mBota. Pokud je robot připojen přes Bluetooth, LED na Bluetooth modulu svítí trvale modře. Při neaktivním spojení LED pomalu bliká.

Připojení mBota přes Bluetooth

mBota můžeme připojit také k aplikacím pro mobil nebo tablet, ale to vydá na samostatný článek.

Jak připojit mBota k počítači (verze 2,4 GHz)

Tato část platí pro robota mBot ve verzi 2,4 GHz. Tohle je model mBota s bílým USB komunikačním modulem. Bezdrátové spojení funguje podobně jako například komunikace s bezdrátovou myší.

1. Před pokusem o spojení vypněte mBota a odpojte USB modul.
2. Zapněte mBota.
3. Stiskněte tlačítko na modulu 2,4 GHz. Blikání LED na desce modulu se zrychlí.
4. Připojte do počítače USB dongle. LED by měla přestat blikat a svítí trvale.
5. Spusťte mBlock a vyberte možnost Připojení –> 2.4 G –> Připojení. Pokud vznikne úspěšné spojení, v kategorii roboti se objeví zelená tečka.

Připojení mBot 2,4 GHz

* Poznámka: USB moduly nejsou mBotům pevně přiřazeny. Může být ale jednodušší označit po propojení USB modul a příslušného mBota. Pokud se vám pomíchají USB moduly a mBoti, zopakujte proces konfigurace výše.

Jak napsat kód pro mBota

Rádi uvidíme, na co všechno při programování mBotů přijdou vaši studenti. Následující příklady slouží jen jako inspirace na úvod.

Příklad základního programování: Podívejte se na umístění bloků na obrázku a vytvořte program, který umožní ovládat vašeho mBota z klávesnice počítače. Je velmi důležité použít funkci „po stisku klávesy“ a také „po uvolnění klávesy“, jinak se může stát, že váš mBot narazí do zdi (což nemusí být to nejhorší, co se může stát…).

Základní programování mBot

Tento základní prográmek vám a vašim studentům nejspíš nevydrží dlouho. Jistě, je zábavné použít ho a zahrát si s vašimi mBoty kopanou, nebo seznámit vašeho mBota s jiným v sousední třídě. Určitě by bylo mnohem lepší, kdyby váš program obsahoval také nějaké podmínkové příkazy. Ve dvou příkladech níže se vaši studenti dozvědí o větvení (postupný seznam akcí) a smyčkách (kolikrát se nějaká akce uskuteční).

Pokročilejší cíl pro robota: mBot se rozjede vpřed a následně zastaví v určité vzdálenosti od překážky. Když je překážka odstraněna, mBot pokračuje ve své jízdě vpřed. Jak to udělat?

1. V programu mBlock se připojte ke svému mBotovi.
2. Klikněte na kategorii „Data a Bloky“
3. Klikněte na „Vytvoř proměnnou“
4. Pojmenujte proměnnou „Vzdálenost“ s volbou pro všechny postavy. Klikněte na OK.
5. Nyní vytvořte blok kódu a začněte příkazem „po kliknutí na vlajku“
6. Přetáhněte a vyplňte odpovídající bloky, jak je ukázáno na obrázku níže.

mBot práce s překážkou 1

Je důležité zmínit, že ultrazvukový snímač vzdálenosti používá jako jednotku centimetry. Vyzkoušejte, co bude mBot dělat po spuštění vašeho kódu. Díky použití podmínkového příkazu „když/tak“ by měl robot jet vpřed, dokud není 10 cm (nebo méně) od překážky. Bohužel s tímto kódem robot nebude pokračovat v jízdě, když mu překážku odstraníme. Hmm… co použít důmyslnější kód se smyčkou?

7. Přetáhněte blok „opakuj dokud není“. Najdete ho v sekci „Ovládání“
8. Přetáhněte blok „klávesa stisknuta“, který najdete v kategorii „Vnímání“, do podmínkového bloku „opakuj dokud není“.
9. Váš program by měl vypadat jako na obrázku níže

mBot práce s překážkou 2

Pokud jste vše zadali správně, váš robot by měl nyní po odstranění překážky pokračovat v jízdě vpřed. Po stisknutí mezerníku by měl zastavit úplně. Tak co, komu to funguje? Pokud jste vše zvládli, tak se vám podařil první nejdůležitější krok na cestě zkrocení vašeho mBota :).

Příště se podíváme na to, jak zkrotit mBota tak, aby poslouchal při zdolávání jízdy po čáře a ukážeme si ještě další příklady.

S laskavým souhlasem autorů přeloženo z https://www.brilliantlabs.ca/mbot-intro a upraveno. Článek mě zaujal tím, jak se opírá o praktické zkušenosti přímo z výuky a tak jsem ho přinesl i tady na Arduino.cz. Jo a taky mám ty „modrý potvůrky“ rád :).

Minule jsme si v seriálu článků o desce TinyLab ukázali, jak se dají využít na ní přítomná tlačítka. Dnes si řekneme, co je to relé, jak se ovládá a k čemu ho můžeme využít.

Relé

Relé je součástka, která se používá k oddělení dvou obvodů tak, abychom mohli jedním obvodem spínat druhý. Jsou různé druhy relé. Asi nejčastěji se používají elektromagnetická relé, dále existují i SS relé, která jsou založená na polovodičích. My si dnes popíšeme relé elekromechanické.

Řídicí obvod přitom může pracovat na nám známých pěti voltech. Řízeným obvodem naopak mohou téci velké proudy a může mít velké napětí – například střídavých 230V, které máme v naší elektrické síti.

Pozor: Pomocí relé jde sice spínat 230V, ale toto napětí může při průchodu lidským tělem být i život ohrožující. Vyvarujte se proto prosím práci s napětím větším, než 24V (popřípadě 12V u střídavého), pokud přesně nevíte, co děláte.

Napětí/proudy řídicího a řízeného obvodu většinou najdeme na pouzdru součástky. Níže vidíte relé, které najdeme na desce TinyLab a jeho parametry.

Relé na desce TinyLab

Z potisku obalu jsme se tedy dozvěděli, že relé na desce je schopné spínat:

• střídavý proud 7A, 240V
• střídavý proud 10A, 125V
• stejnosměrný proud 10A, 28V

Spínaný obvod pracuje na 5V a je stejnosměrný.

Jak relé funguje

Elektromechanické relé pracuje na jednoduchém principu. V řídicím obvodu najdeme elektromagnet, který svým polem přitahuje takzvanou kotvu. To je pohyblivý plíšek, který spíná a rozpíná řízený obvod. Na obrázku níže je symbolicky znázorněná vnitřní struktura relé.

Relé – zdroj: http://www.glolab.com/relays/NC%20RELAY.jpg

Když k pinům COIL TERMINALS relé z obrázku připojíme napájení, přitáhne elektromagnet pohyblivou kotvu (ARMATURE). Řízený obvod může být přopojený přes piny COMMON TERMINAL a NORMALLY OPEN terminal. Takový obvod je sepnutý v případě, když cívkou protéká proud. Pokud bychom místo NORMALLY OPEN TERMINAL  použili pin NORMALLY CLOSED TERMINAL, dojde aktivací elektromagnetu k rozepnutí obvodu.

Elektromagnetických relé existují různé typy, které dělíme podle toho, jak jsou uvnitř uspořádaná, kolik vývodů mají a kolik oddělených obvodů mohou nejednou spínat. Více informací najdete na Wikipedii. Na TinyLab najdeme relé, které odpovídá tomu na obrázku výše – má jeden „vstupní“ pin, které je možné pomocí aktivace relé připojovat ke dvěma výstupním pinům

Připojení k Arduinu

Takový elektromagnet se nezdá, ale k jeho sepnutí mohou být potřeba značné proudy, které mohou poškodit pin. Proto relé nikdy nepřipojujeme k Arduinu přímo, ale využijeme nějakou součástku, která je schopná spínat velké proudy. Může to být tranzistor, nebo jiná součáska (ULN2003). Další možností je využít připravený modul pro Arduino, ke kterému stačí připojit +5V, GND a dalším pinem můžeme relé přímo spínat.

Na desce TinyLab naštěstí nemusíme nic řešit, protože vše máme připravené. Relé ovládáme pomocí pinu A4 (který používáme stejně, jako digitální). Zápis 1 na tento pin relé sepne, 0 ho rozepne.

Příklad

Představte si, že chcete pomocí relé spínat například obyčejný LED pásek, který většinou pracuje na 12V. Takové napětí Arduino dodat nezvládne, takže budeme muset použít nějakou vhodnou součástku – jednou z nich může být například relé. Na obrázku níže vidíme jedno z možných zapojení. Máme zde napájení, k jehož zemi je připojen minus pin LED pásku. Plus pin LED pásku je připojený k prostřednímu terminálu relé. Horní terminál je pak připojený na plusový pin napájení, kde je napětí 12V. K napájení slouží zdroj s nastavitelným napětím (polohu ovladače pro 12V jsem zjistil pomocí voltmetru). Můžete použít jakýkoliv jiný zdroj, který je dostačující k použitému pásku.

Použití relé

K ovládání využijeme tlačítka, která jsme si představili minule. Použijeme dvě tlačítka – jedno pro spínání, druhé pro vypínání LED pásku. Použijeme tlačítka připojená na piny 8 a 9. Relé je na TinyLabu připojené na pinu A4.

Musíme si dát pozor na dvě věci

• nesmíme zapomenout zapnout spínače u použitých pinů
• na TinyLabu jsou tlačítka 8 a 9 zapojená tak, že v nestisknutém stavu vrací funkce digitalRead(pin) hodnotu 1, při stisku 0. Hodnotu z digitalRead tedy znegujeme.

Kód bude tedy vypadat následovně:

byte tl_zap = 8;
byte tl_vyp = 9;
byte rele = A4;

void setup() {
  pinMode(tl_vyp, INPUT);
  pinMode(tl_zap, INPUT);
  pinMode(rele, OUTPUT);

  Serial.begin(115200);
  while(Serial);
}

void loop() {
  byte st_tl_vyp = digitalRead(tl_vyp);
  byte st_tl_zap = digitalRead(tl_zap);
  
  
  if(!st_tl_vyp) {
    digitalWrite(rele, LOW);
  }
  else if(!st_tl_zap) {
    digitalWrite(rele, HIGH);
  }
}

To je pro dnešek vše. Další komponentu z desky TinyLab si představíme příště.

Tento článek vychází z poslední kapitoly knihy Průvodce světem Arduina. Ta popisuje ovládání modulu ESP8266 pomocí desky Arduino Mega. My se dnes podíváme, jak ESP8266 používat s deskou TinyLab. Jen pozor. Dnes bude článek pro trochu pokročilejší čtenáře. Pokud si nejste s programováním zatím jistí, nechte ho na později

Už je to pár let, co byl představen WiFi modul ESP8266. Jeho původní určení bylo rozšíření možností procesorů o WiFi komunikaci. Takových modulů je ale spousta. Zajímavé na tomto modulu je to, že je možné jej přímo programovat. Díky tomu, a také jeho nízké ceně, se stal mezi bastlíři a kutily velice oblíbený.

Když nám přijde tento modul od výrobce, měl by v sobě mít nahraný program, se kterým si dnes vystačíme. Tento program poslouchá po sériové lince speciální příkazy – takzvané AT příkazy. Ty umožňují základní operace s modulem. Dnes se tedy nebudeme zabývat přímo programováním ESP8266 (o tom zase jindy), ale ukážeme si, jak se dá modul ovládat pomocí AT příkazů.

Rodina modulů ESP8266

ESP8266

Můžeme se setkat s více verzemi modulů ESP8266 různých tvarů a velikostí, na všech však nalezneme čip ESP8266EX. Jednotlivé verze se od sebe liší například tím, jestli je elektronika na desce stíněná či nikoliv, nebo také počtem pinů. My použijeme asi nejrozšířenější verzi ESP8266-1. Ta nám, stejně jako ostatní modely, nabídne připojení WiFi 802.11 b/g/n, integrovaný TCP/IP stack (obsluha síťové komunikace) a mnohé další.

ESP8266 verze 1

Tento modul vezmeme a zapojíme do konektoru označeného ESP8266 v horní pravé části desky TinyLab.

Ovládání modulu

Jak už jsem zmínil dříve, ovládání modulu probíhá pomocí AT příkazů. Přehled dostupných příkazů naleznete zde, popřípadě i s vysvětlením zde. My si ty důležitější představíme dále. Na začátek musíme ověřit funkčnost modulu. ESP8266 komunikuje po sériové lince a je propojen s Arduinem na TinyLabu. Z desek, jako je Arduino UNO, jsme zvyklí pouze na jednu sériovou linku. Ale protože máme na TinyLab desku Arduino Leonardo, máme k dispozici dvě sériové linky – Serial, která komunikuje s PC, a Serial1, která má fyzicky vyvedené RX a TX piny na digitálních pinech 0 a 1. Serial1 také využijeme pro komunikaci s modulem.

Nejjednodušším příkladem AT příkazu je příkaz „AT“ doprovázený znaky CR (cariage return – pozůstatek z doby psacích strojů a jehličkových tiskáren, symbolizuje návrat tiskací hlavy na začátek řádku) a LF (line feed – nový řádek). V programu ale nemůžeme napsat „CR“, popřípadě „LF“, protože by je program považoval za řetězec se dvěma znaky. Existuje vícero způsobů, jak tyto znaky napsat – jedním z nich jsou takzvané escape sekvence (CR = „\r“, LF = „\n“), druhým například přímé použití jejich číselné hodnoty z ASCII tabulky (CR = 13, LF = 10). Další možností je použít funkci Serial.println(„…“), která znaky CR a LF odešle za nás na konci řetězce v uvozovkách. Ne vždy se nám ale toto chování hodí.

//ekvivalentní jsou tedy zápisy:
Serial.print("AT\r\n");

Serial.print("AT");
Serial.print("\r");
Serial.print("\n");

Serial.println("AT");

Serial.print("AT");
Serial.write(13);
Serial.write(10);

Pro účely zkoušení si napíšeme program, který bude pouze přeposílat znaky mezi Serial a Serial1 (tedy mezi PC a modulem). Poté budeme pomocí monitoru sériové linky posílat modulu AT příkazy, abychom si je vyzkoušeli.

void setup(){
    Serial.begin(9600);
    Serial1.begin(115200); //9600, 57600, 115200
}

void loop(){
    while(Serial.available()){
        Serial1.write(Serial.read());    
    }

    while(Serial1.available()){
        Serial.write(Serial1.read());    
    }
}

Poznámka: Modul ESP8266 může komunikovat na různých rychlostech, které se liší podle verze programu (firmware), který je v nich nahraný. Moduly dodávané s TinyLab by měly komunikovat na rychlosti 115200. Pokud ale modul koupíte samostatně, může se stát, že nebude komunikovat. V tom případě zkuste zvolit jinou z uvedených rychlostí. 

Než zkusíme první příkaz, musíme sériovému monitoru říci, že chceme za každým odeslaným řetězcem odeslat i znaky CR a LF. Toto je možné nastavit hned vedle výběru rychlosti komunikace.

Nastavení monitoru sériové linky

Nyní už máme vše nastavené. Do textového pole monitoru zadáme příkaz AT a odešleme. Modul by měl odpovědět:

AT

OK

Tím máme jistotu, že modul funguje. To nám ale určitě stačit nebude. Budeme po modulu například chtít, aby se připojil k serveru a něco z něj stáhl. Předtím si ale musíme vysvětlit, na co jsou které AT příkazy.

AT příkazy pro ESP8266

Abychom se v příkazech neztratili, zavedeme si do nich trochu systém. Prvním způsobem dělení je rozdělení podle jejich funkčnosti a také způsobu zápisu:

Druhým způsobem dělení, který také dále budeme používat, je rozdělení do tří kategorií. První kategorii bychom mohli nazvat Základní. Nalezneme v ní ty příkazy, které se starají o samotný běh modulu. Další dvě kategorie můžeme nazvat WiFi příkazy (připojení k wifi…) a TCPIP příkazy (komunikace po síti).

Základní příkazy

WiFi příkazy

TCPIP příkazy

ESP8266 podporuje i vícenásobná připojení. Aktuální mód připojení se nastavuje pomocí AT+CIPMUX. Od jeho nastavení se odvíjí i použití některých příkazů z této skupiny.

Pokud jsou parametry příkazů textové řetězce, musíme je dát do uvozovek. AT příkazy se mohou mírně lišit mezi jednotlivými verzemi firmware.

Snad jsem vás neodradil dlouhým výčtem příkazů. Rozhodně není potřeba je umět nazpaměť, jen je dobré vědět, že něco takového existuje a kde najít další informace. Teď už ale k prvnímu příkladu.

Jednoduchá interakce se serverem

Připojíme se k serveru www.google.com (přímo na jeho IP adresu) a stáhneme pomocí HTTP požadavku jeho obsah jako HTML. Jelikož by se nám některé příkazy často opakovaly, jsou umístěné ve funkcích. Jsou to funkce: resendData(), která jen přeposílá data mezi Serial a Serial1. Pokud si nepamatujete, jak funguje HTTP, podívejte se do článku o Ethernet shieldu, popřípadě Programování webových rozhraní pro Arduino.

boolean resendData(){
    while(Serial.available()){
        Serial1.write(Serial.read());    
    }

    while(Serial1.available()){
        Serial.write(Serial1.read());  
    }    
}

Dále funkce waitFor(), který čeká na zadaný řetězec. Pokud je nalezen, vrátí true, pokud je po určitou dobu nenalezen, vrátí false. Všimněte si funkce Serial1.find(), která čte buffer sériové linky dokud nenarazí na zadaný řetězec, nebo nevyprší čas zadaný funkcí Serial1.setTimeout().

boolean waitFor(char *s, long waitingTime){
    Serial1.setTimeout(waitingTime);
    return Serial1.find(s);
}

A poslední vytvořenou funkcí je command(). Ta odešle zadaný AT příkaz, vypíše přes sériovou linku, co se děje, a čeká na výsledek. Pokud se příkaz povedl, vrátí true. Jinak vrátí false.

boolean command(String cmd, String comment, String success, String unsuccess, char *waitForString, long waitingTime){
    Serial.println();
    Serial.println(comment);
    Serial.println("] " + cmd);
    Serial1.println(cmd);
    boolean result = waitFor(waitForString, waitingTime);
    if(result){
        Serial.println("[ " + success);
    }
    else{
        Serial.println("[ " + unsuccess);    
    }
    resendData();

    return result;
}

Celý program, který stáhne zdrojový kód úvodní stránky google.com, tedy vypadá takto. Jelikož musíme občas poslat po sériové lince znak uvozovek, použijeme escape sekvenci pro uvozovky: \“.

char ssid[] = "ssid"; //SSID wifi sítě
char pwd[] = "pass"; //heslo sítě
char ip[] = "216.58.194.78"; //IP adresa www.google.com

String cmd; //řetězec pro ukládání a skládání příkazů 
String http;

void setup(){
  Serial.begin(9600);
  Serial1.begin(115200); //9600, 57600, 115200

  while(!Serial1);
  while(!Serial);

  cmd = "AT";
  command(cmd, "Zkousim pritomnost modulu", "Modul komunikuje", "Modul nekomunikuje", "OK", 3000);

  cmd = "AT+RST";
  command(cmd, "Restartuji modul", "Modul restartovan", "Modul se nepovedlo restartovat", "ready", 5000);

  cmd = "AT+CWMODE=1";
  command(cmd, "Nastavuji klient mod", "Nastaveno", "Nepovedlo se nastavit", "OK", 2000);

  cmd = "AT+CWDHCP=1,1";
  command(cmd, "Zapínám DHCP", "Zapnuto", "Nepovedlo se Zapnout", "OK", 2000);
  

  cmd = "AT+CWJAP=\"";
  cmd += ssid;
  cmd += "\",\"";
  cmd += pwd;
  cmd += "\"";
  command(cmd, "Pripojuji k WiFi", "Pripojeno", "Nelze se pripojit", "OK", 10000);
  
  cmd = "AT+CIPMUX=0";
  command(cmd, "Nastavuji jednoduche pripojeni", "Nastaveno", "Nepovedlo se nastavit", "OK", 1000);

  cmd = "AT+CIPSTART=\"TCP\",\"";
  cmd += ip;
  cmd += "\",80";
  command(cmd, "Pripojuji k zadane IP", "Pripojeno", "Nepovedlo se pripojit", "OK", 5000);
  waitFor("Linked", 1000);

  http = "GET / HTTP/1.1\r\n\r\n";
  cmd = "AT+CIPSEND=";
  cmd += http.length();
  if(command(cmd, "Posilam HTTP request", "Odeslano", "Cas spojeni vyprsel", ">", 5000)){
    Serial1.print(http); 
    Serial.println(">");
  }
  else{
    cmd = "AT+CIPCLOSE";
    command(cmd, "Ukoncuji", "Ukonceno", "", "OK", 2000);
  }
}

void loop(){
  resendData();
}

boolean command(String cmd, String comment, String success, String unsuccess, char *waitForString, long waitingTime){
  Serial.println();
  Serial.println(comment);
  Serial.println("] <" + cmd + ">");
  Serial1.println(cmd);
  boolean result = waitFor(waitForString, waitingTime);
  if(result){
    Serial.println("[ " + success);
  }
  else{
    Serial.println("[ " + unsuccess); 
  }
  resendData();
  
  return result;
}

boolean waitFor(char *s, long waitingTime){
  Serial1.setTimeout(waitingTime);
  return Serial1.find(s);
}

boolean resendData(){
  while(Serial.available()){
    Serial1.write(Serial.read()); 
  }

  while(Serial1.available()){
    Serial.write(Serial1.read());
  }  
}

Pokud vše proběhne v pořádku, vypíše se nám po sériové lince úvodní stránka google ve formátu HTML včetně HTTP hlavičky. Vrácená data můžeme načítat a dále s nimi pracovat. Pokud nějakému příkazu nerozumíte, nejjednodušší způsob, jak vyzkoušet jeho funkčnost je ho odeslat přes monitor sériové linky. Co když chceme, aby na modulu běžel jednoduchý server?

Vytváříme server

K vytvoření serveru použijeme funkce, které jsme si ukázali v předchozím příkladu. Začneme spuštěním přístupového bodu ESP-WIFI s heslem 12345678. Na něm poběží server, který bude čekat na HTTP request „GET /promenna HTTP/1.1“. Jeho úkolem bude načíst číslo zapsané za lomítkem na místě promenna. ESP8266 má přidělenou IP adresu 192.168.4.1. Na server odešleme tento request tak, že se připojíme na vytvořenou wifi a do adresního řádku prohlížeče zadáme ip/promenna – tedy například 192.164.4.1/5.

Už jsme si řekli, že když modulu přijdou nějaká data, vrátí nám je ve tvaru: „+IPD,id,delka:data“. Data tvoří právě náš HTTP požadavek – například GET /5 HTTP/1.1 (odpovídá zadání 192.164.4.1/5 do adresní řádky prohlížeče). Celá přijatá informace tedy bude vypadat takto: +IPD,id,delka:GET /promenna HTTP/1.1. Nám stačí přečíst třetí číslo po řetězci IPD, čímž získáme naši proměnnou.

String cmd; //řetězec pro ukládání a skládání příkazů
String http;

void setup() {
  Serial.begin(9600);
  Serial1.begin(115200); //9600, 57600, 115200

  while (!Serial);
  while (!Serial1);

  cmd = "AT";
  command(cmd, "Zkousim pritomnost modulu", "Modul komunikuje", "Modul nekomunikuje", "OK", 3000);

  cmd = "AT+RST";
  command(cmd, "Restartuji modul", "Modul restartovan", "Modul se nepovedlo restartovat", "ready", 5000);

  cmd = "AT+CIPSERVER=0";
  command(cmd, "Ukončuji server", "Ukončeno", "Nepovedlo se ukončit server", "OK", 2000);

  cmd = "AT+CWDHCP=0,1";
  command(cmd, "Zapínám DHCP", "Zapnuto", "Nepovedlo se Zapnout", "OK", 2000);

  cmd = "AT+RST";
  command(cmd, "Restartuji modul", "Modul restartovan", "Modul se nepovedlo restartovat", "ready", 5000);

  cmd = "AT+CIPMUX=1";
  command(cmd, "Nastavuji vicenasobne pripojeni", "Nastaveno", "Nepovedlo se nastavit", "OK", 1000);

  cmd = "AT+CWMODE=2";
  command(cmd, "Nastavuji AP mod", "Nastaveno", "Nepovedlo se nastavit", "OK", 2000);

  cmd = "AT+CWSAP=\"ESP-WIFI\",\"12345678\",11,2";
  command(cmd, "Vytvarim pristupovy bod", "Vytvoreno", "Nepovedlo se vytvorit pristupovy bod", "OK", 3000);

  cmd = "AT+CIPSERVER=1,80";
  command(cmd, "Vytvarim server", "Vytvoreno", "Nepovedlo se vytvorit server", "OK", 2000);
}

void loop() {
  if (waitFor("+IPD", 50)) { //hledej výskyt +IPD
    Serial1.parseInt(); //jedno číslo zahoď
    Serial1.parseInt(); //druhé číslo zahoď
    int p = Serial1.parseInt(); //přečti třetí číslo

    Serial.print("Nacetl jsem: ");
    Serial.println(p);

    Serial1.flush(); //zbytek zpravy me ted nezajima, zahod ho
  }
}

boolean command(String cmd, String comment, String success, String unsuccess, char *waitForString, long waitingTime) {
  Serial.println();
  Serial.println(comment);
  Serial.println("] " + cmd);
  Serial1.println(cmd);
  boolean result = waitFor(waitForString, waitingTime);
  if (result) {
    Serial.println("[ " + success);
  }
  else {
    Serial.println("[ " + unsuccess);
  }
  resendData();

  return result;
}

boolean waitFor(char *s, long waitingTime) {
  Serial1.setTimeout(waitingTime);
  return Serial1.find(s);
}

boolean resendData() {
  while (Serial.available()) {
    Serial1.write(Serial.read());
  }

  if (Serial1.available()) {
    while (Serial1.available()) {
      Serial.write(Serial1.read());
    }
  }
}

Po připojení k wifi a načtení adresy modulu by se měla zobrazit zpráva: „Nacetl jsem: x“. Hodnotu x můžeme dále využít – třeba k nastavování stavu LED diody. To už ale jistě zvládnete naprogramovat sami.

Odeslaná data nemusejí být nutně HTTP requesty. Může se jednat například o zprávy protokolu MQTT, který se v zařízeních připojených do internetu věcí používají častěji. MQTT je ale nad rámec této kapitoly a stejně tak přímé programování desky ESP8266.

S představenými příkazy a funkcemi je možné vytvořit jednoduchou stránku, například pro ovládání LED. Více o tvorbě stránek naleznete ve článku Programování webových rozhraní pro Arduino.

Náš čtenář, pan Marek Sukup, nám zaslal článek o jeho programátoru pro moduly ESP8266. Děkujeme.

Nejedná se o klasický Arduino projekt, ale o projekt pro „Arduino“ – resp. pro ESP8266 moduly.

Vzhledem k poměru ceny/výkonu ESP8266 a možnostem využití, je dobré mít možnost naprogramovat a ověřit funkci ještě před tím, než se modul napájí na adaptér, nebo klasické PCB. Připájet pár drátů, napojit je do breadboardu a po otestování je zase odpájet sice není nijak složité, ale časem to začne být otravné.

Požadavky

Určil jsem si hlavní požadavky:

• funkční pro ESP-01, ESP-07, ESP-12 a další které mají stejný layout
• snadné připojení modulu bez pájení
• možnost přepnutí do režimu programování / testování funkčnosti programu
• možnost připojit drátové propojky (připojení senzorů apod.)
• reset modulu
• obsažen převodník USB – serial
• možnost externího napájení

Hledal jsem na internetu, jestli se něco podobného prodává. Výsledek – moc podobných „programatorů/testerů“ se neprodává nebo jsou drahé. Nechal jsem se inspirovat tímto projektem a trochu jej upravil a vylepšil podle mých potřeb. 

Výsledkem je … :

Hotový programátor

Programování

Funkce je jednoduchá – ESP modul se položí na pogo-piny, které jsou odpružené (zdvih cca 2,5 mm) modul se přitlačí a zajistí.  Kontakt je naprosto dostatečný. Posuvným přepínačem se nastaví mod programování (GPIO 0  se připojí na GND) nebo testování (GPIO 0 se odpojí od GND). Režim programování je signalizován SMD LEDkou, která svítí u přepínače. Tuto signalizaci jsem doplnil dodatečně, protože přepínač je malý a přes plexi není na první pohled vidět v jaké je poloze.

LED indikátor módu (programování / běh)

Tlačítko slouží pro reset modulu. Přepínač i resetovací tlačítko jsou utopeny v plexi schválně, chtěl jsem se vyhnout náhodnému stlačení nebo přepnutí.

Piny jsou propojeny na klasickou female pinovou lištu, do které je možné zasouvat drátové propojky. Rozložení pinů je identické jako na ESP modulu. Tato lišta je propojena i na patici pro ESP-01 modul, pro tuto variantu jsou aktivní jen piny, které jsou na ESP-01 modulu.

Pro moduly ESP-01 které není možné připojit přes pogo-piny je určen „slot“ 2×4 – po zasunutí modulu je vše stejné jako pro modul umístěný na pinech.  V programátoru může být vždy jen jeden ESP modul – bud 01 nebo 07 (12…). 

Programování ESP-01

Programování pomocí pogo pinů

Připojení převodníku

USB – serial převodník se zasune do patice vyvedené na boku, patice je pro 6pin variantu, ale je celkem jedno jestli se použije jiná verze. Při použití jiné verze je logicky potřeba zachovat rozložení pinů – pokud je jiné tak převodník připojit přes dráty. Původně jsem měl v úmyslu převodník vestavět dovnitř a nechat trčet jen USB konektor, ale z důvodů velikosti a univerzálnosti jsem se rozhodl pro řešení „externího“ převodníku.

Připojení USB-Serial převodníku

Připojení USB-Serial převodníku

Napájení

Napájení je možné bud přímo přes převodník nebo pomocí 3V3 stabilizátoru (AMS1117), který snese až 800mA. Při připojení pár senzorů a při připojování do wi-fi může vyskočit odběr dost vysoko, takže je lepší mít připojeno externí napájení. Stabilizátor jsem doplnil dodatečně, původní plán byl vytáhnout pouze dráty a využívat stabilizované napájení, tento plán vzal za své v okamžiku, kdy jsem byl líný připojit napájení na kvalitní stabilizátor a připojil jsem napájení do breadboardu. Mám tam levný modul se stabilizátorem, který se zasune přímo do breadboardu. Problém je, že bez zátěže dává skoro 5V… odběr samotného ESP modulu je tak malý že nestačí na to, aby se srazilo napětí na 3,3V a ESP modul šel do kytek. Teď to sice nevypadá moc esteticky, ale je to na jistotu.

Mechanická konstrukce

Konstrukce je z 3mm plexi které je sešroubováno M3 šroubky. Konstrukce je možná zbytečně masivní, ale jednak mám raději, když je něco předimenzováno, než když se to bortí a taky rozdíl v ceně 2 nebo 3mm plexi je zanedbatelný. Plexi je nařezáno laserem. 3D modely a DXF kontury pro laser jsou ke stažení. Piny jsou drženy v dvou kusech plexi, pro uložení by stačil jen horní díl krabičky, ale díry mají určitou vůli a chtěl jsem mít jistotu, že budou stát vždy kolmo, taky se to líp pájelo. Piny jsem pájel zespodu, rozteč pinů je jen 2mm a průměr je 1,02mm takže moc místa na drát mezi piny nezůstane, proto jsem drát pájel zespodu pinu. Piny jsem ještě podložil 1mm plexi aby se zvýšil přítlak.

Pro případně zájemce o stavbu bych ještě dodal cenu plexi – cca 350Kč (materiál + řezání).

Plexi

Plexi

V DXF jsou dvě části plexi které drží ESP modul na pinech – nebyl jsem si jistý životností, tak jsem si nechal říznout dva kousky. Celá sestava ve 3D je ke stažení. Chybí tam odpory, LEDka a stabilizátor. Pro mechanickou konstrukci nejsou součástky podstatné a stabilizátor jsem dodělával dodatečně…

Připojení modulů

Pogo-Piny na které se přitlačí ESP modul jsou typu P75-E2, původně jsem použil typ P75-B1 a později je vyměnil. Původní B1 jsou hladké, E2 jsou na konci rozšířené. Rozhodně doporučuji typ E2. Výměnu jsem udělal kvůli tomu, že průměr hrotu u typu B1 je 0,74mm některé ESP moduly mají otvory tak akorát, že do nich hrot zajede. Kontakt je sice pořád vodivý, ale přítlak je nerovnoměrný. Nechtěl jsem riskovat, že se jednou otvory zvětší a kontakty nebudou spolehlivé. Průměr hrotu u E2 je 1,3mm a to je na jistotu. Pokud byste použili můj DXF soubor pro pálení plexi tak otvory pro piny jsou průměru 1,02mm (+ polovina síly paprsku – laser jede středem paprsku po křivce) takže výsledný otvor je asi 1,15mm takže se trochu komplikuje montáž – první se musí nastrkat všechny piny do obou plexi dílů a pak teprve pájet, hlava pinu E2 otvorem neprojde.

Pogo piny

Připájení pogo pinů

Spojení s modulem ESP

Přikládám ještě jednoduchý obrázek se zapojením drátů (schéma na tak jednoduchou věc snad není potřeba).

Nákres zapojení

Závěr

Nedostatky o kterých vím – motivace na vylepšení další verze:

• není možné využít piny na krátké straně ESP-12E,F modulů
• není určené pro jiný typ layoutu než 01, 07, 12 – to je mi jedno jiné nepoužívám
• spatně pájené piny na dráty – pokud bych to stavěl znovu tak si udělám PCB s ploškami, na které piny postavím a připájím.  Piny nejsou ve stejné výšce, tipl bych rozptyl tak 1mm, naštěstí zdvih pružinek je 2,5mm tak to není problém
• zmatek v propojovacích drátech. Souvisí to s předchozí odrážkou – příště bych to celé postavil na jednom PCB a nahradil dráty za vodivé dráhy… Kromě toho, že by to líp vypadalo, mnohem líp by se to celé vyrábělo
• dodatečně vložený stabilizátor nevypadá moc esteticky a kabely také nejsou nic moc

Konstrukce určitě není ideální a bez chyb, ale je funkční. V průběhu stavby jsem přišel na pár vylepšení, ale nic nebylo tak zásadní, abych to celé předělal.

Seznam komponent

• Pogo piny: P75-E2, P75-B1
• USB – Serial převodník
• Tlačítko
• Přepínač
• Female lišta
• 3V3 stabilizator

Materiály

• ESP-programátor

Děkujeme za článek. Máte i vy projekt, se kterým se chcete pochlubit? Dejte nám vědět!

V dnešním dílu seriálu článků o desce TinyLab se podíváme, jak se dá ovládat sedmisegmentový displej, který je na ní připojený. Na začátku si projdeme trochu teorii k sedmisegmentovým displejům a poté si ukážeme ovládání. Pokud chcete teorii přeskočit, jděte rovnou na část „Jak se to ovládá?“.

Sedmisegmentový displej

Sedmisegmentovka není nic jiného, než 7 ledek zatavených do jednoho pouzdra, které jsou poskládané do podoby znaku. Jednotlivým částem, které znak tvoří a které můžeme nezávisle rozsvěcovat, říkáme segmenty. Některé displeje mají navíc ještě jednu LED pro desetinnou tečku.

Sedmisegmentový displej s desetinnou tečkou (zdroj: https://en.wikipedia.org/wiki/File:Seven_segment_02_Pengo.jpg)

Vnitřní zapojení LED v displeji je většinou takové, že ledky sdílejí jednu z nožiček (pinů). Pokud je to ta, ke které připojujeme kladné napětí, jedná se o displeje se společnou anodou. Pokud spojíme ty, které připojujeme k zemi, získáme displej se společnou katodou. Zapojení se může lišit podle typu displeje i výrobce. Na obrázku níže vidíme jedno z možných zapojení LED v displeji. Jedná se o displej se společnou anodou.

Vnitřní zapojení sedmisegmentového displeje (zdroj: https://www.gme.cz/data/attachments/dsh.512-009.1.pdf)

Kdybychom chtěli na displeji z tohoto obrázku rozsvítit číslici nula, připojili bychom piny 3 a 8 (nebo alespoň jeden z nich) přes rezistor k 5V a piny 9, 7, 6, 4, 2, 1 k zemi.

Více číslic

Když chceme mít více, než jednu číslici, můžeme sáhnout po displeji, který v sobě kombinuje více takovýchto jednočíslicových displejů.

Sedmisegmentový displej se čtyřmi číslicemi (zdroj: https://cz.mouser.com/ProductDetail/Vishay/TDCG1050M?qs=sGAEpiMZZMvkC18yXH9iIqyJsypj8o8kg44rnx4xTqQ%3d)

V rámci šetření pinů jsou v pouzdře opět některé piny spojené dohromady. V tomto případě spojujeme piny všech číslic, které ovládají jeden segment. Přináší to s sebou sice nutnost ovládat číslice postupně (vždy na jedné rozsvítíme požadovanou číslici, zhasneme, jdeme na další a když toto děláme dostatečně rychle, lidské oko si ničeho nevšimne), ale ušetří nám tento přístup spoustu pinů.

Vnitřní zapojení sedmisegmentového displeje se čtyřmi číslicemi (zdroj: https://cz.mouser.com/datasheet/2/427/tdcx10x0m-88849.pdf)

Na ovládání takového displeje tak potřebujeme 14 pinů, což může být pro některé aplikace pořád moc velké číslo.

Jde ušetřit ještě více pinů?

Ale jistě! Musíme ale přizvat na pomoc nějaký čip, ke kterému displej připojíme a on se nám postará o jeho řízení. Jemu pak posíláme pouze příkazy typu: „piny 1 až 13 připoj k 5V, pin 14 k zemi“, popřípadě u chytřejších čipů: „na druhé číslici zobraz jedničku“, „zhasni se“, atd. Jedním z čipů, který můžeme použít, je MAX7219, který najdeme i na desce TinyLab. K jeho ovládání nám stačí připojit tři vodiče (komunikuje přes sběrnici SPI, ale to není podstatné) a to už je pěkná úspora pinů oproti původním čtrnácti.

Jak se to ovládá?

Než začneme ovládat displej na TinyLabu, musíme zapnout potřebné přepínače. Jsou to ty u pinů 10, 11, 12. Také musíme přepnout trojici přepínačů pod sedmisegmentovým displejem do pozice „To Control 7-Segment“.

Poloha přepínačů pro ovládání sedmisegmentového displeje

Pro Arduino existuje knihovna LedControl, kterou už jsme si do Arduino IDE přidali v tomto článku. Nejjednodušší bude si ukázat její použití na příkladu, ve kterém bude TinyLab počítat od 0 do 9999.

#include "LedControl.h"

// na kterých pinech máme připojený čip MAX7219
// poslední jednička značí, máme připojený jeden čip
// čipy MAX7219 totiž můžeme řetězit za sebe a ovládat tak více displejů
LedControl lc = LedControl(10, 12, 11, 1); 

void setup() {
  // po zapnutí napájení je MAX v úsporném režimu
  // musíme ho nejdříve probudit
  // nula značí adresu zařízení
  lc.shutdown(0, false);

  // nastavíme jas displeje (možné hodnoty jsou 0 až 15)
  lc.setIntensity(0,8);
  
  // pro jistotu smažeme vše, co by bylo na displeji zobrazené
  lc.clearDisplay(0);
}

// vrátí číslici na dané pozici číslované zprava
byte digitOnPosition(int num, byte pos) {
  for(byte i = 0; i < pos; i++) {
    num /= 10;
  }

  return num % 10;
}

void loop() {
  for(int i = 0; i < 9999; i++) { // které číslo zobrazit
    for(int j = 0; j < 4; j++) { // na jaké pozici (0 je nejvíce vlevo)
      byte digit = digitOnPosition(i, j);

      // na zařízení s adresou 0 na znaku 3-j nastav číslici digit
      // false značí, že se nemá zobrazit desetinná tečka u této číslice
      lc.setDigit(0, 3 - j, digit, false); 
    }
    delay(10);
  }
}

Knihovna také umí zobrazit znaky, ale jenom ty, které jdou dobře zobrazit na displeji.

• 0 1 2 3 4 5 6 7 8 9
• A a -> A
• B b -> b
• C c -> c
• D d -> d
• E e -> E
• F f -> F
• H h -> H
• L l -> L
• P p -> P
• -
• . , -> rozsvítí desetinnou tečku
• _
• mezera

#include "LedControl.h"

LedControl lc = LedControl(10, 12, 11, 1); 

char chars[] = {'A', 'B', 'C', 'D', 'E', 'F', 'H', 'L', 'P', '-', '.', '_', ' '};

void setup() {
  lc.shutdown(0, false);
  lc.setIntensity(0,8);
  lc.clearDisplay(0);

}

void loop() {
  for(int i = 0; i <  13; i++) {
      lc.setChar(0, 0, chars[i], false);
      lc.setChar(0, 1, chars[i], false);
      lc.setChar(0, 2, chars[i], false);
      lc.setChar(0, 3, chars[i], false);
      
      delay(500);
  }  
}

Více informací k této knihovně najdete zde.

A to je pro dnešek vše. Máte nějaké dotazy? Zeptejte se v komentářích, nebo na našem fóru.