Archives

Arduino 1: Bastlit může každý

Díl 1 z 7 v seriálu Arduino

Tak co to vlastně je zač takové Arduino? Vysvětlení není úplně snadné když nevím na jaké úrovni znalostí o počítačích a hardwaru vlasně jste, ale to nevadí Arduino je pro každého. Úplně jednoduše je to malá destička kterou jde na jedné straně připojit do USB portu a na straně druhé třeba k svítivým LED diodám,  servu nebo dipleji. A této malé konstrukci můžete potom vnuknout život krátkým poměrně jednoduchým prográmkem.

Teď popis pro ty kteří už něco podobného viděli a třeba programovali jednočipové procesory Microchip PIC nebo Atmel. Není to vlatně nic nového pod sluncem, jeden procesor Atmel na vývojové desce s USB portem. Ten podstatný rozdíl je v tom, že u Arduina máte jednoduché GUI na programování a hodně zjednodušený programovací jazyk. Nemusíte umět dělat plošňáky ani pracovat s pájkou.

Tak a teď zpět pro začátečníky, pokročilí radu nebudou potřebovat a nebo strpí pomalejší výklad. Jak tedy začít, hlavní bude asi pořízení Arduina. Na eBay je mnoho nabídek na toto téma v nejrůznějších výhodných sadách. Arduino jsem tam koupil i s programátorem (který není pro začátečníky zrovna podstatný) za stejnou cenu kolik by mě Arduino stálo v čechách. Existuje několik verzí které můžete koupit, k jeji popisu se dostanu někdy později, začátečníkům bude vyhovat jakýkoliv model s USB rozhraním, já koupil Arduino Duemilanove(současný model s procesorem Atmega 328). Za svoje peníze dostanete zhruba něco jako na následujícím obrázku. Provedení (barva, rozložení podpůrných součástek) se může v drobných detailech lišit v závislosti na tom kdo je výrobcem.

Arduino duemilanove detail

Na desce najdete USB port (desku lze napájet pro drobné konstrukce z USB a tak není potřeba řešit zdroj), čtyři konektory pro připojení vašich pokusných konstrukcí, resetovací tlačítko, napájecí port(pro konstrukce s větším odběrem) a programovací rozhraní (pro pokročilejší pokusy nebo programování samostaných čistých čipů pomocí programátoru).

Až vám tento balíček přijde domů tak stačí nainstalovat programovací rozhraní které je na stránkách tvůrců systému arduino.cc, dostupné pro windows i pro linux (je vytvořeno v javě). Pro většinu konstrukcí bude vhodné najít v okolí obchod se součástkami, aby jste měli k desce co připojovat.

To by na první článek bylo všechno, ale můžete se těšit na návod jak začít blbnout s nepájivým kontaktním polem a pár svítivími diodami, popis mojí první kontrukce semaforu s 1W tříbarevnou LED na dálkové ovládání a snad i nějaké ty hrátky s modelářským server. Nedočkavci tohle všechno určitě najdou na fórech Arduino.cc

Arduino 2: Nepájivé kontaktní pole

Díl 2 z 7 v seriálu Arduino

Nepájivé kontaktní pole, anglicky breadboard, je výborný pomocník pro každého elektronika kutila. S jeho pomocí můžete vyvíjet a testovat jednodušší konstrukce bez potřeby pájet každou součástku na dráty nebo plošný spoj. Jednoduše řešeno je nepájivé kontaktní pole jenom takový velký konektor plný zdířek s dobře navrženým propojením.

Polí se vyrábí velké množství typů, ale rozvržení je zhruba stejné u všech typů tak popíši to moje a snad se s tím neztratíte. Na krajích najdete dvě podélné řady pro plus a mínus napájení. Uprostřed bývá širší mezera s roztečí pro zasunutí integrovaného obvodu. Od této štěrbiny vedou sloupce propojených dírek tak, aby se ke každému vývodu Integrovaného obvodu dalo napojit několik drátků a nebo součástek. Na následujícím odporném obrázku z mobilu jsem barevně označil typické propojení zdířek v poli. Na horním a dolním kraji najdete dvě řady zdířek propojených do horizontálních řad(modrá a červená), typicky se vyžívají pro rozvod kladného a záporného napětí. Střední část pole je propojená vertikálně (fialová barva) tak abychom v místě prostředního dělícího pruhu mohli zabodnout integrovaný obvod a měli od každé jeho nožičky vyvedené čtyři další zdířky pro připojení součástek a propojovacích drátků.

Zapojení nepájivého kontaktního pole

Po dlouhých a bolestivých zkušenostech doporučuji věnovat čas a nebo peníze na pořízení propojovacích vodičů. Dlouho jsem zapojoval s odizolovanými měděnými drátky, ale teď to nazývám cestou do pekel. Odizolované drátky nemají často tak dobrý kontakt jako jehlička propojovacího vodiče a také při odizolování často dochází k zeslabení drátku na konci izolace. Holé drátky se často ulamují v dírkách a jdou odsud jenom obtížně vytáhnout.

Propojovací vodiče si můžete koupit hotové a nebo vyrobit. Sám používám jehličky které se dají kleštěmi nalisovat na měděné lanko. Tento postup je poměrně pracný a bez zalisovávacích kleští je obtížné vyrobit kvalitní spoj. Pokud by někdo z čtenářů věděl kde sehnat kleště na zalisovánání konektorů tak mu budu za takovou informaci zavázán. V Brněnském GM jsem strávil dobrou půlhodinu testováním nejrůznějších kleští, které mi prodavač nabídl. Nakonec jsme nenašli nic čím by konektory šly zalisovat.

Měně pracný a levnější postup je naletovat jehličku na odizolované lanko a spoj překrýt smršťovací bužírkou. Tento postup používám spíše nouzově, třeba když mi dojdou nalisovávací jehličky a najdu jenom ty do plošného spoje.

Pro arduino se často využívají miniaturní pole, která je možno přilepit na zvláštní shield (deska která se zasune do konektorů a překryje tak celé arduino). Tato ovšem nabízejí jenom malé možnosti omezené velikostí a pokud vím tak u nás nejsou moc k sehnání. Osobně využívám větší pole, které mám nalepené na plastové desce s přišroubovaným arduinem. Taková konstrukce zjednodušuje hlavně přenášení zapojeného celku. Plast je nějaká lehčená PVC deska z Hornbachu. Většina nepájivých kontaktních polí je ze spodní strany pokrytá samolepící vrstvou a to hodně usnadňuje konstrukci podobných celků.

Arduino společně s breadbordem

A to je dnes vše, moc jsem toho o samotném arduinu nenapsal, snad to příště bude lepší.

Arduino 3: První program

Díl 3 z 7 v seriálu Arduino

Dnešní díl věnuju tomu jak arduino oživit a donutit jej vykonávat nějako činnost, kterou si vymyslíte. Budete potřebovat nějakou Arduino desku ať již originál, nebo některý z jeho klonů. Dále si musíte stáhnout GUI, neboli program kterým budeme kód překládat a nahrávat do desky. Program je zdarma ke stažení na webu http://arduino.cc/en/Main/Software.
Po spuštění před sebou uvídíte zhruba toto (různé verze se drobně liší).
Pohled na hlavní gui po spuštění

Popořadě projdeme všechny možnosti, které se nám nabízejí, pokud by vás to nudilo přeskočte nakonec na odeslání prvního programu.

Ikony:

  •  Verify: kontrola zdrojového kódu programu na výskyt formálních chyb
  •  Upload: provede to samé co verify a nakonci nahraje program do Arduina
  •  New: otevře nové okno s čistým souborem
  •  Open: slouží k otevření staršího souboru (soubory pro arduino se nazývají Sketch)
  •  Save: uloží hotový nebo rozpracovaný soubor
  •  Serial monitor: spustí zobrazení výstupu sériového rozhraní Arduina, význam tohoto výstupu si ukážeme v dalších dílech

Menu: Vyberu pouze podstatné a zajímavé položky, k ostatním se dostanete sami nebo se jim budu věnovat až to bude nezbytné.

  • File > Upload Using Programmer: možnost nahrát kód pomocí programovacího prostředku přímo do čipu, může se hodit jste si koupili některou z minimalistických verzí arduina a programátor
  • File > Examples: tady najdete různé příklady programů s anglickým komentářem, doporučuji prozkoumat, některé z nich budeme používat abych vám ušetřil kopírování z webu
  • Sketch > Import Library: tady najdete připravené knihovny pro jednodušší programování pomocí předpřipravených funkcí, ukážeme si později
  • Tools > Board: předtím než začnete programovat je potřeba zde vybrat které konkrétní arduino vlastně máte
  • Tools > Serial Port: pokud máte připojených více desek najednou tak zde můžete vybrat kterou z nich programovat (který sériový port počítače využívat)
  • Tools > Burn bootloader: pokud máte programátor tak touto položkou se do prádného Atmega čipu nahrává základní SW adruina
  • Help: nápověda

Tam kde je na mém obrázku nápis “Arduino Mega (ATmega1280) on Com11″(spodní použek) tam by se mělo zobrazit jakou desku máte vy a kam je připojená. Pokud je to špatně, nebo to tam není, zvole v menu správné položky.

V černém poli výše se budou zobrazovat informace z průběhu kontroly a nahrávání programu. Pokud bude něco špatně tak zde zjistíte co.

Konec teorie vyberte příklad z menu “file”>”examples”>”1.basic”>”blink” a nebo zkopírujte následující text do hlavního okna. Jediný rozdíl je v překladu komentářů do češtiny

/*Blink
Zapne led diodu na jednu vteřinu, následně ji na vteřinu vypne, takhle pořád dokola.

Tento příklad je možno volně šířit.
*/

// k pinu 13 je připojena led dioda na většině Arduino desek.
// provedeme pojmenování:
int led = 13;

// následující funkce setup se provede vždy jen jednou a to po stisknutí tlačítka reset nebo zapnutí desky:
void setup() {
// nastavíme pin s LED jako výstupní(EN: output).
pinMode(led, OUTPUT);
}

// funkce loop(CZ: smyčka) se pouští pořád dokola dokud je deska zapnutá:
void loop() {
digitalWrite(led, HIGH); // zapni LED (HIGH (CZ: vysoká) je úroveň napětí nebo taky logická úroveň
delay(1000); // čekej 1000ms
digitalWrite(led, LOW); // vypni LED nastavením napětí nebo logické úrovně na LOW (CZ: nízká)
delay(1000); // čekej 1000ms
}

Pokud jste to doteď neudělali tak připojte arduino k počítači, vybrerte v menu správný Board, a můžete stisknout Upload. Následně uvídíte průběh Verify a následně průběh Uploadu. Je možné, že se vás teď Arduino zeptá na správný sériový port. Pokud ano tak je to pravděpodobně ten s nejvyšším číslem.

Pokud nikde nenastala chyba tak v programu vidíte informaci “Upload Done” a na arduinu vám poblikává červená led dioda. Gratuluji, je to tam, a teď si rozebereme proč se to vlastně děje a co znamenají jednotlivé části programu. Hlavní výhodou příkladu Blink je jeho jednoduchost a funkčnost bez připojování dalších součástek. Standardní arduino má totiž k vývodu(pinu) 13 připojenu led diodu.

Když se podíváte na zdrojový kód příkladu tak snadno zjistíte například způsob psaní komentářů a formátování textu.

 /* Takhle se píše libovolný komentář a ukončit ho musíme zase naopak */

//nebo můžete udělat jednodušší jednořádkovou poznámku takhle

//řádky se ukončují středníkem
int led = 13;

//na konci definice funkce se středník nepíše
setup(){
}

Dál uvidíte tři základní části programu, které jsou vždy podobné.

  1. deklarace Nastavení pojmenování portů(pinů), pojmenování proměnných, nastavení konstant, seznam použitých knihoven. Tato část je vždy na začátku před ostatními funkcemi.
  2. nastavení prostředí Funkce “setup”, tady provedete úkony, které jsou nezbytné pro to aby běžel hlavní program například: kontrolu připojených součástek, vynulování poloh mechanismů, nastavení provozních parametrů hardwaru
  3. hlavní smyčka programu Funkce “loop”, sem patří to hlavní co má program vykonávat po celou dobu zapnutí.

Tak to by bylo pro dnešek vše. Můžete pokračovat tím, že budete tento příklad zkoušet upravovat nebo můžete prozkoumat ostatní příklady. Pokud máte nějaké základy angličtiny tak na tom nic těžkého není. V dalším dílu se pokusím vysvětlit funkci a smysl sériového portu. Je to další vybavení arduina, které máte k dispozici aniž by jste museli něco kupovat a připojovat.

+ Ondra

Arduino 4: sériový port a podmínky

Díl 4 z 7 v seriálu Arduino

Sériový port je hodně důležité rozhraní, se kterým by jste se určitě měli naučit pracovat. Můžete pomocí něho zjistit co se děje uvnitř obvodu, když máte pocit, že je s programem něco špatně a přesně nevíte co. Také pomocí něho můžete komunikovat s počítačem nebo jinými obvody či arduiny.

Sériový port je na arduinu standardně vyveden na převodník “USB<>Serial” a přes USB připojen k počítači. Díky tzv. bootloaderu je sériový port využíván také k nahrávání programů do arduina. Tato konstrukce nám umožňuje vyzkoušet používat sériový port aniž bychom museli na běžném arduinu cokoliv měnit nebo zapojovat.

Nahrajte do arduina náledující zdrojový kód a zapněte v programu “Serial Monitor”, který najdete v menu “Tools”. Pozor rychlost musíte nastavit na stejnou hodnotu jakou jsme použili v programu tedy 9600, ale to by mělo být přednastaveno.

void setup() {
 //konfigurace rychlosti serioveho portu
  Serial.begin(9600);

  while (!Serial) {
    ; // cekani na pripojeni serioveho portu, pry nezbytne pouze u desky Leonardo
  }

  // Prvni vypis na seriovy port
  Serial.println("Ahoj tady Arduino");
}

void loop(){
  Serial.println("Odpocet jedne sekundy"); // vypis hlaseni v cyklu po jedne vterine
  delay(1000); // pauza jedna vterina
}

Okno výstupu sériového portu

Na obrazovce máte právě toto okno na kterém každou vteřinu přibývá jedno hlášení. Abych tuto kapitolu nevěnoval jenom téhle drobnosti tak přidáme ještě nějaké kostičky ať si máte s čím hrát. Pro ty kteří už něco programovali bude tahle část dost jednoduchá a zdlouhává.

Naučíme se použít proměnnou typu int. Typ int je základním typem pro ukládání celých čísel. Vejdou se do něj čísla od -32768 do 32767 protože je ukládán v 16 bitech paměti (tohle se může lišit podle typu procesoru, třeba arduino due používá k ukládání dvojnásobek místa a tak je potom rozsah -2147483648 až 2147483647).

void setup() {
 //konfigurace rychlosti serioveho portu
  Serial.begin(9600);

  while (!Serial) {
    ; // cekani na pripojeni serioveho portu, pry nezbytne pouze u desky Leonardo
  }

  // Prvni vypis na seriovy port
  Serial.println("Ahoj tady Arduino");
}
int pocitadlo;
void loop(){
  pocitadlo++; // zvetseni promenne pocitadlo o jednicku na zmenseni muzeme pouzit --
  Serial.print("Ubehlo "); //funkce print je podobná println jenom neukonci radek
  Serial.print(pocitadlo); // vypiseme obsah promene pocitadlo
  Serial.println(" sekund");
  delay(1000); // pauza jedna vterina
}

Když použijete tento program tak výstup vypadá následovně:

Ahoj tady Arduino
Ubehlo 1 sekund
Ubehlo 2 sekund
Ubehlo 3 sekund
Ubehlo 4 sekund
Ubehlo 5 sekund
Ubehlo 6 sekund
Ubehlo 7 sekund
Ubehlo 8 sekund
Ubehlo 9 sekund
Ubehlo 10 sekund
Ubehlo 11 sekund

Program by počítal až do 32767 a potom by takzvaně přetekla proměnná a začal by od znovu od -32767.

Taky se vám ta čeština výpisu moc nelíbí? Tak vylepšíme program ještě o použití podmínek.
Podmínka se píše následovně:

if(pocitadlo>5){ // podmínka "je pocitadlo větší než 5", pokud platí proveď příkazy v následujících složených závorkách
   Serial.println("Ubehlo vice nez 5 sekund");
}else{ // pokud podmínka neplatila proveď v těchto složených závorkách
   Serial.println("Ubehlo mene nez 5 sekund");
}

Tu část, která začíná else nemusíte používat a můžete psaní ukončit uzavřením závorek. Else část je volitelná. Podnímky jdou taky skládat za sebe a to si ukážeme na příkladu.

Podmínku použijeme k tomu abychom narovnali pošramocenou češtinu programu.

void setup() {
 //konfigurace rychlosti serioveho portu
  Serial.begin(9600);

  while (!Serial) {
    ; // cekani na pripojeni serioveho portu, pry nezbytne pouze u desky Leonardo
  }

  // Prvni vypis na seriovy port
  Serial.println("Ahoj tady Arduino");
}
int pocitadlo;
void loop(){
  pocitadlo++; // zvetseni promenne pocitadlo o jednicku na zmenseni muzeme pouzit --
  Serial.print("Ubehlo "); //funkce print je podobná println jenom neukonci radek
  Serial.print(pocitadlo); // vypiseme obsah promene pocitadlo

  if(pocitadlo==1){ // pocitadlo je rovno presne 1
    Serial.println(" sekunda");
  }else if(pocitadlo<5){ // pocitadlo je mensi 5
    Serial.println(" sekundy");
  }else{ // pocitadlo je vetsi 5
    Serial.println(" sekund");
  }

  delay(1000); // pauza jedna vterina

}

Opravu slova sekundy jsme provedli podmínkou pokud se rovná jedné vypiš sekunda, pokud ne tak se rozhodni, je menší než 5 napiš sekundy, pokud je vetší napiš sekund.
Ještě pro úplnost jak se porovnávají čísla:

  • == rovná se (pozor na jedno = to není porovnání, ale přiřazení, tedy nastavení proměnné na hodnotu)
  •  > je větší
  • < je menší
  • <= je menší nebo stené
  • >= je větší nebo stejné
  • != nerovná se

Slovo “Ubehlo” už si určitě napravíte sami. Aby byl výklad o podmínkách trochu kompletní tak si ukážeme ještě konstrukci přepínače. Co kdybychom chtěli vypisovat vteřiny ne čísly, ale slovy? Pomocí nám známých podmínek by to bylo snadné, ale poměrně zdlouhavé a tak trochu kostrbaté.

if(pocitadlo==1){
  Serial.print(" jedna ");
}
if(pocitadlo==2){
  Serial.print(" dve ");
}
if(pocitadlo==3){
  Serial.print(" tri ");
}
// a tak dále

K tomu existuje přepínač neboli anglicky switch.

switch (pocitadlo) {
    case 1:
      Serial.print(" jedna ");
      break;
    case 2:
      Serial.print(" dva");
      break;
    case 3:
      Serial.print(" tri");
      break;
    default:
      Serial.print(" neco jineho");
  }

Je mi jasné,že jeho krásu objevíte až časem, protože ta vynikne až při delším kódu než jsou tyhle hrátky.

Myslím, že máte stavební kameny, se kterými už můžete začít stavět svoje programy. Brzo dopíšu článek o cyklech a pak snad půjdem na něco komplikovanějšího.

Arduino 5: cykly

Díl 5 z 7 v seriálu Arduino

V dnešním díle zkusím rozebrat cykly, tedy jak donutit arduino vykonávat opakované činnosti, nekonečně nebo třeba jenom několikrát.

Základní a věčný cyklus v arduinu je funkce “loop()”, do té píšeme hlavní část programu. Tato hlavní část programu se vykonává pořád dokola v nekonečném cyklu. Na příkladu prvního programu jste určitě rozpoznali obsah cyklu:

  1. zapni led
  2. pockej vterinu
  3. vypni led
  4. pockej vteřinu
/*
Blink
Zapne led diodu na jednu vteřinu, následně ji na vteřinu vypne, takhle pořád dokola.
Tento příklad je možno volně šířit.
*/

// k pinu 13 je připojena led dioda na většině Arduino desek.
// provedeme pojmenování:
int led = 13;

// následující funkce setup se provede vždy jen jednou a to po stisknutí tlačítka reset nebo zapnutí desky:
void setup() {
// nastavíme pin s LED jako výstupní(EN: output).
pinMode(led, OUTPUT);
}

// funkce loop(CZ: smyčka) se pouští pořád dokola dokud je deska zapnutá:
void loop() {
digitalWrite(led, HIGH); // zapni LED (HIGH (CZ: vysoká) je úroveň napětí nebo taky logická úroveň
delay(1000); // čekej 1000ms
digitalWrite(led, LOW); // vypni LED nastavením napětí nebo logické úrovně na LOW (CZ: nízká)
delay(1000); // čekej 1000ms
}

Pro vysvětlení dalších cycklů napíšeme program, který 10krát blikne rychle a 10krát pomaleji. Pro začátek použijeme cyklus “for”, ten má tři parametry:

  1. nastavení počitadla, nebo příkaz který se provede jenom na začátku. Klasicky začínáme od nuly: “pocitadlo=0;”
  2. podmínka pro ukončení, v našem případu dokud je pocitadlo menší než 10: “pocitadlo<10;”
  3. Navýšení počitadla, v našem příkladu je to navýšení počitadla o jedničku příkazem: “pocitadlo++;”

Cyklus “for” je ideální pro případy kdy předem znáte počet opakování, který má cyklus vykonat.
Následuje zdrojový kód s dvěma cykly, jeden pro rychlé blikání a druhý pro pomalé a ty se budou navěky opakovat. Oproti předchozímu příkladu jsem přidal ještě deklaraci proměnné “poc” v úvodu, která slouží jako počitadlo cyklů.

/*
Blink cykly
Tento příklad je možno volně šířit.
*/

int led = 13;
int poc;  //jedna promenna na pocitani cycklu

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

void loop() {
  for(poc=0;poc<10;poc++){  //rychle blikani
    digitalWrite(led, HIGH);
    delay(500);
    digitalWrite(led, LOW);
    delay(500);
  }
  for(poc=0;poc<10;poc++){  //pomale blikani
    digitalWrite(led, HIGH);
    delay(2000);
    digitalWrite(led, LOW);
    delay(2000);
  }
}

Zbývají nám k vysvětlení dva druhy cyklů a to je “while” a “do while”. Dělají v podstatě to samé jenom jejich syntaxe je trochu jiná. While cyklus má jediný parametr a to je podmínka pro ukončení. “While” a “do while” se liší jenom tím, že jeden kontroluje podmínku než začne provádět činnosti a “do while” kontroluje podmínku na konci činností. V praxi to znamená, že “do while” proběhne alespoň jednou, kdežto “while” nemusí proběhnout ani jednou. Tyto cykly se hodí tam kde neprovádíte jednoduché počítání, ale kontrolujete nějaký parametr co se mění v průběhu cyklu. Na vykonávání jednoduchého počítání je lepší “for”, protože všechny parametry a nastavení máte hezky pohromadě na jednom místě.
V následujícím příkladu je ukázka použití obou druhů cyklů.

/*
  Blink cykly
 */

int led = 13;
int poc;  //jedna promenna na pocitani cycklu

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

void loop() {
  poc=0; //nejddriv nastaveni pocitadla
  while(poc<10){  //cyklus pro rychle blikani
    digitalWrite(led, HIGH);
    delay(500);
    digitalWrite(led, LOW);
    delay(500);
    poc++; //navyseni pocitadla o jednicku
  }
  poc=0; //nejddriv nastaveni pocitadla
  do{  //cyklus pro pomale blikani
    digitalWrite(led, HIGH);
    delay(2000);
    digitalWrite(led, LOW);
    delay(2000);
    poc++; //navyseni pocitadla o jednicku
  }while (poc<10); //podminka pro ukonceni nakonci
}

Jenom jako zopakování předchozí lekce přidám kód doplněný o výpisy na sériový port, aby jste nemuseli počítat blikání, když si budete zkoušet cykly upravovat.

/*
  Blink cykly
 */

int led = 13;
int poc;  //jedna promenna na pocitani cycklu

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

void loop() {
  poc=0; //nejddriv nastaveni pocitadla
  while(poc<10){  //cyklus pro rychle blikani
    digitalWrite(led, HIGH);
    delay(500);
    digitalWrite(led, LOW);
    delay(500);
    poc++; //navyseni pocitadla o jednicku
    Serial.print("rychle ");
    Serial.println(poc);
  }
  poc=0; //nejddriv nastaveni pocitadla
  do{  //cyklus pro pomale blikani
    digitalWrite(led, HIGH);
    delay(2000);
    digitalWrite(led, LOW);
    delay(2000);
    poc++; //navyseni pocitadla o jednicku
    Serial.print("pomalu ");
    Serial.println(poc);
  }while (poc<10); //podminka pro ukonceni nakonci
}

Arduino 6: Modelářská serva

Díl 6 z 7 v seriálu Arduino

Modelářské servo je velice zajímavá součástka pokud máte v úmyslu tvořit pohyblivé věci. Servo je v podstatě elektromotor s převodovkou a elektronikou, která za vás vyřeší řízení motoru. Na rozdíl od elektromotoru se klasické servo neumí kontinuálně otáčet, ale zvládá pohyb v rozmezí 180 stupňů. Pro kontinuální rotační pohyb se musí servo upravit a nebo koupit již upravené. K tomu se dostaneme později.

Noname servo z Dealextreme a servo značky Hitec

Serva koupíte v modelářských obchodech a nebo stejně jako většinou součástek přes eBay či DealExtreme z Číny za pár korun. Pokud si servo objednáte tak dostanete přibližně to co vidíte na fotkách. Modul serva a nějaké příslušenství, které se používá k přenosu síly v modelařině typicky na pohyb křidélek na letadle a podobně.

Po elektrické stránce se servo ovládá pomocí impulsů 1ms – 2ms. Kdy impuls dlouhý 1ms znamená 0° natočení , 1.5ms 90° a 2ms 180°. Doporučená frekvence je 50Hz. Pro řízení pomocí arduina ovšem použijeme již připravenou knihovnu a ta tyto detaily pohlídá za nás.
Ze serva vedou tři dráty: červený kladné napájení, černý záporné napájení (na čínských servech může být i hnědý), žlutý řídící impulsy. Typicky se serva fungují na 5V napájení, ale vždy si dejte pozor na specifikace toho co koupíte. Některá serva s větší silou potřebují vyšší napětí, aby dosáhly udávané síly. Pokud začínáte s obyčejným malým servem tak jej můžete napojit přímo na arduino podle následujícího obrázku.

Schéma připojení serva k Arduinu

Pro ovládání budeme potřebovat již slíbenou knihovnu, která je teda součástí instalačního balíku arduina, ale použití knihoven jsem v návodech ještě neukazoval.
Je to poměrně jednoduché na začátku  přidáme knihovnu.

#include <Servo.h>

To bude fungovat pokud je knihovna Servo.h správně přidaná v adresáři “libraries”. Dále v definicích vytvoříme proměnou typu “Servo”.

Servo mojeServo;

Pak v sekci “setup” nadefinujeme ke kterému portu máme servo připojené.

mojeServo.attach(9);

Následně můžeme libovolně volat metodu “write” a říkat pod jakým úhlem má být servo natočeno(0-180).

mojeServo.write(uhel);

Dohromady by tedy mohl celý příklad vypadat takto:

/*
Program na ovládání serva
www.pistek.eu
*/

#include <Servo.h>

Servo mojeServo;

void setup(){
   mojeServo.attach(9);//definice portu připojení serva
}

void loop(){
   mojeServo.write(0);//nastav servo na uhel 0
   delay(500);//počkej 500ms
   mojeServo.write(30);//nastav servo na uhel 30
   delay(60*1000UL);//pockej 60*1000ms
}

A co to bude dělat. Nadefinujeme servo připojené na port 9, jednou za vteřinu přejde na 50ms do úhlu 0 a pak se zase vrátí na úhel 180. Ještě vás na příkaldu může zarazit “UL” u výpočtu dlouhé pauzy. UL znamená Unsigned Long, neboli typ 32 bitů kladné číslo. UL dává vědět překladači, že výsledek výpočtu může být až takhle velký.  A celá tato konstrukce může sloužit přeba jako pravidelná spoušť fotoaparátu pro tvorbu takzvaných timelapse snímků.

Ještě poslední věc a tou je slibovaná úprava na kontinuální rotační pohyb. Takto se serva předělávají na pohonné jednotky pro jednodušší roboty. Šířkou impulsu potom neřídíte úhel natočení, ale rychlost a směr otáčení. Stačí tedy následně ke dvěma upraveným servům připevnit kolečka a máte jednoduchého robotka na diferenciální ovládání. Samotná úprava serva je možná jenom u některých serv a vyžaduje jeho rozebrání. Vevnitř je potřeba ubrousit zarážku na posledním ozubeném kole tak aby se mohlo otáčet o celou otáčku. V elektronice je potřeba nahradit potenciometr, který slouží jako zpětná vazba s informací o úhlu natočení, dvěma odpory které jsou polovičního odporu než původní dráha potenciometru. V některých servech je možné servo jenom mechanicky odpojit a nastavit na střed. Sám jsem úpravu ještě neprováděl, takže vlastní fotky nemám. Možná dodám později, zatím se můžete podívat třeba na tento návod.

Arduino 7: časování s millis() a více činností najednou

Díl 7 z 7 v seriálu Arduino

Jak někteří začínáte psát tak se mi začínají množit dotazy jak kombinovat více činností na jednom arduinu, případně jak vykonat nějakou část programu, když zrovna probíhá delay(). To totiž opravdu nejde, protože máme jednoduchý procesor a když dělá delay tak nebude současně dělat nic jiného. Nezoufejte, protože tu máme funkci millis() a když se naučíte pracovat s časem jinak tak toho arduino zvládne mnohem víc najednou.

Pokud bych měl rozdíl mezi těmi dvěma přístupy přirovnat k normálnímu životu tak, delay funguje tak, že se zastavíte uprostřed chodníku, koukáte na hodinky a dokud není 12 tak nic neděláte a čekáte na oběd. Naproti tomu millis funguje tak, že na hodinky kouknete, zjistíte, že je jedenáct a tak jdete dělat něco jiného, za čas na ně kouknete znovu a pokud už bylo dvanáct tak jdete na oběd. Z toho vyplývá výhoda i nevýhoda, můžete dělat i něco jiného než koukat na hodinky, ale taky možná přijdete na oběd o něco později než přesně ve dvanáct. To zpoždění ovšem pro většinu malých aplikací bude naprosto nepodstatné a pokud už budete psát ovládací program pro jaderný reaktor tak si na to dáte pozor.

Použití ukážu na příkladu ke kterému nebudeme potřebovat nic jiného než arduino připojené k seriovému portu. Dejme tomu, že potřebujeme aby co vteřinu blikla led dioda na půl vteřiny. S použitím delay jednoduchý úkol.

int led = 13;
void setup() {
  pinMode(led, OUTPUT);
}

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

A teď druhý úkol, pokud po sériovém portu něco přijde tak to vrátit zpět. Pro začátek to nebudeme spojovat s blikáním LED.

void setup() {
  //konfigurace rychlosti serioveho portu
  Serial.begin(9600);

  while (!Serial) {
    ; // cekani na pripojeni serioveho portu, pry nezbytne pouze u desky Leonardo
  }

  // Prvni vypis na seriovy port
  Serial.println("Seriovy port aktivni");
}
void loop(){
  if (Serial.available()) {
    int inByte = Serial.read();//nacti znak ze serioveho portu
    Serial.write(inByte); //vypis znak na seriovy port
  }
  //delay(1000); //pokusna pauza
}

Na příkladu si můžete snadno vykoušet jak drtivý dopad má použití delay na rychlost odezvy. Stačí vyzkoušet odeslání textu a potom zkusit druhý program s odkomentovaným řádkem s pauzou. A teď pokud si delay nahradíte blokem pro blikání diodou tak bude zpoždění ještě o polovinu delší a to obsluhujeme jedinou blikající diodu.

Po přepsání na millis a spojení obou úkolů, by program s blikáním LED mohl vypadat asi takhle.

unsigned long aktualniMillis; //aktualni cas
unsigned long predchoziMillis; //cas poseldni akce
boolean led_svetlo; // promenna pro stav LED
int led = 13; //port pro LED

void setup() {
  pinMode(led, OUTPUT);
 //konfigurace rychlosti serioveho portu
  Serial.begin(9600);

  while (!Serial) {
    ; // cekani na pripojeni serioveho portu, pry nezbytne pouze u desky Leonardo
  }

  // Prvni vypis na seriovy port
  Serial.println("Seriovy port aktivni");
}
void loop(){
  aktualniMillis = millis(); //podivam se na hodinky
  if(led_svetlo){ //potrebuju LED zhasnout nebo rosvitit?
    if(aktualniMillis - predchoziMillis > 500) { //pokud zhasnout ubehlu uz 500ms od posledni akce?
            predchoziMillis = aktualniMillis; //v tento cas jsem provedl posledni akci
            led_svetlo=LOW; //zhasni led
    }
  }else if(aktualniMillis - predchoziMillis > 1000) { //pokud zhasnout ubehlu uz 1000ms od posledni akce?
            predchoziMillis = aktualniMillis; //v tento cas jsem provedl posledni akci
            led_svetlo=HIGH; //rozsvit led
  }
  digitalWrite(led, led_svetlo); //aktualizace stavu LED
  if (Serial.available()) {
    int inByte = Serial.read();
    Serial.write(inByte);
  }
}

Program neobsahuje jediný delay a přesto obsluhuje dvě pauzy a plynule odbavuje tok na sériovém portu. Základní myšlenou je nechat cyklus funkce loop co nejrychlejší a brzdit jej pouze vykonáváním akcí pokud je to potřeba. Kód je o něco složitější, je potřeba proměnné na to aby si pamatovaly časy, ale běh je potom plynulý. V některém dalším díle se podíváme ještě na přerušení. Využití přerušení je postup, kterak donutit arduino obsloužit opravdu neodkladné akce bez ohledu na to co je právě rozdělané.