Ve druhém článku o displejích se dostaneme k LCD displejům. Popíšeme si znakové i grafické displeje a jak s nimi pracovat.

Úvod

Od jednodušších maticových displejů se dnes dostaneme ke (konstrukčně) složitějším displejům LCD. Ty v současné době nalezneme téměř všude. Stačí rozebrat například rozbitý fax a téměř jistě v něm nějaký nalezneme.

LCD displeje

Jak už jsem zmínil před chvílí, existuje celá řada LCD displejů. Všeobecně se užívají dva typy dělení. První z nich rozděluje LCD displeje do dvou skupin na znakové a grafické. Druhý z nich je dělí na barevné a monochromatické (jednobarevné). My si nyní jednotlivé skupiny představíme.

Znakové LCD

Tato skupina displejů je snazší na ovládání. Ovladač jim totiž zasílá pouze informace o tom, jaký znak mají kde zobrazit. Tyto znaky jsou předem definované – displej obsahuje základní „slovník“ znaků. Existuje celá řada velikostí displejů, které se však neudávají v počtech pixelů, ale v počtu řádků a míst pro znaky, kdy každé místo má na displeji přesně dané umístění. Můžeme se tedy běžně setkat s displeji 8×1 (jeden řádek s osmi znaky) až 40×4 (čtyři řádky po čtyřiceti znacích). Ovládání poté probíhá tak, že nastavíme kurzor na místo, na které chceme znak napsat a poté ho odešleme. Znakové displeje jsou většinou monochromatické. Můžeme se ale setkat s různými barvami podsvícení displeje.

LCD displeje

Pro lepší představu níže vidíme umístění míst pro znaky na displeji – každý obdélník odpovídá jednomu místu.

Maximální kontrast

Pro práci se znakovými LCD displeji je Arduino vybaveno knihovnou, která je zahrnutá již v základním balíku IDE. Ta umožňuje ovládání všech znakových displejů, které jsou kompatibilní s řadičem Hitachi HD44780, což většina současných displejů je. Tyto displeje mají většinou šestnáct pinů. V tomto příkladu budeme pracovat s tímto 20×4 LCD displejem. Pokud se podíváme na jeho zadní stranu, nalezneme zde piny popsané 1 a 16. Pojďme si je nyní představit.

Poznámka: Některé starší displeje nemusejí mít podsvícení – piny 15 a 16 u nich tedy nenajdeme.

Displej zapojíme podle schématu. Také můžeme přes 10 Ohm rezistor připojit napájení k podsvícení. Potenciometr zde slouží k nastavení kontrastu displeje. Rezistor i potenciometr jsou součástí naší sady.

Zapojení znakového LCD displeje

Znakový LCD

Jak už jsem řekl dříve, obsahuje Arduino IDE pro komunikaci se znakovými LCD knihovnu. Ta má pro ovládání displeje několik funkcí. Použití některých z nich si ukážeme na příkladu.

V prvním příkladu si vypíšeme na disleji počet vteřin od začátku běhu programu.

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //nastavení pinů

void setup() {
    lcd.begin(20, 4); //inicializace displeje
}

void loop() {
    if(millis() % 1000 == 0){
        lcd.clear();
        lcd.setCursor(9,1);
        lcd.print(millis()/1000);
    } 
}	

Nyní si ukážeme, jak se používá funkce .createChar(). Pod hodnotu 1 si vytvoříme znak dvou trojúhelníků. Námi definovaný znak se funkci předá jako jednorozměrné pole čísel (pro jednoduchou editaci v binární soustavě). V některých programovacích prostředích se pro zápis čísla ve dvojkové soustavě používá syntaxe 0b1111 (což odpovídá desítkové hodnotě 15). Arduino IDE však tento zápis neumožňuje. Pro pohodlnější práci s nižšími binárními čísly však v prostředí nalezneme několik předdefinovaných konstant začínajících velkým písmenem B. Konkrétně se jedná o rozsah hodnot od B0 (= 0) až B11111111 (= 255). Konstanta B00000010 tedy odpovídá hodnotě 2. Více o číselných soustavách si můžete přečíst na Wikipedii.

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

byte znak[8] = {B11111,
                B01010,
                B00100,
                B00000,
                B00000,
                B00100,
                B01010,
                B11111};

void setup() {
    lcd.createChar(1, znak);
    lcd.begin(20, 4);  
    lcd.write(1);
}

void loop() {}

Ve třetím příkladu se na displej vypíše text, který mu pošleme po sériové lince. K určení pozice na displeji slouží pomocná proměnná i. Pokud je celý displej zaplněn, smaže se a kurzor se vrátí do levého horního rohu.

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

int i = 0;

void setup() {
    Serial.begin(9600);
    lcd.begin(20,4);
}

void loop() {
    while(Serial.available() > 0){
        lcd.setCursor(i%20, (i-i%20)/20);
        lcd.write(Serial.read());
        i++;
        if(i == 80){
            i = 0;
            lcd.clear();
        }
    }
}

Poznámka: Existují i znakové displeje se sériovým řadičem. Jeden z nich naleznete například v našem setu. Těm se ale dnes nebudeme věnovat.

Grafické monochromatické LCD

Další skupinou displejů jsou grafické displeje, z nichž jednodušší jsou ty jednobarevné. My se jimi budeme zabývat pouze zběžně. Více se zdržíme až u barevných displejů. V tomto článku si ukážeme použití displeje ATM12864D (128 x 64 pixelů) s Arduinem Mega. Tento displej obsahuje řadič KS0107B, k jehož ovládání je pro Arduino napsaná knihovna (i pro typ A a C). Tu stáhneme z archivu knihovny. Dalším důležitým dokumentem je datasheet displeje, ve kterém najdeme funkce jednotlivých pinů. Posledním dokumentem, který budeme potřebovat je dokumentace knihovny.

Displej s Arduinem propojíme podle následující tabulky. Pro jiné typy desek je zapojení popsáno v dokumentaci knihovny na straně 2.

Piny 3, 18 a 19 nejsou připojeny k Arduinu. Zapojení pinů 3 a 18 s potenciometrem je naznačeno na následujícím obrázku. Pin 19 je připojen na +5V přes 220 ohm Rezistor.

Zapojení potenciometru

Všechny funkce jsou přehledně popsány v již zmíněné dokumentaci. My si ukážeme, jak jednoduše na displej vykreslit graf hodnot naměřených na pinu A0.

#include <glcd.h>

int data[128];

void setup(){
    GLCD.Init(); //inicializace displeje
}

void loop(){
    data[0] = map(analogRead(A0), 0, 1023, 0, 63);

    for(int i = 127; i > 0; i--){
        bod(i,data[i]);
        data[i] = data[i-1];
    }
    
    delay(40);
    
    GLCD.ClearScreen();
}

void bod(int x, int y){
    y = 63 - y; //převrácení os
    GLCD.SetDot(x,y, BLACK); //nastavení bodu
    GLCD.SetDot(x+1,y, BLACK);
    GLCD.SetDot(x+1,y-1, BLACK);
    GLCD.SetDot(x,y-1, BLACK);
}

Graf naměřených hodnot

Barevné grafické LCD

Nyní už se konečně dostáváme k barevným displejům. Představíme si dotykový displej s úhlopříčkou 2,8 palce a 320×240 pixely. Nebudeme se tedy zabývat pouze zobrazováním, ale i interakcí s dotykovou plochou. Ta nás bude zajímat jako první. Pro její funkci budeme potřebovat knihovnu Touch Screen Driver.

Arduino a TFT Shield

Vytvoříme si program, který nám odešle souřadnice právě zmáčknutého bodu. Na začátek programu vložíme kód, který za nás určí typ Arduina (v tomto případě Leonardo) a nastaví piny použité pro dotykovou vrstvu. Část kódu společně s vložením knihoven, vytvořením objektu displeje a kalibrací dotykové plochy vypadá následovně.

#include <stdint.h>
#include <SeeedTouchScreen.h> 

#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) // mega
#define YP A2 
#define XM A1 
#define YM 54 
#define XP 57 

#elif defined(__AVR_ATmega32U4__) //leonardo
#define YP A2 
#define XM A1
#define YM 18 
#define XP 21

#else
#define YP A2 
#define XM A1
#define YM 14 
#define XP 17 

#endif

TouchScreen ts = TouchScreen(XP, YP, XM, YM);

Funkcí definic se nemusíme zabývat. Hlavní je, že nám tato část kódu zajistí správný chod displeje. Dalším krokem je kalibrace dotykové plochy. Na displeji je použita rezistivní technologie dotykové membrány. Její princip by se dal zjednodušeně popsat tak, že tlak na pružnou membránu se projeví určitým elektrickým odporem měřeným na této membráně. V ideálním případě by se například při tlaku v bodě [10,20] naměřil odpor na membráně měřící odpor v ose x 10 ohm a u y 20 ohm. Naše plocha ale není takto ideální a musíme ji tedy nějakým způsobem zkalibrovat. Přibližné hodnoty maximální a minimální hodnoty odporu na osách vidíte v tabulce.

V další části tedy musíme do kódu zahrnout údaje pro kalibraci.

int min_x = 232;
int max_x = 1780;
int min_y = 166;
int max_y = 1826;

int x, y;

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

V dalším kroku vytvoříme objekt pro bod, se kterým budeme dále pracovat. Jak se zachází s objekty jsme si vyzkoušeli už při programování v Processing, takže to pro nás nebude žádné překvapení. Bod má tři vlastnosti: x, y odpovídající odporu na souřadnicích a z, která uchovává informaci o tlaku (s ní se dá poté do programu zakomponovat i citlivost dotyku). Pro získání souřadnic x a y musíme porovnat naměřené hodnoty s údaji pro kalibraci. Poté je už můžeme po sériové lince vypsat.

void loop(){
    Point p = ts.getPoint();
    
    x = map(p.x, min_x, max_x, 0, 239);
    y = map(p.y, min_y, max_y, 0, 319);
    
    if(p.z > 10){
        Serial.print(x);
        Serial.print(':');
        Serial.println(y);
    }
    
    delay(500);
}	

Poznámka: Kalibrace dotykové plochy displeje se dá provést získáním naměřených hodnot pomocí funkce .getPoint a postupním přejížděním os z minima do maxima. Poté stačí najít maximální a minimální hodnotu pro obě osy a změnit kalibrační proměnné.

Už jsme zjistili, jak se dá z displeje zjistit souřadnice stlačeného bodu. Druhá (a důležitější) část je práce se samotnou zobrazovací plochou. I k tomuto účelu existuje pro náš displej knihovna, kterou stáhneme zde. Ta nám přináší funkce pro jednodušší práci s displejem. Níže vidíte některé z nich.

Displej umí pracovat s 2¹⁶ (65536) různými barvami. Informace o barvě jednoho pixelu tedy zabere 16 bitů. Červené a modrá barva mají každá pět bitů, zelená má bitů šest, protože je na ní lidské oko více citlivé, tudíž rozezná více jejích rozdílů. Tento způsob míchání barev se nazývá 16-bit high color a více se o něm můžete dočíst na anglické Wikipedii. Červená a modrá barva tedy můžou mít 32 různých sytostí, na zelenou jich připadá 64. Knihovna obsahuje několik předdefinovaných konstant barev. Jsou to:

Pokud by nám nestačila výchozí paleta, můžeme si vytvořit i barvy vlastní. Jeden ze způsobů vidíte na příkladu. Jedná se o trošku pokročilejší programování, na které přijde řeč možná až časem. S čísly se zde pracuje na úrovni jednotlivých bitů. Důležité ale je to, že funkce barva má tři parametry – r, g a b pro jednotlivé barvy a vrací číslo barvy. Parametry r a b mohou nabývat hodnot od 0 do 31. Parametr g 0 až 63. Následující program zobrazí na displeji tři kružnice tří základních barev.

#include <stdint.h>
#include <TFTv2.h> //knihovna displeje
#include <SPI.h> //knihovna pro komunikaci s displejem

void setup(){
    Tft.TFTinit();
    
    Tft.drawCircle(120, 60, 20, barva(31,0,0));
    Tft.drawCircle(120, 160, 20, barva(0,63,0));
    Tft.drawCircle(120, 260, 20, barva(0,0,31)); 
}

void loop(){

}

uint16_t barva(int r, int g, int b){
    r = r % 32;
    g = g % 64;
    b = b % 32;    
    
    r = r << 11;
    g = g << 5;
    
    return r | g | b;
}

Jednotlivě jsme již vyřešili dotykovou plochu i displej. Nyní pojďme dát vše dohromady. Vytvoříme si aplikaci pro jednoduché malování černou barvou na bílé pozadí. Aplikace bude obsahovat také tlačítko reset.

#include <stdint.h>
#include <SeeedTouchScreen.h>
#include <TFTv2.h>
#include <SPI.h>

#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) // mega
#define YP A2 
#define XM A1 
#define YM 54 
#define XP 57 

#elif defined(__AVR_ATmega32U4__) //leonardo
#define YP A2 
#define XM A1
#define YM 18 
#define XP 21

#else
#define YP A2 
#define XM A1
#define YM 14 
#define XP 17 

#endif

TouchScreen ts = TouchScreen(XP, YP, XM, YM);

int min_x = 232;
int max_x = 1780;
int min_y = 166;
int max_y = 1826;

int x, y;

void setup(){
    Tft.TFTinit();
    
    Tft.fillScreen(10,230,10,230, WHITE);
    Tft.fillScreen(10,230,240,310, GRAY2);
    
    Tft.drawString("RESET", 45, 255, 5, BLACK);
}

void loop(){
    Point p = ts.getPoint();
    
    x = map(p.x, min_x, max_x, 0, 239);
    y = map(p.y, min_y, max_y, 0, 319);
    
    if(p.z > 10){
        if(x >= 10 && x <= 220 && y >= 250 && y <= 310){
            Tft.fillScreen(10,230,10,230, WHITE);
        }
        else if(x >= 10 && x <= 220 && y >= 10 && y <= 230 ){
            Tft.fillRectangle(x,y,2,2,BLACK);
        }
    }

    delay(1);
}

Výsledný program

Zdroje obrázků

[Zapojení znakového LCD]

V případě jakýchkoliv dotazů či nejasností se na mě neváhejte obrátit v komentářích.

Náš pravidelný čtenář Jiří Procházka nám poslal odkaz na svůj první projekt postavený na platformě Arduino. Jedná se o automatizovaný závlahový systém pro balkony. Systém je krom automatického provozu také zcela nezávislý na vnější dodávce elektrického proudu, protože pro svůj provoz využívá malý solární panel. Ústředním mozkem celého zařízení je Arduino Nano, které takto malý systém s přehledem utáhne. Ku pomoci mu pak je několik čidel, spínací relé, LCD display a další báječné věci z rodiny Arduino. Zajímavým řešením je také využití ultrazvukového modulu HC-SR04, pomocí kterého se měří výška hladiny vody v nádrži. Své zkušenosti ze stavby i provozu a některé omyly a chyby, kterých se při vývoji dopustil, shrnul autor v přehledném reportu. Ten uveřejnil na svých nově vznikajících stránkách Digital Druid, aby se s Vámi o něj podělil.

Ovládací panel pro závlahový systém

Jelikož se mu platforma Arduino velmi zalíbila, plánuje v brzké době další projekty. Budeme se tedy těšit, že časem přibudou i další zajímavé články.

V dnešním článku si ukážeme, jak pracovat s Ethernet shieldem, což je zajímavé rozšíření pro Arduino, které nám přináší nové možnosti interakce Arduina se sítí i internetem.

Ethernet Shield

Ethernet shield si (stejně jako celé Arduino) prošel poměrně dlouhým vývojem, proto se setkáme hned s několika jeho verzemi. My budeme pracovat s jeho nejnovější verzí Arduino Ethernet Rev3 WITH PoE.

Ethernet shield

Dominantním prvkem desky je RJ45 konektor pro připojení Ethernet kabelu. Mimo něj ale na shieldu nalezneme i slot na SD kartu, jejíž používání jsme si popsali v minulém dílu. Ovládání čipu (W5100) i SD karty probíhá přes SPI rozhraní. Rychlost síťové komunikace 10/100 MB není v dnešní době zrovna strhující, ale pro naše účely je zcela dostačující. Než shield připojíme k Arduinu, otočíme jej.

MAC Adresa

Na jeho spodní straně nalezneme nálepku s MAC adresou (unikátní identifikační číslo síťového zařízení). Tu si někam poznamenáme pro pozdější použití. Když máme MAC adresu zapsanou, můžeme shield připojit na Arduino (v našem případě Arduino Mega).

Arduino Mega s připojeným Ethernet shieldem

Funkce

Pro programování Ethernet shieldu se používá hned několik tříd. Třída Ethernet slouží k základnímu nastavení.

Jakousi pomocnou třídou je třída IPAddress. Ta slouží k uchování IP adresy.

Třída Server slouží k odesílání a přijímání dat mezi shieldem a připojenými klienty (programy na jiných zařízeních, které se připojují k serveru).

Ke zpracování dat ze serveru slouží třída Client. Tato třída vytvoří ze shieldu klienta, který se může připojit k jiným serverům.

Poslední třída EthernetUDP slouží k přijímání a odesílání UDP zpráv. My se jí však nebudeme zabývat. Pro více informací navštivte dokumentaci.

Použití

Když už jsme si popsali všechny potřebné funkce, můžeme se pustit do programování.

Vytváříme server

Na úvod si naprogramujeme jednoduchý server. Než ale začneme, musíme pochopit, jak spolu komunikuje server s klientem. Komunikace zde probíhá na principu dotaz-odpověď. Tyto dotazy a odpovědi mají formát pouhého textu. Jakým způsobem musí být text zapsán, definuje HTTP protokol. Nejjednodušší bude si vše předvést na ukázce komunikace. Když se chce klient připojit na server, zašle mu požadavek přibližně v tomto tvaru:

GET / HTTP/1.1
Host: 10.0.0.15
Connection: keep-alive
Cache-Control: max-age=0
Accept: text/html,application/xhtml+xml, application/xml;q=0.9, image/webp,*/*;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.114 Safari/537.36
Referer: http://10.0.0.15/
Accept-Encoding: gzip,deflate,sdch
Accept-Language: cs,en;q=0.8,de;q=0.6,sk;q=0.4

Tato zpráva obsahuje vše potřebné pro server pro odeslání vodných dat klientovi. Obsahuje informaci o tom, s jakou verzí HTTP pracujeme, jaký je pro klienta přijatelný formát, o jakého klienta se jedná, jaké kódování používá a jaký jazyk očekává. Prázdný desátý řádek zde není z nepozornosti. Tímto způsobem se označuje, že je požadavek ukončen.

Server poté musí požadavek zpracovat a odeslat zpět odpověď v HTML tvaru s vhodnou HTTP hlavičkou. Hlavička obsahuje informace o verzi HTTP, o stavu připojení po ukončení přenosu, nebo o automatickém obnovování. Tyto informace nám nyní stačí. Existuje ale samozřejmě celá řada dalších HTTP příkazů, jejichž seznam nalezneme například na wikipedii. Hlavička odpovědi tedy vypadá takto (opět s volným řádkem).

HTTP/1.1 200 OK
Content-Type: text/html
Connection: close
Refresh: 1

Po hlavičce a volném řádku následuje kód stránky ve formátu HTML. Představme si nyní základní strukturu stránky.

<!DOCTYPE HTML> - říkáme prohlížeči, že pracujeme s HTML
<html>
	<head>
		mezi značky head se píší základní informace o stránce (kódování, CSS styly...)
		<title>Titulek stránky </title> - zobrazí se v záložce
	</head>
	<body>
		sem patří obsah stránky (ten, který vidíme v prohlížeči)
	</body>
</html>

Se všemi získanými informacemi už můžeme poskládat program jednoduchého serveru, který bude měnit barvu pozadí pomocí css stylů podle toho, jestli je nebo není stisknuto tlačítko připojené k Arduinu na pinu 45. Tlačítko budeme kontrolovat každou vteřinu. Mimo tlačítka budeme potřebovat ještě 10k resistor a několik vodičů.

V programu použijeme také jednoduché css stylování. My budeme chtít, aby pozadí celé stránky bylo zelené nebo červené. To se v html provede tak, že se k elementu <body> připojí style=“background: red/green“. Dvojité uvozovky by ale program Arduina mohly mást, proto se používá tzv. escapování, kdy se před vybraný znak dá zpětné lomítko. Ten se poté projeví až při zpracování prohlížečem. Výsledný element body tedy bude vypadat třeba takto: <body style=\“background: green\“>

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {0x90, 0xA2, 0xDA, 0x00, 0x9C, 0xB7 };
IPAddress ip(10,0,0,15); //ip serveru je 10.0.0.15

EthernetServer mujSvr(80); //vytvoříme server na portu 80

void setup(){
    Ethernet.begin(mac);

    mujSvr.begin(); //spustíme server

    pinMode(45, INPUT);
}


void loop(){
    EthernetClient client = mujSvr.available();
    if (client){
        boolean prazdnyRadek = true;
        while (client.connected() && client.available()){ 
            //dokud klient něco odesílá (HTTP požadavek)
            char c = client.read(); //přečti byte od klienta
            
            if(c == '\n' && prazdnyRadek){
                client.println("HTTP/1.1 200 OK");
                client.println("Content-Type: text/html");
                client.println("Connection: close");
                client.println("Refresh: 1");
                client.println();
                client.println("<!DOCTYPE HTML>");
                client.println("<html>");
                client.println("<head>");    
                client.println("<title>Zkoumame HTML a HTTP</title>");
                client.println("</head>");
                
                if(digitalRead(45) == HIGH){
                    client.println("<body style=\"background:green\">");
                }
                else{
                    client.println("<body style=\"background:red\">");
                }

                client.println("</body>");
                client.println("</html>");
            }
            
            if(c == '\n'){
                prazdnyRadek = true;
            } 
            else if(c != '\r'){
                prazdnyRadek = false;
                /*dokud klient nepošle dvakrát za sebou \r a \n
				znamená to, že stále odesílá data*/
            }
        }
        delay(1); //dáme klientovi čas na zpracování
        client.stop(); //komunikace je u konce
    }
}

Arduino Mega s Ethernet shieldem a připojeným tlačítkem

Sosáme data

V druhém příkladu se připojíme k serveru a budeme po něm požadovat nějaká data, která si vypíšeme po sériové lince. Konkrétně to bude server ahwk.ic.cz, po kterém budeme chtít soubor ahoj.txt. Ten je uložen v kořenovém adresáři serveru, tedy přímo na adrese ahwk.ic.cz/ahoj.txt. Na začátek si sestavíme HTTP požadavek.

GET /ahoj.txt HTTP/1.1
Host: ahwk.ic.cz
Connection: close

Slovy: Dej mi soubor ahoj.txt přes protokol HTTP verze 1.1 z ahwk.ic.cz a potom ukonči spojení.

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {0x90, 0xA2, 0xDA, 0x00, 0x9C, 0xB7};

char server[] = "ahwk.ic.cz"; //server, kam se připojujeme

EthernetClient client;

void setup(){
    Serial.begin(9600);
    Ethernet.begin(mac);
    delay(1000);

    Serial.println("Spojuji...");

    if(client.connect(server, 80)){ //připojí se k serveru
        Serial.println("Pripojeno!");
        
        client.println("GET /ahoj.txt HTTP/1.1");
        client.println("Host: ahwk.ic.cz");
        client.println("Connection: close");
        client.println();
    } 
    else {
        Serial.println("Spojeni se nepovedlo.");
    }
}

void loop(){
    if(client.available()) {
        char c = client.read();
        Serial.print(c); //vypíše přijatá data
    }

    if(!client.connected()) {
        Serial.println();
        Serial.println("Odpojuji.");
        client.stop();
        while(true){} //zastaví činnost shieldu
    }
}

Ovládání přes síť

V posledním příkladu si ukážeme, jak Arduino ovládat pomocí prohlížeče, či jiného síťového zařízení. Budeme ovládat čtyři LED připojené na pinech 3, 4, 5 a 6. Informaci o tom, která LED bude svítit, předáme shieldu pomocí parametru v URL (to co píšeme do adresního řádku). Parametr se píše za ?. My tedy budeme v HTTP požadavku klienta hledat ? a poté čísla za ním následující. Náš program poté rozsvítí postupně LED diody daných čísel. Pokud napíšeme do prohlížeče: 10.0.0.15/?3456, HTTP požadavek odeslaný na server vypadá nějak takto.

GET /?3456 HTTP/1.1
Host: 10.0.0.15
Connection: keep-alive
Cache-Control: max-age=0
Accept: text/html,application/xhtml+xml, application/xml;q=0.9, image/webp,*/*;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.114 Safari/537.36
Accept-Encoding: gzip,deflate,sdch
Accept-Language: cs,en;q=0.8,de;q=0.6,sk;q=0.4

Jediná věc, která nás teď zajímá je první řádek, a to až za otazníkem. Poté už nás další informace nezajímají. Data, která chceme, tedy začínají otazníkem a končí mezerou. Pozor na to, že jsou tu i číslice kódovány jako ASCII.

#include <Ethernet.h>
#include <SPI.h>

boolean zacatekCteni = false;

byte mac[] = {0x90, 0xA2, 0xDA, 0x00, 0x9C, 0xB7 };
IPAddress ip(10,0,0,15);

EthernetServer mujSvr = EthernetServer(80);

void setup(){
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);

  Ethernet.begin(mac, ip);

  mujSvr.begin();
}

void loop(){
    EthernetClient client = mujSvr.available();
    
    if(client){
        boolean prazdnyRadek = true;
        boolean hlavickaPoslana = false;
        
        while(client.connected() && client.available()){
            if(!hlavickaPoslana){ //jednou pošleme hlavičku
                client.println("HTTP/1.1 200 OK");
                client.println("Content-Type: text/html");
                client.println();
                hlavickaPoslana = true;
            }
            
            char c = client.read();
            
            if(zacatekCteni && c == ' '){ //ukončí čtení
                zacatekCteni = false;
            }
            
            if(c == '?'){ //začne čtení
                zacatekCteni = true;
            }
            
            if(zacatekCteni){                
                if(c == '3'){
                    blikni(3, client);
                }
                else if(c == '4'){
                    blikni(4, client);
                }
                else if(c == '5'){
                    blikni(5, client);
                }
                else if(c == '6'){
                    blikni(6, client);
                }
            }
            
            if (c == '\n') {
                prazdnyRadek = true;
            }
            
            else if (c != '\r'){
                prazdnyRadek = false;
            }
        }
        delay(1);
        client.stop();
    } 
}

void blikni(int pin, EthernetClient client){
    client.print("Sviti LED na pinu ");
    client.print(pin);
    client.print("<br>"); //zalomení řádku
    
    digitalWrite(pin, HIGH);
    delay(250);
    digitalWrite(pin, LOW);
    delay(250);
}

Ovládání LED diod přes Ethernet Shield

Tímto jsme získali základní přehled o tom, co Ethernet shield umí. To ale samozřejmě není vše. Můžeme ho například naučit komunikovat s Twitterem, zjišťovat čas podle atomových hodin a další. Několik zajímavých příkladů nalezneme v oficiální dokumentaci.

V případě jakýchkoliv dotazů či nejasností se na mě neváhejte obrátit v komentářích.

V tomto tutoriálu předvede Massimo Banzi, jak se dá pomocí Arduina sestavit lampa ovládaná kapacitním senzorem. Také představí koncept používání externích knihoven.

V dnešním dílu si ukážeme, jak se dají pomocí Arduina programovat jiné čipy od Atmelu. Na začátek si předvedeme, jak pracovat s malými čipy z řady ATtiny, poté se dostaneme k větším čipům z řady ATmega a jak už název článku napovídá, vytvoříme vlastní klon Arduina.

Už v prvním dílu jsem se zmínil o neoficiálních deskách, tzv. klonech. Nejedná se jenom o sériově vyráběné desky. Takovýto klon si může každý udělat sám. Ještě než se pustíme do stavby vlastní desky, ukážeme si, jak se dají programovat menší čipy z řady ATtiny. A poté už se dostaneme ke tvorbě vlastní plnohodnotné desky.

Příprava Arduina

Než se pustíme do připojování a programování čipů, musíme z Arduina udělat ISP programátor. Ten slouží k nahrávání programů do připojených čipů. To provedeme velmi jednoduše – z Examples otevřeme program ArduinoISP a nahrajeme ho do našeho Arduina. V dalším kroku musíme „identifikovat“ důležité piny, které při programování použijeme. Jsou to: MISO, MOSI, SCK a SS. Jejich umístění se u různých desek může lišit. Příklad rozmístění pinů vidíte v tabulce.

Poznámka: Informace o pinech jsou k nalezení v dokumentaci každé desky. Některé verze ale nemusejí mít tyto piny lehce dostupné. Například Leonardo je nemá vyvedeny standardně. O jeho použití jako ISP programátor pojednává tento článek.

Na vybraném čipu si podle dokumentace najdeme piny MISO, MOSI, SCK a Reset. Poté propojíme sobě odpovídající piny Arduina a čipu. Pin SS Arduina propojíme s pinem Reset čipu. Tímto se budeme podrobněji zabývat dále.

Čipy ATtiny

Jak už jsem zmínil dříve, v řadě ATtiny nalezneme menší a méně výkonnější čipy. To ale nevadí, protože nám v některých situacích budou plně dostačovat. Běžně se setkáme s použitím čipů ATtiny85, ATtiny45, ATtiny84, ATtiny44 a dalšími. Na internetu nalezneme i jiné čipy s této řady. Důležité však je, aby použitý čip měl k sobě odpovídající „popis“ – informaci v podobě textu, která programu říká informace o čipu, jako jsou rychlost, velikost paměti, rychlost komunikace a další. Soubor s informacemi o běžných deskách nalezneme ve složce s Arduino IDE pod hardware/arduino/boards.txt. Abychom si tento soubor nezahltili informacemi, umístíme data o čipech ATtiny do složky, kterou máme nastavenou pro ukládání programů Arduina. Tu většinou najdeme v Dokumentech ve složce Arduino. Stáhneme si tento archiv a rozbalíme jej do složky Arduino v Dokumentech. Pokud máme spuštěné Arduino IDE, restartujeme jej. V nabídce Board by se nám nyní mělo objevit několik nových možností.

Menu Boards

My si předvedeme, jak programovat čip ATtiny85. Ten má osm pinů – dva piny pro napájení, jeden pro restart a pět zbývá na libovolné použití. Popis funkcí pinů vidíme na obrázku 3. Orientaci čipu určíme buď podle půlkruhového symbolu na jedné ze stran (viz obr. 3), nebo podle označení pinu 1 kroužkem. Když budeme chtít v programu pracovat s pinem, dovoláme se ho podle číselného označení popsaného zvenku (čísla uvnitř čipu nás v tuto chvíli nezajímají).

ATtiny 85

ATTiny 85 pinout

Jelikož se jedná o malé čipy s menším výkonem, i škála použitelných funkcí je zde omezena. Většinu základních funkcí zde ale najdeme. Jsou to:

• pinMode()
• digitalWrite()
• digitalRead()
• analogRead()
• analogWrite() – připomeňme si, že je tato funkce použitelná jen u pinů PWM
• millis()
• micros()
• delay()
• delayMicroseconds()

Také můžeme použít ještě neprobrané funkce shiftOut() a pulseIn().

Základ použití máme vysvětlený a můžeme se pustit do propojení Arduina s čipem. Propojení provedeme následovně:

Zapojení

Po zapojení se ujistíme, že v Arduinu máme nahraný program ArduinoISP (viz výše). Čipy ATtiny85 jsou ve výchozím nastavení taktované na frekvenci 1MHz, proto z nabídky Board vybereme možnost ATtiny85 (internal 1 MHz clock). Pro otestování funkčnosti připojíme mezi Pin 0 (MOSI) a GND přes 330 Ohm resistor LED diodu. Z Examples otevřeme program Blink a proměnnou led nastavíme na hodnotu 0.

int led = 0;

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

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

Poznámka: Změnu taktovací frekvence na 8 MHz provedeme jednoduše – z nabídky vybereme možnost ATtiny85 (internal 8 MHz clock) a v menu Tools klikneme na Burn Bootloader. Stejným postupem čip nastavíme zpět na frekvenci 1 MHz.

Čipy ATmega

Pokud se chceme od malých čipů ATtiny přesunout k něčemu výkonnějšímu, nabízí se nám použití čipů ATmega. Ty jsou větší, výkonnější a mají více použitelných pinů. Stejně jako u ATtiny i zde platí, že můžeme použít všechny piny, ke kterým nalezneme patřičnou modifikaci souboru boards.txt. Jako nejjednodušší se jeví použití těch čipů, na kterých jsou založeny standartní desky Arduina, tedy ATmega168, ATmega328 a další. My si ukážeme použití čipu ATmega168. Stejně jako u ATtiny, i zde musíme najít potřebné piny.

ATmega 168

ATmega 168 pinout

Abychom využili celý potenciál čipu, budeme potřebovat ještě 16 MHz oscilátor, 10 kOhm resistor, dva 22 pF kondenzátory a spínač (tlačítko). Také budeme potřebovat USB-serial převodník. Na výběr máme z více možností – FTDI Basic Breakout – 5V, USB 2 Serial Converter a další. Vše zapojíme podle schématu.

Arduino on board

V našem Arduinu máme nahraný program ArduinoISP. Poté z nabídky Board vybereme Arduino Diecimila or Duemilanove w/ ATmega168. V Tools/Programmer vybereme možnost Arduino as ISP a spustíme Burn Bootloader. Po chvilce se ve stavovém řádku zobrazí Done burning bootloader. Tímto jsme nastavili čip tak, aby byl programovatelný pomocí USB-serial převodníku. V dalším kroku připojíme čip s převodníkem. To provedeme tak, že GND čipu propojíme s GND převodníku a stejně tak 5V. Dále propojíme RX pin čipu s TXD převodníku a TX čipu s RXD převodníku. Tím máme čip připravený k programování. Od čipu odpojíme Arduino, kterým jsme jej programovali a připojíme převodník k PC přes USB. V menu Serial Port by se nám měla objevit nová možnost, kterou vybereme. Poté se můžeme pustit do programování našeho nového klonu Arduina tak, jak jsme zvyklí.

Zdroje obrázků

[Rozložení pinů ATtiny85]

[Rozložení pinů ATmega168]

V případě jakýchkoliv dotazů či nejasností se na mě neváhejte obrátit v komentářích.

Kolikrát se mi stane, že bych strašně rád něco kutil s Arduinem, ale ať se snažím, jak se snažím, nedaří se mi vymyslet, co bych mohl vytvořit. Aby se vám tohle o prázdninách s Arduinem nestalo, vybrali jsme pro vás několik zajímavých Arduino projektů a aplikací, které můžete použít jako inspiraci.

U každého projektu jsou přidány odkazy na konkrétní součástky z nabídky e-shopu HW Kitchen.

Začneme od těch jednodušších Arduino projektů:

Používání sedmisegmentového displeje

Sedmisegmentové displeje najdeme snad všude. Od budíků, přes pračky, až po automaty. Nejen, že jsou poměrně jednoduché na ovládání, ale také dodají projektu ten správný design a hlavně možnost zobrazení různých stavů, čísel nebo písmen. Rozhodně neškodí se s nimi naučit pracovat. Vše potřebné naleznete v tomto návodu.

Číslicová klávesnice

Ať už stavíte zabezpečovací systém, numerickou klávesnici nebo telefon, může vám přijít vhod umět používat číslicový keypad. Na dvanáctitlačítkovém keypadu nenajdeme dvanáct vývodů (každý pro jedno tlačítko) a nebo většinou sedm. Tlačítka jsou totiž uspořádána do matice pro ušetření počtu výstupů. Musíte se tak umět pohybovat mezi jednotlivými řádky a sloupci, a to už nemusí být tak triviální, jako číst hodnotu na jednom vstupu. Jak to zvládnout naleznete zde.

IR ovládání

Infračervené ovládání se zase hodí, třeba když stavíte robota nebo na ovládání žaluzií. Stačí vám k tomu ovladač a IR dioda nebo IR modul. Přidejte trochu kódu a můžete se pustit do ovládání čehokoliv – třeba LED diod.

Arduino monitor prostředí pro rostliny

Pokud patříte mezi vášnivé zahradníky, můžete posunout svůj koníček na další úroveň. Nechte Arduino, aby za vás měřilo veličiny jako vlhkost půdy, osvětlení či teplotu. Podle toho se pak můžete rozhodnout, co změnit, aby se květině dařilo co nejlépe. Budete k tomu potřebovat dva hřebíky, nějaký senzor teploty a senzor osvětlení. Více se dozvíte zde.

Arduino Robot

Pokud máte rádi ten pocit, když věc vybalíte z krabice a hned můžete začít tvořit, je Arduino Robot to pravé pro Vás. Na jedné desce tak naleznete vše podstatné, co byste do začátku mohli potřebovat – pět tlačítek, dva potenciometry, kompas, čtečku SD karet a mnohé další. To vše na podvozku s kolečky. Více informací o Arduino Robot se dočtete na oficiální stránce.

Senzor náklonu

Další ze základních součástek, které je dobré znát, je akcelerometr. Využijete ho třeba při stavbě autonomního vozítka nebo kvadrokoptéry. V tomto návodu je použit jako jednoduchý senzor náklonu.

Digitální hodiny

Často se také hodí, aby umělo Arduino vnímat čas. Aby se však čas nevynuloval vždy při vypnutí napájení, je nutné použít nějaký externí obvod s vlastní baterií. Jedním z nejjednodušších příkladů je obvod hodin reálného času DS1307, o kterém jsme už dříve psali. Na něm se dají založit třeba takovéto hodiny. Každý správný geek by měl mít alespoň jedny binární hodiny. Pokud takové ještě nemáte, můžete zkombinovat tento návod s návodem předchozím a postavit si vlastní binární hodiny.

Robotická ruka

Koho baví robotická ramena, může si z pár servomotorů, několika kloubů a klepet udělat vlastní robotickou ruku – třeba takovou, jakou naleznete zde.

Arduino online teploměr

Někdy se hodí vědět, kolik je venku stupňů, bez toho, aby člověk musel opravdu opustit dům. K tomu nepotřebujete nic víc, než Arduino Uno, Ethernet Shield a nějaký teploměr. Podrobnosti jak to dát dohromady naleznete zde.

Vývoj ceny akcií

Obchodujete-li na burze, nebo se jen zajímáte o hodnotu Vaší oblíbené společnosti, mohl by se Vám líbit projekt Stocker. Ten za Vás sleduje vývoj akcií v čase a barevně indikuje, jestli se ceně daří, nebo ne. Je k němu potřeba jenom Arduino a RGB led. Nevýhodou je, že získávání dat obstarává program v Processing, který běží na PC. Aby Stocker fungoval, musí být počítač stále zapnutý. Zajímavé by bylo tento projekt předělat s použitím Ethernet nebo WiFi shieldu, aby byl trochu více autonomní.

Počítač parkovacích míst

Tímto projektem můžete potěšit vaše děti. Výsledkem je automatický parkovací systém, který obsahuje servem ovládanou závoru, počítadlo zbývajících parkovacích míst a senzor vjezdu a také výjezdu autíček z parkoviště.

Arduino univerzální měřící systém

Napětí, proud, výkon, fázi a mnohé další – to vše umí změřit Arduino, když k němu připojíte správné komponenty. A když už budete mít tyto veličiny změřené, jste jen krok od toho je všechny zobrazit na LCD displeji nebo odeslat do PC, kde je můžete dále zpracovávat a analyzovat. Všechno podstatné naleznete v tomto velmi zajímavém tutoriálu. 

GPS tracker

Pokud patříte mezi ty, kteří často zapomínají kam zaparkovali auto, nebo chcete mít pojistku v případě krádeže, je právě pro vás tento GPS tracker. Co je ale důležité, je to, že umí po určitých časových intervalech informovat majitele o poloze pomocí SMS. Budete potřebovat Arduino Uno, GPS shield a GSM shield (nebo Arduino shield, který umí oboje).

Hardwarová verze online šachů

Koho baví šachy, je tento projekt přesně pro něj. Kolikrát se nepoštěstí sejít se se svým soupeřem, a tak nezbude nic jiného, než hrát šachy po internetu. Pokud však nechcete být ochuzeni o hardwarový požitek, můžete si postavit tyto Arduinem poháněné šachovnice. Každý pohyb je zaznamenán pomocí magnetických spínačů a pomocí malého dvouosého plotteru je odpovídající figurka přesunuta i na druhé šachovnici. Projekt je dostupný hned v několika verzích (první, druhá). Při stavbě se Vám budou hodit magnetické spínače jako detektory figurek a pro ovládání plotteru také krokové motory a jejich drivery.

Miniaturní kvadrokoptéra

Poslední projekt je určen pro ty, kteří by rádi měli vlastní kvadrokoptéru, ale nechce se jim pouštět do stavby velkého stroje za desítky tisíc. Crazyflie je kvadrokoptéra s rozměry nepřesahujícími 10 cm a váhou 19g. Po seznámení s ovládáním se tak nemusíte bát ani létání ve větším bytě (což u většiny kvadrokoptér moc nejde). V balení dostanete vysílač a kvadrokoptéru, kterou si budete muset sami sestavit. Většina plošného spoje je sice osazena, budete ale muset připájet motory, což vyžaduje trochu zručnosti.

Nyní je k dispozici také nová verze kvadrokoptéry pod označením Crazyflie 2.0!

Tato nová verze přináší řadu vylepšení. Při stavbě není potřeba pájet, ovládat se dá mobilem s Bluetooth nebo z PC pomocí speciálního rádiového modulu až na vzdálenost více než kilometr. K dispozici je také velké množství přídavných modulů jako světlo, bezdrátové nabíjení nebo kit pro vývoj vlastních aplikací s Crazyflie…

Nadchli jsme vás ke tvorbě nějakého projektu, nebo máte rozdělaný svůj vlastní?

Dejte nám o tom vědět v komentářích nebo na Facebooku.

Tým Arduino.cz vám přeje krásné prázdninové bastlení a ať vám aplikace fungují na první spuštění :-)!

Dnešní díl bude věnován praktickým aplikacím Arduina. V první části si předvedeme, jak pracovat s keypadem s dvanácti tlačítky. Vytvoříme si velmi jednoduchý zabezpečovací systém a také si ukážeme, jak si při programování zkrátit čas – vytvoříme si klávesnici pro programátory. V druhé části se dostaneme k servomotorům. Ukážeme si, jak se ovládají a poté si sestavíme kreslící robotickou ruku.

Keypad

V tomto článku budeme pracovat s tímto dvanáctitlačítkovým keypadem. Jeho tlačítka jsou uspořádány do matice 3 x 4. Jistě si vzpomínáte, jak jsme ve dvanáctém článku ovládali maticový displej. Práce s keypadem je velmi podobná práci s displejem. Tlačítka jsou seřazena do třech sloupců a čtyř řádků, kdy každému je přiřazen jeden pin. Propojení je znázorněno na obrázku.

Vnitřní propojení keypadu

Je tedy zřejmé, že při stisknutí tlačítka [1] jsou propojeny piny 2 a 3. Pokud bychom si chtěli připojit toto tlačítko k Arduinu, na pin 2 by bylo připojeno +5V a na pin 2 přes 10k ohm resistor GND a také vstup (standardní připojení tlačítka). My ale potřebujeme zjistit stav všech dvanácti tlačítek. To provedeme tak, že si vybereme sloupce nebo řádky. Poté všechny piny jednoho typu připojíme na vstupy Arduina a přes 10k ohm resistor na GND. Druhou skupinu připojíme na výstupy. Do těch budeme stále dokola střídavě pouštět proud, který poté budeme detekovat na vstupech. K dispozici pak máme dvě informace: na jaký pin pouštíme proud a na kterém jsme ho detekovali. Z těchto informací už můžeme zjistit, jaké tlačítko je stisknuto.

Zapojení a programování

Jako první příklad si vytvoříme program, který po stisknutí tlačítka vypíše po sériové lince jemu odpovídající znak. Pokud tlačítko budeme držet stisknuté, znak se bude v určitém časovém intervalu opakovat. Můžeme si vybrat, jakým způsobem keypad zapojíme. Použijeme variantu, kdy řádky (2, 4, 6, 7) budou připojeny na výstupy Arduina a sloupce (1, 3, 5) na vstupy a také přes 10k resistor na GND. V této části použijeme Arduino Micro, které budeme potřebovat při tvorbě klávesnice (také bychom mohli využít Arduino Leonardo). Pokud nevíte, proč budeme muset při tvorbě klávesnice použít právě tyto dvě desky, můžete si to připomenout v osmém článku. Keypad s Arduinem je možné propojit různými způsoby. My si zvolíme zapojení, kdy je pin n keypadu připojen na pin n+1 Arduina. Pin 1 je tedy připojen na pin 2, pin 2 na pin 3 atd. Zapojení je k vidění na obrázku.

Zapojení Keypadu

Na začátku musíme programu říct, jaké piny jsou připojeny na co. To budeme mít uloženo ve dvou polích – sloupce a radky. Navíc si sloupce a řádky seřadíme z leva doprava a odshora dolů. Vytvoříme si dvojrozměrné pole se znaky odpovídajícími klávesám. Poté si piny odpovídající řádkům nastavíme jako výstupy a sloupce jako vstupy. V těle funkce setup() si ještě nastavíme aktuální čas. Ve funkci loop() budeme neustále dokola pouštět proud do jednotlivých řádků a detekovat jeho průchod na sloupcích.

byte radky[4] = {3,8,7,5};
byte sloupce[3] = {4,2,6};

char znaky[4][3] = {{'1','2','3'},
                   {'4','5','6'},
                   {'7','8','9'},
                   {'*','0','#'}};

int cekej = 200;
long cas;

void setup(){
    for(int i = 0; i < 4; i++){
        pinMode(radky[i], OUTPUT);
    }  
    for(int i = 0; i < 3; i++){
        pinMode(sloupce[i], INPUT);
    }
    
    cas = millis();
}

void loop(){
    for(int a = 0; a < 4; a++){
        digitalWrite(radky[a],HIGH);
        for(int b = 0; b < 3; b++){
            if(digitalRead(sloupce[b]) == HIGH && millis() - cekej > cas){
                Serial.println(znaky[a][b]);
                cas = millis();
            }
        }
        digitalWrite(radky[a],LOW);
    }        
}

Bezpečnostní systém

V této části bude naším úkolem naprogramovat jednoduché bezpečnostní zařízení. To bude vybaveno keypadem pro zadávání kódu a piezzo bzučákem, který začne pípat při zadání špatného kódu. Ten bude připojený na pin 10. Stisknuté znaky z keypadu se budou nahrávat do řetězce. Znak # bude sloužit k vynulování řetězce a * k potvrzení zadání kódu. Vše je vysvětleno v programu níže. Vyjdeme z kódu z předchozího příkladu. Předpokládejme, že náš kód nebude delší než 100 znaků.

Keypad s bzučákem

byte radky[4] = {3,8,7,5};
byte sloupce[3] = {4,2,6};

char znaky[4][3] = {{'1','2','3'},
                   {'4','5','6'},
                   {'7','8','9'},
                   {'*','0','#'}};

int cekej = 200;
long cas;

byte pozice = 0; //pomocná proměnná udávající aktuální znak
byte chyby; //proměnná pro ukládání neshod kódů
char spravnyKod[100] = "12321";
char kod[100];

void setup(){
    for(int i = 0; i < 4; i++){
        pinMode(radky[i], OUTPUT);
    }  
    for(int i = 0; i < 3; i++){
        pinMode(sloupce[i], INPUT);
    }
    
    cas = millis();
}

void loop(){
    for(int a = 0; a < 4; a++){
        digitalWrite(radky[a],HIGH);
        for(int b = 0; b < 3; b++){
            if(digitalRead(sloupce[b]) == HIGH 
			&& millis() - cekej > cas){
                tone(10,440,100);
                cas = millis();
                
                if(znaky[a][b] == '#'){ 
				//pokud najde křížek, vymaže kod
                    vynuluj();
                }
                else if(znaky[a][b] == '*'){ 
				//když najde hvězdičku, zkontroluje shodu
                    for(int c = 0; c < 100; c++){
                        if(kod[c] != spravnyKod[c]){
                            chyby++;
                        }
                    }
                    if(chyby > 0){
                        vynuluj();
                        for(int d = 0; d < 10; d++){ //siréna
                            for(int c = 200; c < 2000; c++){
                                tone(10, c, 5);
                            }
                            for(int c = 2000; c > 200; c--){
                                tone(10, c, 5);
                            }
                        }
                    }    
                    else{
                        vynuluj();
                        tone(10, 1000, 100); //třikrát pípne
                        delay(200);
                        tone(10, 1000, 100);
                        delay(200);
                        tone(10, 1000, 100);
                    } 
                }
                else{
                    kod[pozice] = znaky[a][b];
                    pozice++;
                }
            }
        }
        digitalWrite(radky[a],LOW);
    }        
}

void vynuluj(){ //funkce pro vymazání řetězce kod
    for(int c = 0; c < 100; c++){
        kod[c] = 0;
    }
    pozice = 0; 
    chyby = 0;   
}

Programátorská klávesnice

Posledním příkladem využívajícím keypad je slibovaná programátorská klávesnice. Ta naše bude používat jenom osm kláves keypadu – pro každý typ závorek dvojici kláves (pravá a levá závorka). ASCII kódy jednotlivých znaků v desítkové soustavě vidíte v tabulce.

Tyto kódy přepíšeme do pole znaky. Stisknutí klávesy do počítače odešleme pomocí funkce Keyboard.print() (viz osmý článek). Dále je kód stejný jako v předchozích příkladech. Když odešleme tyto znaky do PC, budou správně fungovat, jen pokud máme nastavenou anglickou klávesnici. Pokud tomu tak je použijeme pro odeslání znaku funkci zmackniAnglicky – ta odešle pouze hodnotu znaku. Pokud ale máme nastavenou českou klávesnici, musíme před odesláním znaku přepnout na anglickou a po odeslání zase zpět. K přepínání jazyků slouží klávesová zkratka L_ALT + L_SHIFT. Pro speciální klávesy má Arduino vyhrazené konstanty, o nichž nalezneme podrobnější informace zde. Kód klávesnice vypadá následovně.

byte radky[4] = {3,8,7,5};
byte sloupce[3] = {4,2,6};

char znaky[4][3] = {{40,41,' '},
                   {123,125,' '},
                   {91,93,' '},
                   {60,62,' '}};

int cekej = 200;
long cas;

void setup(){
    for(int i = 0; i < 4; i++){
        pinMode(radky[i], OUTPUT);
    }  
    for(int i = 0; i < 3; i++){
        pinMode(sloupce[i], INPUT);
    }
    
    cas = millis();
}

void loop(){
    for(int a = 0; a < 4; a++){
        digitalWrite(radky[a],HIGH);
        for(int b = 0; b < 3; b++){
            if(digitalRead(sloupce[b]) == HIGH 
			&& (millis() - cekej) >= cas){
                zmackniCesky(znaky[a][b]);
                cas = millis();
            }
        }
        digitalWrite(radky[a],LOW);
    }        
}

void zmackniCesky(char znak){
    Keyboard.press(KEY_LEFT_ALT);
    delay(10);
    Keyboard.press(KEY_LEFT_SHIFT);
    delay(10);
    Keyboard.releaseAll();
    delay(10);
    Keyboard.print(znak);
    delay(10);
    Keyboard.press(KEY_LEFT_ALT);
    delay(10);
    Keyboard.press(KEY_LEFT_SHIFT);
    delay(10);
    Keyboard.releaseAll();
    delay(10);
}

void zmackniAnglicky(char znak){
    Keyboard.print(znak);
}

Uvedené kódy mohou sloužit jako základ pro další tvorbu – jednoduchou úpravou se dá vytvořit například smajlíková klávesnice.

Servomotory

Pro účely práce se servomotory je Arduino vybaveno knihovnou Servo.h. Tu do kódu vložíme příkazem #include <Servo.h>. Knihovna obsahuje několik funkcí a příkazů, z nichž nejpoužívanější jsou:

• Servo motor – vytvoří objekt Servo se jménem motor (jméno je volitelné)
• motor.attach(pin) – řekne programu, na kterém pinu je servo připojeno
• motor.write(hodnota) – nastaví pozici serva, hodnota je většinou v rozmezí 0 až 180 (občas i méně)

Ze serva vychází tři vodiče – žlutý/oranžový, hnědý a červený, odpovídající postupně signálu (připojuje se k Arduinu), GND a +5V. Jednoduchý program, který vezme hodnotu naměřenou na pinu A0, upraví její rozsah a odešle ji jako pozici serva, vypadá takto.

#include <Servo.h>
 
Servo motor;
int h; //hodnota měření

 
void setup(){ 
    motor.attach(10); //připojíme servo na pin 10
} 
 
 
void loop(){ 
    h = map(analogRead(A5),0,1024,0,180); 
    
    motor.write(h);
}  

To je k teorii řízení serv vše. Jednoduché že? Nyní se tedy můžeme pustit do projektu robotické ruky.

Robotická ruka

Cílem tohoto příkladu bude vytvořit jednoduchou robotickou ruku, která bude mít na konci fixu. Tou budeme moct vytvářet kresby na papíru. Budeme potřebovat:

1. Dřevo na mechanické konstrukce – v našem případě dřevěná laťka s průřezem 20x5mm.
2. Tavná pistole (nebo šrouby a herkules či jiné lepidlo – v závislosti na provedení)
3. Vodiče
4. Piny
5. Dutinkovou lištu – třípinovou
6. Kousek prototypovacího plošného spoje
7. 2x 10k potenciometr s lineárním průběhem
8. velké servo s konstrukcí
9. střední servo
10. Klip na papíry o velikosti pera, se kterým budeme kreslit
11. Dřevěnou desku o rozměrech alespoň 30x40cm

Začneme tím, že si nařežeme dřevěné části. Uřízneme jednu 17 cm dlouhou, jednu 15 cm dlouhou a dvě třícentimetrové části. Na jeden konec patnácticentimetrové laťky navrtáme dvě dírky se stejnou roztečí, jako ty na konstrukci u velkého serva. Na druhý konec vyřežeme obdélníkovou díru velikosti menšího serva. Sem servo vložíme a zalepíme nebo přišroubujeme.

Menší rameno

V dalším kroku přišroubujeme vytvořené rameno ke konstrukci většího serva.

Budeme pokračovat úpravou delší laťky. Na jeden konec nalepíme plastový kulatý převod menšího serva plochou stranou ke dřevu. Slepíme dva nejmenší kousky dřeva největší stranou k sobě a přilepíme je v pravém úhlu na druhý konec laťky. Na takto vzniklou podpěru přilepíme klip na papíry.

Na dřevěnou desku přilepíme, nebo přišroubujeme část konstrukce velkého serva (plastovou částí nahoru). Rozměry můžete vidět na obrázku.

Velké servo připojíme k Arduinu a funkcí .write() ho nastavíme na polohu 105. Poté nasadíme první rameno rovnoběžně s delším okrajem.

Připojíme malé servo a nastavíme ho na hodnotu 60. Poté připojíme druhé rameno kolmo k prvnímu.

Jelikož má menší servo krátký kabel, musíme si vyrobit „prodlužku“. Budeme potřebovat třížilový kabel, na jehož jednom konci budou piny a na druhém zdířky.

Nyní přichází na řadu zapojení. V tomto příkladu je použito následující: Velké servo je připojeno na pin A3, malé na A2. Také využijeme dva potenciometry, kterými budeme nastavovat polohu serv. Ty jsou připojeny k pinům A5 a A4. Výběr pinů však záleží čistě na nás. Na obrázku níže vidíte příklad konstrukce ovládání.

#include <Servo.h>
 
Servo sv, sm; 
int h1, h2; //hodnoty měření

 
void setup(){ 
    sv.attach(A3); 
    sm.attach(A2); 
} 
 
 
void loop(){ 
    h1 = map(analogRead(A5),0,1024,0,170); 
    h2 = map(analogRead(A4),0,1024,0,170); 
    
    sv.write(h1);
    sm.write(h2);
    
    Serial.println(h2);
}  

Už máme vše sestaveno a zapojeno i naprogramováno. Na desku si izolepou upevníme papír A4 (má přibližně stejnou velikost jako naše deska), připevníme tužku, nebo fixu do klipu a můžeme začít malovat.

Pokud se vám zdá ovládání, kdy se potenciometry nastavují úhly serv neohrabané, máte jistě pravdu. Poměrně jednoduše se dá ale vytvořit algoritmus, ve kterém budete mít možnost nastavit přímo souřadnice požadovaného bodu. Stačí k tomu jenom pár goniometrických funkcí – to už ale nechám na vás.

Zdroje obrázků

[Obr. 1: Datasheet keypadu]

V případě jakýchkoliv dotazů či nejasností se na mě neváhejte obrátit v komentářích.

Jestli jste zrovna dostali chuť na nějaké to experimentování s propojenými objekty, pak bude asi nejlepší začít projektem s pořádným tutoriálem. Uvedeným videem vás bude provázet svými instrukcemi Dana, Documentation Hero ze společnosti relayr, aby tak za pomocí Arduina Yún, plynového senzoru a relayr cloudu roztančila figurku Batmana do rytmu dat:

Jako vstup nám poslouží senzor plynu, zatímco servo motor bude hrát roli výstupu, k jehož ovládání využijeme webovou aplikaci vytvořenou pomocí browser-sdk.

Takto uložený kód nám do budoucna zpřístupní možnost propojit prototyp Arduino projektu s platformou relayr, stejně jako je tomu v případě zařízení vytvořených přes Particle.io Photon. Součástí cloudu je kromě detailních instrukcí i demo aplikace, jejíž cílem je poskytnout hladký přechod do světa Arduino-relayr prototypů.

V tomto článku se zaměříme na použití Arduina s WiFi shieldem. Ten nám umožní připojit se k síti bez nutnosti připojování Ethernet kabelu.

Seznámení

Občas se hodí mít možnost s Arduinem komunikovat bezdrátově. Pro různé účely se hodí různé způsoby komunikace – někdy je vhodnější použít bluetooth, někdy potřebujeme větší dosah a šáhneme například po modulech nRF24L01+, a když jsme v dosahu nějaké WiFi sítě, můžeme použít

WiFi shield. Jedná se o výrobek z oficiální produkce Arduina, tudíž k němu (jako k většině oficiálních desek) existuje výborná dokumentace. Na začátek si představme základní vlastnosti shieldu.

• WiFi shield se umí připojit k WiFi sítím se standardem 802.11b a 802.11g.
• Může se připojit k sítím bez hesla a také k těm se zabezpečením WEP a WPA2 Personal.
• Shield obsahuje slot na microSD kartu.
• S Arduinem shield komunikuje přes SPI rozhraní (stejně jako Ethernet Shield).
• SS pin WiFi shieldu je vyveden na pinu 10. SS pin SD slotu je připojen na pin 4.
• WiFi a SD kartu není možné používat současně.
• Na desce také nalezneme mini USB port pro update firmware shieldu.
• Aby se mohl shield k síti připojit musí síť vysílat svoje SSID (nesmí být skryto).
• Po zmáčknutí tlačítka RESET dojde k restartu Arduina i shieldu.
• Při práci se shieldem je doporučeno nepoužívat pin 7. Je totiž využíván knihovnou pro ovládání shieldu.

Na desce nalezneme i několik LED diod.

Piny WiFi shieldu

Pokud používáme shield s Arduinem starším než Arduino UNO rev3, musíme propojit 3.3V s IOREF. Starší desky poznáme podle toho, že mají méně konektorů a pin IOREF shieldu zůstane nepřipojen. Pozor ale na to, abychom toto propojení nepoužili s novější deskou.

Propojení pro starší desky

Pro ovládání slouží knihovna WiFi.h. Tu obsahuje Arduino IDE, tudíž ji nemusíme stahovat. Do kódu ji vložíme známým příkazem #include <WiFi.h>. Předtím, než se pustíme do programování shieldu, musíme ověřit, jestli je jeho firmware aktuální.

Zjištění verze firmware

Přestože je poslední verze firmware používaná už dlouhou dobu, může se stát, že narazíme na shield využívající starší verzi. Abychom zajistili správnou funkčnost, je vhodné firmware aktualizovat. Nejdříve ale musíme zjistit, jakou verzi vlastně máme. To provedeme pomocí jednoduchého kódu, který nám po sériové lince vypíše verzi firmware. S funkcemi se zatím zaobírat nemusíme, vše bude vysvětleno později.

#include <SPI.h>
#include <WiFi.h>

void setup() {
    Serial.begin(9600); 
    if (WiFi.status() == WL_NO_SHIELD) {
        Serial.println("WiFi shield je nepřipojen"); 
        while(true); //zacyklí program - ten dále nepokračuje
    } 
    Serial.print("Verze firmware: ");
    Serial.println(WiFi.firmwareVersion());
}

void loop() {}

Poznámka: Uvedený postup je použitelný pro Windows. Návod upgrade pro Mac a Linux naleznete zde.

Pokud verze firmware není 1.1.0 (nebo vyšší), je vhodné provést aktualizaci.

Aktualizace firmware

Před začátkem udpate musíme propojit dva piny, které umožní komunikaci s čipem AT32UC3 – mozkem procesoru. Jsou umístěny vedle microSD slotu. Procesor řídí chod čipu HDG104, který se stará o WiFi. Také bychom měli shield odpojit od Arduina.

Konfigurační piny

Firmware obou čipů můžeme nahrát přes USB. K tomu ale budeme potřebovat speciální software, který se jmenuje FLIP. Je to oficiální software od Atmel a dá se stáhnout přímo z jeho stránek. Po stažení vhodné verze spustíme instalaci a bez jakékoliv nutnosti konfigurace jej nainstalujeme. Z Githubu stáhneme nejnovější verzi firmware. Zde nás budou zajímat soubory wifi_dnld.elf a wifiHD.elf, které stáhneme.

Poté spustíme příkazový řádek a přepneme se do složky, kde je nainstalovaný soubor FLIP (většinou C:\Program Files (x86)\Atmel\Flip X.X.X\bin). Pozor! Může být nutné spouštět příkazový řádek s právy správce. V příkazovém řádku se do požadované složky přesuneme pomocí příkazu cd následovaným absolutní adresou, například tedy:

cd C:\Program Files (x86)\Atmel\Flip 3.4.7\bin

Příkazový řádek

Pomocí mini USB připojíme shield k počítači. Ve většině případů nedojde k automatické instalaci ovladačů a my je tedy budeme muset nainstalovat ručně. To provedeme tak, že otevřeme Ovládací panely a v nich s právy administrátora spustíme Správce zařízení. Pokud nedošlo ke správné instalaci driverů uvidíme zde podobnou položku, jaká je na obrázku.

Neznámé zařízení

Pravým tlačítkem na něj klikneme a vybereme možnost Aktualizovat software ovladače, poté zvolíme Vyhledat ovladač v počítači a v následující nabídce otevřeme složku s nainstalovaným programem FLIP (např. C:\Program Files (x86)\Atmel\Flip X.X.X). Kliknutím na tlačítko další program nalezne potřebné ovladače a nainstaluje je. Nyní už je vše připraveno pro instalaci nového firmware. Postupně nahrajeme oba stažené soubory, oba pomocí příkazu níže. V příkladu jsou oba soubory uložené ve složce C:\Users\uzivatel\Downloads.

batchisp.exe -device AT32UC3A1256 -hardware usb -operation erase f memory flash blankcheck loadbuffer C:\cesta\k\souboru program verify start reset 0

Začneme souborem wifi_dnld.elf.

batchisp.exe -device AT32UC3A1256 -hardware usb -operation erase f memory flash blankcheck loadbuffer C:\Users\uzivatel\Downloads\wifi_dnld.elf program verify start reset 0

Po úspěšném uploadu shield restartujeme, a poté nahrajeme i soubor wifiHD.elf.

batchisp.exe -device AT32UC3A1256 -hardware usb -operation erase f memory flash blankcheck loadbuffer C:\Users\uzivatel\Downloads\wifiHD.elf program verify start reset 0

Tím je proces instalace aktuálního software u konce. Dva konektory, které jsme předtím spojili, teď rozpojíme a odpojíme shield od USB. Aktuální firmware by měl mít verzi 1.1.0 (nebo vyšší).

Údaje potřebné pro připojení k WiFi

Pro připojení k otevřené síti nechráněné heslem stačí vědět její SSID (název).

Pro sítě se zabezpečením WEP je potřeba znát SSID, klíč (key) a index klíče (key index). Klíč je heslo v hexadecimální podobě. Většinou se získává převedením řetězce do hexadecimální reprezentace, nebo přímo zadáním tohoto řetězce (záleží na nastavení WiFi přístupového bodu).

Ukázka nastavení wep klíče

U sítí WPA2 Personal nám stačí SSID a heslo.

Přehled funkcí pro práci s WiFi

V následujícím přehledu si ukážeme funkce a objekty, které jsou potřeba při práci s WiFi shieldem. Některé funkce knihovny WiFi jsou velmi podobné těm, se kterými jsme se setkali při práci s Ethernet shieldem a některé jsou dokonce stejné.

Třída WiFi

Třída WiFiServer

Třída, která obsahuje informace o serveru a funkce pro práci s ním.

Třída WiFiClient

Obsahuje informace o klientovi a funkce pro jeho obsluhu.

Příklady

Tímto jsme si představili funkce používané pro obsluhu WiFi shieldu. Nyní si můžeme předvést několik ukázek. Ty vycházejí z oficiálních příkladů z dokumentace.

Připojení k síti

Následující příkladu ukazuje, jak se připojit k síti se zabezpečením WEP. Jednoduchou úpravou parametrů u WiFi.begin() se ale dá příklad modifikovat i pro WEP2 síť a také síť bez zabezpečení.

#include <WiFi.h>

char ssid[] = "SSID_site";      	//SSID sítě
char key[] = "klic_site";       	//klíč sítě
int keyIndex = 0;         			//číslo klíče
int status = WL_IDLE_STATUS;		//pomocná proměnná uchovávající stav připojení

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

    //zkontroluje, jestli je shield připojen 
    if (WiFi.status() == WL_NO_SHIELD) {
        Serial.println("WiFi shield neni pripojen"); 
        while(true); //zacyklí program, nic se nebude dít dál
    } 

    //pripoji se k síti
    while ( status != WL_CONNECTED) { 
        Serial.print("Pripojuji se k SSID: ");
        Serial.println(ssid);
        status = WiFi.begin(ssid, keyIndex, key);
        delay(10000);
    }

    Serial.print("Jste pripojen");
    printCurrentNet();
    printWifiData();
}

void loop(){
    //každých 10 sekund zkontrolujeme WiFi síť
    delay(10000);
    printCurrentNet();
}

void printWifiData() {
    //funkce pro výpis IP a MAC shieldu
    IPAddress ip = WiFi.localIP();
    Serial.print("IP adresa: ");
    Serial.println(ip);
    Serial.println(ip);

    byte mac[6];  
    WiFi.macAddress(mac);
    Serial.print("MAC adresa: ");
    Serial.print(mac[5],HEX);
    Serial.print(":");
    Serial.print(mac[4],HEX);
    Serial.print(":");
    Serial.print(mac[3],HEX);
    Serial.print(":");
    Serial.print(mac[2],HEX);
    Serial.print(":");
    Serial.print(mac[1],HEX);
    Serial.print(":");
   Serial.println(mac[0],HEX);
}

void printCurrentNet() {
    //odešle SSID sítě
    Serial.print("SSID: ");
    Serial.println(WiFi.SSID());

    //odešle MAC adresu přístupového bodu
    byte bssid[6];
    WiFi.BSSID(bssid);    
    Serial.print("BSSID: ");
    Serial.print(bssid[5],HEX);
    Serial.print(":");
    Serial.print(bssid[4],HEX);
    Serial.print(":");
    Serial.print(bssid[3],HEX);
    Serial.print(":");
    Serial.print(bssid[2],HEX);
    Serial.print(":");
    Serial.print(bssid[1],HEX);
    Serial.print(":");
    Serial.println(bssid[0],HEX);

    //odešle sílu signálu
    long rssi = WiFi.RSSI();
    Serial.print("Sila signalu:");
    Serial.println(rssi);

    //odešle typ zabezpečení
    byte encryption = WiFi.encryptionType();
    Serial.print("Typ zabezpeceni:");
    Serial.println(encryption,HEX);
    Serial.println();
}

Interakce se serverem

Pomocí dvou odkazů (zapni a vypni) budeme ovládat LED diodu připojenou na pin 9. Pomocí sériové linky nám Arduino vypíše, na jakou IP adresu se máme připojit. V příkladu se používá HTTP request. Práci s ním jsme si popsali v příkladu s Ethernet shieldem.

#include <SPI.h>
#include <WiFi.h>

char ssid[] = "SSID_site";  
char pass[] = "heslo_site";    

int status = WL_IDLE_STATUS;
WiFiServer server(80);

void setup() {
    Serial.begin(9600);  
    pinMode(9, OUTPUT);  

    if (WiFi.status() == WL_NO_SHIELD) {
        Serial.println("Shield nepripojen"); 
        while(true); 
    } 

    while ( status != WL_CONNECTED) { 
        Serial.print("Pripojuji k SSID: ");
        Serial.println(ssid);

        status = WiFi.begin(ssid, pass);
        delay(10000);
    } 
    server.begin();    
    printWifiStatus();    
}

void loop() {
	//čeká na připojení klienta
    WiFiClient client = server.available(); 

    if(client){  //když naleznem klienta
        String currentLine = "";         
        while (client.connected()){       
            if (client.available()){    
                char c = client.read();        
                Serial.write(c);     
				//pokud najde znak zalomení řádku (ukončuje request od klienta)
                if (c == '\n'){                 
                    if (currentLine.length() == 0) {   
                        client.println("HTTP/1.1 200 OK");
                        client.println("Content-type:text/html");
                        client.println();             
						//hlavička je oddělena znakem nového řádku 
  
                        //zde začíná HTML kód stránky
                        client.print("<a href=\"/H\">ZAPNI</a><br>");
                        client.print("<a href=\"/L\">VYPNI</a><br>");
  
                        client.println(); //dalším prázdným řádkem končí HTML část
                        break;         
                    } 
                    else{
                        currentLine = "";
                    }
                }     
		else if (c != '\r') {    
		    currentLine += c;
		}

		//kontroluje, jestli request končí na H, nebo L
		if (currentLine.endsWith("GET /H")) {
		    digitalWrite(9, HIGH);            //zapne LED
		}
		if (currentLine.endsWith("GET /L")) {
		    digitalWrite(9, LOW);             //vypne LED
		}
	    }
	}
        client.stop();
        Serial.println("client disonnected");
    }
}

void printWifiStatus() {
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);

  long rssi = WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.print(rssi);
  Serial.println(" dBm");
  
  Serial.print("http://");
  Serial.println(ip);
}

Tyto základní příklady, společně se znalostmi zmíněnými ve článku o Ethernet shieldu, slouží jako odrazový můstek pro další tvorbu.

Zdroje obrázků

[Obr. 1: Piny shieldu]

[Obr. 2: Propojení pro starší desky]

[Obr. 3: Konfigurační piny]

V případě jakýchkoliv dotazů či nejasností se na mě neváhejte obrátit v komentářích.

Na internetu existuje celá řada různých zdrojů, ze kterých je možné se dozvědět něco o programování Arduina a vyzkoušet si některé Arduino projekty a aplikace. Níže najdete zajímavé kousky v rozsahu od desítek stránek po několik stovek. Stejně tak, jako se liší rozsahem, liší se i tématy, kterých se dotýkají. Vyjma té naší (Průvodce světem Arduina) jsou všechny zmíněné knihy v angličtině.

Kniha první: Getting Started with Arduino A Beginners Guide

Spíše než o knihu se jedná o brožurku, ve které najdete naprosté základy pro práci s Arduinem. Je vhodná pro všechny, kteří s Arduinem a elektronikou spíše začínají a chtějí se dozvědět, jak funguje nepájivé kontaktní pole, rezistor, fotorezistor, spínač a další základní prvky elektronických obvodů.

Knihu můžete stáhnout ZDE.

Kniha druhá: Introduction to Arduino – A piece of cake!

Tato kniha se zabývá Arduinem od úplných základů (co je to mikroprocesor) a končí u středně pokročilých projektů. Prozradí vám například, jak s Arduinem a servem vytvořit gumičkovou zbraň. Vše je doplněno o ukázky kódu a schémata pro zapojení obvodů.

Knihu můžete stáhnout ZDE.

Kniha třetí: 20 Unbelievable Arduino Projects

V této knize naleznete návody na dvacet projektů s Arduinem, které se objevily na serveru Instructables.com. Občas se hodí mít projekty někde u sebe bez nutnosti přístupu k internetu. Naleznete zde například LED kostku 8x8x8, robota hrajícího šachy nebo svatební fotostánek.

Knihu můžete stáhnout ZDE.

Kniha čtvrtá: Open softwear – fashionable prototyping and wearable computing using the Arduino

Tento kousek potěší všechny, které baví vytváření nositelných technologií. V přehledné podobě představuje, co je to rezistor, svítivá dioda a další základní komponenty. Hlavně se ale zabývá způsoby, jak vytvářet obvody na oblečení. Jak vytvořit měkký spínač, jak udělat spínač z druku nebo jak ze zipu udělat detektor zapnutí. Vše doplňují povedené ilustrace.

Knihu můžete stáhnout ZDE.

Kniha pátá: Arduino Microcontroller Guide

V této krátké publikaci naleznete rychlý průřez programováním Arduina. Od základních konstrukcí jazyka se přes čtení hodnot na vstupech dostanete až k bitovému posunu.

Knihu můžete stáhnout ZDE.

Kniha šestá: Arduino Tips, Tricks, and Techniques

Autorem této publikace je americká elektro inženýrka a zakladatelka společnosti Adafruit – Ladyada, vlastním jménem Limor Fried, která si svůj pseudonym vybrala podle Ady Lovelace. Ta je dnes považována za vůbec první programátorku! Nyní už ale k samotné publikaci. Nalezneme v ní vše od popisu komponent Arduino desek, základních funkcí jazyka Wiring, až po výměnu stabilizátoru z 5V na 3.3V a tipy na uvolnění paměti na čipu.

Knihu můžete stáhnout ZDE.

Kniha sedmá: Průvodce světem Arduina

Jako jediná ze zmíněných knih je tato kniha v češtině. Kniha se zabývá vším kolem fenoménu Arduino. Od představení jednotlivých desek, přes konstrukce jazyka Wiring, až po používání několika vybraných shieldů. Můžete ji stáhnout tak, že zadáte své jméno a email vpravo vedle tohoto článku.

Průvodce světem Arduina

Arduino Robot RedBot od společnosti SparkFun je určen všem, kteří by se rádi pustili do programování a bastlení vlastního pojízdného robota, ale nechtějí řešit, jestli jim náhodou nechybí nějaká potřebná součástka. Robot RedBot je k dostání ve dvou kitech, které se liší výbavou komponent pro vaše robotí hry.

RedBot Basic Kit je první a jednodušší varianta stavebnice robota. Obsahuje mechanickou konstrukci, motory, kola, hlavní desku, senzory na sledování čáry, akcelerometr, vodiče a krabičku na baterie.

Druhý a rozšířenější kit se nazývá Inventor’s Kit for RedBot. Mimo komponenty ze základní sady zde nalezneme navíc Hallovy sondy, nárazníky a bzučák.

V prvním článku ze seriálu o robotu RedBot si představíme, co všechno nalezneme v setu Inventor’s Kit for RedBot. Velká část postupů ze seriálu ale bude použitelná i pro základní kit.

Celý seriál o stavbě, programování a provozu robota RedBota bude postupně vycházet na Arduino.cz a bude tak doplňovat zajímavé Arduino projekty. RedBot robot je vhodný jak pro začínající bastlíře, tak i pro zkušenější uživatele. Je možné ho totiž provozovat se základním programem, ale také se složitějším a komplexnějším programovým vybavením a funkcemi.

Co ve stavebnici „Inventor’s Kit for RedBot“ najdeme?

Abychom věděli, k čemu je která součástka z kitu, nyní si je představíme.

Krabička s kitem RedBot

Základní deska robota RedBot

Základní deska

Jak už název napovídá, jedná se o centrální mozek celého robota. Uprostřed desky má čestné místo procesor AtMega328, kterou nalezneme například na Arduino UNO. Vedle čipu nalezneme dvě řady pinů sloužící k zasunutí bezdrátových modulů XBee. Díky nim je možné robota ovládat na dálku. Nahoře uprostřed nalezneme přepínač sloužící ke konfiguraci softwarové linky XBee. Vlevo dole nalezneme konektor pro připojení napájení, vpravo dole zase USB port. Po obou stranách nalezneme volné výstupy napájení. V levé polovině dole nalezneme dva vypínače. Jeden slouží k zapnutí robota, druhý k zapnutí motorů. Výrazným prvkem na obou polovinách je šestice šestipinů, které jsou popsané SERVO, popřípadě SENSOR. Každý sloupec pinů má dole GND, uprostřed +5V a nahoře jeden z digitálních, či analogových pinů – všechny jsou přehledně popsány. Dva konektory dole uprostřed slouží k připojení motorů.

Akcelerometr

Akcelerometr

Akcelerometr je zařízení, které je schopné měřit akceleraci – tedy zrychlení. U robota RedBot se jedná o tříosý akcelerometr – tzn. měří zrychlení ve všech třech osách. Můžeme ho použít na detekci pohybu, nebo otřesů při jízdě.

Bzučák

Bzučák

Bzučák neslouží k ničemu jinému, než aby vám dal zvukovou signalizací vědět, že se něco děje. Připojíte ho na základní desku a pomocí funkce tone() můžete hrát melodie.

Senzor na sledování čáry

Senzory pro sledování čáry

V kitu nalezneme hned tři senzory pro sledování čáry. Na každé desce nalezneme infračervený vysílač a přijímač. Pomocí rozdílu odraženého světla od černé a bílé plochy jsme schopni určit, jestli je robot stále nad čárou, nebo nikoliv. Senzory jsou tři, protože jsou umístěny na přední stranu robota všechny a slouží tak k přesnějšímu navádění.

Nárazníky

Nárazník

Dva nárazníky trochu připomínají kočičí fousky. Jejich princip je velice jednoduchý. V případě, že se drátku vedoucího z jedné poloviny něco dotkne, spojí se obvod s druhou polovinou a je detekován náraz.

Dvě Hallovy sondy

Hallovy sondy

Magnety pro Hallovy sondy

Hallova sonda je schopná měřit magnetické pole. Spolu v kombinaci s magnety nasazenými na osu motoru je díky ní možné zjistit, kolik otáček motor udělal. Umožňuje tak mít větší přehled o aktuální poloze vozítka. Důležité je vědět, že mají magnety po obvodu celkem osm pólů (čtyři severní a čtyři jižní).

Další části už není třeba komentovat

Motor

Vodiče

Krabička na baterie

Kola

Mechanické části

Dále v kitu naleznete ještě baterie, USB kabel a malý šroubovák.

Bastlení zdar! Těšte se na další pokračování článku o RedBotovi.

Na začátku prázdnin jsme tu měli článek, ve kterém jsme vám představili hned několik velmi zajímavých Arduino projektů a aplikací pro vaši inspiraci. Na konci prázdnin vám přinášíme další várku cool Arduino projektů!

Arduino Hodiny

Tyto futuristické hodiny vám zobrazí čas tak, že zvýrazní slova tvořící aktuální hodiny a minuty a to tak, že vytvoří větu informující o čase. Budete potřebovat nejenom Arduino UNO, ale také několik dalších součástek, jako Shift registry a podobně. Také se k tvorbě tohoto projektu hodí umět vytvářet plošné spoje. Instrukce pro stavbu naleznete zde.

„Slovní Hodiny“

LED kostka 8x8x8

Oblíbenou činností hardwarových nadšenců je tvorba různých LED kostek. Nejedná se totiž jen o pěknou hračku, ale také o zajímavou výzvu, co se technologické stránky projektu týče. U kostky o straně a je potřeba celkem a²+a ovládacích pinů, což na Arduinu většinou nenajdete (u menších kostek samozřejmě ano, ale už s a=7 by to mohl být problém). Nastává tedy nutnost použít multiplexer, nebo podobnou součástku. Stejně tak v kostce o hraně a nalezneme celkem a³ LED (u kostky 8x8x8 celkem 512 diod!), které si už vyžádají poměrně velký odběr. Chcete-li se nechat inspirovat, podívejte se na tento Arduino projekt. Dalším krokem by mohlo být vytvoření kostky s RGB LEDkami!

LED kostka 8x8x8

POV kouzelná hůlka

POV zařízení (zkratka z Persistence Of Vision) využívají setrvačnosti lidského oka, popřípadě délku uzávěrky fotoaparátu. Budete-li před sebou ve tmě mávat LEDkou, bude se vám zdát, že před sebou vidíte křivky nakreslené světlem do vzduchu. Je to dáno tím, že lidské oko má setrvačnost. Jedná se tedy o iluzi způsobenou nedokonalostí vidění. Dají se s ní však dělat zajímavá kouzla. Představte si, že máte vedle sebe těchto LED hned několik a budete je vypínat a zapínat v přesném načasování. Pokud zapínání správně načasujete, objeví se před vámi ve vzduchu nápis, či obrázek. Přesně na tomto principu funguje i další projekt POV hůlky.

POV hůlka

Generátory zvuku

Patříte-li mezi ty, kteří rádi generují elektronickou hudbu, určitě vás potěší sada projektů Making noise machines.  Naleznete zde například krabičku, která vytváří zvuk podle toho, jak se dotýkáte květiny, nebo také zařízení generující zvuk podle dotyků touchpadu. To vše v krásných dřevěných obalech.

Zvukové krabičky

Hodiny kreslící čas

Jedny hodiny jsme tu už měli. Tyto jsou ale mnohem podivnější – a to už svým principem. Čas totiž zobrazují tak, že je kreslí mazatelnou fixou na plastovou tabulku. Vždy při aktualizaci času ji smažou a kreslení začne od začátku. Budete potřebovat Arduino, Hodiny reálného času a Servomotory.

MicroView hrací kostka

Na desce MicroView naleznete malé Arduino, které je navíc vybaveno OLED displejem. To nabádá k jeho použití k různým vizualizacím. V tomto projektu je MicroView použito jako hrací kostka. Senzor náklonu pozná, že došlo k pohybu a poté dojde k „hodu“. Náhodně je vygenerováno nové číslo a také je překreslen display. Vše je zabaleno v obalu vytištěném na 3D tiskárně. Na stránce microview.io naleznete spoustu dalších projektů s deskou MicroView.

Microview kostka

Etch-a-Sketch a laserová řezačka

Patříte-li mezi šťastlivce, kteří mají přístup k laserové řezačce, můžete vyzkoušet následující Arduino projekt. Asi si pamatujete Etch-a-Sketch – dětskou kreslící tabulku, kde jste pomocí dvou koleček ovládali železný hrot, který na plexisklo potažené hliníkovým práškem kreslil kostrbaté malůvky. Stačilo zatřást, prášek opět pokryl plexisklo a bylo po malůvce. Stejné ovládání si nyní můžete sestrojit pomocí Arduina a ovládat jím laserový řezák. Pozor! Tady zatřesení neobnoví plochu do původního stavu!

Arduino telefon

S Arduinem se dá dělat mnohé, tak proč si například nesestrojit vlastní telefon! Budete potřebovat TFT displej, GPRS shield a Arduino.

Game of Life na Arduinu

Wikipedie říká o Game of Life:

Hra života nebo také život (anglicky Game of Life či pouze Life) je dvoustavový, dvourozměrný celulární automat^[1], který svým chováním připomíná vývoj společenství živých organismů.^[2] Odehrává se na matici buněk, jejíž stav předurčuje podobu hry v následujícím kroku.

Game of Life – Hra života

Představte si, že máte buňky seřazené na čtverečkovaném papíru. Každá buňka může mít dva stavy – živá nebo mrtvá (odtud dvoustavový). Celý systém prochází různými „koly“. Mezi jednotlivými koly může dojít k tomu, že:

1. buňka zemře
2. buňka ožije
3. buňka zůstane ve stavu v jakém je

To, co se s buňkou stane je závislé na jejích okolních podmínkách. Pravidla se mohou lišit v různých verzích Game of Life, ale v původní verzi jsou to:

1. Každá živá buňka s méně než dvěma živými sousedy zemře.
2. Každá živá buňka se dvěma nebo třemi živými sousedy zůstává žít.
3. Každá živá buňka s více než třemi živými sousedy zemře.
4. Každá mrtvá buňka s právě třemi živými sousedy oživne.

Díky těmto pravidlům dochází k postupné proměně celého systému. Mohou vznikat velmi zajímavé obrazce. Na displeji počítače je to pěkná podívaná, ale co teprve, když ji zobrazíte na maticovém displeji obohaceném o barvy! Jak na to se dozvíte v tomto návodu. Pokud si chcete pohrát s velmi zajímavou platformou, můžete použít Rainbowduino a RGB maticové displeje. Více o Rainbowduinu se můžete dočíst ve článku Arduino a displeje.

Arduino zahradník

Patříte-li mezi megalomany nebo zahrádkáře, asi se vám bude líbit tento projekt. Jedná se o automatického zahradníka, který je založen na stejném principu jako například 3D tiskárny, ale v mnohem větším měřítku. Je ovládán Arduinem, shieldem Ramps a připojení k internetu a hlavní část logiky zajišťuje Raspberry PI.

Arduino zahrádkář

Arduino hodinky WatchDuino2

V době rozmachu nositelné elektroniky by žádnému geekovi neměly chybět chytré hodinky, nebo alespoň nějaký ten tracker. O to lépe, když jsou hodinky vytištěné na 3D tiskárně a ovládané Arduinem! Více na stránkách projektu.

Arduino hodinky

Máte nějaký zajímavý projekt? Pochlubte se s ním v komentářích pod článkem, nebo na našem Facebooku, kde také běží soutěž o Arduino M0.

DIY Arduino Jukebox se řadí mezi Arduino projekty Maria Pucci. V tomto projektu je představeno, jak vytvořit funkční hrací skříňku pomocí NFC Shieldu, programování v Pythonu a Arduino Uno.

NFC je zkratka pro Near field communication, komunikace mezi zařízeními na krátkou vzdálenost do 4 cm. Tato technologie je dnes běžně používána například v mobilních telefonech. Samotný NFC Arduino Shield může zaznamenat objekty připojené na malé čipy, NFC visačky, které přenášejí specifické zprávy. Pro projekt Mario naprogramoval každý čip tak, aby hrál vlastní hudební žánr, potom co visačku pohltí lepenkový jukebox.

Jednotlivé body tutoriálu jsou v italštině, ale v nouzi můžete použít google překladač. A nebo vyzkoušejte podobný anglický návod zde.

Přeloženo z https://blog.arduino.cc/2015/09/16/a-diy-jukebox/.

DIY Arduino Jukebox s NFC Shieldem – nákres

Stejně jako v minulém případě stroj pracuje na bázi technologie rozpoznávání barev, přičemž všechny jeho součásti pochází z útrob 3D tiskárny. Kalibrace senzorů ale probíhá „zachycením“ prvního bonbonu určité barvy v rotačním disku (viz video).

V jádru tohoto Arduino projektu nalezneme známé Arduino Uno spolu s Adafruit Motor v2 shieldem (pohon DC motorů), senzor pro snímání barev ZITRADES (TCS3200) + LED dioda, dvě HY860D fotozávory (určování polohy disků), foto resistor (na zjištění kdy Skittles spadne) a tři DC motory s převodovkami. Nasvícení bonbónů Skittles je provedeno vždy LED diodou. Světlo z LED diody je usměrňováno tak, aby se nedostalo přímo na snímač barev. Odleskům světla pak brání polarizační filtr, který je umístěn před snímačem barvy. Tento Arduino robot využívá zajímavé principy, které by mohly být vhodné i pro vaše další Arduino projekty.

Více informací o projektu naleznete zde. Jelikož se jedná o open-source řešení, naleznete tam také všechny návody a kód pro programování k vytvoření vlastní třídičky. K dispozici jsou také data pro 3D tiskárnu.

V minulém článku jsme si ve stručnosti představili, co je to Arduino robot RedBot. Dnešní článek je vlastně návod, jak tohoto robota sestavit do použitelné podoby. Sestavíme si všechny jednotlivé části a postupně je připevníme k hlavním mechanickým deskám. Stavebnice robota může být inspirací pro vaše další Arduino projekty.

Pozor! Používejte minimum násilí. Mohlo by dojít k mechanickému poškození částí. Sestavení robota občas vyžaduje například více zatlačit, ale buďte opatrní. Nedoporučujeme používat žádné nářadí (kleště…) kromě přiloženého šroubováku.

Součásti robota

Níže vidíte všechny součásti Inventor’s Kitu popsané písmeny.

Všechny komponenty robota RedBot

Hallovy sondy

Hallovy sody detekují pomocí magnetů otáčky motorů. Musí být tedy umístěny blízko nim. Nejdříve si navlékneme magnety (2x N) na osy motorků.

Motor s navléknutým magnetem

Z jedné z hlavních mechanických desek vyloupněte menší destičky (2x F) obdélníkového tvaru a provlékněte jí Hallovu sondu.

První Hallova sonda umístěná v držáku

To stejné proveďte s druhou sondou, ale zrcadlově.

Druhá Hallova sonda umístěná v držáku

Oba moduly nyní umístěte podle obrázku do desky, ze které jste vyloupli destičky pro sondy (A).

Spodní deska se zasazenými moduly s Hallovými sondymi

Hallovy sondy máme umístěné, zbývá k nim přidat motory.

Motory a kola

Budeme potřebovat kola (2x L), motory (2x K), a úchyty motorů (2x D, 2x C). Začneme tím, že na motory navlékneme středový úchyt (D). Pozor! Není to tak jednoduché. Začneme tím, že ve navlečeme úchyt na motor ze strany, kde je magnet. Měli bychom ho mít v poloze, jakou vidíte na obrázku. Pozor, aby se vodiče nezapletly někam jinam. Mohlo by dojít k jejich poškození.

Připevnění motoru – Krok první

Přidržujte vodiče na místě a opatrně otočte úchytem do polohy na obrázku níže.

Připevnění motoru – Krok druhý

Poté připevněte zadní úchyt (C). To stejné proveďte s druhým motorem.

Připevnění motoru – Krok třetí

Motory přidělejte ke spodní desce (A).

Připevnění motoru – Krok čtvrtý

Nakonec nasuňte kola na bílé plastové osy motorů.

Připevnění motoru – Krok pátý

Senzory sledující čáru

Nyní budeme potřebovat senzory na sledování čáry (3x Q), vodiče (3x Y) a úchyty senzorů (I, J).

Začneme tím, že senzory umístíme do úchytu I.

Umístění senzorů do úchytu

Zajistíme je úchytem J.

Zajištění senzorů

Připojíme vodiče tak, aby bylo zapojení odpovídající tabulce:

Připojení vodičů k senzorům

Nakonec umístíme senzory zespodu hlavní hlavní desky.

Připevnění senzorů k podvozku

Nárazníky

Budeme potřebovat horní desku (B), modul nárazníku (2x T), drát (2x U), šroub (6x V), rozpěra (2x W), matka (2x X), vodiče (2x Y), šroubovák. Budeme potřebovat křížový šroubovák. Dodávaný šroubovák je oboustranný. Pokud je zrovna viditelná část s plochou hlavou, vytáhněte stříbrnou osu a otočte ji. Nyní bude venku křížová hlava. Začneme tím, že na modul nárazníku přišroubujeme šroubek a matku.

Umístění šroubku na nárazník

Nyní musíme ohnout drátek, který bude sloužit jako nárazník. Pokud nemáme po ruce kleště, můžeme použít samotný elektrický modul nárazníku. Prostrčte drát malou dírkou v nárazníku tak, aby kousek koukal ven. Ale hlavně – pozor na oči, drát může být ostrý!

Drátek nárazníku

Opatrně jej ohněte o 180°.

Ohnutí drátu nárazníku

Připevněte drátek k elektrickému modulu pomocí šroubu a umělohmotné rozpěry.

Umístění drátu

Připevnění drátu

To stejné proveďte s druhým modulem, ale zrcadlově.

Oba moduly nárazníku

Dále moduly přišroubujeme do obdélníkové dírky na přední straně horní desky.

Umístění modulů nárazníku

Vodiče připojíme stejně, jako jsme je připojili u senzorů pro sledování čáry.

Připojení vodičů

Spojení horní a dolní desky

Budeme potřebovat kluznou část (M) – ta tvoří třetí opěrný bod robota – a spojovací díly (4x E). Začneme tím, že přiděláme kluznou část na spodní desku.

Připojení kluzné části

Dále připojíme spojovací části do všech rohů spodní desky.

Připojení spojovacích částí

Než připojíme horní desku, musíme si protáhnou vodiče odpovídajícími dírami. Levé vodiče povedeme levými dírami, pravé pravými. Strana vedení vodiče středního senzoru pro sledování čáry je na nás. Poté můžeme obě desky spojit.

Spojení horní a dolní desky

Hlavní deska

Budeme potřebovat hlavní desku (P) a úchyt (2x G). Začneme tím, že připevníme úchyty na horní desku.

Úchyty hlavní desky

Do úchytů připevníme hlavní desku.

Hlavní deska

Nyní nás čeká poměrně obtížný úkol, a to vše správně zapojit. Pomůžou nám k tomu následující tabulky:

Levý Senzor pro sledování čáry

Střední Senzor pro sledování čáry

Pravý Senzor pro sledování čáry

Levý Nárazník

Pravý Nárazník

Levý Motor:

Pravý Motor:

Pozor! U pravého motoru je zapojení opravdu obrácené, než u levého!

Levá Hallova sonda:

Pravá Hallova sonda

Zapojení by tedy mělo vypadat následovně:

Schéma zapojení

Obrázky pocházejí z anglického návodu od společnosti SparkFun.

Bastlení zdar! A těšte se na další pokračování seriálu o RedBotovi.

V příštím článku už si ukážeme, jak na Arduino RedBot programování.

V dalším dílu seriálu předvede Massimo Banzi, jak Arduinem ovládat software ve vašem PC. Pokud vám angličtina dělá problém, nezapomeňte zapnout titulky!

Zajímáte-li se o Arduino programování a chtěli byste se dozvědět více o práci s prostředím Processing, podívejte se na některé naše další články. Ve článku Processing se tímto prostředím zabýváme podrobněji. Ve článku Arduino a Processing si můžete přečíst více o propojení a komunikaci těchto dvou platforem.

Něco vám ve videu není jasné? Ptejte se v komentářích!

V minulých dílech jsme si RedBota představili a také jsme si ho sestavili dohromady. Dnes už nám tedy nic nebrání v tom, abychom se vrhli do jeho programování. Začneme tím úplně nejzákladnějším.

Připojení RedBota
Abychom mohli s naším Arduino robotem dále pracovat, připojíme ho k bateriím a také pomocí přiloženého USB kabelu k počítači. Pokud ještě nemáte Arduino IDE, stáhněte si jej ze stránky Arduino.cc. Můžete také použít jeho alternativu Arduino Studio.

Může se stát, že váš počítač nebude správně komunikovat s RedBotem. Stáhněte si ovladač (Windows, OS X >=10.9, OS X <= 10.8) a nainstalujte jej podle specifikací vašeho OS.

Instalace RedBot knihovny
Abychom si všechny obslužné funkce nemuseli psát sami, stáhneme si RedBot knihovnu. V počítači nalezneme složku, ve které má Arduino uložené knihovny. Ve Windows je to například  složka Dokumenty/Arduino sketches/libraries. Složku libraries také nalezneme přímo ve složce, kam jsme nainstalovali, popřípadě rozbalili Arduino IDE. Stažená knihovna obsahuje složku RedBot. Knihovnu extrahujeme do složky libraries (nezáleží, do které ze dvou zmíněných). Tato složka by nyní měla mít přibližně následující obsah:

• libraries
  • …
  • RedBot
    • RedBot_Experiments
    • RedBot.cpp
    • RedBot.h
    • …
  • …

Složka RedBot_Experiments navíc obsahuje programy, se kterými budeme ve článcích o RedBotovi pracovat.

Výběr desky
Možná byste čekali, že v menu Tools/Board budeme vybírat nějakou speciální desku – například RedBot_board. Tak tomu však není. Hlavní deska robota totiž není nic jiného, než trochu upravené Arduino UNO – i použitý procesor, kterým je AtMega328, je stejný. V menu Tools/Board tedy vybereme Arduino UNO, popřípadě Genuino/Arduino UNO v novějších verzích IDE. Poté vybereme příslušný port z Tools/Port. 

První program
Nyní máme robota připraveného k programování. Vyzkoušejme tedy, jestli se vše povedlo jednoduchým programem, který nám zabliká LEDkou. Ten nalezneme pod: File/Examples/RedBot/RedBot_Experiments/Exp1_BasicTest.

void setup(){
  pinMode(13, OUTPUT); // budeme blikat LED na pinu 13
}

void loop(){
  digitalWrite(13, HIGH); // zapneme LED na pinu 13
  delay(500);             // počkáme 500 milisekund
  digitalWrite(13, LOW);  // vypneme LED na pinu 13
  delay(500);             // počkáme 500 milisekund
  //celý cyklus trvá 1000ms = 1s a opakuje se stále dokola
}

RedBota zapneme pomocí přepínače označeného Power.

RedBot hlavní vypínač

Nyní stiskneme tlačítko Upload v Arduino IDE. Pokud vše proběhne úspěšně, měli bychom vidět blikat LEDku označenou D13 LED. Všimněte si, že v této chvíli ještě nevkládáme knihovnu RedBot. Žádná z funkcí, které jsou použité v programu, totiž tuto knihovnu nevyžaduje.

Co dál?
Můžete si například pohrát s délkou blikání LEDky. Co takhle zkusit délku cyklu 20ms, 10ms, nebo třeba LED načasovat tak, aby svým blikáním připomínala tlukot srdce?

Možné problémy
Pokud vám RedBot nepracuje tak, jak by měl, může to býz způsobeno vícero věcmi. Ty nejpravděpodobnější jsou:

• USB kabel není správně připojen. Zkuste ho odpojit a znovu připojit do Arduina i do PC.
• Ujistěte se, že přepínač POWER je v poloze ON.
• Pokud se vám nedaří program nahrát, ujistěte se, že máte vybrán správný sériový port. Nejjednodušší způsob, jak zjistit, jaký port náleží robotovi je odpojit USB a sledovat, který port z nabídky zmizel.
• Pokud máte na hlavní desce připojený XBee modul, je důležité, aby byl přepínač pro volbu portu Xbee přepnut do polohy XBEE SW SERIAL.
• Ještě jednou zkontrolujte, jestli máte vybranou správnou desku v nabídce Boards
• Také se může stát, že budou vybité baterie. To poznáte podle toho, že LED označená Power nesvítí ani po zapnutí robota.

Na co se můžete těšit příště? Příště se už s naším Arduino robotem konečně projedeme!

Seriál Arduino robot RedBot vychází z Experiment Guide for RedBot od společnosti SparkFun, ze kterého také pocházejí některé obrázky.

Konečně se dostáváme k tomu, že našeho robota rozpohybujeme! Začneme tím, že si napíšeme krátký program, který robota rozjede dopředu a zastaví.

Abychom nemuseli komponenty ovládat přímo, použijeme knihovnu RedBot. Ta nám ušetří mnohé problémy, na které bychom mohli narazit. Abychom tuto knihovnu mohli použít, vložíme na začátek programu část: #include <RedBot.h>. (Pamatujte na to, že Arduino kód je case-sensitive, tedy rozlišuje malá a velká písmena. Musíte tedy opravdu napsat RedBot.h, jinak program nebude fungovat). Součástí knihovny je i objekt RedBotMotors, který v tomto příkladu použijeme k ovládání motorů.

RedBotMotors motors;

Tento příkaz vytvoří objekt s názvem motors, který nám umožní ovládat pravý a levý motor robota.

Před tím, než do robota nahrajete následující kód, ujistěte se, že je RedBot na bezpečném místě a je kolem něj dostatek prostoru. Program začne okamžitě a robot by mohl například sjet z vašeho stolu a poškodit se. Pro účely testování navrhujeme robota podložit tak, aby byla kolečka podložena a robot nikam neujížděl.

Před nahráním robota zapněte, připojte motory a baterie. Přepínač motorů nastavte na RUN.

RedBot přepínač pro nastavení motorů

Nahrajte program do Arduina

Otevřete program Exp2_DriveForward v File > Examples > RedBot_Experiments, nebo si ho zkopírujte níže:

#include <RedBot.h>

RedBotMotors motors; 

void setup()
{
  motors.drive(255);   
  delay(2000);         // Waits for 2 seconds
  motors.stop();       // Stops both motors
}

void loop(){}

Nahrajte kód do Arduina. Motory by se měly začít točit plnou rychlostí (pravý po směru hodinových ručiček, levý proti směru) a po dvou vteřinách by měly zastavit.

Odpojte USB kabel a postavte robota na podlahu. Zmáčkněte tlačítko RESET. Program začne znovu a robot popojede dopředu a zastaví se.

Můžete zkusit změřit, jak daleko robot ujede a také měnit hodnotu v motors.drive().

Něco víc o motorech

Úvodní příklad by mohl stačit, ale pro lepší porozumění se podíváme, jaké možnosti nám pro ovládání motorů nabízí knihovna RedBot. Jejím vložením získáme přístup k několika třídám, které souží k jednoduchému ovládání jednotlivých součástí robota.

• RedBotMotors – ovládání motorů
• RedBotAccel – ovládání akcelerometru
• RedBotBumper – ovládání nárazníků
• RedBotEncoder – ovládání enkodérů na motorech
• RedBotSensor – různé senzory
• RedBotSoftwareSerial – SoftwareSerial pro připojení Xbee ovládání

V této části nás bude zajímat třída RedBotMotors. Tato třída má hned několik metod, použitelných pro ovládání motorů.

RedBotMotors motors; // Instantiate the motor control object.

Tento řádek deklaruje objekt motors, který je instancí třídy RedBotMotors. Nyní můžeme na objektu motors volat jakoukoliv metodu, která je součástí RedBotMotors. To zní složitě, ale podívejte se na následující příklady a hned bude jistě vše jasné. Volání se provádí:

motors.jmeno_metody();

Jízda dopředu a dozadu

motors.drive(sila_motoru) roztočí oba motory. Tato metoda vyžaduje jeden parametr sila_motoru, který může nabývat celočíselných hodnot od -255 do 255. Hodnoty větší než nula rozjedou robota dopředu, menší než nula dozadu.

motors.drive(255);
// rozjede se dopředu na plný výkon 
 motors.drive(-255);
// rozjede se dozadu na plný výkon

Zastavování

motors.stop() vypne napájení obou motorů, čímž zastaví robota. Robot má ale setrvačnost, takže zastavení není okamžité.

motors.stop();

Někdy možná budete chtít kola zastavit ihned. Pohyb způsobený setrvačností nebude žádoucí. K tomuto účelu slouží motors.brake(). Zkuste rozjet robota a zastavit ho pomocí motors.stop() a pomocí motors.brake() a sledujte rozdíl brzdné dráhy.

motors.brake();

Další experimenty

Vyzkoušejte si program, který robota rozjede na vteřinu dopředu a na vteřinu dozadu. Toto zopakujte několikrát a sledujte, jestli se vždy vrátí na původní místo. Jak daleko jsou od sebe počáteční a koncový bod vzdáleny? Co může způsobit, že se robot nevrátí na původní místo?

Dále můžete zkusit upravit rychlost, kterou se robot pohybuje. Zkuste najít rychlost, kterou robot za dvě sekundy ujede asi 1 metr. Hodnotu si někam poznamenejte, protože ji za chvíli použijeme. Vyzkoušejte to několikrát a zkuste najít optimální hodnotu.

Spočítejte průměrnou rychlost pohybu v centimetrech za sekundu.

rychlost = draha[cm]/cas[s]

Napište vlastní funkci pro ujetí určité vzdálenosti

Mimo funkcí definovaných v knihovnách si můžeme napsat i vlastní funkce. Každá funkce se skládá z několika částí:

Definice funkce

Return type je datový typ, který funkce vrací. Function name je název funkce. Údaje v kulatých závorkách – parameters – značí parametry funkce. Tato funkce je datového typu void, tedy nevrací žádnou hodnotu.

V tomto příkladu použijeme rychlost, kterou jsme si spočítali dříve, abychom si trochu usnadnili plánování pohybu. Pomocí vypočtené hodnoty určíme přibližný čas čekání mezi zapnutými a vypnutými motory. Z rovnice pro rychlost můžeme vyjádřit čas:

cas = draha / rychlost

Zkopírujte si následující funkci pod funkci loop().

void driveDistance(int distance)
{ 
    int avgSpeed = 16;  //rychlost, kterou jsme vypocetli

    long driveTime;
    driveTime = (long) 1000 * distance / avgSpeed;
    motors.drive(200);  // zadejte rychlost, kterou jste pouzili pri testu
    delay(driveTime);
    motors.brake();
}

V programu nyní můžeme použít driveDistance(12) k ujetí 12 cm (přibližně). Zkuste tuto funkci použít ve vašem programu. Pokud se ujetá vzdálenost liší o více než 1 cm, zkuste upravit hodnotu proměnné avgSpeed.

Řešení problémů

Problémy s kompilací

Exp2_DriveForward:18: error: 'RedBotMotors' does not name a type
Exp2_DriveForward.ino: In function 'void setup()':
Exp2_DriveForward:23: error: 'motors' was not declared in this scope

Tento problém je nejčastěji způsoben tím, že knihovna RedBot není správně vložená do programu.

• Ověřte, že na začátku programu máte: #include <RedBot.h> (se stejnými velkými a malými písmeny)
• Arduino IDE nemůže najít knihovnu RedBot. Podívejte se do Sketch > Include Library > Manage Libraries, jestli máte knihovnu RedBot staženou.

Motory se netočí

• Zkontrolujte přepínač MOTOR, jestli je nastaven na RUN
• Máte desku připojenou k baterii, nebo adaptérů? Motory potřebují více, než dokáže dodat pouhé USB, takže pouze s ním si nevystačíte.
• Ověřte, zda jsou motory správně zapojené

Robot se pohybuje, ale točí se dokola

• Zkontrolujte zapojení motorů. Je pravděpodobné, že je jeden z motorů zapojen naopak.

Robot se nepohybuje rovně

Toto je běžná věc u robotů, které mají motory individuálně pro každé kolo. Existuje několik důvodů proč tomu tak je.

• Zkontrolujte, jestli některé z kol nedrhne o konstrukci robota.
• Jízda rovně vyžaduje rovnoměrné napájení motorů. Může se stát, že když je rychlost nastavena na 255, ztratí motory tah a pohyb pak není rovnoměrný. Zkuste začít s nižší hodnotou.
• Dále v tomto seriálu se naučíme používat enkodér s hallovými sondami k zajištění rovnoměrného pohybu obou kol.

V tomto článku se naučíme, jak ovládat jednotlivé motory robota zvlášť. Tím ho budeme moci navést tam, kam budeme potřebovat. Také si představíme několik nových metod třídy RedBotMotor.

Ukážeme si, jak napsat příkazy pro sekvenci: jeď rovně, otoč se o 90 stupňů, jeď rovně, zastav. Ujistěte se, že má robot kolem sebe dostatek prostoru, nebo že jsou kola ve vzduchu (aby po nechtěném spuštění programu nedošlo k jeho poškození). Zkontrolujte, jestli jsou motory správně připojené a jestli funguje napájení z baterií.

Na začátek nahrajeme dnešní program do robota. Najdete ho zde: File > Examples > RedBot_Experiments > Exp3_Turning. Nebo také můžete zkopírovat kód níže.

/*********************************************************************** 
* Exp3_Turning -- RedBot Experiment 3 
*  
* Explore turning with the RedBot by controlling the Right and Left motors 
* separately. 
*  
* Hardware setup: 
* This code requires only the most basic setup: the motors must be 
* connected, and the board must be receiving power from the battery pack. 
*  
* 23 Sept 2013 N. Seidle/M. Hord * 04 Oct 2014 B. Huang 
***********************************************************************/
#include <RedBot.h>  // This line "includes" the library into your sketch.

RedBotMotors motors; // Instantiate the motor control object.

void setup(){
  // drive forward -- instead of using motors.drive(); Here is another way.
  motors.rightMotor(150); 
  // Turn on right motor clockwise medium power (motorPower = 150) 
  motors.leftMotor(-150);
  // Turn on left motor counter clockwise medium power (motorPower = 150) 
  delay(1000);       // for 1000 ms.
  motors.brake();    // brake() motors

  // pivot -- spinning both motors CCW causes the RedBot to turn to the right
  motors.rightMotor(-100); // Turn CCW at motorPower of 100
  motors.leftMotor(-100);  // Turn CCW at motorPower of 100
  delay(500);        // for 500 ms.    
  motors.brake();    // brake() motors
  delay(500);        // for 500 ms.    

  // drive forward -- instead of using motors.drive(); Here is another way.
  motors.rightMotor(150); 
  // Turn on right motor clockwise medium power (motorPower = 150) 
  motors.leftMotor(-150); 
  // Turn on left motor counter clockwise medium power (motorPower = 150)
  delay(1000);       // for 1000 ms.
  motors.brake();     // brake() motors
}

void loop(){
  // Figure 8 pattern -- Turn Right, Turn Left, Repeat
  //  motors.leftMotor(-200);  // Left motor CCW at 200
  //  motors.rightMotor(80);   // Right motor CW at 80
  //  delay(2000);
  //  motors.leftMotor(-80);    // Left motor CCW at 80
  //  motors.rightMotor(200);   // Right motor CW at 200
  //  delay(2000); 
}

Co by se mělo dít?

Po nahrání programu by se měla kola otočit souhlasným směrem, poté jedno změní směr, po chvilce se opět začnou točit souhlasně a nakonec zastaví. Nyní můžete robota odpojit od USB, položit jej na podlahu a manuálně Resetovat. Robot by se měl začít pohybovat.

Za ideálních podmínek (rovný, hladký povrch…) by se měl robot pohybovat v přímých liniích a otočit se přesně o 90 stupňů. Pokud se neotočí o 90 stupňů, můžete změnit dvě věci: a) v části

  // pivot -- spinning both motors CCW causes the RedBot to turn to the right
  motors.rightMotor(-100); // Turn CCW at motorPower of 100
  motors.leftMotor(-100);  // Turn CCW at motorPower of 100
  delay(500);        // for 500 ms.    
  motors.brake();    // brake() motors
  delay(500);        // for 500 ms.    

změňte čas čekání v prvním delay(). b) Změňte výkon motorů ve stejné části kódu – místo -100 zkuste jinou hodnotu.

Pamatujte, že pro přesné otočení je důležité, aby kola nepodkluzovala. V případě, že podkluzují, je nutné snížit jejich rychlost.

Otáčení

Způsob otáčení je jednoduchý. Pokud chceme, aby se robot otočil, musíme jedním koly otáčet s různou rychlostí. Může dojít k několika situacím.

K první situaci dojde, když budeme koly točit v opačném směru. Nastavíme-li navíc stejnou velikost  rychlosti u obou kol, osa otáčení bude přibližně v polovině osy kol (kolmá na horní desku robota). Tuto situaci máme i v kódu výše (nenechte se zmást tím, že rychlost obou motorů je -100, levý motor má pro stejné hodnoty opačný směr rotace než pravý motor).

  motors.rightMotor(-100); // Turn CCW at motorPower of 100
  motors.leftMotor(-100);  // Turn CCW at motorPower of 100

Otáčení na místě

Často ale nebudete chtít robota zastavit a až poté otáčet, ale budete s ním chtít manévrovat za jízdy. To provedete tak, že směr otáčení kol při pohybu dopředu zachováte, jen upravíte jejich rychlost. Budete-li chtít například zatáčet mírně doprava, zpomalíte pravé kolo (popřípadě zrychlíte levé, nebo také oboje).

Otáčení při pohybu dopředu

Jakýsi kompromis mezi předchozími dvěma způsoby je zastavit jedno kolo a nechat otáčet pouze druhé. Osa otáčení nyní prochází kolem, které je zastaveno.

Otáčení jedním kolem

Ovládání motorů

Ve čtvrtém dílu článků o Robotovi Redbot jsme k pohybu robota dopředu použili funkci motors.drive(rychlost). Pokud jsme zadali rychlost větší než nula, pravé kolo se začalo točit po směru hodinových ručiček, levé kolo proti směru a robot se tak rozjel dopředu.

Pro ovládání jednotlivých motorů obsahuje třída RedBotMotors dvě metody (každou pro jeden motor).

motors.rightMotor(rychlost_p); //pravý motor
motors.leftMotor(rychlost_l); //levý motor

Stejně jako parametr metody .drive(), i parametr metod .rightMotor() a .leftMotor() může nabývat hodnot -255 až 255. Hodnoty větší než nula roztočí motor po směru hodinových ručiček, záporné hodnoty proti směru.

Jelikož mohou motory jet celkem slušnou rychlostí, je lepší při otáčení použít nižší rychlosti. Pokud při něm podkluzuje, můžete zkusit upravit hodnoty parametrů (jak již bylo zmíněno dříve), nebo rychlost zvyšovat postupně.

setup() vs. loop()

Asi jste si všimli, že zatím všechen kód, který jsme zkoušeli byl pouze ve funkci setup(). Bylo to z toho důvodu, že jsme potřebovali vyzkoušet, co který příkaz udělá a nechtěli jsme, aby nám robot zběsile jezdil po podlaze. Nyní si ale můžete vyzkoušet umístit kód do funkce loop() a naučit robota dělat například osmičku, kolečko a podobně. Kód pro osmičku je ve funkci loop() připravený, takže ho stačí odkomentovat. Možná bude potřeba upravit časy a rychlosti pro přesné osmičky.

void loop(){
  // Figure 8 pattern -- Turn Right, Turn Left, Repeat
  //  motors.leftMotor(-200);  // Left motor CCW at 200
  //  motors.rightMotor(80);   // Right motor CW at 80
  //  delay(2000);
  //  motors.leftMotor(-80);    // Left motor CCW at 80
  //  motors.rightMotor(200);   // Right motor CW at 200
  //  delay(2000); 
}

Čtverec

Pro pohyb robota po čtverci potřebujeme opakovat stále dokola: jeď dopředu, otoč se o 90 stupňů. Nepřipomíná vám to něco? Je to podobný případ, jako v prvním kódu tohoto článku.

Nechte robota dělat čtverce stále dokola. Můžete sledovat, jestli vždy dojede na počáteční místo, nebo nikoliv. V tom případě můžete zkusit upravit rychlosti a časy otáčení.

Otočení o určitý úhel

Na konec programu přidáme funkci turnAngle().

void turnAngle(int angle){
  int turningSpeed = 180; // degreees / second

  long turningTime;
  turningTime = (long) 1000 * angle / turningSpeed;

  motors.rightMotor(-100); // Turn CCW at motorPower of 100
  motors.leftMotor(-100);  // Turn CCW at motorPower of 100
  delay(turningTime);      // turning Time
  motors.brake();     // brake() motors
}

Poté část kódu, která zajišťovala otáčení nahraďte turnAngle(90). Robot by se měl i poté otáčet o 90 stupňů. Pokud tomu tak není, změňte hodnotu proměnné turningSpeed. Společně s funkcí driveDistance() z minulého dílu můžete nyní naprogramovat pohyby po čtvercích, pětiúhelnících (obecně n-úhelnících) a mnohé další tvary.

Možné problémy

Kola se neotáčí, ale je slyšet vysoký tón.

• Kola nemají dostatečný točivý moment na to, aby se rozjela. Zkuste zvýšit rychlost otáčení, nebo zmenšit váhu robota (pokud na něm například něco vezete).

Kdykoliv, když připojím USB kabel, se robot na chvíli chová podivně.

• RedBot se snaží provést nahraný kód kdykoliv, když dojde k restartu. Když ho připojíte k počítači, musí ho počítač identifikovat. Při tom dojde několikrát k restartu programu (bootloaderu). S robotem se ve skutečnosti neděje nic špatného. Pokud vám toto chování vadí, přepněte přepínač motorů z RUN na STOP.

Přeloženo z https://learn.sparkfun.com/tutorials/experiment-guide-for-redbot-with-shadow-chassis/experiment-3-turning a mírně upraveno.
Původní text je licencován pod CC BY-NC-SA 3.0.

V poslední době se u nás na webu čas od času objevovaly prosby typu:

A je pravda, že takovýto článek tu chyběl. Psali jsme sice již o Ethernet Shieldu (dokonce dvakrát) i o WiFi shieldu. Vždy jsme ale rozebírali spíše jak naprogramovat Arduino pro čtení senzorů, ovládání LED… O programování webového rozhraní vždy zaznělo jen několik zběžných informací. To bych chtěl nyní napravit.

Úvod

Jak už to tak bývá, máme prakticky neomezeně možností, co se použitých komponent týče. Ať už chceme měřit vlhkost, teplotu, či rychlost větru, máme na výběr ze spousty různých senzorů. Stejně tak existuje celá řada modulů a shieldů, které připojí Arduino k internetu (zběžně například Ethernet Shield, WiFi Shield, modul ESP8266 a další). I výstupních zařízení můžeme mít spoustu (LED, Motory, Bzučáky…). Celý systém by se dal symbolicky zakreslit takto:

Schéma systému

Arduino tedy komunikuje se sítí pomocí modulu „Připojení“. Dále ze senzorů získává hodnoty (vlhkost vzduchu, rychlost větru atd.) a může odesílat jiné hodnoty na výstupní zařízení (rychlost otáčení motoru, úhel servomotoru, jas LED atd.). Co mají tyto hodnoty společné?

Všechno jsou to čísla! Ať už desetinná nebo celá, pořád jsou to jenom číselné hodnoty. Proto se dnes nebudeme moc zabývat tím, jaké senzory a výstupy máme. Pro jednoduchost si zvolíme dva analogové senzory – potenciometry (na pinech A4, A5) – a jeden digitální – tlačítko (pin D2). Stejně tak si ale můžete představit že se jedná o teploměr nebo vlhkoměr. Jako výstupní zařízení nám poslouží obyčejná LED (pin D3).

Také se moc nebudeme zabývat částí „Připojení“. Její ovládání závisí na konkrétním použitém modulu. Často je ale práce s moduly velmi podobná (například Ethernet Shield a Wifi Shield). My použijeme Ethernet Shield.

Naše zapojení

Výběr řešení

Nyní přichází na řadu rozhodnutí, jakým způsobem vytvoříme komunikační rozhraní. Existuje celá řada řešení třetích stran. Některé z nich si představíme na konci článku. Jako první si ale vyzkoušíme vše vytvořit od začátku.

Umístění webové stránky

Jak si možná pamatujete z článku o Ethernet a Wifi shieldu, může Arduino v síti vystupovat dvěma způsoby. Buďto jako server nebo jako klient. V případě prvním běží webová stránka pro ovládání přímo na Arduinu. Nemáme tak tolik možností, protože má Arduino omezenou paměť, ale na základní ovládání to stačí. Toto řešení použijeme v případě, že neplánujeme nad daty provádět analýzy, popřípadě složitější vizualizace.

Arduino jako Server

Základem je HTTP protokol

Základem komunikace mezi serverem a klientem je (většinou) HTTP protokol. Ten přenáší všechny potřebné informace, které klient od webu může očekávat a zároveň pomocí HTTP protokolu klient říká, jaká data od serveru požaduje. O HTTP jsem psal ve článku o Ethernet Shieldu, kde si můžete tuto problematiku připomenout.

Zběžně si připomeňme činnost Shieldu na příkladu z Examples > WebClient, který stáhne obsah webu www.google.com a vypíše jej přes sériovou linku (včetně HTTP hlavičky).

/*
  Web client

 This sketch connects to a website (http://www.google.com)
 using an Arduino Wiznet Ethernet shield.

 Circuit:
 * Ethernet shield attached to pins 10, 11, 12, 13

 created 18 Dec 2009
 by David A. Mellis
 modified 9 Apr 2012
 by Tom Igoe, based on work by Adrian McEwen

 */

#include <SPI.h>
#include <Ethernet.h>

// Enter a MAC address for your controller below.
// Newer Ethernet shields have a MAC address printed on a sticker on the shield
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
// if you don't want to use DNS (and reduce your sketch size)
// use the numeric IP instead of the name for the server:
//IPAddress server(74,125,232,128);  // numeric IP for Google (no DNS)
char server[] = "www.google.com";    // name address for Google (using DNS)

// Set the static IP address to use if the DHCP fails to assign
IPAddress ip(192, 168, 0, 177);

// Initialize the Ethernet client library
// with the IP address and port of the server
// that you want to connect to (port 80 is default for HTTP):
EthernetClient client;

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  // start the Ethernet connection:
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Failed to configure Ethernet using DHCP");
    // try to congifure using IP address instead of DHCP:
    Ethernet.begin(mac, ip);
  }
  // give the Ethernet shield a second to initialize:
  delay(1000);
  Serial.println("connecting...");

  // if you get a connection, report back via serial:
  if (client.connect(server, 80)) {
    Serial.println("connected");
    // Make a HTTP request:
    client.println("GET /search?q=arduino HTTP/1.1");
    client.println("Host: www.google.com");
    client.println("Connection: close");
    client.println();
  } else {
    // if you didn't get a connection to the server:
    Serial.println("connection failed");
  }
}

void loop() {
  // if there are incoming bytes available
  // from the server, read them and print them:
  if (client.available()) {
    char c = client.read();
    Serial.print(c);
  }

  // if the server's disconnected, stop the client:
  if (!client.connected()) {
    Serial.println();
    Serial.println("disconnecting.");
    client.stop();

    // do nothing forevermore:
    while (true);
  }
}

Když si otevřeme monitor sériové linky, vypíše se nám:

connecting...
connected
HTTP/1.1 302 Found
Location: http://www.google.cz/search?q=arduino&gws_rd=cr&ei=LP61VsHFHofjywOK2a3IDA
Cache-Control: private
Content-Type: text/html; charset=UTF-8
P3P: CP="This is not a P3P policy! See https://www.google.com/support/accounts/answer/151657?hl=en for more info."
Date: Sat, 06 Feb 2016 14:07:40 GMT
Server: gws
Content-Length: 278
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN
Set-Cookie: NID=76=ypwExw5cTiZ5fFfmeEwtEoGo1d8QLO14kjvx7WysrpCleRdBfNX8EhCYE6vkfHt56bneI6Lyi5utrZw7mLVjRBWJS2rj8Z2Jl2NsyobTCeRBUow3PfrL6C81CkeX4AzJPo7vwSiv; expires=Sun, 07-Aug-2016 14:07:40 GMT; path=/; domain=.google.com; HttpOnly
Connection: close

<HTML><HEAD><meta http-equiv="content-type" content="text/html;charset=utf-8">
<TITLE>302 Moved</TITLE></HEAD><BODY>
<H1>302 Moved</H1>
The document has moved
<A HREF="http://www.google.cz/search?q=arduino&gws_rd=cr&ei=LP61VsHFHofjywOK2a3IDA">here</A>.
</BODY></HTML>

disconnecting.

Rychlokurz HTML

Základem většiny webových stránek je HTML – HyperText Markup Language, tedy „hypertextový značkovací jazyk“. V češtině asi nejrozsáhlejší stránka zabývající se HTML je http://www.jakpsatweb.cz/, v angličtině je HTML velmi podrobně popsáno na stránkách W3CSchools. Základním stavebním prvkem stránky je značka (častěji se používá anglické označení tag). Tyto tagy se píší do špičatých závorek: <tag>. Mohou být párové – ty ohraničují nějakou část webové stránky, například <strong>Tučné písmo</strong> (ve stránce samozřejmě nejsou vidět, zde jsou pro názornost). Každý otevírací párový tag musí mít jemu odpovídající uzavírající tag (ten začíná lomítkem). Druhou možností jsou tagy nepárové – například nový řádek: <br /> (nepárovost je znázorněna tím, že končí lomítkem). Tagy je navíc možné do sebe vnořovat (jinak by HTML nemělo moc význam :)). <em>ABC<strong>DEF</strong></em> se tedy zobrazí jako ABCDEF.

Základní kostra stránky vypadá takto:

<html>
	<head>
		<title>Titulek - text v záložkách prohlížeče...</title>
		Tato část se nazývá hlavička. 
		Obsahuje například vložení skriptů, metadata pro vyhledávače, sociální sítě atd.
	</head>
	<body>
		Tato část se nazývá tělo. Sem se píše samotný obsah stránky. 
	</body>
</html>

My tedy potřebujeme, aby nám Arduino po připojení odeslalo webovou stránku, která bude obsahovat patřičné ovládací prvky. Začneme zvolna. Budeme chtít ovládat LED diodu pomocí odkazů vypnout a zapnout.

Ovládání LED

V HTML se odkaz vytvoří pomocí tagu <a href=“URL adresa“>Text odkazu</a>. Parametry budeme serveru předávat metodou GET (tak jako ve článku o Ethernet Shieldu). Když si tedy sestavíme odkaz <a href=“/?l=0″>VYPNI</a>, na který poté klikneme, HTTP request, který klient odešle serveru bude začínat následovně:

GET /?l=0 HTTP/1.1

Z toho my potřebujeme „vyextrahovat“ právě část l=0. Budeme tedy hledat první výskyt ‚?‘ v requestu a dále číst, co část GET obsahuje. Použijeme upravený kód z článku o Ethernet Shield. Všimněte si, že uvozovky, které jsou součástí odkazu před sebou mají zpětné lomítko: \“. To je zde nutné kvůli kompilátoru. Řekneme mu tím, že chceme pracovat se znakem uvozovek a že se nejedná o část programu (začátek/konec řetězce). Tag <meta charset=“UTF-8″> říká, že budeme pracovat se znakovou sadou UTF-8, která podporuje i české znaky.

#include <Ethernet.h>
#include <SPI.h>

boolean zacatekCteni = false;

byte mac[] = {0x90, 0xA2, 0xDA, 0x00, 0x9C, 0xB7}; //MAC adresa
IPAddress ip(10,0,0,3); //IP adresa
EthernetServer server = EthernetServer(80); //port

void setup(){
    pinMode(3, OUTPUT);

    Ethernet.begin(mac, ip); //vytvoření serveru
    server.begin(); //spuštění serveru
}

void loop(){
    EthernetClient client = server.available(); //načtení klienta
    
    if(client){
        boolean prazdnyRadek = true;
        boolean hlavickaPoslana = false;
        
        while(client.connected() && client.available()){
            if(!hlavickaPoslana){ //jednou pošleme hlavičku
                client.println("HTTP/1.1 200 OK");
                client.println("Content-Type: text/html");
                client.println();
                hlavickaPoslana = true;
                //dále pošleme obsah stránky
                client.println("<html>");
                client.println("<head><meta charset=\"UTF-8\"></head>");
                client.println("<body>");
                client.println("<a href=\"/?l=0\">VYPNI</a>");
                client.println(" - ");
                client.println("<a href=\"/?l=1\">ZAPNI</a>");
                client.println("<br />");
                client.println("</body>");
                client.println("</html>");
            }
            
            char c = client.read();
            
            if(zacatekCteni && c == ' '){ //ukončí čtení
                zacatekCteni = false;
            }
            
            if(c == '?'){ //začne čtení
                zacatekCteni = true;
            }
            
            if(zacatekCteni){                
                if(c == 'l'){
                    client.read(); //přeskočíme jeden znak (=)
                    c = client.read(); //přečteme další znak -> hodnota LED
                    if(c == '0'){
                        digitalWrite(3, LOW);
                    }
                    else if(c == '1'){
                        digitalWrite(3, HIGH);
                    }
                    break; //vyskočí z cyklu
                }
            }
            
            if (c == 'n') {
                prazdnyRadek = true;
            }
            
            else if (c != 'r'){
                prazdnyRadek = false;
            }
        }
        delay(1);
        client.stop();
    } 
}

Zobrazení informací

Přidání informací o stavu potenciometrů a tlačítka je velice jednoduché. Můžeme si vybrat, jakým způsobem data zobrazíme. Abychom si ukázali jednoduchost HTML, zobrazíme si je přehledně v tabulce. Použijeme stejný kód, jen přidáme několik řádek. Tagy pro vytvoření tabulky jsou <table> pro samotnou tabulku, <tr> pro řádek, <td> pro buňku. Všechny tři jsou párové. Kód stránky vypadá následovně:

client.println("<html>");
client.println("<head><meta charset=\"UTF-8\"></head>");
client.println("<body>");
client.println("<a href=\"/?l=0\">VYPNI</a>");
client.println(" - ");
client.println("<a href=\"/?l=1\">ZAPNI</a>");
client.println("<br />");
client.println("<table>");
client.println("<tr>"); //tlačítko
client.println("<td>Tlačítko<td>");
client.println("<td>");
client.println(digitalRead(2));
client.println("</td>");
client.println("</tr>");
client.println("<tr>"); // POT A5
client.println("<td>POT A5<td>");
client.println("<td>");
client.println(analogRead(A5));
client.println("</td>");
client.println("</tr>");
client.println("<tr>"); //POT A4
client.println("<td>POT A4<td>");
client.println("<td>");
client.println(analogRead(A4));
client.println("</td>");
client.println("</tr>");
client.println("</table>");
client.println("</body>");
client.println("</html>");

Mohli bychom pokračovat i dále. Často totiž nepotřebujete aktuální hodnotu, ale spíše průběh v čase. Hodnoty bychom si tedy museli logovat do Arduina a při připojení je zobrazit. Zobrazování hodnot se ale budeme věnovat později.

Poznámka pro zkušenější webaře: Zajímavé by mohlo být použití nějakého JS scriptu vloženého z externího zdroje pro hezké grafy a vizualizace. 

Arduino jako Klient

V tomto případě Arduino odesílá hodnoty na server, který je poté zpracovává. Tato možnost je podle mě daleko vhodnější, protože ulehčíte práci Arduinu. Nevýhodou je, že potřebujete zmíněný server. V našem případě to bude PHP server, který bude přijaté hodnoty zaznamenávat do MySQL databáze (pěkný tutoriál zabývající se PHP naleznete například na serveru ITnetwork). Můžete použít klidně i nějaký free hosting. My budeme hodnoty logovat na adrese http://arduino.cz/data/logger.php. Zde umístěný program bude čekat na hodnoty, které po přijetí uloží do databáze společně s časovým údajem záznamu.

Arduino Datalogger

Vytvoření MySQL tabulky

V dostupném nástroji pro správu MySQL databáze (například phpMyAdmin) vytvořte tabulku arduino_data, která bude mít tři sloupce: id, timestamp, hodnota. V již zmíněném phpMyAdmin to po přihlášení provedeme následovně:

1. Vybereme databázi
2. V dolní části okna vyplníme část Vytvořit tabulku. Do Název zadáme arduino_data a do Počet polí zadáme 3.
3. Klikneme na  tlačítko Proveď.

   Vytvoření MySQL tabulky – Část první

4. Objeví se nastavení jednotlivých sloupců.
5. Řádky nazveme po řadě: id, timestamp, hodnota.
6. Typ nastavíme pořadě: INT, TIMESTAMP, INT.
7. V prvním řádku zaškrtneme vlastnost A_I, tedy Auto Increment – automatické zvětšování.
8. U druhého řádku nastavíme vlastnosti Výchozí na CURRENT_TIMESTAMP.
9. Zmáčkneme tlačítko Uložit.

Logování hodnot do tabulky

Tak, jak jsme si tabulku vytvořili, nám stačí přidat hodnotu a id a timestamp se přidají automaticky. Nyní k PHP kódu – jednotlivé části jsou okomentovány. Takto vypadá obsah souboru logger.php.

<?php 
	$server = "localhost";
	$user = "uzivatel";
	$pass = "heslo";
	$db = "jmeno_databaze";
	
	$mysqli = mysqli_connect($server, $user, $pass, $db); //připojení k MySQL
	
	if($mysqli and isset($_GET['hodnota'])){ //pokud GET obsahuje 'hodnota', pokračuj
		$hodnota = sanitize($_GET['hodnota']);
		
		$sql = "INSERT INTO arduino_data (hodnota) VALUES (".$hodnota.")"; //sestavení SQL
		$doSql = $mysqli->query($sql); //vykonání SQL
		
		if($doSql){ //test úspěchu
			echo 'Zápis byl úspěšný';
		}
		else{
			echo 'Něco se nepovedlo';
		}
		
	}
	else{
		echo "Neco je špatně";
	}
	
	function sanitize($input){ //ořízne řetězec
		$input = htmlspecialchars($input);
		$input = htmlentities($input);
		$input = strip_tags($input);
		$input = trim($input);
		return $input;
	}
?>

Pokud nyní nahrajeme tento kód na server a otevřeme jej v prohlížeči přes http://arduino.cz/data/logger.php/?hodnota=1000, objeví se nám v databázi nový záznam:

Záznam v databázi

Arduino program

Nyní se přesuňme k Arduinu. Z něj potřebujeme odeslat naměřenou hodnotu.

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {0x90, 0xA2, 0xDA, 0x00, 0x9C, 0xB7}; //MAC adresa
IPAddress ip(10,0,0,3); //IP adresa
char server[] = "arduino.cz"; //URL adresa serveru   

EthernetClient client;

void setup() {
    Serial.begin(9600);
    
    if (Ethernet.begin(mac) == 0) {
        Ethernet.begin(mac, ip);
    }
    delay(1000);
}

void loop() {
    if(client.connect(server, 80)){
        delay(1000);
        Serial.println("OK");
        client.print("GET http://arduino.cz/data/logger.php?hodnota=");
        client.println(analogRead(A5));
        client.println("Host: arduino.cz");
        client.println("Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8");
        client.println("Connection: close");
        client.println();

        client.stop();
        delay(5000);
    }
}

Tento kód každých přibližně pět vteřin odešle hodnotu na server. Tabulka se nám postupně plní údaji.

Hodnoty v MySQL

Zobrazení naměřených hodnot

Pro zobrazení hodnot použijeme JavaScript knihovnu Chart.js. Stáhneme ji z GitHub repozitáře a uložíme do data/Chart. K práci nám stačí Chart.js a obsah složky src. Program, který bude data zobrazovat nazveme show.php.

<?php
	$server = "localhost";
	$user = "uzivatel";
	$pass = "heslo";
	$db = "jmeno_databaze";

	$mysqli = mysqli_connect($server, $user, $pass, $db); //připojení k MySQL
	
	//načtení hodnot z MySQL
	$sql = 'SELECT * FROM arduino_data ORDER BY timestamp';
	$doSql = $mysqli->query($sql);
	while($row = $doSql->fetch_assoc()){
		$popisky[] = $row['timestamp']; //načte popisky do pole
		$hodnoty[] = $row['hodnota'];    //načte hodnoty do pole
	}
	
	$json_popisky = json_encode($popisky);
	$json_hodnoty = json_encode($hodnoty);
?>

<html>
	<head>
		<script src="Chart/Chart.js"></script>
	</head>
	<body>
		<div style="width:50%">
			<div>
				<canvas id="canvas" height="100%" width="100%"></canvas>
			</div>
		</div>
		<script>
			var randomScalingFactor = function(){ return Math.round(Math.random()*100)};
			var lineChartData = {
				labels : <?php echo $json_popisky ?>,
				datasets : [
				{
					label: "My First dataset",
					fillColor : "rgba(220,220,220,0.2)",
					strokeColor : "rgba(220,220,220,1)",
					pointColor : "rgba(220,220,220,1)",
					pointStrokeColor : "#fff",
					pointHighlightFill : "#fff",
					pointHighlightStroke : "rgba(220,220,220,1)",
					data : <?php echo $json_hodnoty ?>
				}
				]
			}
			window.onload = function(){
				var ctx = document.getElementById("canvas").getContext("2d");
				window.myLine = new Chart(ctx).Line(lineChartData, {
					responsive: true
				});
			}
		</script>
	</body>
</html>

Na výsledek se můžete podívat na http://arduino.cz/data/show.php. Chart.js nabízí celou řadu typů grafů. Spolu s přehledným popisem je naleznete v dokumentaci Chart.js.

Ovládání Arduina

Možná si říkáte, jak ovládat Arduino, které se ke stránce připojuje jako klient. I zde existuje více cest. My použijeme opět PHP a MySQL. V MySQL budeme mít uložené konfigurační hodnoty, které Arduino získá připojením na stránku sloužící jako prostředník mezi Arduinem a MySQL.

Vytvoření tabulky

Začneme vytvořením velice jednoduché tabulky, kterou nazveme arduino_ovladani a bude mít dva sloupce. První nazveme modul (co ovládáme) a druhý hodnota (jaký má stav). Zbytek nastavíme podle obrázku. (Ano, měli bychom nastavit klíč, ale pro jednoduchost to vynechávám.).

Konfigurační tabulka

Konfigurační formulář

Nyní si vytvoříme formulář, který bude měnit hodnoty v tabulce. V našem případě budeme pracovat s jediným řádkem tabulky. Jeho hodnota modul bude led a bude mít hodnotu 0 nebo 1. Ve formuláři použijeme pro přepínání hodnoty mezi 0 a 1 tzv. radio button (který určitě znáte, jen možná nevíte, že se tak jmenuje). Kód bude obsahovat i část, která zjistí, zda řádek s názvem led existuje. Pokud neexistuje vytvoří jej. Soubor nazveme config.php.

<?php
	$server = "localhost";
	$user = "uzivatel";
	$pass = "heslo";
	$db = "jmeno_databaze";

	$mysqli = mysqli_connect($server, $user, $pass, $db); //připojení k MySQL
	
	$sql = 'SELECT * FROM arduino_ovladani WHERE modul="led"';
	$doSql = $mysqli->query($sql);
	if($doSql->num_rows == 0){
		$sql = 'INSERT INTO arduino_ovladani (modul, hodnota) VALUES ("led", 0)';
		$doSql = $mysqli->query($sql);
	}
	
	if(isset($_POST['odeslano'])){ //pokud byl formulář odeslán
		$hodnota = sanitize($_POST['stav']);
		
		$sql = 'UPDATE arduino_ovladani SET hodnota="'.$hodnota.'" WHERE modul="led"';
		$doSql = $mysqli->query($sql);
		
		if($hodnota == 1){
			echo 'Zapnuto';
		}
		else{
			echo 'Vypnuto';
		}
		echo '<br /><br />';
	}
	
	$sql = 'SELECT * FROM arduino_ovladani WHERE modul="led"';
	$doSql = $mysqli->query($sql);
	$hodnota = $doSql->fetch_assoc()['hodnota']; //načte hodnotu led z DB

	$zapnutoChecked = $hodnota == 1 ? 'checked' : ''; //nastaví výchozí hodnotu radio buttonu
	$vypnutoChecked = $hodnota == 0 ? 'checked' : '';

	echo '<form action="" method="POST" >';
		echo '<input type="hidden" value="1" name="odeslano" />';
		echo '<input type="radio" name="stav" value="1" '.$zapnutoChecked.' /> Zapnout<br>';
		echo '<input type="radio" name="stav" value="0" '.$vypnutoChecked.' /> Vypnout<br><br>';
		echo '<input type="submit" value="Odeslat">';
	echo '</form>';
	
	function sanitize($input){
		$input = htmlspecialchars($input);
		$input = htmlentities($input);
		$input = strip_tags($input);
		$input = trim($input);
		return $input;
	}
?>

Když se nyní podíváte na http://arduino.cz/data/config.php, uvidíte následující formulář:

Konfigurační formulář

Formulář nemusí obsahovat pouze radio button, ale celou řadu různých vstupů. Jejich přehled si můžete zobrazit například zde. Nyní musíme vytvořit stránku, která Arduinu pošle údaje z databáze.

Stránka zobrazující konfiguraci

Soubor nazveme controller.php. Za úkol bude mít vypisovat obsah tabulky arduino_ovladani ve tvaru modul:hodnota: (zobrazí takto za sebou všechny případné řádky tabulky). Bude se jednat o velice jednoduchý program:

<?php
	$server = "localhost";
	$user = "uzivatel";
	$pass = "heslo";
	$db = "jmeno_databaze";

	$mysqli = mysqli_connect($server, $user, $pass, $db); //připojení k MySQL
	
	$sql = 'SELECT * FROM arduino_ovladani';
	$doSql = $mysqli->query($sql);
	while($row = $doSql->fetch_assoc()){
		echo $row['modul'].':'.$row['hodnota'].':';
	}
?>

Nyní zbývá vytvořit Arduino program, který se připojí ke stránce http://arduino.cz/data/controller.php a podle toho nastaví stav LED.

Změna stavu LED

Závisí na projektu, jak často potřebujeme kontrolovat změnu stavu. Někdy stačí kontrolu provést jednou za hodinu a někdy je zase vteřina moc. My si zvolíme interval kontroly přibližně jednou za minutu.

#include <SPI.h>
#include <Ethernet.h>

#define BUFF_DELKA 255

byte mac[] = {0x90, 0xA2, 0xDA, 0x00, 0x9C, 0xB7}; //MAC adresa
IPAddress ip(10,0,0,3); //IP adresa
char server[] = "arduino.cz"; //URL adresa serveru   

char buffer[BUFF_DELKA]; //zásobník na příchozí řetězec

EthernetClient client;

void setup() {
    pinMode(3, OUTPUT);
    
    Serial.begin(9600);
    
    if (Ethernet.begin(mac) == 0) {
        Ethernet.begin(mac, ip);
    }
    delay(1000);
}

void loop() {
    if(client.connect(server, 80)){
        delay(1000);
        client.println("GET http://arduino.cz/data/controller.php");
        client.println("Host: arduino.cz");
        client.println("Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8");
        client.println("Connection: close");
        client.println();

        delay(1000);

        int inBuffer = 0;

        for(int i = 0; i < BUFF_DELKA; i++){ //vyprázdní buffer
            buffer[i] = '\0'; //nastaví všechny prvky buffer na znak konce řetězce
        }
        
        while(client.available()){
            buffer[inBuffer] = client.read();    
            inBuffer++;
        }
        
        if(inBuffer == 6){
            if(buffer[0] == 'l' && buffer[1] == 'e' && buffer[2] == 'd'){
                if(buffer[4] == '1'){
                    digitalWrite(3, HIGH);
                }
                else{
                    digitalWrite(3, LOW);
                }
                Serial.println(buffer[4]);
            }
        }

        client.stop();
    }

    delay(60000);
}

Dobré je si uvědomit, že stránka, která Arduinu poskytuje údaje může být zároveň i stránka, která od Arduina hodnoty přijímá a zapisuje je do databáze.

Tímto jsme dokončili část, kdy jsme si vše programovali sami a můžeme se stručně podívat na některé existující služby, které můžeme využít.

Řešení třetích stran

Plotly

Jak už název napovídá, služba Plotly slouží primárně k vizualizaci dat. Nabízí neplacený program pro menší objemy dat. Naleznete jej na URL adrese plot.ly. Inspirovat se můžete například u projektů zobrazujících aktuální teplotu nebo teplotu a vlhkost.

Phant

Americká společnost Sparkfun, která prodává velmi povedené shieldy a komponenty pro Arduino i další desky je autorem projektu Phant. Ten naleznete na data.sparkfun.com. Výhodou je, že Phant běží na Node.js a je možné jej rozběhnout i na vlastním serveru. Jeho používání přehledně popisují v sérii Pushing Data to Data.SparkFun.com. Veřejné feedy si můžete prohlédnout na data.sparkfun.com/streams.

IFTTT

Tuto službu možná znáte. Slouží k propojování API různých aplikací, které spolu normálně komunikovat neumí. Vytvoříte si předpis, který na základě akce spustí nějakou reakci (odsud také pochází název – IF This Then That – když to, tak ono). Například si můžete vytvořit předpis, který vám automaticky uloží všechny přílohy z Gmail do Skydrive, všechny Tweety o vás vám pošle na mail a podobně. Magie nastává, když k IFTTT připojíte Arduino. Co třeba vytvořit detektor otevření dveří s ESP8266 (za pomoci Adafruit.io), odeslat email po stisknutí tlačítka nebo zapnout WiFi zásuvku při detekci pohybu?

Thingspeak

Thingspeak je služba, který si klade za cíl propojit IoT zařízení. Vyzkoušejte například jednoduchý tutoriál zabývající se nahráváním dat nebo logováním vlhkosti.

IBM Bluemix

Poslední dva příklady patří spíše do kategorie „s kanonem na vrabce“. Jejich použití ale může přijít vhod, máte-li s těmito platformami nějaké zkušenosti. S IBM Bluemix můžete začít například v tutoriálu, se kterým k Bluemix připojíte teploměr. Ten využívá MQTT protokol, který má být náhražkou HTTP pro zařízení v internetu věcí.

Amazon Web Services

Amazon v srpnu minulého roku oznámil podporu SDK pro Arduino Yun. Více o AWS se můžete dočíst zde.

Závěr

Vidíte, že různých kombinací je nepřeberné množství, které není možné vtěsnat do jednoho článku. Doufám ale, že jsem vám poskytl dobrý vhled do probírané problematiky a že nabyté znalosti budou dostačující pro jednoduchý průchod vašimi projekty

Není vám z výkladu něco jasné, nebo máte jiné nápady, jak kterou část udělat? Neváhejte nám dát vědět v komentářích nebo na fóru!