Vˇ
SB – Technick´
a univerzita Ostrava
Fakulta elektrotechniky a informatiky
Katedra informatiky
Microsoft Robotics Studio –
– programov´
an´ı robot˚
u
Microsoft Robotics Studio –
– Robots Programming
Souhlas´ım se zveˇrejnˇen´ım t´eto diplomov´e pr´ace dle poˇzadavk˚u ˇcl. 26, odst. 9 Studijn´ıho a zkuˇsebn´ıho ˇr´adu pro studium v magistersk´ych programech V ˇSB-TU Ostrava.
V Ostravˇe 30. dubna 2010 . . . .
Prohlaˇsuji, ˇze jsem tuto diplomovou pr´aci vypracoval samostatnˇe. Uvedl jsem vˇsechny liter´arn´ı prameny a publikace, ze kter´ych jsem ˇcerpal.
R´ad bych na tomto m´ıstˇe podˇekoval vˇsem, kteˇr´ı mi s prac´ı jak´ymkoliv zp˚usobem pomohli, zvl´aˇstˇe pak RNDr. Eliˇsce Ochodkov´e, Ph.D. za cenn´e rady.
Abstrakt
Tato pr´ace pojedn´av´a o moˇznostech programov´an´ı robot˚u LEGO Mindstorms NXT v n´ a-stroji Microsoft Robotics Developer Studio (MRDS). Krom tohoto n´astroje jsou pops´any n´astroje RobotC a LEGO Mindstorms (NXT–G). Jsou zde vyˇcteny v´yhody a nedostatky jednotliv´ych n´astroj˚u a vytvoˇrena aplikace s ˇreˇsen´ım bludiˇstˇe pro robota LEGO NXT. Kl´ıˇcov´a slova: MRDS, LEGO NXT, VPL, RobotC, robot
Abstract
This thesis describes the possibilities of programming LEGO Mindstorms NXT robots with Microsoft Robotics Developer Studio (MRDS). Besides this tool, two other tools are described here, namely RobotC and LEGO Mindstorms (NXT–G). There are lists of pros and cons for particular tools and a ready–made application solving the labyrinth for LEGO NXT robot.
Seznam pouˇzit´ych zkratek a symbol˚u
API – Application Programming Interface CLR – Common Language Runtime
CRR – Concurrency and Coordination Runtime DSS – Decentralized Software Services
DSSME – DSS Manifest Editor
EOPD – Electro – Optical Proximity Detector HTTP – Hypertext Transfer Protocol
I2C – Inter – Integrated Circuit
IDE – Integrated Development Environment
IR – Infra Red
LED – Light – Emitting Diode
MRDS – Microsoft Robotics Developer Studio PDF – Portable Document Format
REST – Representational State Transfer
RF – Radio frequency
RIS – Robotics Invention System RPC – Remote Procedure Call
SOAP – Simple Object Access Protocol
SVN – Subversion
URI – Uniform Resource Identifier URL – Uniform Resource Locator USB – Universal Serial Bus
VPL – Visual Programming Language VSE – Visual Simulation Environment
WWW – World Wide Web
OBSAH I
Obsah
1 Uvod´ 1 2 LEGO Mindstorms 2 2.1 LEGO NXT . . . 2 2.2 Senzory . . . 3 2.3 NXT–G . . . 6 3 RobotC 10 3.1 Sezn´amen´ı s v´yvojov´ym prostˇred´ım . . . 103.2 Tvorba programu pro robota . . . 11
3.3 Zhodnocen´ı . . . 13 4 MRDS 14 4.1 Architektura . . . 15 4.2 DSSME . . . 17 4.3 VPL . . . 18 4.4 VSE . . . 21 5 Jednoduch´e ´ulohy ve VPL 22 5.1 Ulohy s vyuˇ´ zit´ım motor˚u . . . 22
5.2 Ulohy se svˇ´ eteln´ym senzorem . . . 24
5.3 Ulohy s ultrazvukov´´ ym senzorem . . . 27
5.4 Ulohy s rotacemi . . . .´ 29
6 NXT Labyrinth Solver 31 6.1 N´avrh ˇreˇsen´ı bludiˇstˇe . . . 31
6.2 Implementace ˇreˇsen´ı bludiˇstˇe . . . 37
7 Z´avˇer 46
8 Reference 47
Pˇr´ılohy i
A Obr´azky i
SEZNAM OBR ´AZK˚U II
Seznam obr´
azk˚
u
1 NXT inteligentn´ı kostka [9] . . . 3
2 LEGO Mindstorms NXT (NXT–G) v´yvojov´e prostˇred´ı . . . 7
3 LEGO Mindstorms NXT – Update NXT Firmware . . . 8
4 LEGO Mindstorms NXT – Detekce objektu . . . 9
5 RobotC v´yvojov´e prostˇred´ı . . . 10
6 RobotC v´yvojov´e prostˇred´ı – nastaven´ı motor˚u a senzor˚u . . . 11
7 MRDS bˇehov´e prostˇred´ı [11] . . . 15
8 MRDS architektura CCR [10] . . . 16
9 MRDS architektura sluˇzeb [10] . . . 17
10 MRDS DSSME . . . 18
11 MRDS VPL . . . 19
12 MRDS VPL – program pro detekci pˇrek´aˇzky . . . 21
13 Program ”nxt moving forward“ ve VPL . . . 22 14 Program ”nxt modifiers“ ve VPL . . . 23 15 Program ”nxt line track“ ve VPL . . . 25 16 Program ”nxt wait for dark“ ve VPL . . . 26
17 Program ”nxt line track timer“ ve VPL . . . 27
18 Program ”nxt obstacle detect“ ve VPL . . . 28
19 Program ”nxt sonar display“ ve VPL . . . 28
20 Program ”nxt point turns enc“ ve VPL . . . 29
21 Program ”nxt line track rotations“ ve VPL . . . 30
22 MRDS VPL – Sledov´an´ı ˇc´ary s dvˇema senzory . . . 31
23 LEGO NXT – konstrukce TriBot [1] . . . 33
24 LEGO NXT – konstrukce se dvˇema svˇeteln´ymi senzory a kompasem . . . . 33
25 Kˇriˇzovatka pro jeden svˇeteln´y senzor . . . 34
26 Navrˇzen´a kˇriˇzovatka pro dva svˇeteln´e senzory . . . 35
27 Navrˇzen´e bludiˇstˇe . . . 36
28 MRDS VPL – ˇreˇsen´ı bludiˇstˇe . . . 39
29 MRDS VSE . . . i
30 Program ”nxt loop 1 while“ ve VPL . . . ii
31 Diagram aktivit prohled´av´an´ı bludiˇstˇe . . . iii
32 Sekvenˇcn´ı diagram komunikace MRDS s programy NXT–G . . . iv
SEZNAM V ´YPIS˚U ZDROJOV´EHO K ´ODU III
Seznam v´
ypis˚
u zdrojov´
eho k´
odu
1 RobotC – program pro detekci pˇrek´aˇzky . . . 12
2 RobotC – upraven´y program pro detekci pˇrek´aˇzky . . . 12
3 Program ”nxt moving forward“ v RobotC . . . 22
4 Program ”nxt modifiers“ v RobotC . . . 23
5 Program ”nxt loop 1 while“ v RobotC . . . 24
6 Program ”nxt line track“ v RobotC . . . 25
7 Program ”nxt wait for dark“ v RobotC . . . 26
8 Program ”nxt line track timer“ v RobotC . . . 26
9 Program ”nxt obstacle detect“ v RobotC . . . 27
10 Program ”nxt sonar display“ v RobotC . . . 28
11 Program ”nxt point turns enc“ v RobotC . . . 29
12 Program ”nxt line track rotations“ v RobotC . . . 30
13 C´ˇast metody oˇsetˇruj´ıc´ı pˇr´ıjem bluetooth zpr´av . . . 40
14 Metoda cross tˇr´ıdy Labyrinth . . . 41
15 Metoda direction tˇr´ıdy Labyrinth . . . 42
16 Metoda processDirection tˇr´ıdy Labyrinth . . . 42
17 Metoda calculateShortestPath tˇr´ıdy Labyrinth . . . 44
1 ´Uvod 1
1
Uvod
´
N´astroje na programov´an´ı robot˚u lze obecnˇe dˇelit do dvou skupin, prvn´ı skupina nahr´av´a programy do pamˇeti robota a druh´a skupina vyuˇz´ıv´a vzd´alen´e vol´an´ı procedur (RPC) robota. Pˇredstav´ıme z´astupce z obou skupin. Z prvn´ı LEGO Mindstorms NXT a RobotC, z druh´e Microsoft Robotics Developer Studio (MRDS). D´ale lze dˇelit n´astroje na n´astroje s grafick´ym programovac´ım jazykem a na n´astroje se strukturovan´ym programovac´ım ja-zykem. Do n´astroj˚u s grafick´ym jazykem patˇr´ı LEGO Mindstorms NXT, do n´astroj˚u se strukturovan´ym jazykem RobotC. MRDS patˇr´ı do obou skupin.
C´ılem t´eto pr´ace je navrhnout a implementovat ´ulohy pro robota LEGO Mindstorms NXT v prostˇred´ı MRDS. Tato pr´ace popisuje architekturu MRDS, z ˇceho se skl´ad´a a jak pomoc´ı MRDS programovat roboty. Aˇckoli MRDS um´ı programovat nespoˇcet druh˚u ro-bot˚u, zamˇeˇr´ıme se pouze na roboty LEGO NXT. Uk´aˇzeme zde nˇekter´e moˇznosti pro-gramov´an´ı LEGO NXT v prostˇred´ıch RobotC a LEGO Mindstorms NXT, jejich klady a z´apory, moˇznosti kooperace mezi jazyky. Ve Visual Programming Language (VPL) vy-tvoˇr´ıme kopie jednoduch´ych ´uloh napsan´ych v RobotC pro porovn´an´ı mezi grafick´ym a strukturovan´ym programovac´ım jazykem. Pop´ıˇseme taky senzory, kter´e LEGO NXT vyuˇz´ıv´a. Nakonec uk´aˇzeme tvorbu aplikace pro prohled´av´an´ı bludiˇstˇe a nalezen´ı nejkratˇs´ı cesty s robotem LEGO NXT.
2 LEGO Mindstorms 2
2
LEGO Mindstorms
Kaˇzd´y z n´as jistˇe proˇsel obdob´ım, kdy dostal od rodiˇc˚u do ruky nˇejakou stavebnici Merkur nebo LEGO. Mohl svou tv˚urˇc´ı ˇcinnost´ı vytvoˇrit nˇejakou vlastn´ı hraˇcku. Bud’ ˇslo o hraˇcku z nˇejak´e pˇredlohy nebo o vlastn´ı n´apad. Tato hraˇcka mohla umˇet spoustu vˇec´ı, ale pokaˇzd´e j´ı nˇeco chybˇelo. To nˇeco byla inteligence. Spoleˇcnost LEGO ˇsla ovˇsem s dobou. Chybˇej´ıc´ı inteligenci doplnila pomoc´ı programovateln´ych procesor˚u skr´yvaj´ıc´ıch se v ´utrob´ach tˇechto hraˇcek. LEGO Mindstorms je ˇrada programovateln´ych robotick´ych stavebnic, kter´e firma LEGO vyr´ab´ı.
Nejprve v roce 1998 vytvoˇrila prvn´ı programovatelnou hraˇcku pojmenovanou Robotics Invention System (RIS), pozdˇeji v roce 2006 vytvoˇrila verzi LEGO NXT, kter´a byla pouˇzita v t´eto diplomov´e pr´aci. V roce 2009 vyˇsla nov´a verze nazvan´a NXT v2.0, kter´a obsahuje nav´ıc senzor rozpozn´avaj´ıc´ı barvy a novou verzi softwaru a firmwaru. Pˇri popisu NXT ˇ
cerp´ame z [9].
2.1 LEGO NXT
LEGO NXT kit se skl´ad´a z nˇekolika ˇc´ast´ı: • NXT inteligentn´ı kostka,
• NXT senzory,
• NXT komponenty pro stavbu robota (klasick´e LEGO souˇc´astky), • software pro programovan´ı robota v jazyce NXT–G.
Inteligentn´ı kostka obsahuje 32 bitov´y mikroprocesor s FLASH pamˇet´ı a 100x64 pixel˚u velk´y monochromatick´y displej. Pod displejem nalezneme ˇctyˇri tlaˇc´ıtka pro nastaven´ı ro-bota a spouˇstˇen´ı program˚u. M˚uˇzeme je vyuˇz´ıt v programu a pˇriˇradit jim nˇejakou funkci. Shora nalezneme tˇri v´ystupn´ı porty a jeden USB 2.0 port, zdola ˇctyˇri vstupn´ı porty. Na-p´ajen´ı je moˇzno bud’ 6 AA 1.5V bateriemi nebo Li-Ion bateri´ı. Krom toho disponuje integrovan´ym reproduktorem, kter´ym je schopen pˇrehr´at zvukov´e soubory s vzorkovac´ı frekvenc´ı aˇz 8kHz a Bluetooth v2.0. Inteligentn´ı kostka je zobrazena viz Obr´azek 1 na n´asleduj´ıc´ı stranˇe.
LEGO uvolnilo firmware pro NXT jako OpenSource, proto jsou k dispozici API pro r˚uzn´e jazyky. Vˇetˇsina programovac´ıch jazyk˚u pracuje s origin´aln´ım firmwarem, nˇekter´e pouˇz´ıvaj´ı jeho r˚uzn´e modifikace napˇr. RobotC[7] (zaloˇzeno na C). V t´eto pr´aci je pouˇzita nejnovˇejˇs´ı verze firmware 1.28.
Vstupn´ı a v´ystupn´ı porty jsou osazeny konektory RJ12 s ˇsesti vodiˇci. Jsou podobn´e telefonn´ım RJ11, ale vz´ajemnˇe nekompatibiln´ı. Firma LEGO moˇzn´a chtˇela zabr´anit pˇ ri-pojen´ı jin´ych zaˇr´ızen´ı, kter´e by mohly kostku poˇskodit. V´ystupn´ı porty oznaˇcen´e A, B, C slouˇz´ı k pˇripojen´ı motor˚u. Motory jsou kvalitn´ı krokov´e motory s nejmenˇs´ım krokem 1◦. Vstupn´ı porty jsou oznaˇcen´e ˇc´ısly 1 – 4, ty slouˇz´ı k pˇripojen´ı senzor˚u. V z´akladn´ım kitu nalezneme dotykov´y senzor, pomoc´ı kter´eho m˚uˇzeme napˇr´ıklad zaznamenat n´araz robota na pˇrek´aˇzku. D´ale pak svˇeteln´y senzor, rozezn´avaj´ıc´ı stupnˇe ˇsedi, mikrofon napˇr.
2.2 Senzory 3
Obr´azek 1: NXT inteligentn´ı kostka [9]
pro reakci robota na potlesk a nakonec ultrazvukov´y senzor pro mˇeˇren´ı vzd´alenosti. Na prvn´ı pohled se zd´a, ˇze k robotovi m˚uˇzeme pˇripojit jen 4 vstupn´ı zaˇr´ızen´ı, zd´an´ı ale klame. Tyto porty podporuj´ı totiˇz sbˇernici I2C a RS-485. I2C sbˇernice umoˇzˇnuje pˇripojit aˇz 127 zaˇr´ızen´ı v s´erii. Tato sbˇernice norm´alnˇe vyuˇz´ıv´a 4 vodiˇce – nap´ajen´ı, zem, hodinov´y sig-n´al a data. NXT pouˇz´ıv´a 6 vodiˇc˚u, protoˇze vyv´ad´ı z kostky dvˇe r˚uzn´a napˇet´ı +9V jako analogov´y interface (kv˚uli zpˇetn´e kompatibility se starˇs´ım RIS) a +4.3V. Takto m˚uˇzeme pˇripojit k robotovi cokoliv, pak jen staˇc´ı naprogramovat komunikaci s t´ımto zaˇr´ızen´ım.
Ned´ılnou souˇc´ast´ı jsou mechanick´e komponenty pro sestaven´ı robota. LEGO pˇrikl´ad´a nˇekolik n´avod˚u pro r˚uzn´e konstrukce robota. Dalˇs´ı konstrukce lze vytvoˇrit zkombinov´an´ım v´ıce kit˚u a komponent rozˇsiˇruj´ıc´ıch kit. Lze vytvoˇrit prakticky cokoliv, od chod´ıc´ıho robota aˇz po tisk´arnu.
2.2 Senzory
Bez senzor˚u by byl robot NXT jen obyˇcejn´a hraˇcka s programovateln´ym displejem. Senzory dˇelaj´ı z NXT nˇeco v´ıc, nˇeco co m˚uˇze prozkoum´avat prostor nebo reagovat na r˚uzn´e pod-nˇety. LEGO vytvoˇrilo nˇekolik senzor˚u, seznam se neust´ale rozˇsiˇruje. Kromˇe firmy LEGO vytv´aˇrej´ı senzory i jin´e firmy, jako napˇr. firma HiTechnic [2]. D´ıky komunikaci pˇres I2C si sv´e senzory vytv´aˇrej´ı i dom´ac´ı kutilov´e a zveˇrejˇnuj´ı je na internetu. To d´av´a podnˇet fir-m´am, tvoˇr´ıc´ım tyto senzory, inspiraci k hromadn´e v´yrobˇe. Nˇekter´e senzory LEGO dod´av´a pˇr´ımo s kitem, ostatn´ı lze objednat pˇres internet. Ne vˇsechny senzory jsem mˇel moˇznost otestovat.
2.2.1 NXT Touch Sensor
Asi jeden z nejz´akladnˇejˇs´ıch senzor˚u obsahuj´ıc´ı pouze tlaˇc´ıtkov´y sp´ınaˇc. M˚uˇze b´yt pouˇzit jako detekce n´arazu robota do nˇejak´e pˇrek´aˇzky nebo jako kontrola uchycen´ı m´ıˇcku. Ze
2.2 Senzory 4
dvou tˇechto senzor˚u lze udˇelat dr´atov´e d´alkov´e ovl´ad´an´ı (jedno tlaˇc´ıtko smˇer doleva nebo doprava, druh´e smˇer dopˇredu nebo dozadu).
2.2.2 NXT Light Sensor
Z´akladem svˇeteln´eho senzoru je fotocitliv´a dioda. Ta umoˇzˇnuje sn´ımat osvˇetlen´ı. Pro moˇ z-nost testovan´ı odst´ın˚u povrchu pˇredmˇet˚u obsahuje senzor jeˇstˇe svˇetlo vyzaˇruj´ıc´ı diodu LED (Light – Emitting Diode), kter´a je um´ıstˇen´a hned vedle diody fotocitliv´e. Pak senzor fun-guje n´asledovnˇe: LED vyzaˇruje svˇetlo, to se odr´aˇz´ı od sn´ıman´eho objektu zpˇet do senzoru. T´ım lze rozeznat stupnˇe ˇsedi barvy objektu. Z´aleˇz´ı samozˇrejmˇe na povrchu objektu, jestli je matn´y nebo leskl´y, ploch´y nebo ˇclenit´y. Senzor dok´aˇze pracovat ve dvou reˇzimech:
1. aktivn´ı – s rozsv´ıcenou LED diodou, 2. pasivn´ı – se zhaslou LED diodou.
Aplikac´ı pro aktivn´ı reˇzim m˚uˇze b´yt napˇr´ıklad rozpozn´an´ı povrchu sebran´eho tˇelesa nebo sledov´an´ı ˇc´ary. Pasivn´ı reˇzim m˚uˇze b´yt pouˇzit napˇr´ıklad pro zmˇenu rychlosti j´ızdy robota v z´avislosti na osvˇetlen´ı v m´ıstnosti.
2.2.3 NXT Sound Sensor
Senzor s mikrofonem mˇeˇr´ı intenzitu okoln´ıho zvuku v dB a dBA. Sn´ım´a frekvenci kolem 3 – 6kHz (lidsk´e ucho slyˇs´ı cca 0 – 16kHz). M˚uˇze b´yt pouˇzit napˇr´ıklad pro zastaven´ı robota potleskem.
2.2.4 NXT RF (Radio frequency) ID Sensor
Tento senzor je novinkou z d´ılen LEGA. Umoˇzˇnuje bezdr´atovˇe ˇc´ıst k´ody ˇcip˚u. Je dod´av´an se dvˇema bezdr´atov´ymi ˇcipy. Vyuˇzit´ı je libovoln´e, napˇr. po pˇriloˇzen´ı prvn´ıho ˇcipu proved’ jednu rotaci kolem sv´e osy, po pˇriloˇzen´ı druh´eho ˇcipu proved’ dvˇe rotace.
2.2.5 NXT Ultrasonic Sensor
Ultrazvukov´y senzor je asi jeden z nejuˇziteˇcnˇejˇs´ıch senzor˚u. Umoˇzˇnuje robotovi rozeznat vzd´alenost od pˇrek´aˇzky v rozmez´ı od 0 – 250cm. Funguje na principu odrazu zvuku. D´ıky zn´am´e rychlosti ˇs´ıˇren´ı zvuku se zaznamen´a ˇcas vysl´an´ı zvuku a ˇcek´a se, dokud se odraˇzen´y zvuk nevr´at´ı zpˇet. Pak se z rozd´ılu tˇechto dvou ˇcas˚u vypoˇcte vzd´alenost. Funguje pˇresnˇe, ale z´aleˇz´ı opˇet na povrchu tˇelesa a ´uhlu, kter´y sv´ır´a senzor a sn´ıman´y objekt. Nˇekter´e tˇelesa zvuk pohlt´ı a neodraz´ı v˚ubec zpˇet, pak se zd´a, ˇze je tˇeleso pˇr´ıliˇs daleko. Nebo naopak u tˇeles s dobrou odrazivost´ı m˚uˇze doj´ıt k odrazu mimo, pokud nen´ı tˇeleso pˇribliˇznˇe kolmo k sn´ımaˇci. ˇCastou aplikac´ı je prohled´av´an´ı bludiˇstˇe tvoˇren´eho zdmi nebo rozezn´av´an´ı vzd´alenosti.
2.2 Senzory 5
2.2.6 HiTechnic EOPD (Electro – Optical Proximity Detector) Sensor
Tento senzor je urˇcen stejnˇe jako ultrazvukov´y senzor pro sn´ım´an´ı vzd´alenosti od objektu. Je zaloˇzen na podobn´em principu jako svˇeteln´y senzor, ale pracuje jen v aktivn´ım reˇzimu (pouze s rozsv´ıcenou LED diodou). Fotocitliv´a dioda je z´avisl´a pouze na svˇetle speci´aln´ı LED diody. Proto sn´ımaˇc funguje bez ohledu na okoln´ı osvˇetlen´ı. T´ım je moˇzno ho pouˇz´ıt za r˚uzn´ych svˇeteln´ych podm´ınek. Oproti ultrazvukov´emu senzoru je mnohon´asobnˇe citli-vˇejˇs´ı, ale mˇeˇr´ı jen do vzd´alenosti cca 20cm. Nevrac´ı hodnotu v centimetrech, pouze jen bezrozmˇern´e ˇc´ıslo v rozsahu 0 – 100 nebo jako nezpracovan´a data 0 – 1023. V´yhoda je, ˇze funguje i pod vˇetˇs´ımi ´uhly sv´ıran´ymi s objektem nˇeˇz ultrazvukov´y senzor.
2.2.7 HiTechnic Acceleration Sensor
Senzor sn´ım´a pohyb v souˇradnic´ıch x,y,z. Pouˇzit´ı: napˇr. robot s t´ımto senzorem m˚uˇze odes´ılat informace o sv´em pohybu druh´emu robotovi, a ten bude kop´ırovat jeho pohyb. 2.2.8 HiTechnic Compass Sensor
Kompas senzor umoˇzˇnuje robotovi sn´ımat sever. Vrac´ı hodnoty v rozmez´ı 0 – 359◦, sever je 0◦. Aby se omezily neˇz´adouc´ı vlivy (motor˚u, bateri´ı), mus´ı b´yt um´ıstˇen alespoˇn 10cm od kostky a 15cm od motor˚u. V okol´ı senzoru samozˇrejmˇe nesm´ı b´yt ˇz´adn´e magnety. M˚uˇze b´yt pouˇzit pro ot´aˇcen´ı robota na sever, nebo ot´aˇcen´ı o urˇcit´y ´uhel. Rychlost sn´ım´an´ı je pˇribliˇznˇe 100kr´at za vteˇrinu. Senzor je moˇzno taky kalibrovat pro sn´ıˇzen´ı neˇz´adouc´ıch ´
uˇcink˚u magnetick´eho ruˇsen´ı (motor˚u aj.). 2.2.9 HiTechnic Color Sensor
Dok´aˇze detekovat v´ıce jak 15 barev, je nastaven na rozpozn´av´an´ı standardn´ıch LEGO barev (napˇr. barvy m´ıˇck˚u v kitu aj.). Funguje na podobn´em principu jako svˇeteln´y senzor, ale ˇcerven´a LED dioda byla nahrazena b´ılou LED diodou.
2.2.10 HiTechnic Gyro Sensor
Jedn´a se o mal´y gyroskop. Zaznamen´av´a velikost zmˇeny ´uhlu za vteˇrinu v rozsahu +/-360◦. Pouˇzit´ı m˚uˇze b´yt napˇr´ıklad pro udrˇzen´ı rovnov´ahy robota na dvou kolech. Rychlost sn´ım´an´ı je pˇribliˇznˇe 300kr´at za vteˇrinu.
2.2.11 HiTechnic IRLink Sensor
Jde o infraˇcerven´y modul, jak´y je moˇzno nal´ezt v nˇekter´ych mobilech. Pomoc´ı nˇej m˚uˇze NXT ovl´adat rychlost a smˇer nˇekter´ych LEGO zaˇr´ızen´ı podporuj´ıc´ı IR komunikaci napˇr. LEGO vl´aˇcky(7897 a 7898), buldozer (8275) a Monster Dino (4958)[3].
2.3 NXT–G 6
2.2.12 HiTechnic IRReceiver Sensor
Tento senzor je urˇcen pro pˇr´ıjem a dek´odov´an´ı IR sign´al˚u z d´alkov´eho ovl´ad´an´ı LEGO (8879 a 8885). Pomoc´ı d´alkov´eho ovl´ad´an´ı pak lze ovl´adat smˇer a rychlost robota, popˇ r´ı-padˇe jinou funkci programu.
2.2.13 HiTechnic IRSeeker V2 Sensor
Tento senzor umoˇzˇnuje detekovat IR sign´aly standardn´ıch d´alkov´ych ovladaˇc˚u nebo Hi-Technic IRBallu a urˇcit jejich s´ılu a smˇer, ze kter´eho vych´azej´ı. Realizovat tak lze fotbal robot˚u nebo robota, kter´y V´as sleduje, kdyˇz maˇck´ate tlaˇc´ıtko ovladaˇce od televize.
2.3 LEGO Mindstorms NXT (NXT–G)
LEGO pˇrikl´ad´a ke kitu v´yvojov´e prostˇred´ı na programov´an´ı robot˚u, kter´e vytv´aˇr´ı pro-gramy jazykem NXT–G. Jedn´a se o grafick´y, snadno pochopiteln´y jazyk kompilovan´y pˇr´ımo do FLASH pamˇeti kostky. Po kompilaci se spouˇst´ı pˇr´ımo na kostce pomoc´ı tlaˇc´ıtek. Z´akladem grafick´eho programov´an´ı je skl´ad´an´ı existuj´ıc´ıch blok˚u syst´emem drag and drop (t´ahni a pust’) dohromady. LEGO pˇripravilo nˇekolik z´akladn´ıch blok˚u, kter´e postaˇcuj´ı pro vytvoˇren´ı jednoduch´ych program˚u. Mezi bloky nalezneme bloky pro:
• vˇsechny dod´avan´e senzory LEGO a ovl´ad´an´ı motor˚u, • ˇr´ızen´ı toku programu (cykly, podm´ınky),
• z´apis na displej, konverzi ˇc´ısla na text, • z´akladn´ı matematick´e operace a promˇenn´e.
Na LEGO [4] str´ank´ach jsou k dispozici nov´e verze blok˚u. Funkci maj´ı stejnou jako pˇredchoz´ı bloky, ale jsou optimalizov´any tak, ˇze po kompilaci nezab´ıraj´ı moc m´ısta ve FLASH pamˇeti NXT. Krom ofici´aln´ıch LEGO blok˚u lze st´ahnout i jin´e bloky napˇr. pro senzory vyr´abˇen´e jin´ymi firmami, bloky pro komunikaci pˇres I2C aj. Obr´azek 2 na n´ asle-duj´ıc´ı stranˇe zobrazuje v´yvojov´e prostˇred´ı.
Bloky lze libovolnˇe kombinovat a seskupen´ım nˇekolika blok˚u m˚uˇzeme vytvoˇrit vlastn´ı blok, kter´y pozdˇeji znovu pouˇzijeme. To provedeme tak, ˇze kurzorem vybereme bloky, ze kter´ych chceme vytvoˇrit vlastn´ı blok. V menu zvol´ıme Edit → Make A New My Block. Pouˇz´ıv´an´ı vlastn´ıch blok˚u ˇsetˇr´ı pamˇet’. Pokud v jednom sch´ematu pouˇzijeme v´ıce stejn´ych blok˚u, zabere pamˇet’ pouze jeden. Pokud vˇsak ve sch´ematu blok pouˇzijeme jen jednou, zabere v´ıc m´ısta v pamˇeti, neˇz kdyby bylo sch´ema tvoˇreno jen z´akladn´ımi bloky. Bloky se prov´adˇej´ı postupnˇe tak, jak jsou poskl´ad´any za sebou. Lze ale vytvoˇrit tˇri paralelnˇe bˇeˇz´ıc´ı vˇetve. Bloky se napojuj´ı rovnobˇeˇznˇe a vytv´aˇrej´ı tak pˇrehledn´e sch´ema. Nˇekter´e bloky se mus´ı propojit pomoc´ı
”dr´atov´ych“ propojek ( Obr´azek 4 na stranˇe 9) pro pˇrenos hodnot promˇenn´ych.
Mezi velk´e nedostatky patˇr´ı nemoˇznost rekurze blok˚u. Pokud napˇr. chceme v jednom bloku volat stejn´y blok, mus´ıme vytvoˇrit kopii bloku a pˇrejmenovat ji. To ovˇsem neˇreˇs´ı moˇznost rekurzivn´ıho vol´an´ı stejn´eho bloku, pouze d´av´a moˇznost volat znova tent´yˇz blok
2.3 NXT–G 7
Obr´azek 2: LEGO Mindstorms NXT (NXT–G) v´yvojov´e prostˇred´ı
pod jin´ym n´azvem. Dalˇs´ım nedostatkem je to, ˇze pˇri vytvoˇren´ı vˇetˇs´ıho sch´ematu se stane v´yvojov´e prostˇred´ı naprosto neovladateln´e. Potom je probl´em s bloky manipulovat a pˇ re-t´ahnout nˇekam jinam. ˇReˇsen´ım je velk´e sch´ema rozdˇelit pomoc´ı vlastn´ı blok˚u do nˇekolika menˇs´ıch. Dalˇs´ım probl´emem byl pˇrechod na novˇejˇs´ı verzi 2.0. Pˇri nˇem se smazaly defi-nice promˇenn´ych z blok˚u nadˇrazen´ych. Promˇenn´e se pak chovaly jako znova nadefinovan´e a nepˇrenesly hodnotu uloˇzenou v bloku o ´uroveˇn v´yˇs.
2.3.1 Sezn´amen´ı s v´yvojov´ym prostˇred´ım
Po spuˇstˇen´ı v´yvojov´eho prostˇred´ı LEGO Mindstorms NXT se n´am objev´ı ´uvodn´ı obra-zovka, na kter´e si m˚uˇzeme vybrat, jestli chceme zaloˇzit nov´y projekt nebo otevˇr´ıt starˇs´ı. Krom toho LEGO na t´eto obrazovce nab´ız´ı prohl´ednut´ı dvou vide´ı pro sezn´amen´ı s pro-stˇred´ım a uˇzivatelsk´y manu´al. Vˇrele doporuˇcuji tato videa shl´ednout. Zvol´ıme vytvoˇren´ı nov´eho projektu. Uprostˇred se n´am objev´ı pr´azdn´e pl´atno, na kter´e m˚uˇzeme d´avat bloky. Bloky nalezneme vlevo od pl´atna, jsou rozdˇeleny do tˇrech z´aloˇzek. Prvn´ı obsahuje bˇeˇznˇe pouˇz´ıvan´e bloky, druh´a kompletn´ı seznam blok˚u a tˇret´ı uˇzivatelsk´e bloky a bloky staˇzen´e z internetu. Horn´ı liˇsta obsahuje ikony pro standardn´ı pr´aci s dokumentem, pak ikony pro pˇrep´ınan´ı reˇzimu kurzoru – v´ybˇer nebo posuv. Vpravo nalezneme ikonu, kter´a ukr´yv´a n´avody na sestaven´ı r˚uzn´ych tvar˚u robota a ikonu s novinkami na internetu. Na pl´atnˇe jsou ikony pro staˇzen´ı programu do robota, spuˇstˇen´ı nebo zastaven´ı programu a informace o kostce. Pod pl´atnem je n´ahled na cel´e sch´ema a n´apovˇedu. Menu nahoˇre obsahuje kla-sick´e poloˇzky jako File, d´ale Edit – zde jsou poloˇzky pro vytv´aˇren´ı a editaci vlastn´ıch blok˚u, vytv´aˇren´ı vlastn´ıch promˇenn´ych. V menu Tools nalezneme poloˇzky pro kalibraci
2.3 NXT–G 8
senzor˚u, aktualizaci firmware, vytv´aˇren´ı vlastn´ıch bal´ık˚u, import a export blok˚u, editor obr´azk˚u a zvuku pro NXT a d´alkov´e ovl´ad´an´ı robota.
2.3.2 Instalace firmware
Nejprve je d˚uleˇzit´e nal´ezt nejnovˇejˇs´ı firmware, ten je k dispozici na LEGO[4] str´ank´ach v sekci Support → Files. Nov´y firmware m˚uˇze opravovat r˚uzn´e chyby a pˇrin´aˇset nov´e funkce. Po staˇzen´ı firmwaru do poˇc´ıtaˇce zvol´ıme Tools → Update NXT Firmware. Objev´ı se okno, viz Obr´azek 3, kde vybereme cestu k firmwaru a stiskneme tlaˇc´ıtko download.
Obr´azek 3: LEGO Mindstorms NXT – Update NXT Firmware
2.3.3 Tvorba programu pro robota
Vytvoˇr´ıme jednoduch´y program na zobrazen´ı vzd´alenosti ultrazvukov´eho senzoru na dis-pleji a detekci pˇrek´aˇzky. Pokud bude vzd´alenost menˇs´ı neˇz 20cm, spust´ı se v´ystraˇzn´y zvuk. Nejprve pˇripoj´ıme k robotovi ultrazvukov´y senzor k portu ˇc.1. Program mus´ı bˇeˇzet ve smyˇcce, jinak by robot z´ıskal hodnotu ze senzoru a program by se ukonˇcil. Proto vlo-ˇ
z´ıme do sch´ematu cyklus – klikneme na z´aloˇzku Complete Palette, tam vybereme Flows → Loop a pˇret´ahneme do sch´ematu. Pˇrid´ame ultrazvukov´y senzor Sensor → Ultrasonic Sensor. Klikneme na senzor a nastav´ıme ho na port 1, nastav´ıme jednotky na cm, vzd´ ale-nost na menˇs´ı neˇz 20. Blok ultrazvukov´y senzor m´a porovn´avaj´ıc´ı blok pˇr´ımo v sobˇe, takˇze nemus´ıme vkl´adat do sch´ematu porovn´avaj´ıc´ı blok a m˚uˇzeme vyuˇz´ıt v´ystupu porovn´an´ı. Klikneme proto na spodn´ı ˇc´ast bloku, t´ım se rozbal´ı vstupy a v´ystupy bloku. Vloˇz´ıme konverzi ˇc´ısla na text Advanced → Number to Text a displej Action → Display. Propoj´ıme
2.3 NXT–G 9
v´ystup Distance se vstupem Number konvertoru, obdobnˇe v´ystup Text se vstupem Text displeje. T´ım se n´am bude zobrazovat hodnota vzd´alenosti na displeji. Pˇrehr´an´ı zvuku je z´avisl´e na podm´ınce (vzd´alenost je menˇs´ı neˇz 20cm), vloˇz´ıme do sch´ematu tedy podm´ınku Flow → Switch. Klikneme na blok podm´ınky a zmˇen´ıme Control na Value – Logic. Pro-poj´ıme v´ystup bloku ultrazvukov´eho senzoru Yes/No s vstupem podm´ınky. Do podm´ınky vloˇz´ıme zvukov´y blok Action → Sound a nastav´ıme zvuk na Object detected. V´ysledek by mˇel vypadat pˇribliˇznˇe jako Obr´azek 4. T´ım je program hotov. Staˇc´ı propojit robota a stisknout na pl´atnˇe tlaˇc´ıtko Download and run.
Obr´azek 4: LEGO Mindstorms NXT – Detekce objektu
2.3.4 Zhodnocen´ı
Jazyk NXT–G je snadno pochopiteln´y, a proto je to urˇcitˇe nejlepˇs´ı volba pro zaˇc´ateˇcn´ıky v programov´an´ı robot˚u NXT. Nav´ıc je pˇr´ımo od v´yrobce, t´ım by mˇelo b´yt zaruˇceno, ˇze nedojde k poˇskozen´ı NXT napˇr. chybou v ciz´ım firmware. Protoˇze se program stahuje pˇr´ımo do pamˇeti robota, nen´ı potˇreba k spouˇstˇen´ı program˚u poˇc´ıtaˇc a reakce na stav senzor˚u je rychlejˇs´ı. Nev´yhodou je absence debuggeru. Bez nˇej by byl pro komplikovan´y projekt tento n´astroj moˇzn´a nedostaˇcuj´ıc´ı.
3 RobotC 10
3
RobotC
RobotC[7] je v´yvojov´e prostˇred´ı a programovac´ı jazyk (zaloˇzen´y na jazyku C) pro pro-gramov´an´ı robot˚u LEGO Mindstorms NXT, RCX a Innovation FIRST VEX (pro kaˇ z-dou platformu existuje jin´y instalaˇcn´ı bal´ık). Vytvoˇrila jej univerzita Carnegie Mellon, 30 denn´ı demoverze je k staˇzen´ı na domovsk´ych str´ank´ach. Stejnˇe jako NXT–G nahr´av´a sv´e programy pˇr´ımo do pamˇeti NXT, k jejich spuˇstˇen´ı je ale potˇreba nahr´at RobotC fir-mware. Tento firmware ovˇsem pˇrin´aˇs´ı mnoho v´yhod oproti origin´aln´ımu firmware. Mezi velk´e pˇrednosti patˇr´ı vˇetˇs´ı rychlost prov´adˇen´ı operac´ı, a t´ım rychlejˇs´ı ˇcten´ı dat ze sen-zor˚u, v´ıce rozhodnut´ı nebo v´ypoˇct˚u za sekundu. D´ale je rychlejˇs´ı i pos´ıl´an´ı zpr´av mezi PC a NXT, ud´av´a se o 50 – 500% oproti origin´aln´ımu firmwaru. Jedinou nev´yhodou je nekompatibilita s MRDS. Prostˇred´ı obsahuje taky interaktivn´ı real-time debugger, kter´y dˇel´a z tohoto prostˇred´ı opravdu kvalitn´ı n´astroj pro programov´an´ı robot˚u. K dispozici jsou tak´e pˇripraven´e uk´azkov´e ´ulohy a rychl´y pr˚uvodce s n´apovˇedn´ymi videy. Obr´azek 5 ukazuje v´yvojov´e prostˇred´ı RobotC.
Obr´azek 5: RobotC v´yvojov´e prostˇred´ı
3.1 Sezn´amen´ı s v´yvojov´ym prostˇred´ım
V dobˇe psan´ı t´eto pr´ace jsem mˇel k dispozici v´yvojov´e prostˇred´ı ve verzi 1.05. Po spuˇstˇen´ı prostˇred´ı RobotC se objev´ı okno rozdˇelen´e do dvou ˇc´ast´ı. Prav´a ˇc´ast je urˇcena pro psan´ı k´odu tak, jak jsme zvykl´ı z ostatn´ıch v´yvojov´ych prostˇred´ı (IDE). Lev´a ˇc´ast je tvoˇrena knihovn´ımi RobotC API funkcemi, kter´e m˚uˇzeme syst´emem drag and drop pˇret´ahnout do k´odu. K´od se skl´ad´a obdobnˇe jako k´od jazyka C z hlavn´ı spouˇstˇec´ı metody main. V RobotC zaˇc´ın´a kaˇzd´a ´uloha kl´ıˇcov´ym slovem task. Prvn´ı ˇr´adky oznaˇcen´e jako auto jsou
3.2 Tvorba programu pro robota 11
tvoˇreny nastaven´ım port˚u, ty se ale needituj´ı pˇr´ımo v editoru, n´ybrˇz ve speci´aln´ım oknˇe k tomu urˇcen´em. Pak se v pˇr´ıpadˇe zmˇeny automaticky pˇregeneruj´ı.
Nahoˇre v menu File nalezneme kromˇe klasick´ych poloˇzek poloˇzku pro otevˇren´ı uk´ azko-v´ych pˇr´ıklad˚u a otevˇren´ı s kompilac´ı. V menu Edit nalezneme nav´ıc kop´ırov´an´ı konfigurace pˇripojen´ych port˚u do schr´anky. Dalˇs´ı menu poloˇzky jsou z´avisl´e na reˇzimu zobrazen´ı. Na v´ybˇer m´ame Basic nebo Expert. Nastaven´ı nalezneme v menu Window → Menu Level. Budeme popisovat expertn´ı reˇzim. N´asleduje poloˇzka View. Tady nalezneme poloˇzky pro zobrazen´ı a smaz´an´ı logu zpr´av, nastaven´ı editoru a rychl´e nastaven´ı editoru do dvou pro-fil˚u – debug a release. Dalˇs´ı poloˇzka je pro smaz´an´ı vˇsech hodnot z registr˚u. N´asleduj´ıc´ı poloˇzky slouˇz´ı k zobrazen´ı a skryt´ı panel˚u. Asi nejd˚uleˇzitˇejˇs´ı poloˇzkou menu je poloˇzka Ro-bot. V n´ı se ukr´yvaj´ı z´akladn´ı funkce v´yvojov´eho prostˇred´ı jako napˇr. kompilace a st´ahnut´ı programu do naˇseho NXT. Je zde i poloˇzka pro staˇzen´ı firmware, doporuˇcuji ale pouˇz´ıt origin´aln´ı LEGO software pro staˇzen´ı firmwaru, viz kapitola 2.3.3. Obˇcas se totiˇz stalo, ˇ
ze se firmware stahoval pˇr´ıliˇs dlouho nebo se stahovan´ı nedokonˇcilo. V menu nalezneme i debugger, kter´y poskytuje krokov´an´ı programu. V poloˇzce Robot → NXT Brick nalez-neme n´astroje pro spr´avu soubor˚u v NXT, test I2C sbˇernice, nastaven´ı pˇripojen´ı NXT a n´astroj s informacemi o aktu´aln´ım stavu senzor˚u a motor˚u. D´ale n´asleduje poloˇzka pro nastaven´ı robotick´e platformy RCX nebo NXT. Jako dalˇs´ı je poloˇzka pro nastaven´ı motor˚u a senzor˚u viz Obr´azek 6. Zde nastav´ıme pˇripojen´e senzory a motory, potvzen´ım tlaˇc´ıtka Ok si nech´ame vygenerovat konfiguraci do zdrojov´eho k´odu.
Obr´azek 6: RobotC v´yvojov´e prostˇred´ı – nastaven´ı motor˚u a senzor˚u
3.2 Tvorba programu pro robota
Nejprve je potˇreba nahr´at RobotC firmware z instalaˇcn´ı sloˇzky RobotC/firmware, bud’ pˇres origin´aln´ı software viz kapitola 2.3.3, anebo pˇres menu Robot → Download Firmware. Pro prvn´ı program doporuˇcuji pouˇz´ıt jako vzor nˇejak´y z uk´azkov´ych pˇr´ıklad˚u. Zvol´ıme
3.2 Tvorba programu pro robota 12
proto v menu File → Open Sample Program, tam otevˇreme sloˇzku Sonar a v n´ı program nxt obstacle detect. RobotC nedovol´ı editaci uk´azkov´ych pˇr´ıklad˚u, proto si uloˇz´ıme kopii programu nˇekam jinam – File → Save as .... Mus´ıme nastavit porty, kde m´ame pˇripojeny motory a ultrazvukov´y senzor. To provedeme v menu Robot → Motors and Sensors Setup. Zdrojov´y k´od programu viz V´ypis 1.
task main() { do{ motor[motorA] = 75; motor[motorB] = 75; }while(SensorValue(sonarSensor) > 20); }
V´ypis 1: RobotC – program pro detekci pˇrek´aˇzky
Uk´azkov´y program funguje n´asledovnˇe. Nejprve se spust´ı task main. V nˇem je cyklus typu do – while, nejprve se provede blok do. V nˇem je nastaven´ı rychlosti obou motor˚u na 75%. Pak dojde k porovn´an´ı hodnot z ultrazvukov´eho senzoru se zadanou hodnotou (hodnota je v palc´ıch). Pokud podm´ınka plat´ı, cyklus se opakuje. V opaˇcn´em pˇr´ıpadˇe dojde k ukonˇcen´ı cyklu, a t´ım k ukonˇcen´ı programu a robot se zastav´ı.
My bychom chtˇeli, aby robot na displej vypsal Obstacle (pˇrek´aˇzka), zahr´al nˇejak´y v´ystraˇzn´y zvuk a zastavil se. Po odstranˇen´ı pˇrek´aˇzky by se opˇet rozjel. Z p˚uvodn´ıho cyklu udˇel´ame klasick´y while cyklus a vloˇz´ıme cel´y cyklus do nov´eho nekoneˇcn´eho cyklu while(true). Pokud bude bl´ızko pˇrek´aˇzky, chceme aby se zastavil, proto vloˇz´ıme za cyklus testuj´ıc´ı vzd´alenost, nastaven´ı rychlosti obou motor˚u na 0. Pak chceme, aby se na displeji zobrazilo Obstacle. Z lev´eho menu s knihovn´ımi funkcemi vloˇz´ıme Display → Intrinsics → nxtDisplayStringAt. Nakonec chceme zahr´at v´ystraˇzn´y zvuk. Obdobnˇe z lev´eho menu vybereme Sound → Intrinsics → playSoundFile. Zvukov´e soubory k pˇrehr´an´ı nalezneme v menu Robot → NXT Brick → File Management. Jeˇstˇe je potˇreba do p˚uvodn´ıho cyklu vloˇzit vymaz´an´ı displeje – Display → Intrinsics → eraseDisplay. Zdrojov´y k´od programu viz V´ypis 2. task main() { while(true){ while(SensorValue(sonarSensor) > 20){ eraseDisplay () ; motor[motorA] = 75; motor[motorB] = 75; } motor[motorA] = 0; motor[motorB] = 0; nxtDisplayStringAt (7, 7, ”Obstacle”) ; PlaySoundFile(”Obstacle detected . rso ”) ; }
}
3.3 Zhodnocen´ı 13
Nakonec staˇc´ı program zkompilovat a nahr´at do FLASH pamˇeti robota. To provedeme pˇres menu Robot → Compile and Download Program.
3.3 Zhodnocen´ı
Jedn´a se o velice propracovan´y n´astroj, ve kter´em jdou ˇreˇsit komplikovan´e projekty. Po-dobnost programovac´ımu jazyku C je velkou v´yhodou. D´ıky znalosti jazyka C a spousty uk´azkov´ych pˇr´ıklad˚u se lze v RobotC rychle nauˇcit programovat. Knihovn´ı funkce neznaj´ı mez´ı a lze si naprogramovat I2C komunikaci s prakticky libovoln´ym, i vlastnoruˇcnˇe
vyro-ben´ym zaˇr´ızen´ım. D´ıky debuggeru a propracovan´ym n´astroj˚um na sledov´an´ı stavu senzor˚u a motor˚u m´ame naprostou kontrolu nad t´ım, co se aktu´alnˇe prov´ad´ı. V´yhodou m˚uˇze, ale nemus´ı b´yt, optimalizovan´y firmware (d´ıky nekompatibilitˇe s MRDS). Celkovˇe hodnot´ım RobotC jako nejlepˇs´ı n´astroj k programovan´ı NXT, kter´y jsem mˇel moˇznost poznat.
4 MRDS 14
4
Microsoft Robotics Developer Studio (MRDS)
Microsoft pˇriˇsel s revoluˇcn´ı myˇslenkou – oprostit se od hardware, pro kter´y jsou IDE pro robotick´a zaˇr´ızen´ı ps´ana a s pomoc´ı sluˇzeb vytvoˇrit n´astroj nez´avisl´y platformˇe. V podstatˇe jde o to, ˇze pro kaˇzd´y hardware se nap´ıˇse sluˇzba poskytuj´ıc´ı pˇr´ıstup ke sv´ym port˚um, se kter´ymi pak ostatn´ı sluˇzby komunikuj´ı. Sjednocen´ı v´yvojov´eho prostˇred´ı pro v´ıce platforem mˇelo jedin´y c´ıl – a to ´usporu ˇcasu a penˇez znovupouˇzit´ım existuj´ıc´ıch knihoven a jednotn´y pˇr´ıstup ke vˇsem robotick´ym zaˇr´ızen´ım. N´asleduj´ıc´ı informace jsou ˇcerp´any z [8, 10, 11]. Hlavn´ımi poˇzadavky pro vznik t´eto technologie byly:
• Snadn´e nastaven´ı senzor˚u a motor˚u, moˇznost je spouˇstˇet asynchronnˇe. • Spouˇstˇen´ı a zastavov´an´ı softwarov´ych komponent dynamicky.
• Interaktivn´ı sledov´an´ı robota a jeho ˇr´ızen´ı.
• Dovolen´ı v´ıce uˇzivatel˚um sd´ılet pˇr´ıstup k jednomu robotovi nebo jednomu uˇzivateli povolit pˇr´ıstup k v´ıce robot˚um.
• Znovupouˇzit´ı softwarov´ych komponent napˇr´ıˇc robotick´ymi platformami.
Microsoft dod´av´a v´yvojov´e prostˇred´ı v nˇekolika verz´ıch. Zdarma je k dispozici Express verze, kter´a ale m´a r˚uzn´a omezen´ı ve vˇsech n´astroj´ıch. Napˇr. z VPL nelze generovat do C# k´odu, nen´ı podpora .NET Compact Frameworku a dalˇs´ı omezen´ı. V´ıce informac´ı nalezneme v [5]. Pro komerˇcn´ı ´uˇcely je dostupn´a placen´a verze Standard v cenˇe 500$. Microsoft uvolnil pro akademick´e ´uˇcely zdarma verzi Academic bez omezen´ı, kterou lze st´ahnout pˇres MSDN Academic Alliance nebo DreamSparkTM. MRDS obsahuje n´astroje:
• Visual Programming Language (VPL), • Visual Simulation Environment (VSE), • DSS Manifest Editor (DSSME),
• DSS Log Analyzer, • a dalˇs´ı.
VPL je grafick´y n´astroj na programov´an´ı robotick´ych aplikac´ı. N´astroj VSE slouˇz´ı k simulaci a testov´an´ı robotick´ych aplikac´ı ve 3D s podporou fyziky. DSS Manifest Editor slouˇz´ı pro vytv´aˇren´ı a editaci konfigurac´ı aplikace. DSS Log Analyzer, jak n´azev napov´ıd´a, slouˇz´ı k anal´yze toku zpr´av mezi sluˇzbami s moˇznost´ı detailn´ıho zobrazen´ı zpr´avy.
Krom n´astroj˚u pˇrikl´ad´a Microsoft k MRDS spoustu uk´azkov´ych pˇr´ıklad˚u a tutori-´
al˚u. Pˇr´ıklady popisuj´ı jak vytv´aˇret sluˇzby, d´ale jsou to pˇr´ıklady pro sezn´amen´ı s n´astroji VPL a VSE a uk´azky sluˇzeb pro platformy jako je Fischertechnik, iRobot, Kondo, LEGO a MobileRobots.
4.1 Architektura 15
4.1 Architektura
MRDS je zaloˇzeno na .NET, proto pro programov´an´ı m˚uˇzeme vyuˇz´ıt libovoln´y z jazyk˚u podporovan´ych v .NET (C++, C#, Visual Basic .NET, Dephi, Python aj.), ale vˇetˇsina uk´azkov´ych pˇr´ıklad˚u je psan´a v C# a Visual Basic .NET. Nav´ıc VPL um´ı sch´ema pˇ rege-nerovat pouze do C# k´odu.
Bˇehov´e prostˇred´ı MRDS je zaloˇzeno na Common Language Runtime (CLR). Vyu-ˇ
z´ıv´a dvou kl´ıˇcov´ych prvk˚u Concurrency and Coordination Runtime (CCR) a Decentra-lized Software Services (DSS) k vytvoˇren´ı mnoˇziny podporuj´ıc´ı centr´aln´ı objekt MRDS – sluˇzby. Obr´azek 7 ukazuje bˇehov´e prostˇred´ı MRDS. CLR poskytuje obˇema knihovn´am pˇr´ıstup k .NET Frameworku.
Obr´azek 7: MRDS bˇehov´e prostˇred´ı [11]
4.1.1 Concurrency and Coordination Runtime (CCR)
CCR je hlavn´ı knihovna MRDS staraj´ıc´ı se o koordinaci jednotliv´ych aktivit (napˇr. in-formace ze sn´ımaˇc˚u, pohyb robota aj.). Poskytuje asynchronn´ı bˇeh tˇechto aktivit pomoc´ı vl´aken (napˇr. bˇehem ot´aˇcen´ı robota se prov´ad´ı ˇcten´ı hodnot nˇejak´eho senzoru). CCR je .NET knihovna, kterou m˚uˇze vyuˇz´ıt libovoln´a .NET aplikace vyˇzaduj´ıc´ı asynchronn´ı zpracov´an´ı. Knihovna zakr´yv´a pr´aci s vl´akny a t´ım zjednoduˇsuje programov´an´ı aplikac´ı s asynchronn´ım zpracov´an´ım. Z´akladem knihovny jsou porty reprezentovan´e tˇr´ıdou Port. Port m˚uˇze b´yt libovoln´y sn´ımaˇc nebo motor robota. Kaˇzd´y port si udrˇzuje frontu zpr´av nebo dat urˇcit´eho typu. Ze senzor˚u aplikace data ˇcte a do motor˚u je zapisuje. Sch´ema CCR viz Obr´azek 8 na n´asleduj´ıc´ı stranˇe.
Dalˇs´ı d˚uleˇzitou tˇr´ıdou je tˇr´ıda Arbiter. Tato tˇr´ıda umoˇzˇnuje vytv´aˇret handlery na ud´ a-losti port˚u (pokud pˇrijde zpr´ava do nˇejak´eho portu). S pomoc´ı t´eto tˇr´ıdy se daj´ı ud´alosti
4.1 Architektura 16
Obr´azek 8: MRDS architektura CCR [10]
propojovat, a vytv´aˇret tak nˇejak´e podm´ınˇen´e ud´alosti (napˇr. proved’ nˇejakou akci pokud pˇrijdou zpr´avy na tyto dva porty). Toto propojen´ı se v CCR naz´yv´a join. Pˇr´ıkladem joinu m˚uˇze b´yt j´ızda robota s ultrazvukov´ym a svˇeteln´ym senzorem. Pokud bude vzd´alenost pˇrek´aˇzky menˇs´ı jak 20cm a z´aroveˇn svˇeteln´y senzor bude sn´ımat ˇcernou barvu, pak se robot zastav´ı. Dalˇs´ım propojen´ım je propojen´ı typu choice. To naopak ˇcek´a na pˇr´ıjem zpr´avy z libovoln´eho portu ze skupiny vybran´ych port˚u, a pak provede urˇcitou akci. Tak jako v pˇredchoz´ım pˇr´ıkladˇe, tentokr´at by robotovi k zastaven´ı staˇcila bud’ vzd´alenost od pˇrek´aˇzky menˇs´ı jak 20cm, anebo sejmut´ı ˇcern´e barvy svˇeteln´ym senzorem. Kaˇzd´y han-dler vrac´ı n´avratovou hodnotu IEnumerator<ccr.ITask>, d´ıky tomu m˚uˇze postupnˇe asyn-chronnˇe vracet pˇr´ıkazy, kter´e se maj´ı v r´amci oˇsetˇren´ı ud´alosti vykonat (vrac´ı se pomoc´ı kl´ıˇcov´eho slova yield return).
4.1.2 Decentralized Software Services (DSS)
DSS je aplikaˇcn´ı model, kter´y umoˇzˇnuje v´yvoj´aˇr˚um interaktivnˇe sledovat sluˇzby v re´ al-n´em ˇcase. Je zaloˇzen na REST (Representational State Transfer). REST je architektura rozhran´ı pro webov´e aplikace, navrˇzen´a pro distribuovan´e prostˇred´ı. V prostˇred´ı WWW (World Wide Web) se pˇri kaˇzd´em nov´em poˇzadavku na zobrazen´ı str´anky ztr´ac´ı infor-mace o pˇredeˇsl´em poˇzadavku. V´yvoj´aˇri .NET sice mohou pouˇz´ıt session promˇenn´e pro uloˇzen´ı stavu mezi poˇzadavky, ale kaˇzd´y poˇzadavek je nez´avisl´y na dalˇs´ım poˇzadavku. REST umoˇzˇnuje a definuje efektivn´ı zp˚usob pˇr´ıstupu k tˇemto dat˚um. Vyuˇz´ıv´a Hypertext
4.2 DSSME 17
Transfer Protocol (HTTP) a skrz nˇej pomoc´ı Extensible Markup Language (XML) vrac´ı rychle strukturovan´a XML data. D´ıky tomu m˚uˇzeme ovl´adat a sledovat roboty vzd´alenˇe a efektivnˇe.
DSS umoˇzˇnuje sluˇzb´am komunikovat s jin´ymi sluˇzbami nez´avisle na tom, kde sluˇzba bˇeˇz´ı. Kaˇzd´a sluˇzba m´a jednoznaˇcn´y identifik´ator Uniform Resorce Identifier (URI) v r´amci MRDS. Kaˇzd´a sluˇzba, kter´a komunikuje s jin´ymi partnersk´ymi sluˇzbami, zn´a jejich URI. Zjednoduˇsen´e sch´ema sluˇzeb je zobrazeno viz Obr´azek 9.
Obr´azek 9: MRDS architektura sluˇzeb [10]
4.2 DSS Manifest Editor (DSSME)
Soubory typu Manifest (pˇr´ıpona .Manifest.xml nebo .xml) lze sice editovat v libovoln´em textov´em editoru, jsou to pouh´e textov´e soubory v XML. Je ale potˇreba zn´at pˇresn´y form´at jednotliv´ych poloˇzek. Proto je vhodnˇejˇs´ı pouˇz´ıt DSSME viz Obr´azek 10 na n´ asle-duj´ıc´ı stranˇe. Pokud pouˇz´ıv´ame k vytv´aˇren´ı aplikace n´astroj VPL, nen´ı pouˇzit´ı DSSME nutn´e. VPL za n´as vygeneruje potˇrebn´y manifest a poskytuje grafick´e rozhran´ı k editaci manifest˚u partnersk´ych sluˇzeb.
Na lev´e stranˇe je rolovac´ı seznam se vˇsemi dostupn´ymi sluˇzbami. Sluˇzby se naˇc´ıtaj´ı z adres´aˇre bin. Pokud chceme pˇridat do manifestu svoji sluˇzbu, mus´ıme ji do tohoto adre-s´aˇre nahr´at a pak v menu zvolit View → Reload Services. Sluˇzby lze jednoduˇse pˇrid´avat do manifestu syst´emem drag and drop, uprostˇred pak vid´ıme cel´y diagram manifestu se vˇsemi vloˇzen´ymi sluˇzbami. Pokud na nˇekterou klikneme, uvid´ıme vpravo jej´ı vlastnosti, kter´e m˚uˇzeme snadno editovat.
Krom editace manifest˚u um´ı DSSME vygenerovat samorozbalovac´ı arch´ıv cel´e aplikace na z´akladˇe jej´ıho manifestu. To lze jednoduˇse prov´est v menu Deploy → Create Deployment Package.
4.3 VPL 18
Obr´azek 10: MRDS DSSME
4.3 Visual Programming Language (VPL)
Je to grafick´y programovac´ı n´astroj zaloˇzen´y na syst´emu drag and drop, viz Obr´azek 11 na n´asleduj´ıc´ı stranˇe. Je urˇcen pro zaˇc´ınaj´ıc´ı v´yvoj´aˇre v MRDS. Oproti NXT–G umoˇzˇnuje rekurzi, a t´ım mohou b´yt programy vyuˇz´ıvaj´ıc´ı stejn´e funkce jednoduˇsˇs´ı.
4.3.1 Sezn´amen´ı s v´yvojov´ym prostˇred´ım
N´astroj VPL je dosti podobn´y DSSME, jen uprostˇred m´ısto manifestu m´ame diagram aplikace v z´aloˇzce, a vlevo je krom rolovac´ıho seznamu sluˇzeb seznam blok˚u z´akladn´ıch aktivit. Aktivitami se rozum´ı prvky programov´an´ı, jejichˇz v´yˇcet je n´asleduj´ıc´ı: Activity, Variable, Calculate, Data, Join, Merge, If, Switch, List, List Functions, Comment.
Pomoc´ı bloku Activity m˚uˇzeme vytv´aˇret nov´e sluˇzby z existuj´ıc´ıch sluˇzeb a z blok˚u z´akladn´ıch aktivit. Po pˇretaˇzen´ı bloku Activity do diagramu dvojklikem otevˇreme nov´y diagram (jako novou z´aloˇzku) t´eto aktivity. Aktivita m´a vstup pro pˇr´ıjem dat, v´ystup pro odesl´an´ı v´ysledku a v´ystup pro notifikaci o nˇejak´e ud´alosti. Kaˇzd´a aktivita se m˚uˇze skl´adat z nˇekolika akc´ı. Ke kaˇzd´e akci definujeme typ vstupu a v´ystupu pˇres ikonu na-hoˇre nad diagramem. Variable slouˇz´ı k ukl´ad´an´ı a naˇc´ıtan´ı promˇenn´ych. Pro jednoduch´e matematick´e operace (jako +, −, ∗, /, %) vyuˇzijeme blok Calculate, v pˇr´ıpadˇe sloˇzitˇejˇs´ıch operac´ı je k dispozici sluˇzba Math Functions. Pomoc´ı bloku Data nastavujeme hodnotu promˇenn´ych jako vstup do bloku. Blokem Join ˇcek´ame, dokud nepˇr´ıjdou data ze vˇsech pˇripojen´ych vstup˚u. Merge n´am poslouˇz´ı k vytv´aˇren´ı cykl˚u. Spojuje datov´e toky do jed-noho. N´asleduje blok If, v´ysledkem kaˇzd´e podm´ınky mus´ı b´yt hodnota True nebo False. Podobn´ym blokem je Switch, ten oproti bloku If nemus´ı m´ıt v´ysledek kaˇzd´e podm´ınky
4.3 VPL 19
Obr´azek 11: MRDS VPL
True nebo False, ale mus´ı b´yt porovnateln´y se vstupem. Pokud budeme potˇrebovat data ukl´adat do seznamu, m˚uˇzeme pouˇz´ıt blok List. K nˇemu existuje blok List Functions, kter´y obsahuje z´akladn´ı operace se seznamem (jako pˇr´ıd´an´ı prvku na konec a na urˇcit´y index, smaz´an´ı prvku, spojen´ı dvou seznam˚u, obr´acen´ı poˇrad´ı prvk˚u, setˇr´ızen´ı prvk˚u, zjiˇstˇen´ı in-dexu prvku). Posledn´ım blokem je blok Comment, pomoc´ı nˇej vytvoˇr´ıme textov´e pole, do kter´eho m˚uˇzeme vloˇzit koment´aˇr k diagramu.
Menu File disponuje nav´ıc moˇznost´ı pˇrid´an´ı diagramu do otevˇren´eho projektu, ten se zobraz´ı jako nov´a z´aloˇzka. V menu Edit se ukr´yvaj´ı funkce jako editace akc´ı a no-tifikac´ı, promˇenn´ych, pˇr´ıpojen´ı, datov´e pˇripojen´ı, ale ty jsou aktivn´ı jen v urˇcit´ych pˇ r´ı-padech. Nˇekdy je potˇreba znovu naˇc´ıst sluˇzby, to nalezneme v menu View. Tam jsou tak´e uˇziteˇcn´e poloˇzky pro zobrazen´ı mˇr´ıˇzky a zarovn´av´an´ı blok˚u horizont´alnˇe ˇci verti-k´alnˇe. Jedin´a poloˇzka se nach´az´ı v menu Build, a to kompilace do C#. Pro spuˇstˇen´ı m˚uˇzeme pouˇz´ıt menu Run, jin´a moˇznost je pouˇzit´ı pˇr´ıkazov´e ˇr´adky MRDS, nebo pokud m´ame diagram zkompilovan´y jako sluˇzbu, m˚uˇzeme vyuˇz´ıt Visual Studio. V menu Run nalezneme spuˇstˇen´ı programu, spuˇstˇen´ı programu jako kompilovan´e sluˇzby (pokud byl diagram pozmˇenˇen nebo doˇslo k pˇrekompilov´an´ı ve Visual Studiu, budeme vyzv´ani k opˇ e-tovn´e kompilaci). D´ale je moˇznost spuˇstˇen´ı v debug m´odu nebo spuˇstˇen´ı distribuovanˇe na v´ıce poˇc´ıtaˇc´ıch. Zde nalezneme i nastaven´ı portu (v´ychoz´ı hodnota je 50000 pro HTTP a 50001 pro TCP), pod kter´ym sluˇzba bˇeˇz´ı a je moˇzno zobrazit ji v prohl´ıˇzeˇci na URL http://localhost: ˇC´ISLO PORTU HTTP/.
4.3 VPL 20
4.3.2 Tvorba programu pro robota
Opˇet jako v kapitole 3.2 a v kapitole 2.3.3 budeme vytv´aˇret program pro detekci pˇrek´aˇzky. Zde si budeme muset vystaˇcit se zahr´an´ım t´onu po pˇribl´ıˇzen´ı k pˇrek´aˇzce (zobrazen´ı textu na displej a pˇrehr´an´ı zvukov´eho souboru nen´ı k dispozici).
Po otevˇren´ı nov´eho projektu vloˇz´ıme do diagramu sluˇzbu LEGO NXT Brick (m˚uˇzeme do vyhled´avaˇce zadat NXT), klikneme na ni a ve vlastnostech nastav´ıme ˇc´ıslo portu (Set initial configuration), se kter´ym m´ame kostku sp´arovanou. Pot´e vloˇz´ıme sluˇzbu LEGO NXT Drive, ta n´am zajist´ı ˇze robot pojede dopˇredu. Je potˇreba u n´ı nastavit, ke kter´ym port˚um jsou motory pˇripojeny (pro spr´avn´e ot´aˇcen´ı tak´e rozteˇc a velikost kol). Je potˇreba nastavit rychlost motor˚u, to provedeme vloˇzen´ım aktivity Data a Variable. Data nastav´ıme na hodnotu 0.75, kliknut´ım na Variable vytvoˇr´ıme novou promˇennou DrivePower, typu int. Propoj´ıme blok Data s blokem Variable a nastav´ıme Set. Pak propoj´ıme blok Variable s blokem LEGO NXT Drive a nastav´ıme SetDrivePower na hodnotu value.DrivePower (naˇse promˇenn´a). M˚uˇzeme zkusit spustit program v menu Run → Start, robot by mˇel jet bez zastaven´ı (proto ho chyt’te neˇz do nˇeˇceho naraz´ı). Ted’ je potˇreba udˇelat detekci pˇrek´aˇzky, to provedeme vloˇzen´ım sluˇzby LEGO NXT Ultrasonic Sensor a nastav´ıme ji na port, kde je pˇripojen ultrazvukov´y senzor. Vloˇz´ıme aktivitu If a propoj´ıme ultrazvu-kov´y senzor s touto aktivitou. Nastav´ıme AnalogSensorUpdate a v bloku If nastav´ıme RawMeasurement < 20. Oznaˇc´ıme bloky LEGO NXT Drive, Data a Variable a vloˇz´ıme znova jejich kopii (staˇc´ı CTRL+C a CTRL+V na vloˇzen´e sluˇzbˇe). Spoj´ıme blok If se vstupem Data a nastav´ıme data na 0. Udˇel´ame kopii LEGO NXT Brick a spoj´ıme If s t´ımto blokem, nastav´ıme PlayTone, hodnoty nastav´ıme ruˇcnˇe (Edit values directly) na 1000ms pro trv´an´ı a 1000Hz pro frekvenci. Obr´azek 12 na n´asleduj´ıc´ı stranˇe ukazuje jak by mˇel vypadat v´ysledek. Nakonec d´ame program zkompilovat jako sluˇzbu Build → Compile as Service a spust´ıme Run → Compiled Services. M˚uˇzeme si prohl´ednout zkompilovanou sluˇzbu ve Visual Studiu a upravit ji podle libosti, ale pozor – nen´ı moˇzn´e z upraven´e sluˇzby vygenerovat zpˇet VPL diagram. Proto doporuˇcuji pˇri tvorbˇe program˚u udˇelat po-kud moˇzno co nejv´ıce funkc´ı ve VPL, a funkce, kter´e se komplikovanˇe vytv´aˇr´ı ve VPL, pak dopsat v C#. Pˇri tvorbˇe program˚u pro robota se m˚uˇzeme nechat inspirovat pˇripraven´ymi uk´azkami diagram˚u od Microsoftu, kter´e nalezneme v M RDS\samples\V plExamples\. 4.3.3 Zhodnocen´ı
VPL je sice urˇcen pro zaˇc´ateˇcn´ıky, ale dle m´eho n´azoru je komplikovanˇejˇs´ı neˇz NXT–G. Sluˇzby totiˇz bˇeˇz´ı ve vl´aknech, a ne vˇzdy je zcela jasn´e, kdy se kter´a provede. V NXT–G se bloky skl´adaj´ı za sebe a je pˇresnˇe d´ano, kdy se provede urˇcit´y blok. Zde bloky sice lze zarovnat do roviny, ale propojen´ı mezi bloky je tvoˇreno kˇrivkou a sloˇzitˇejˇs´ı diagramy pak vypadaj´ı trochu nepˇrehlednˇe. Dalˇs´ı nev´yhodou je nemoˇznost kompilace pˇr´ımo do pamˇeti robota, to ale pˇrin´aˇs´ı v´yhodu moˇznosti vyuˇzit´ı dokonalejˇs´ıch knihoven a spuˇstˇen´ı distribu-ovanˇe na v´ıce poˇc´ıtaˇc´ıch. Bohuˇzel pr´avˇe tato vlastnost zp˚usobuje u NXT nemoˇznost ˇcten´ı hodnot ze senzor˚u v re´aln´em ˇcase. Velkou v´yhodou je moˇznost kompilace do strukturo-van´eho jazyka C#, to zat´ım ˇz´adn´y, mˇe zn´am´y n´astroj s grafick´ym jazykem pro roboty neumoˇzˇnuje. ˇC´asteˇcnˇe lze dos´ahnout opaˇcn´eho smˇeru a zkompilovanou sluˇzbu znovu
po-4.4 VSE 21
Obr´azek 12: MRDS VPL – program pro detekci pˇrek´aˇzky
uˇz´ıt v dalˇs´ım VPL diagramu. Ale pouze bez moˇznosti zobrazen´ı vnitˇrn´ı struktury bloku. Dalˇs´ı obrovskou v´yhodou je moˇznost rekurze, uvnitˇr sluˇzby m˚uˇzeme volat znovu tuto sluˇzbu. T´ım se zjednoduˇs´ı n´avrh sluˇzby.
4.4 Visual Simulation Environment (VSE)
Tento n´astroj umoˇzˇnuje simulovat sluˇzby vytvoˇren´e v MRDS bez nutnosti vlastnit jak´ yko-liv robotick´y hardware. Simulace ve 3D podporuje z´akladn´ı fyzik´aln´ı vlastnosti. K dispozici jsou r˚uzn´e 3D prostˇred´ı a 3D modely robot˚u. Probl´emem mohou b´yt speci´aln´ı konstrukce robot˚u, kdy je nutno vytvoˇrit si vlastn´ı model nebo sehnat jiˇz vytvoˇren´y nˇekde na inter-netu. Ve sloˇzce M RDS\samples\SimulationT utorials\ nalezneme tutori´aly jak vytvoˇrit simulaci. Nˇekter´e pˇripraven´e simulace lze spustit pˇr´ımo z nab´ıdky Start → Vˇsechny pro-gramy → MRDS → Visual Simulation Environment 2008 R2. V t´eto pr´aci se nezab´yv´am simulacemi vytvoˇren´ych sluˇzeb, proto nebudu podrobnˇe popisovat tento n´astroj. Uk´azka n´astroje se simulac´ı sluˇzby s robotem NXT, viz Obr´azek 29 na stranˇe i v pˇr´ıloze.
5 Jednoduch´e ´ulohy ve VPL 22
5
Jednoduch´
e ´
ulohy ve VPL
Souˇc´ast´ı t´eto pr´ace jsou uk´azky vytv´aˇren´ı jednoduch´ych program˚u ve VPL. Jako vzor byly vybr´any nˇekter´e uk´azkov´e programy napsan´e v jazyce RoborC, popsan´em v kapitole 3. M˚uˇzeme tak porovnat rozd´ıl sloˇzitosti mezi grafick´ym a strukturovan´ym programovac´ım jazykem. Obecnˇe lze povaˇzovat grafick´e programov´an´ı pro zaˇc´ateˇcn´ıky za snadnˇejˇs´ı. Nˇekdy ale sloˇzitˇejˇs´ı vˇeci se snadnˇeji ˇreˇs´ı pomoc´ı strukturovan´eho programov´an´ı. Je nutn´e ovˇsem strukturovan´y jazyk dobˇre zn´at. Aˇckoliv RoborC dod´av´a spoustu vzorov´ych ´uloh, nˇekter´e byly pˇr´ıliˇs komplikovan´e na to, aby ˇsly vytvoˇrit ve VPL.
5.1 Ulohy s vyuˇ´ zit´ım motor˚u
Tyto ´ulohy sice popisuj´ı uk´azku vyuˇzit´ı motor˚u, prim´arnˇe ale slouˇz´ı jako uk´azka pouˇzit´ı cykl˚u a z´akladn´ıch konstrukc´ı programu.
5.1.1 Program
”nxt moving forward“
Asi nejjednoduˇsˇs´ı program, kter´y jen spust´ı oba motory maxim´aln´ı rychlost´ı vpˇred a po 8s se zastav´ı. Zdrojov´y k´od programu viz V´ypis 3.
task main(){ motor[motorA] = 100; motor[motorB] = 100; wait1Msec(8000); } V´ypis 3: Program
”nxt moving forward“ v RobotC
Pomoc´ı VPL vytvoˇr´ıme podobn´y program konaj´ıc´ı stejnou ˇcinnost. Po pˇripojen´ı k NXT nastav´ıme rychlost motor˚u na maximum a nastav´ıme ˇcasovaˇc Timer na 8s. Po tuto dobu pojede robot rovnˇe, pot´e se zastav´ı a program se ukonˇc´ı odpojen´ım od NXT, viz Obr´ a-zek 13. Nastaven´ı rychlost´ı nen´ı na obr´azku vidˇet, jde vidˇet aˇz pˇri kliknut´ı na spojovac´ı linii mezi bloky. Rychlost ve VPL je nutno dˇelit 100.
Obr´azek 13: Program
5.1 Ulohy s vyuˇ´ zit´ım motor˚u 23
5.1.2 Program
”nxt modifiers“
Program ukazuje, jak nastavit motory na r˚uzn´e hodnoty s r˚uzn´ymi intervaly ˇcek´an´ı mezi pˇrenastaven´ım rychlosti. Nejprve nastav´ı motory na maxim´aln´ı rychlost vpˇred a prov´ad´ı tento ´ukon 2s, pot´e oba motory jedou rychlost´ı 65 ze 100 vzad po dobu 4s. Nakonec se provede rotace pomoc´ı nastaven´ı jednoho motoru vpˇred a druh´eho vzad po dobu 2,5s. Program napsan´y v RoborC, viz V´ypis 4.
task main(){ motor[motorA] = 100; motor[motorB] = 100; wait1Msec(2000); motor[motorA] = −65; motor[motorB] = −65; wait1Msec(4000); motor[motorA] = 75; motor[motorB] = −75; wait1Msec(2500); } V´ypis 4: Program ”nxt modifiers“ v RobotC
Ve VPL je potˇreba pouˇz´ıt tˇri ˇcasovaˇce. Program je celkem jednoduch´y, viz Obr´azek 14, po pˇripojen´ı robota dojde k nastaven´ı maxim´aln´ı rychlosti vpˇred a nastaven´ı ˇcasovaˇce Ti-mer na 2s. Po uplynut´ı doby se spust´ı rutina prov´adˇen´a ˇcasovaˇcem, kter´a nastav´ı rychlost motor˚u na zpˇetn´y chod a nastav´ı ˇcasovaˇc Timer0 na 4s. Pak se obdobnˇe nastav´ı rychlost a tˇret´ı ˇcasovaˇc, po kter´em dojde k ukonˇcen´ı programu.
Obr´azek 14: Program
5.2 Ulohy se svˇ´ eteln´ym senzorem 24
5.1.3 Program
”nxt loop 1 while“
Tento program je jednoduchou uk´azkou pouˇz´ıv´an´ı cyklu while. Ve VPL ovˇsem cykly ne-m´ame, proto je tˇreba nahradit je jinou konstrukc´ı. Program napsan´y v RoborC viz V´ypis 5. Program v cyklu 5kr´at spust´ı oba motory vpˇred po dobu 2 sekund, n´aslednˇe spust´ı jeden motor vpˇred a druh´y vzad a vykon´av´a rotaci 750ms.
task main(){ int count = 0; while(count < 5){ motor[motorA] = 75; motor[motorB] = 75; wait1Msec(2000); motor[motorA] = 75; motor[motorB] = −75; wait1Msec(750); count++; } } V´ypis 5: Program
”nxt loop 1 while“ v RobotC
Ve VPL je situace o nˇeco komplikovanˇejˇs´ı, cyklus while mus´ıme nahradit blokem Merge a promˇenn´e inicializovat pomoc´ı bloku Variable. Z´aroveˇn nelze ˇcek´an´ı jednoduˇse realizovat pomoc´ı wait, ale je nutno pˇridat blok Timer. Cel´y program pˇrepsan´y do VPL viz Obr´ a-zek 30 na stranˇe ii v pˇr´ıloze.
Na zaˇc´atku dojde k pˇripojen´ı zaˇr´ızen´ı a nastaven´ı rychlost´ı obou motor˚u vpˇred. Mezi tuto akci je nutno pˇridat blok Merge jako n´ahradu cyklu while. Promˇennou count pro cyklus je potˇreba inicializovat jako samostatn´y blok. Po nastaven´ı rychlosti se nastav´ı prvn´ı ˇcasovaˇc Timer na 2s. Aˇz tato doba uplyne, nastav´ı se rychlost jednoho motoru vpˇred a druh´eho motoru vzad. Dojde k nastaven´ı druh´eho ˇcasovaˇce Timer0 na 750ms. Po uplynut´ı t´eto doby dojde k nav´yˇsen´ı hodnoty count o jedna. N´aslednˇe se testuje hodnota count, n´ahrada za testov´an´ı v cyklu while. Pokud je hodnota menˇs´ı neˇz pˇet, ˇr´ızen´ı se pˇred´av´a do bloku Merge, jinak dojde k ukonˇcen´ı programu. Vˇsimnˇete si, jak se program zkomplikoval. Napˇr. jednoˇr´adkov´e pˇriˇcten´ı hodnoty count++ je zde nahrazeno tˇremi bloky.
5.2 Ulohy se svˇ´ eteln´ym senzorem
Zde uvedeme uk´azky nˇekolika aplikac´ı pouˇzit´ı svˇeteln´eho senzoru. 5.2.1 Program
”nxt line track“
Jedn´a se o jednoduch´y program pro sledov´an´ı ˇcern´e ˇc´ary pomoc´ı svˇeteln´eho senzoru po-psan´eho v kapitole 2.2.2. Pokud robot sn´ım´a svˇeteln´ym senzorem ˇcernou barvu, spust´ı jeden motor a druh´y ponech´a vypnut´y. V opaˇcn´em pˇr´ıpadˇe se prohod´ı nastaven´ı motor˚u
5.2 Ulohy se svˇ´ eteln´ym senzorem 25
a t´ım robot tzv. pohybem
”ZIG – ZAG“ sleduje ˇc´aru. Program je v nekoneˇcn´e smyˇcce while, t´ım je zaruˇceno neust´al´e sledovan´ı ˇc´ary. Program napsan´y v RoborC viz V´ypis 6.
task main(){ while(true){ if (SensorValue( lightSensor ) < 45){ motor[motorA] = 75; motor[motorB] = 0; } else{ motor[motorA] = 0; motor[motorB] = 75; } } } V´ypis 6: Program
”nxt line track“ v RobotC
Ve VPL nemus´ıme cyklus while nahrazovat blokem Merge, protoˇze svˇeteln´y senzor m´a nastavenu pooling frekvenci, kter´a urˇcuje interval nov´eho sn´ım´an´ı hodnoty. Blok If – Else se nahrad´ı blokem If. Je nutn´e tak´e zapnout senzor do aktivn´ıho reˇzimu nastaven´ım hodnoty Spotlight na true. Bohuˇzel ve VPL nedos´ahneme stejn´e rychlosti jako u programu v RoborC. D´ıky zahlcen´ı fronty zpr´av NXT pˇres bluetooth n´am robot pˇri stejn´e rychlosti vyjede mimo, tento probl´em je vysvˇetlen v kapitole 6.1. Nezbude nic jin´eho, neˇz nastavit rychlost niˇzˇs´ı, viz Obr´azek 15.
Obr´azek 15: Program
”nxt line track“ ve VPL
5.2.2 Program
”nxt wait for dark“
Dalˇs´ı jednoduch´y program s vyuˇzit´ım svˇeteln´eho senzoru: zde robot jede neust´ale rovnˇe, dokud nezaznamen´a senzorem ˇcernou barvu. Program napsan´y v RoborC viz V´ypis 7. Oproti pˇredeˇsl´emu programu je if nahrazen cyklem while.
5.2 Ulohy se svˇ´ eteln´ym senzorem 26 task main(){ while((SensorValue( lightSensor ) < 45){ motor[motorA] = 100; motor[motorB] = 100; } motor[motorA] = 0; motor[motorB] = 0; } V´ypis 7: Program
”nxt wait for dark“ v RobotC
Zde, aˇckoliv program v RoborC dˇelal nˇeco naprosto odliˇsn´eho, jde ve VPL o prakticky stejnou vˇec. Dokud zaznamen´a b´ılou jede vpˇred, pokud zaznamen´a ˇcernou zastav´ı a ukonˇc´ı program, viz Obr´azek 16. Rychlosti bohuˇzel nejsou vidˇet, proto vypad´a obr´azek dosti podobnˇe jako pˇredeˇsl´y.
Obr´azek 16: Program
”nxt wait for dark“ ve VPL 5.2.3 Program
”nxt line track timer“
Obdobn´y program na sledov´an´ı ˇc´ary, ale s ˇcasov´ym omezen´ım: v RoborC je pouˇzita di-rektiva time1(T1), coˇz je pˇr´ım´y pˇr´ıstup k prvn´ımu ˇcasovaˇci mikroprocesoru. Po dokonˇcen´ı urˇcit´e doby je vyvol´ano hardwarov´e pˇreruˇsen´ı. Program napsan´y v RoborC viz V´ypis 8.
task main(){ time1(T1) = 0; while(time1(T1) < 20000){ if (SensorValue( lightSensor ) < 45){ motor[motorA] = 75; motor[motorB] = 0; }else{ motor[motorA] = 0; motor[motorB] = 75; } } } V´ypis 8: Program
5.3 Ulohy s ultrazvukov´´ ym senzorem 27
Ve VPL nahrad´ıme ˇcasovaˇc blokem ˇcasovaˇce. Jinak je program podobn´y obyˇcejn´emu programu na sledov´an´ı ˇc´ary, viz Obr´azek 17.
Obr´azek 17: Program
”nxt line track timer“ ve VPL
5.3 Ulohy s ultrazvukov´´ ym senzorem
Zde si uk´aˇzeme pouˇzit´ı ultrazvukov´eho senzoru popsan´eho v kapitole 2.2.5. 5.3.1 Program
”nxt obstacle detect“
Detekce pˇrek´aˇzky je v podstatˇe obdobn´a, jako detekce ˇcern´e ˇc´ary. M´ısto cyklu while je pouˇzit cyklus do – while. Program napsan´y v RoborC viz V´ypis 9.
task main(){ do{ motor[motorA] = 75; motor[motorB] = 75; }while(SensorValue(sonarSensor) > 30); } V´ypis 9: Program
”nxt obstacle detect“ v RobotC
Ve VPL je opˇet detekce pˇrek´aˇzky podobn´a jako detekce ˇc´ary. M´ısto vyuˇzit´ı druh´e vˇetve bloku If je pouˇzit blok LegoNXTBrickV2 pro spuˇstˇen´ı obou motor˚u vpˇred. Program ve VPL viz Obr´azek 18 na n´asleduj´ıc´ı stranˇe.
5.3 Ulohy s ultrazvukov´´ ym senzorem 28
Obr´azek 18: Program
”nxt obstacle detect“ ve VPL 5.3.2 Program
”nxt sonar display“
Toto je jednoduch´y program pro zobrazen´ı vzd´alenosti objektu od ultrazvukov´eho senzoru. V nekoneˇcn´em cyklu se naˇc´ıt´a hodnota ze senzoru, zapisuje se na diplej NXT. Po 1s se displej smaˇze a akce se opakuje. Program napsan´y v RoborC viz V´ypis 10.
task main(){ int x=0; while(true){
x = SensorValue(sonarSensor);
nxtDisplayTextLine (1, ”Sonar Reading:%d”,x); wait1Msec(1000);
eraseDisplay () ; }
}
V´ypis 10: Program
”nxt sonar display“ v RobotC
RoborC umoˇzˇnuje pˇr´ım´y z´apis na displej. Ve VPL bohuˇzel pro z´apis textu na displej NXT neexistuje ˇz´adn´a sluˇzba. M˚uˇzeme vyuˇz´ıt zobrazen´ı hodnoty pˇr´ımo na monitor po-moc´ı bloku SimpleDialog. Existuje sice moˇznost spuˇstˇen´ı programu NXT–G, kter´y pˇrijme bluetooth zpr´avu a zap´ıˇse jej´ı obsah na displej. To ale nen´ı ˇcist´e ˇreˇsen´ı pomoc´ı VPL. Program ve VPL viz Obr´azek 19.
Obr´azek 19: Program
5.4 Ulohy s rotacemi´ 29
5.4 Ulohy s rotacemi´
Nyn´ı si uk´aˇzeme aplikace, kter´e pro urˇcen´ı ´uhlu otoˇcen´ı vyuˇz´ıvaj´ı senzor˚u rotace motor˚u. Kaˇzd´y motor m´a sv˚uj senzor rotace, zaznamen´av´a rotaci s pˇresnost´ı na 1◦.
5.4.1 Program
”nxt point turns enc“
V RoborC pomoc´ı direktivy nMotorEncoder pˇristupujeme k hodnot´am ˇc´ıtaˇce ot´aˇcek mo-toru. Nejprve je ale nutno ˇc´ıtaˇc vynulovat. V jednoduch´em programu vynulujeme ˇc´ıtaˇce obou motor˚u a nech´ame robota toˇcit se kolem sv´e osy, dokud jeden z motor˚u nedos´ahne ot´aˇcen´ım 1800◦. Program napsan´y v RoborC viz V´ypis 11.
task main(){ nMotorEncoder[motorA] = 0; nMotorEncoder[motorB] = 0; while(nMotorEncoder[motorA] < 1800 || nMotorEncoder[motorB] > −1800){ motor[motorA] = 100; motor[motorB] = −100; } } V´ypis 11: Program
”nxt point turns enc“ v RobotC
Ve VPL mus´ıme tak´e vynulovat hodnotu ˇc´ıtaˇc˚u, to provedeme pomoc´ı metody Dri-veEncodersUpdate bloku LegoNXTDriveV2. Pot´e m˚uˇzeme v bloku If pˇristupovat pˇr´ımo k hodnot´am ˇc´ıtaˇc˚u pomoc´ı promˇenn´ych RightEncoderCurrent a LeftEncoderCurrent. Pro-gram ve VPL viz Obr´azek 20.
Obr´azek 20: Program
”nxt point turns enc“ ve VPL
5.4.2 Program
”nxt line track rotations“
Tento program ukazuje, jak pˇri sledov´an´ı ˇc´ary omezit dr´ahu sledov´an´ı poˇctem rotac´ı mo-toru. Sledov´an´ı ˇc´ary prob´ıh´a dokud se motor A neotoˇc´ı o 1800◦. Program napsan´y v Ro-borC viz V´ypis 12.
5.4 Ulohy s rotacemi´ 30 task main(){ nMotorEncoder[motorA] = 0; while(nMotorEncoder[motorA] < 1800){ if (SensorValue( lightSensor ) < 45){ motor[motorA] = 75; motor[motorB] = 0; }else{ motor[motorA] = 0; motor[motorB] = 75; } } } V´ypis 12: Program
”nxt line track rotations“ v RobotC
Zde je podobn´a kombinace pˇr´ıkladu sledov´an´ı ˇc´ary a pˇredchoz´ıho pˇr´ıkladu omezen´ı rotac´ı. Mus´ı se vynulovat ˇc´ıtaˇc ot´aˇcek jako v pˇredch´azej´ıc´ım pˇr´ıpadˇe. Program ve VPL viz Obr´azek 21.
Obr´azek 21: Program
6 NXT Labyrinth Solver 31
6
Aplikace NXT Labyrinth Solver
ˇCastou aplikac´ı v robotick´em svˇetˇe je implementace ˇreˇsen´ı bludiˇstˇe. Typick´ym bludiˇstˇem b´yv´a bludiˇstˇe tvoˇren´e stˇenami nebo bludiˇstˇe sloˇzen´e z kˇriˇzovatek. Robot se pomoc´ı sv´ych senzor˚u mus´ı orientovat v bludiˇsti a naj´ıt s´am bez z´asahu ˇclovˇeka cestu k v´ychodu. My jsme se rozhodli implementovat bludiˇstˇe tvoˇren´e kˇriˇzovatkami s robotem LEGO NXT. Implementace bludiˇstˇe je ˇreˇsena vyuˇzit´ım dvou prostˇred´ı MRDS a NXT–G.
6.1 N´avrh ˇreˇsen´ı bludiˇstˇe
Bylo potˇreba navrhnout konstrukci robota a n´avrh implementace pro ˇreˇsen´ı takov´ehoto bludiˇstˇe. K dispozici jsme mˇeli 2 svˇeteln´e senzory a samozˇrejmˇe robota LEGO NXT. Pro implementaci jsme zvolili n´astroj MRDS VPL popsan´y v kapitole 4.3. Nejprve bylo potˇreba implementovat sledov´an´ı ˇc´ary. Pro sledov´an´ı ˇc´ary sice staˇc´ı jen jeden senzor, ale robot pak dˇel´a tzv.
”ZIG – ZAG“ pohyb. Pokud senzor sn´ım´a ˇcernou zat´aˇc´ı doprava, pokud sn´ım´a b´ılou zat´aˇc´ı doleva. Tak vykon´av´a kyvadlov´y pohyb, kter´ym se posouv´a vpˇred. Toto se d´a ˇreˇsit r˚uzn´ymi algoritmy, kter´e omezuj´ı tento jev. Elegantn´ı je ale vyuˇz´ıt dva svˇeteln´e senzory, jak je pops´ano v [6]. Tam popisuj´ı ˇreˇsen´ı pomoc´ı n´asleduj´ıc´ıch pˇeti podm´ınek:
1. Pokud oba senzory sn´ımaj´ı b´ılou (napˇr. > 75%), jed’ rovnˇe.
2. Pokud lev´y senzor sn´ım´a ˇc´asteˇcnˇe ˇcernou (napˇr. 25-75%), jed’ m´ırnˇe doleva. 3. Pokud lev´y senzor sn´ım´a ´uplnˇe ˇcernou (napˇr. < 25%), jed’ prudce doleva. 4. Pokud prav´y senzor sn´ım´a ˇc´asteˇcnˇe ˇcernou, jed’ m´ırnˇe doprava.
5. Pokud prav´y senzor sn´ım´a ´uplnˇe ˇcernou, jed’ prudce doprava.
Po pˇrepsan´ı algoritmu do VPL vypadal diagram zhruba n´asledovnˇe, viz Obr´azek 22.
6.1 N´avrh ˇreˇsen´ı bludiˇstˇe 32
Bohuˇzel pˇri spuˇstˇen´ı programu vypadala j´ızda robota dost trhanˇe, nav´ıc ˇcastokr´at robot pˇrejel ˇc´aru a jel mimo dr´ahu. Zkouˇseli jsme zvyˇsovat pooling frekvenci (rychlost sn´ım´an´ı) sn´ımaˇce a sniˇzovat rychlosti motor˚u, ale nebylo to dokonal´e ˇreˇsen´ı. Robot jel pak pˇr´ıliˇs pomalu a nˇekdy stejnˇe nezaregistroval ˇc´aru, a proto vyjel mimo. Zkouˇseli jsme obdobn´y program napsat v NXT–G a v RobotC, tam byla rychlost o mnoho vyˇsˇs´ı a bez chyb. Robot nikdy nevyjel z dr´ahy. Po dlouh´em hled´an´ı chyby jsme narazili na ˇcl´anek s anal´yzou bluetooth komunikaˇcn´ıho protokolu LEGO NXT [12], kter´y napsal Sivan Toledo. V nˇem se p´ıˇse o tom, ˇze NXT m´a frontu jen pro pˇet zpr´av a pokud se zahlt´ı, dojde k zahazov´an´ı nejstarˇs´ıch zpr´av. Z toho jsme usoudili, ˇze pr´avˇe toto je pˇr´ıˇcinou cel´eho probl´emu. Moˇzn´a ˇ
ze u robot˚u jin´ych platforem k tomuto probl´emu nedoch´az´ı.
Cel´e to vzniklo t´ım, ˇze robot musel neust´ale ˇc´ıst data ze svˇeteln´eho senzoru a pos´ılat je pˇres bluetooth do poˇc´ıtaˇce. Z´aroveˇn musel neust´ale pˇrij´ımat zpr´avy z poˇc´ıtaˇce s korekcemi rychlost´ı motor˚u. T´ım se stane aplikace t´emˇeˇr neprovediteln´a v re´aln´em ˇcase. Uvaˇzovali jsme nad t´ım, jak´ym zp˚usobem sn´ıˇzit ˇcetnost zas´ıl´an´ı zpr´av mezi poˇc´ıtaˇcem a robotem. Napadlo n´as, ˇze by moˇzn´a staˇcilo, pokud by informace ze sn´ımaˇc˚u nemusel odes´ılat. Jen by zas´ılal informace o stavu, ve kter´em se nach´az´ı. T´ım by byl probl´em vyˇreˇsen, ale poˇr´ad jsme nepˇrich´azeli na zp˚usob, jak to za pomoc´ı VPL vyˇreˇsit.
Posl´eze jsme naˇsli mezi VPL tutori´aly ve sloˇzce MRDS\samples\VplExamples\LEGO\ MsgReadWrite pˇr´ıklad, kter´y ve VPL text vyplnˇen´y v textov´em poli na poˇc´ıtaˇci zapisuje na displej robota. Po podrobn´em prozkoum´an´ı pˇr´ıkladu jsme zjistili, jak´ym zp˚usobem funguje. Byl rozdˇelen na dvˇe ˇc´asti. Jedna byla nahr´ana v poˇc´ıtaˇci, druh´a pomoc´ı NXT–G v pamˇeti kostky. Program fungoval n´asledovnˇe. Na zaˇc´atku byl odesl´an pˇres bluetooth pˇr´ıkaz na spuˇstˇen´ı programu v kostce. Program v kostce obsahoval smyˇcku, kde ˇcekal na pˇr´ıchoz´ı zpr´avu z bluetooth, tu zobrazil na displej. N´asledovalo ve VPL zobrazen´ı dialogu s textov´ym polem na poˇc´ıtaˇci, tam uˇzivatel zadal text a stiskl tlaˇc´ıtko OK. Poˇc´ıtaˇc odeslal zpr´avu pˇres bluetooth. Cel´y cyklus se pak opakoval. Napadlo n´as podobn´y princip vyuˇz´ıt pro omezen´ı zas´ıl´an´ı zpr´av mezi poˇc´ıtaˇcem a robotem.
6.1.1 N´avrh konstrukce robota
Mˇeli jsme robota v konstrukci TriBot, viz Obr´azek 23 na n´asleduj´ıc´ı stranˇe. Ten mˇel pouze jen jeden svˇeteln´y senzor, nav´ıc mˇel chapadla na uchopen´ı m´ıˇcku, tlaˇc´ıtkov´y senzor pro zjiˇstˇen´ı, ˇze doˇslo k uchopen´ı m´ıˇcku, mikrofon a ultrazvukov´y senzor pro mˇeˇren´ı vzd´alenosti. Jeden svˇeteln´y senzor byl uprostˇred, my jsme se ale rozhodli pouˇz´ıt senzory dva.
Bohuˇzel do konstrukce TriBota se nedal nijak pˇripevnit druh´y svˇeteln´y senzor. Od-stranili jsme proto celou pˇredn´ı ˇc´ast konstrukce TriBota – chapadlo, ultrazvukov´y senzor, tlaˇc´ıtkov´y senzor a svˇeteln´y senzor. Nav´ıc jsme nepotˇrebovali mikrofon, tak jsme jej taky odstranili. Bylo potˇreba navrhnout vhodn´e uchycen´ı pro dva svˇeteln´e senzory. Prvn´ı po-kus byl sice ´uspˇeˇsn´y, ale v´ysledn´a konstrukce nedovolovala zmˇenu v´yˇsky a rozteˇce mezi senzory. Kv˚uli moˇznosti testov´an´ı r˚uzn´ych sestav pro r˚uzn´e ˇs´ıˇrky p´asek a druhy p´asek pouˇzit´ych na cestu pro bludiˇstˇe, bylo potˇreba vytvoˇrit ˇsk´alovatelnou konstrukci uchopen´ı senzor˚u.
Nov´a konstrukce si vyˇz´adala nˇekolik hodin zkoum´an´ı pouˇziteln´ych LEGO souˇc´astek. Mˇeli jsme k dispozici souˇc´astky z kompletn´ıho LEGO NXT 1.0 kitu. V´ysledn´a konstrukce
6.1 N´avrh ˇreˇsen´ı bludiˇstˇe 33
Obr´azek 23: LEGO NXT – konstrukce TriBot [1]
se dala jednoduˇse posouvat a po dlouh´em testov´an´ı jsme nechali svˇeteln´e senzory ve v´yˇsce cca 4mm nad zem´ı a rozteˇc mezi svˇeteln´ymi senzory pro p´asku ˇs´ıˇre 15mm byla ide´aln´ı pˇribliˇznˇe 350 – 400mm (br´ano stˇred lev´eho senzoru ⇔ stˇred prav´eho senzoru). Existuje mnoho faktor˚u a nespoˇcet moˇznost´ı nastaven´ı rychlost´ı motor˚u pˇri urˇcit´e intenzitˇe sn´ıman´e hodnoty svˇeteln´eho senzoru a rozteˇce mezi senzory. Tato ˇc´ast testov´an´ı zabrala spoustu ˇ
casu a nedok´aˇzeme ˇr´ıct, zda je tou nejlepˇs´ı variantou.
Katedra z´ıskala nov´y HiTechnic kompas senzor popsan´y v 2.2.8 a rozhodli jsme se ho takto uplatnit v ˇreˇsen´ı bludiˇstˇe, byt’ to nebylo nezbytnˇe nutn´e. Bylo nutn´e ho um´ıstit 15cm od motor˚u a 10cm od kostky. Pomoc´ı dlouh´eho b´ıl´eho d´ılu LEGA jsme ho um´ıstili pˇr´ımo nad svˇeteln´e senzory. Obr´azek 24 zn´azorˇnuje celou konstrukci robota.
