NXT-G

Blok pro ovládání vyhledávače IR signálů

Rozcestník

• Umístění bloku
• Popis bloku
• Parametry bloku

UMÍSTĚNÍ BLOKU

Vyhledávač IR signálů je v programovacím prostředí NXT-G řízen blokem  IRSeeker Sensor V2. Tento blok není součástí základní instalace. Pro jeho použití je nutné jej do prostředí importovat. Návod k importu rozšiřujících modulů naleznete v kapitole Instalace rozšiřujících modulů.

POPIS BLOKU

Programový blok vyhledávače IR signálů obsahuje celkem 8 konektorů pro propojení s ostatními bloky.

 Port - vyjadřuje, ke kterému ze vstupních portů (1-4) je senzor připojen.

 IRDirection - výstup, který vyjadřuje hodnotu v podobě sektoru, ze kterého byl IR signál přijat.

 Mode - konektor, který značí, zda vyhledávač pracuje v módu AC nebo DC.

 Detect - výstup, který v podobě logické hodnoty vyjadřuje, zda byl nebo nebyl detekován IR signál.

 Strength1 - označuje hodnotu síly signálu v kanálu 1.

 Strength2 - označuje hodnotu síly signálu v kanálu 2.

 Strength3  - označuje hodnotu síly signálu v kanálu 3.

 Strength4  - označuje hodnotu síly signálu v kanálu 4.

 Strength5 - označuje hodnotu síly signálu v kanálu 5.

PARAMETRY BLOKU

Port: vyjadřuje, ke kterému ze vstupních portů je vyhledávač IR signálů připojen.

Mode: značí, zda vyhledávač pracuje v módu AC nebo DC.

RobotC

PŘÍKAZY PRO OVLÁDÁNÍ vyhledávače IR signálů

Rozcestník

• Nastavení senzoru
• Nastavení typu senzoru
• Práce s hodnotou snímanou senzorem
• Využití předdefinovaných metod

NASTAVENÍ SENZORU

Stejně jako u použití jiných senzorů, je i u vyhledávače IR signálů před započetím práce nutné provést deklaraci senzoru. Robotickým prostředím RobotC automaticky generovaný zápis, se skládá z klíčového slova #pragma a příkazu config(), který obsahuje čtyři parametry. První parametr definuje, zda se jedná o deklaraci senzoru či motoru. Druhý parametr definuje, ke kterému vstupnímu portu (S1 - S4) je senzor připojen. Třetí parametr je volitelný, zadávaný uživatelem. Jedná se o název senzoru, který se poté dále používá při vytváření programu. Poslední parametr deklarace je standardizovaný název senzoru (v případě vyhledávače IR signálů = sensorHiTechnicIRSeeker1200).

 
#pragma config(Sensor, S1,     IRvyhledavac,        sensorHiTechnicIRSeeker1200) // Kod je automaticky generovan pruvodcem deklaraci RobotC.
 

Poznámka: Deklaraci lze provést ručním zapsáním deklarace v příkladu nebo v menu programovacího prostředí RobotC. Postup je uveden v kapitole Deklarace motorů a senzorů.

NASTAVENÍ TYPU SENZORU

Deklarace senzoru pomocí průvodce není jediná možnost. Druhou variantou deklarace je pomocí příkazu SensorType[]. Parametrem tohoto příkazu je název senzoru, který musí být nejprve nadeklarován pro třídu tSensors, která definuje rozšiřující moduly v prostředí RobotC. Pro úplnost zápisu musíme k příkazu přiřadit standardizovaný název senzoru (vyhledávač IR signálů = sensorHiTechnicIRSeeker1200).

Tento typ deklarace je doporučeno provádět zkušenějším uživatelům. Začátečníkům se doporučuje deklarovat moduly pomocí Deklarace motorů a senzorů v horní liště menu.

 
tSensors IRvyhledavac;
SensorType[IRvyhledavac] = sensorHiTechnicIRSeeker1200;
 

Práce s hodnotou snímanou senzorem

Vyhledávač IR signálů vrací výstupní hodnotu, která je rovna číslu od 1 do 9. Toto číslo vyjadřuje směr kolem senzoru, ze kterého byl infračervený signál přijat. Naše zařízení nebo robot tak může podle tohoto zjištění reagovat. Můžeme například vytvořit program, ve kterém se bude robot opatřený IR vyhledávačem natáčet za zdrojem infračervených signálů.

Hodnotu zjištěnou senzorem vyjadřujeme pomocí příkazu SensorValue[]. Jeho parametrem v závorce je název senzoru, který jsme si nadefinovali v úvodní deklaraci. Možný zápis příkazu vidíte níže.

 
SensorValue[IRvyhledavac] == 5;
SensorValue[IRvyhledavac] > 5
 

Využití předdefinovaných metod

Stejně jako u ostatních rozšiřujících modulů, tak i u vyhledávače IR signálů nalezneme buďto v instalačních souborech programového prostředí RobotC nebo na stránkách výrobce (můžete si ji stáhnout ZDE) vývojovou knihovnu obsahující ovladače pro senzor. Knihovnu ovšem musíme nejprve v programu zavolat. Provedeme to v jeho úvodu následovně:

 
#include "drivers/hitechnic-irseeker-v2.h"
 

Úkolem vyhledávače infračervených signálů je vracet číslo, které označuje sektor vyjadřující směr přijetí signálu. Ve vývojové knihovně nalezneme k tomuto účelu dvě předdefinované funkce. Jejich návratový typ je v obou případech datového typu integer. První funkce se nazývá HTIRS2readDCDir(). Vrací nám číslo od 0 do 9, označující sektor, ze kterého byl signál přijat v nemodulovaném DC módu. Druhá se nazývá HTIRS2readACDir(). Její funkce je naprosto totožná jako u předchozí. Ovšem tato funkce vrací hodnotu zjištěnou v modulovaném AC módu. Parametrem uváděným v závorce je u obou volitelný název senzoru, který si uživatel definuje při deklaraci senzoru.

NXT-G

Detekce polohy míče

Při vytváření programu je nejprve důležité si rozmyslet, co všechno musíme ošetřit. Robot se musí pohybovat tak, aby zjistil, kde se nachází míč. Jakmile se míč bude nacházet přímo před ním, tedy ve výseči číslo 5 vyhledávače, musí zareagovat. Adekvátní reakcí bude prudký pohyb vpřed, kterým se pokusí "kopnout" do míče.

Krok 1 - Vyhledávání míče

První krok, který zrealizujeme, bude to, aby robot dokázal rozlišit, jestli se před ním nachází míč či nikoliv. Zjišťovat bude tuto skutečnost tak, že se bude točit kolem své osy. Nejprve použijeme dva bloky  Motor. Jeden pro motor A a druhý pro motor B. Zvolíme příslušné porty, ke kterým jsou připojeny a každému z nich nastavíme opačné otáčení. Jeden se bude otáčet vpřed a druhý vzad. Rychlost otáčení jsme zvolili 50%. Tento pohyb bude prováděn stále dokola.

Dále musí robot zjistit, jestli se před ním nenechází infračervený míč. Použijeme tedy blok  IR Seeker Sensor v2. Nyní budeme ověřovat, zda se míč nenachází přímo před senzorem, tedy v sektoru číslo 5. Ověříme, jakou hodnotu vrací senzor na výstupu  IRDirection. Tento výstup přivedeme na vstup bloku  Compare, kde budeme porovnávat, zda je tato hodnota rovna 5.

V současné situaci by ověření proběhlo pouze jednou a program by skončil. My ale chceme, aby ověřování probíhalo neustále. Všechny čtyři bloky tak umístíme do cyklu  Loop. Jeho řízení bude prováděno pomocí hodnoty logického datového typu (Logic). Ukončení tohoto cyklu tak bude závislé na splnění podmínky uvnitř (IRDirection = 5). Pokud bude splněna podmínka, cyklus se ukončí a program pokračuje dále. Výstup Result bloku  Compare tak přivedeme na konektor cyklu. 

Krok 2 - Reakce

Náš robot už nyní dokáže zjistit, zda se před ním nachází infračervený míč či nikoliv. Nyní musí pouze zareagovat, pokud bude míč přímo před ním. Při splnění podmínky musí "kopnout" do míče. Použijeme blok  Move, zvolíme příslušné motory, směr vpřed a pohyb trvající půl vteřiny. Ještě před tento blok ale umístíme dva bloky  Motor, které budou zastavovat motory A a B. Při okamžitém přechodu z rotačního pohybu v prudký pohyb vpřed by se totiž mohlo stát, že robot díky setrvačnosti v pohybu infračervený míč mine.

Aby robot i po prvním "kopnutí" pokračoval v hraní fotbalu, musíme ještě všechny bloky umístit do cyklu  Loop, u kterého nastavíme nekonečné provádění.

Výsledný program

Po správné realizaci jednotlivých kroků by měl program vypadat tak, jak vidíte na obrázku. Tento program není kompletním řešením pro realizaci robotického fotbalu. Pro správné řešení bychom museli použít i další moduly a vyřešit mnoho dalších situacích. Tento program slouží pouze jako demonstrace funkce vyhledávače IR signálů

Program ke stažení

Stažení ve formátu .rbt

RobotC

DETEKCE POLOHY MÍČE

Při řešení programu v programovacím prostředí RobotC musíme nejprve deklarovat vyhledávač IR signálů. Následně je důležité programově zapsat konstrukt, díky kterému robot detekuje infračervený míč. Na závěr musí robot provést "kopnutí" do míče.

Krok 1 - Deklarace senzoru

Stejně jako v jiných úlohách, ve kterých použijeme některý ze senzorů, tak i v tomto musíme nejprve vyhledávač IR signálů nadeklarovat. Deklaraci je možné zapsat buďto ručně nebo pomocí průvoce deklarací. Deklarace se skládá klíčového slova #pragma a příkazu config(), který obsahuje čtyři parametry. První označuje, že se jedná o senzor (Sensor). Druhý označuje port, ke kterému je senzor připojen (S1-S4). Třetí parametr je volitelný a uživatel si zde volí název senzoru, který bude posléze používat v programu. Poslední je standardizovaný název senzoru (sensorHiTechnicIRSeeker1200).

 
#pragma config(Sensor, S1, vyhledavac, sensorHiTechnicIRSeeker1200)
 

Krok 2 - Reakce

Nyní již můžeme začít s vytváření programu. Nejprve musíme zajistit, aby robot dokázal rozlišit, zda se před ním nachází infračervený míč či nikoliv. Konkrétně musí být umístěn ve výseči číslo 5 přímo před senzorem. Použijeme podmínku if(), jejíž parametr v závorce bude, že hodnota zjištěná senzorem bude rovna 5 (SensorValue(vyhledavac) == 5). V tomto okamžiku musí ustat veškerý pohyb robota, to znamená, že oběma motorům přiřadíme nulovou rychlost. Tento úkon jsme nastavili pouze na krátký časový úsek (200 milisekund). Následně se prudce rozjede kupředu. Vteřinu pojedou oba motory vpřed rychlostí 75%.

 
if (SensorValue(vyhledavac) == 5)
 {
   motor[motorA]=0;
   motor[motorB]=0;
   wait1Msec(200);
   motor[motorA]=75;
   motor[motorB]=75;
   wait1Msec(1000);
 }
 

Krok 3 - Detekce míče

Po zjištění, že se před robotem nachází infračervený míč, do něj musí robot "kopnout". Kopnutí jsme provedli příkazem motor[]. Podobným způsobem provedeme i detekci míče. Robot se bude při detekování otáčet kolem své osy tak dlouho, dokud míč nenajde. Za podmínku if() vložíme else a použijeme opět dva příkazy motor[] pro motory A a B. Oběma nastavíme rychlost 20% pro otáčení, ovšem každému opačným směrem.

 
 motor[motorA]=20;
 motor[motorB]=-20;
 

Výsledný program

Po správné realizaci jednotlivých kroků byste měli dojít k úspěšnému vytvoření úlohy. Nesmíme zapomenout na to, že celý kód musí být umístěný v nekonečném cyklu while(). Hotový program můžete vidět níže.

 
#pragma config(Sensor, S1, vyhledavac, sensorHiTechnicIRSeeker1200)
// deklarace senzoru
 
task main()
{
while(true)
{
 // otaceni a detekce mice
 if (SensorValue(vyhledavac) == 5)
 {
   motor[motorA]=0;
   motor[motorB]=0;
   wait1Msec(200);
   motor[motorA]=75;
   motor[motorB]=75;
   wait1Msec(1000);
 }
 else
 {
   motor[motorA]=20;
   motor[motorB]=-20;
 }
}
}
 

Program ke stažení

Stažení ve formátu .c

NXT-G

Blok pro ovládání senzoru akcelerace

Rozcestník

• Umístění bloku
• Popis bloku
• Parametry bloku

UMÍSTĚNÍ BLOKU

Senzor akcelerace je v programovacím prostředí NXT-G řízen blokem  Acceleration Sensor. Tento blok není součástí základní instalace. Pro jeho použití je nutné jej do prostředí importovat. Návod k importu rozšiřujících modulů naleznete v kapitole Instalace rozšiřujících modulů.

POPIS BLOKU

Programový blok senzoru akcelerace obsahuje celkem sedm konektorů pro propojení s dalším bloky.

 Port - určuje, ke kterému ze vstupních portů (1-4) je senzor připojen.

 x - výstup vyjadřující hodnotu naměřenou ve směru osy x.

 y - výstup vyjadřující hodnotu naměřenou ve směru osy y.

 z - výstup vyjadřující hodnotu naměřenou ve směru osy z.

 Yes / No - hodnota logického datového typu vyjadřující výsledek porovnání zrychlení na ose x.

 Trigger Point - v programovacím prostředí nastavená hodnota zrychlení určená k porovnání s hodnotou naměřenou senzorem.

 Greater / Less - vstupně výstupní konektor určující znaménko k porovnání hodnot.

PARAMETRY BLOKU

Port: značí, ke kterému ze vstupních portů (1-4) je senzor připojen.

Compare: část bloku, ve které je možné pomocí tažítka nastavit hodnotu pro osu x určenou k porovnání s hodnotou naměřenou senzorem. Rozsah hodnot je zde možné volit od -400 do +400. Hodnotu je možné nastavit buďto pomocí tažítka nebo přímým zadáním hodnoty do menšího bloku. V rozbalovacím menu jsou k dispozici znaménka určená pro porovnání.

RobotC

Příkazy pro ovládání senzoru akcelerace

Rozcestník

• Nastavení senzor
• Nastavení typu senzoru
• Práce se hodnotou snímanou senzorem

Nastavení senzoru

Před započetím práce se senzorem akcelerace je nutné jej v programovacím prostředí RobotC nadeklarovat. Zápis deklarace se skládá z klíčového slova #pragma a příkazu config(), který obsahuje čtyři parametry. Prvním parametrem je rozlišeno, zda se jedná o deklaraci motoru či senzoru (v našem případě se jedná o senzor). Druhý parametr udává, ke kterému vstupnímu portu (S1 - S4) je senzor připojen (v příkladu port číslo 1). Třetí parametr je volitelný. Jedná se o název senzoru v deklaraci a je zadáván uživatelem. Poslední částí deklarace je typ senzoru (sensorI2CHiTechnicAccel = označení senzoru akcelerace).

 
#pragma config(Sensor, S1,     Akceleracni,    sensorI2CHiTechnicAccel) // Kod je automaticky generovan pruvodcem deklaraci RobotC.
 

Poznámka: Deklaraci lze provést ručním zapsáním v příkladu nebo v menu programovacího prostředí RobotC. Postup je uveden v kapitole Deklarace motorů a senzorů.

nastavení typu senzoru

Druhou možností deklarace senzoru je definování pomocí  příkazu SensorType[]. Parametrem v závorce je volitelný název senzoru, který je předem definován pro třídu tSensors, která pro programovací prostředí RobotC definuje rozšiřující moduly. K nadefinovanému názvu senzoru poté přiřadíme konkrétní typ senzoru podle jeho označení pro RobotC (např. sensorI2CHiTechnicAccel = označení senzoru akcelerace).

Tento typ deklarace je doporučeno provádět zkušenějším uživatelům. Začátečníkům se doporučuje deklarovat moduly pomocí Deklarace motorů a senzorů v horní liště menu.

 
tSensors akceleracni;
SensorType[akceleracni] = sensorI2CHiTechnicAccel;
 

Práce s hodnotou snímanou senzorem

Během vyhodnocování nebo porovnávání hodnot snímaných senzorem a fixních hodnot zadaných uživatelem, budeme využívat příkaz k práci s touto hodnotou. V programovacím prostředí RobotC se k této činnosti používá příkaz SensorValue[]. Parametrem tohoto příkazu je předem definovaný název senzoru. Tomuto příkazu může být poté přiřazena určitá hodnota k porovnání s hodnotou ze senzoru.

 
SensorValue[sensorAccel] > 60; // Nastaveni hodnoty senzoru, ktera ma byt porovnana s urcitou fixne zadanou hodnotou.
 

V programovacím prostředí RobotC je připravena vývojová knihovna, která nese název AdvancedSensors.c. Slouží k tomu, abychom mohli provádět s rozšiřujícími senzory pokročilejší operace. V jejím těle jsou předdefinovány některé výpočtové operace, které nám umožní získat jednoduše data z rozšiřujících senzorů. Zavolání tohoto souboru provedeme následovně:

 
#include "AdvancedSensors.c"
 

Pro senzor akcelerace je zde nadefinována funkce getAccel(), která umožňuje získat hodnotu zrychlení v osách x, y a z. Zavoláním funkce getAccel(), která má čtyři parametry - název senzoru a tři hodnoty zjišťujeme, jaké jsou aktuálně snímané hodnoty senzorem. Celý zápis můžete vidět níže.

 
 int X;
 int Y;
 int Z;
 
 getAccel(akceleracni, X, Y, Z);
 

NXT-G

VYUŽITÍ SENZORU AKCELERACE

Použití senzoru jako stabilizačního prvku si často vyžaduje vytvoření složitějšího programového konstruktu. Jeho funkci si ukážeme na analýze dat, která zjišťuje. Vytvoříme si jednoduchý program a prozkoumáme, jaký průběh mají křivky vykreslené do grafu pomocí zjištění hodnot všech tří os senzoru. Zároveň si tak blíže představíme funkci Data Logging.

Zobrazení snímaných hodnot

Před analýzou hodnot si musíme vytvořit vhodný program. Použili jsme stejný program jako u analýzy dat gyroskopického senzoru. Jedná se o program, ve kterém se nejprve robot pohybuje vpřed, poté se natočí nejprve vlevo a poté vpravo a nakonec vyrazí kupředu vyšší rychlostí než v úvodu. Pomocí funkce Data Logging programovacího prostředí NXT-G nakonec zanalyzujeme hodnoty zjištěné senzorem a zobrazené v grafu.

Vytvoření programu 

Na obrázku níže můžete vidět finální podobu programu pro analýzu. Robot se nejprve rozjede vpřed pomocí bloku  Move po dobu tří vteřin. Následně je pomocí bloků  Motor realizováno nejprve natočení o 360° vlevo a poté o 360° vpravo. Nakonec robot vyrazí vpřed dvojnásobnou rychlostí než při rozjetí, opět po dobu tří vteřin. Pro analýzu dat musíme ještě na úvod programu umístit blok  Start Datalog a na konec programu  Stop Datalog.

Musíme ještě provést nastavení bloku pro Data Logging. Důležité je hlavně nastavení dostatečného počtu zaznamenaných vzorků dat za sekundu. Nastavili jsme frekvenci snímání 10 sekund za sekundu, což je dostačující. Na port 1 připojíme senzor a navolíme ho v nastavení.

Analýza dat

Po spuštění programu provedeme pomocí vestavěné funkce pro zaznamenávání dat Data Logging analýzu dat. Zanalyzujeme nejprve hodnoty zjištěné na každé ose zvlášť a nakonec jejich průběhy porovnáme.

Osa X

První osou, na kterou se zaměříme bude osa X. Na náš model robota jsme umístili senzor na přední část, nasměrovaný přímo před robota. Osa X je ta, která směřuje přímo před přední část robota. Měla by tedy měřit zrychlení při pohybu vpřed. Na obrázku níže vidíte průběh hodnot zaznamenaný do grafu. Na křivce je patrný nárůst hodnot po rozjetí robota. Následně se křivka ustálí, protože robot se pohybuje konstantní rychlostí vpřed. Velmi dobře patrné je také natočení vpravo a vlevo. Po započetí natáčení hodnota také lehce naroste. Další nárůst hodnot můžeme vidět také u opětovného rozjetí vpřed. Jelikož při zastavení z vysoké rychlosti robot prudce sníží svoji rychlost a kola se o malinký úsek natočí zpět, můžeme na grafu vidět i prudkou změnu zrychlení do záporných hodnot a okamžitý nárůst do hodnot kladných, na konci programu.

Na základě analýzy této křivky tedy můžeme konstatovat, že senzor přesně zachytil okamžiky, kdy robot změnil svoji rychlost v přímém směru.

Osa Y

Osa Y směřuje při našem umístění senzoru do bočních stran robota. Monitoruje tedy zrychlení vpravo a vlevo. Pokud se podíváme na křivku průběhu zaznamenaných hodnot, vidíme, že kmitání je po celou dobu programu přibližně stejně velké. Je to z toho důvodu, že se robot pohyboval po ne úplně rovném povrchu. Je navíc aktivováno řízení pohybu robota, které zajišťuje jeho rovnoměrný pohyb vpřed. Mírné dorovnávání přímého pohybu tedy zapříčiní lehké nachylování do stran. Tuto změnu natáčení tedy senzor také zachytil. Na obrázku níže můžete vidět velice dobře patrný úsek, ve kterém se robot natáčel na obě strany. Na začátku a na konci tohoto pohybu je velmi dobře patrná změna hodnot (zrychlení).

Po analýze hodnot snímaných na ose Y, můžeme na obrázku zřetelně vidět, že senzor přesně zachytil okamžik, kdy se robot vychýlil z přímého směru.

Osa Z

Jako poslední se podíváme na hodnoty snímané v ose Z. Hodnoty jsou snímané ve vertikálním směru senzoru. Na obrázku níže můžete vidět průběh hodnot. Při prudkém rozjezdu je patrný jejich nárůst. Další velmi patrnou změnu můžeme vidět při opětovném rozjezdu vpřed. Jelikož rychlost robota zde dvojnásobně vzrostla, došlo při prudké akceleraci k přizvednutí čelní části robota. Hodnota je proto rozdílná od prvního pohybu vpřed. Velmi dobře partné je také zastavení robota. Při prudkém zastavení opět došlo k mírnému vertikálnímu pohybu robota, což senzor znovu zaznamenal.

Nezvyklý je posun hodnot po ose X grafu. Hodnoty se nezaznamenávají od 0, ale jejich nejnižší hodnota se pohybuje kolem 200 m/s. Senzor akcelerace totiž v této poloze měří gravitační zrychlení. Díky tomu je hodnota neustále takto vysoká.

Porovnání hodnot

Na posledním obrázků můžete vidět průběh hodnot měřených na všech třech osách v jediném grafu. Zeleně je znázorněna osa X, modře osa Y a červeně osa Z. V grafu jsou znázorněny také všechny tři části programu (rozjetí, natáčení, opětovné rozjetí).

Na této analýze můžete vidět, že senzor akcelerace je skutečně užitečný nástroj, který dokáže přesně snímat pohyby robota ve všech třech směrech. Při správném vyhodnocení můžeme následně na jednotlivé změny reagovat podle potřeby.

RobotC

VYUŽITÍ SENZORU AKCELERACE

Jelikož v programovacím prostředí RobotC chybí funkce, která by graficky zobrazovala snímané hodnoty ze senzoru, představíme si možnosti práce se senzorem akcelerace na jiném příkladu. Nemusíme jej totiž používat pouze pro zjišťování hodnot, ale také jako řídící prvek. Sestrojili jsme si z technických dílů stavebnice ovládací páku podobnou kniplu letadla, která se pohybuje pomocí spodního pohyblivého kloubu do všech směrů. Vzhled ovladače můžete vidět na obrázku.

Zobrazení polohy ovladače

Funkci akceleračního senzoru ověříme pomocí jednoduchého programu. Ten bude na displej řídící jednotky vykreslovat kolečko, které se bude po displeji pohybovat v závislosti na pohybu ovladače. Záležet vždy bude na tom, do jaké polohy jej uživatel natočí. Jednoduše tak budeme ověřovat polohu ovladače. Pomocí bluetooth komunikace bychom tímto ovladačem mohli ovládat také vlastní vytvořené vozítko.

Krok 1 - Deklarace senzoru a volání knihoven

Než začneme programovat, musíme si v úvodu našeho programu deklarovat senzor, který používáme. Zápis deklarace vidíte níže. Klíčové jsou čtyři parametry uvedené v závorce. Jedná se o typ modulu (Sensor), port, ke kterému je připojen (S1), volitený název (akcel) a standardizovaný název. V našem programu využijeme vývojovou knihovnu vytvořenou pro rozšiřujícící senzor akcelerace. Musíme proto senzor deklarovat jako rozšiřující. Z toho plyne jeho název v deklaraci - sensorI2CCustom. Následně zavoláme také vývojovou knihovnu, kterou naleznete v knihovnách vývojového prostředí. Její název zní hitechnic-accelerometer.h. Nezapomeňte správně zadat umístění knihovny. V našem příkladu je knihovna umístěna ve stejném adresáři jako program.

 
#pragma config(Sensor, S1, akcel, sensorI2CCustom)
// deklarace senzoru
 
#include "hitechnic-accelerometer.h"
 

 Poznámka: Ve stejném adresáři jako program musí být ještě vývojová knihovna common.h, jinak by program nefungoval správně.

Krok 2 - Zjišťování hodnot

 Dále přistoupíme ke zpracování hodnot, které nám senzor vrací. Nejprve jsme si nadeklarovali tři proměnné datového typu integer pro uložení hodnot tří směrů zrychlení (X, Y a Z). Nyní použijeme příkaz, díky kterému hodnoty získáme. Ten nalezneme ve vývojové knihovně hitechnic-accelerometer.h a jeho název je HTACreadAllAxes(). Obsahuje čtyři parametry uvedené v závorce. První je volitelný název senzoru z deklarace a další tři jsou názvy proměnných, do kterých se mají hodnoty uložit (X, Y a Z).

 
 // promenne pro ulozeni hodnot ze senzoru
 int X = 0;
 int Y = 0;
 int Z = 0;
 
 // zjisteni hodnot ze senzoru
 HTACreadAllAxes(akcel, X, Y, Z);
 

Krok 3 - Výpočet souřadnic

Po zjištění jsme již mohli přejít ke zpracování hodnoty. Pro neustálé vykreslování kolečka na displeji potřebujeme dvě proměnné, které budou reprezentovat souřadnice jeho umístění v Kartézské soustavě souřadnic (dispX a dispY). Do nich uložíme vypočítanou hodnotu aktuálního umístění. Budeme zpracovávat pouze hodnotu X a Y, protože pro zobrazení na displeji nepotřebujeme pracovat se zrychlením ve vertikálním směru senzoru. Jelikož vrácené hodnoty jsou příliš velké, vydělili jsme je nejprve dvěma. Při výpočtu pozice na ose Y jsme museli hodnotu X ze senzoru ještě vynásobit -1, protože jinak by zobrazování fungovalo opačně. Při pohybu vpřed by se kolečko pohybovalo vzad a naopak. Jako poslední bylo nutné upravit pozici kolečka na displeji tak, aby v případě, že je ovladač ve středové poloze, bylo uprostřed displeje. Pozice na ose X tak byla posunuta o 60 bodů displeje a po ose Y o 40.

 
// promenne pro ulozeni souradnic kolecka
 int dispX;
 int dispY;
 
// vypocet souradnic pro umisteni kolecka na displeji
 dispX = (Y / 2) + 60;
 dispY = ((X * (-1)) / 2) + 40;
 

Krok 4 - Vykreslení kolečka

Dynamické vykreslování kolečka na displeji jsme provedli příkazem nxtDrawCircle(). Příkaz obsahuje tři parametry. První dva vyjadřují pozici v Kartézské soustavě souřadnic, ze které se má kolečko začít vykreslovat. Použili jsme proto hodnoty uložené v proměnných dispX a dispY. Třetí parametr vyjadřuje průměr kolečka. Pro konzistentnost vykreslování jsme ještě za vykreslení přidali příkaz wait1Msec() a oddálili tak vykonávání dalšího příkazu o 50 milisekund.

 
 // vykreslovani kolecka
 nxtDrawCircle(dispX, dispY, 15);
 wait1Msec(50);
 

Výsledný program

Níže můžete vidět hotový program. Veškeré příkazy pro zjišťování hodnot a vykreslování kolečka jsou umístěny v nekonečném cyklu while(). Před každým průchodem cyklem nesmíme zapomenout na smazání displeje příkazem eraseDisplay().

 
#pragma config(Sensor, S1, akcel, sensorI2CCustom)
// deklarace senzoru
 
#include "hitechnic-accelerometer.h"
 
task main () {
 // promenne pro ulozeni hodnot ze senzoru
 int X = 0;
 int Y = 0;
 int Z = 0;
 
 while (true)
 {
   eraseDisplay();
 
   // promenne pro ulozeni souradnic kolecka
   int dispX;
   int dispY;
 
   // zjisteni hodnot ze senzoru
   HTACreadAllAxes(akcel, X, Y, Z);
 
   // vypocet souradnic pro umisteni kolecka na displeji
   dispX = (Y / 2) + 60;
   dispY = ((X * (-1)) / 2) + 40;
 
   // vykreslovani kolecka
   nxtDrawCircle(dispX, dispY, 15);
   wait1Msec(50);
 }
}
 

Program ke stažení

Stažení ve formátu .c

NXT-G

Blok pro ovládání gyroskopického senzoru

Rozcestník

• Umístění bloku
• Popis bloku
• Parametry bloku

UMÍSTĚNÍ BLOKU

Gyroskopický senzor je v programovacím prostředí NXT-G řízen blokem  Gyro Sensor. Tento blok není součástí základní instalace. Pro jeho použití je nutné jej do prostředí importovat. Návod k importu rozšiřujících modulů naleznete v kapitole Instalace rozšiřujících modulů.

POPIS BLOKU

 Port - označuje, ke kterému ze vstupních portů je je senzor připojen.

 Trigger Point - značí vstupní nastavenou hodnotu senzoru, která je určena k porovnávání s hodnotami snímanými senzorem. Možný rozsah hodnoty je od -400 do +400 stupňů za sekundu.

 Greater / Less - hodnota logického datového typu sloužící pro srovnání dvou hodnot (větší nebo menší).

 Yes / No - hodnota logického datového typu vyjadřující výsledek porovnání.

 Offset - výstup vyjadřující vstupní posun nastavený v poli Offset.

 Raw Value - výstup udávající čistou naměřenou hodnotu rychlosti otáčení v RAW.

PARAMETRY BLOKU

Port: vyjadřuje, ke kterému ze vstupních portů (1-4) je senzor připojen.

Offset: hodnota, jejímž zadáním určuje vstupní hodnotu posuvu.

Compare: pole, které slouží k zadání hodnoty od -400 do +400 stupňů za sekundu, která je poté porovnávána s hodnotami snímanými senzorem.

RobotC

Příkazy pro ovládání gyroskopického senzoru

Rozcestník

• Nastavení senzoru
• Nastavení typu senzoru
• Práce s hodnotou snímanou senzorem
• Využití předdefinovaných metod

Nastavení senzoru

Na úvod práce s gyroskopickým senzorem v programovacím prostředí RobotC je nutné provést jeho deklaraci. Programový zápis deklarace se skládá z klíčového slova #pragma a příkazu config(), který obsahuje čtyři parametry. Jelikož je možné deklarovat také motory, tak první parametr konkretizuje, že se v našem případě jedná o sensor. Druhý parametr označuje, ke kterému ze vstupních portů (S1 - S4) je senzor připojen. Třetí parametr je volitelný a zadává jej uživatel. Jedná se o název senzoru, který je poté dále používán při odkazování na senzor. Naopak poslední parametr je předdefinovaný a jedná se o standardizované označení gyroskopického senzoru (sensorI2CHiTechnicGyro).

 
#pragma config(Sensor, S1, gyroskopicky, sensorI2CHiTechnicGyro) // Kod je automaticky generovan pruvodcem deklaraci RobotC.
 

Poznámka: Deklaraci lze provést ručním zapsáním deklarace v příkladu nebo v menu programovacího prostředí RobotC. Postup deklarace je uveden v kapitole Deklarace motorů a senzorů.

Nastavení typu senzoru

Senzory je také možné deklarovat pomocí příkazu SensorType[], jehož parametrem je název senzoru. K tomuto příkazu je také nutné přiřadit oficiální název senzoru pro programovací prostředí RobotC (u gyroskopického senzoru sensorI2CHiTechnicGyro). Volitelný název uváděný jako parametr příkazu musí být nejprve definován pro třídu senzoru tSensors, která definuje rozšiřují moduly. Příklad deklarace senzoru je uveden níže.

Tento postup deklarace je doporučeno provádět zkušenějším uživatelům. Začátečníkům se doporučuje deklarovat moduly pomocí Deklarace motorů a senzorů v horní liště menu.

 
tSensors gyroSensor;
SensorType[gyroSensor] = sensorI2CHiTechnicGyro;
 

Práce s hodnotou snímanou senzorem

Pro práci s hodnotami snímanými senzorem nebo pro jejich vyhodnocování či porovnávání budeme potřebovat použít příkaz, který nám použití hodnoty umožní. V programovacím prostředí RobotC je jím příkaz SensorValue[]. Jeho parametrem uvedeným v hranaté závorce je název senzoru. Senzoru pomocí tohoto příkazu můžeme nastavit vstupní fixně zadanou hodnotu nebo hodnotu, která bude určena pro porovnání s hodnotou snímanou gyroskopickým senzorem.

 
SensorValue[gyroSensor] = 60; // Nastaveni vstupni hodnoty senzoru (u gyroskopickeho senzoru napriklad hodnota posunu - offset).
 

Využití předdefinovaných metod

Gyroskopický senzor patří mezi rozšiřující senzory. Pro jeho využívání nalezneme po nainstalování programovacího prostředí RobotC vývojovou knihovnu, která obsahuje další předdefinované funkce pro ovládání gyroskopu. Knihovnu ovšem musíme nejprve v programu zavolat. Provedeme to v jeho úvodu následovně:

 
#include "drivers/hitechnic-gyro.h"
 

Při zjišťování hodnoty rotace využijeme několik předdefinovaných funkcí, které si nyní představíme. První metoda se nazývá HTGYROstartCal(). Využijeme jí v úvodu programu. Slouží totiž pro kalibraci gyroskopického senzoru, díky které docílíme přesnějšího snímání. Pokud máme senzor správně zkalibrovaný, můžeme zjisit jeho posun oproti stavu po kalibraci. K tomuto účelu slouží příkaz HTGYROreadCal().

Hlavním účelem používání gyroskopického senzoru je ale detekce rotačního pohybu. Ke zjištění aktuální rychlosti otáčení slouží předdefinovaná funkce HTGYROreadRot().

U všech tří funkcí zadáváme pouze jediný parametr umístěný v závorce. Jedná se o volitelný název senzoru, který uživatel zadává při deklaraci.

NXT-G

Zobrazení snímané hodnoty

Pro analýzu hodnoty, kterou vrací v určitých situacích gyroskopický senzor si musíme nejprve vytvořit vhodný program. Část programu, kterou chceme analyzovat je poté nutné v programovacím prostředí NXT-G vymezit pomocí bloků pro analýzu dat. Až poté můžeme program spustit a zjistit snímané hodnoty.

Vytvoření programu

Nejprve si představíme program, během jehož chodu jsme analyzovaly hodnoty snímané gyroskopickým senzorem. Program je pouze krátký, slouží jen k jednoduché demonstraci. Robot se díky němu tři vteřiny pohybuje vpřed. Následně se natočí o 360° vpravo, poté o 360° vlevo a nakonec se pohybuje opět tři vteřiny vpřed. První úsek vpřed se pohybuje rychlostí 50%, koncový úsek rychlostí 80%. Pohyb vpřed je realizován pomocí bloku  Move. Během natáčení do stran jsou motory ovládány blokem  Motor (více o ovládání robota pomocí motorů naleznete v kapitolách Motor a jeho pohyb a Synchronizace pohybu dvou motorů).

Aby mohla být data zaznamenávána, musíme na začátek programu umístit blok  Start Datalog, který spustí zaznamenávání dat. Na konec programu poté vložíme blok  Stop Datalog pro ukončení záznamu.

U bloku  Start Datalog musíme nastavit parametry záznamu. Dobu trvání jsme zvolili 10 sekund. Pro přesnější záznam hodnot jsme zvolili frekvenci záznamu 10 snímků za sekundu. Poslední věcí, kterou nastavíme, je typ senzoru připojený na příslušném portu.

Analýza dat

Senzor je umístěn na čelní straně robota ve vodorovné poloze a namířen směrem vpřed. Po spuštění programu se začala zaznamenávat data do grafu. Na obrázku můžete vidět křivku vyjadřující jeho průběh. Vodorovná osa grafu označuje čas běhu programu a svislá osa hodnotu, kterou vracel gyroskopický senzor (ve stupních za sekundu). První tři sekundy se robot pohyboval přímo vpřed. Na grafu je vidět, že hodnota gyroskopického senzoru se po tuto dobu pohybovala kolem nuly. Drobné odchylky jsou způsobeny nerovnostmi povrchu, po kterém se robot pohyboval. Dále se robot natočil o 360° vlevo. Hodnota okamžitě klesla až na -100 stupnňů za sekundu. Jakmile se robot začal natáčet o 360° vpravo, stoupla hodnota až na +100 stupňů za sekundu. Při opětovném pohybu vpřed se hodnota znovu pohybovala kolem nuly.

Z tohoto příkladu je patrné, že robot díky gyroskopickému senzoru dokáže reagovat pouze na natočení v jediné ose senzoru. Ačkoliv byl pohyb vpřed v úvodu a na konci programu prováděn rozdílnou rychlostí, z grafu tuto skutečnost nezjistíme. Na křivce je pouze dobře patrné, že bylo provedeno natočení nejprve na jednu stranu (senzor vrací zápornou hodnotu) a následně na druhou stranu (vrácená hodnota je kladná).

RobotC

ZOBRAZENÍ SNÍMANÉ HODNOTY

Analýzu hodnot, které vrací gyroskopický senzor v programovacím prostředí RobotC provedeme na příkladu pojídzného robota. Ten se bude pohybovat vpřed a během pohybu se natočí na obě dvě strany. Měnit bude také svoji rychlost. Pomocí funkce Poll NXT Brick poté zjistíme, na kolik je možné analyzovat v tomto programovací prostředí data ze senzoru.

Vytvoření programu

Nejprve si představíme program, během jehož chodu jsme analyzovaly hodnoty snímané gyroskopickým senzorem. Program je krátký, slouží jen k jednoduché demonstraci. Robot se díky němu tři vteřiny pohybuje vpřed. Následně se natočí o 360° vpravo, poté o 360° vlevo a nakonec se pohybuje opět tři vteřiny vpřed. První úsek vpřed se pohybuje rychlostí 50%, koncový úsek rychlostí 80%. Pokud nevíte, jak takovýto program vytvořit, více o ovládání robota pomocí motorů naleznete v kapitolách Motor a jeho pohyb a Synchronizace pohybu dvou motorů.

Analýza dat

Po spuštění funkce Poll NXT Brick a spuštění vizualizace pomocí tlačítka Poll Continuous začnou být zobrazována aktuálně snímaná data (více o zobrazování hodnot v RobotC v kapitole Zaznamenávání a vizualizace hodnot). Na prvním obrázku můžete vidět náhled při zobrazování hodnot úvodního pohybu robota vpřed. V horním okně se zobrazují informace o motorech. Můžeme vyčíst jak jejich rychlost, tak i počet otáček. Nás bude ale zajímat gyroskopický senzor. Nalezneme jej v dolním okně z pohledu uživatele vlevo. Byl připojen k portu S3. Jelikož patří mezi rozšiřující senzory, nebylo jej možné přiřadit ke třetímu portu a tak se zde zobrazuje popisek No Sensor. Hodnota je ovšem snímána, a to v podobě RAW. Můžete vidět, že v aktuálním okamžiku pořízení snímku byla hodnota 613.

Nyní se zaměříme na okamžik, kdy se robot natáčel do stran. Začneme natočením vpravo. Nahoře vidíme, že se otáčel pouze motor C. Změnu hodnoty zaznamenáme i u tabulky zobrazující hodnotu ze senzoru. Ta oproti pohybu vpřed nepatrně vzrostla.

Při natočení na levou stranu je již změna hodnoty patrná více. Při natočení vpravo hodnota rostla, při natočení v opačném směru klesla až na 473. Vidíme tak, že senzor skutečně i v tomto okamžiku zaznamenal odklonění od přímého směru.

Jako poslední si můžeme prohlédnout hodnoty naměřené při závěrečném zrychlení. Hodnota ze senzoru je pouze nepatrně nižší. To je způsobeno jak zrychlením, tak také otřesy způsobenými pohybem po drobných nerovnostech podkladu.

Jelikož programovací prostředí RobotC umožňuje pouze zaznamenávání v reálném čase, není snímání hodnot z gyroskopického senzoru příliš efektivní. Můžeme sice při pohybu robota pozorovat, v jakém rozmezí se pohybují hodnoty, ale nemůžeme je zaznamenávat. Překážkou také může být skutečnost, že robot musí být připojen k počítači pomocí USB kabelu. Přesto bychom mohli získat přibližnou představu o tom, jak vysoké hodnoty v jednotlivých okamžicích jsou. Reakci na ně následně využijeme při vytváření programu.