NAVIGAREA ROBOILOR O comparaie practic a cilor de planificare algoritmice date de informaii locale.

Instituii implicate
Centrul pentru procesarea sistemelor informatice inteligente. coala de inginerie electric si electronic. Universitatea din vestul Australiei.

Rezumat
Lucrarea compar si analizeaz aspectele practice ale cilor de planificare si navigare algoritmice pentru roboii autonomi.Algoritmii bug1, bug2, alg1, alg2, distbug, tangentbug i D* au fost implementai i testai pe simulatorul EyeSim. Pentru fiecare algoritm au fost adunate date referitoare la complexitatea relativ, cerinele de memorie, lungimea cii, rotaia, timpul de calcul i robusteea mpotriva erorilor. O analiz ulterioar a artat c tangentbug i D* produc cea mai scurt lungime de cale si cea mai mic rotaie.n mod surprinztor, tangentbug i D* de asemenea aveau in medie timpi de calcul foarte sczui, iar D* avea cel mai puin scump algoritm pe harti deschise si nchise.D* de asemenea avea cel mai robust algoritm datorit segmentrii lui.n schimb, bug1 i bug2 au fost cele mai simple, au necesitat cerina cea mai sczut de memorie i au fost competitive din punct de vedere al timpului de calcul. Per total, dac este necesar o soluie simpl, ieftin, cu memorie puin, atunci recomand bug1 pentru hri inchise, altminteri, trebuie ales bug2.Dac atribuiile dorite sunt robusteea, timpul sczut de calcul si convergena, atunci se folosete D* dect dac harta implic un minim local.n acest caz, tangentbug trebuie ales.Dac este solicitat un compromis,alg2 ar trebui ales pentru hri inchise altminteri, alegei distbug.

Cuprins
1.Introducere 2.Obiective 3.Algoritmi de convergen 3.1.Algoritmul bug1 3.2.Algoritmul bug2

3.3.Algoritmul alg1 3.4.Algoritmul alg2 3.5.Algoritmul distbug 3.6.Algoritmul tangentbug 3.7.Algoritmul D* 4.Implementarea de algoritmi 4.1.Module comune 4.2.Implementare bug1 4.3.Implementare bug2 4.4.Implementare alg1 4.5.Implementare alg2 4.6.Implementare distbug 4.7.Implementare tangentbug 4.8.Implementare D* 4.9.Probleme ntlnite la implementare 5.Simulri 5.1.Msurare de atribuii 5.2.Hri de simulare 5.3.Generator de teren 6.Rezultate i discuii 6.1.Verificarea convergenei 6.2.Lungimea cii 6.3.Rotaia 6.4.Timpul mediu de calcul 6.5.Robustee 6.6.Complexitate 6.7.Cerine de memorie

7.Concluzii 8.Viitoare mbunatairi 8.1.Segmentarea algoritmilor bug 8.2.Localizare 8.3.mbunatairi D* 8.4.nvare robot 8.5.Toleran la greeli 8.6.Imbuntiri tangentbug 8.7.Clasificare hri 9.Apendix 9.1.Rezultate bug1 9.2.Rezultate bug2 9.3.Rezultate alg1 9.4.Rezultate alg2 9.5.Rezultate distbug 9.6.Rezultate tangentbug 9.7.Rezultate D* 10.Referine

Introducere
Imaginai-v mergnd ntr-o diminea la lucru, mergnd la biroul unui coleg, sau pur i simplu plimbndu-v pe plaj.Toate acestea par simple datorit faptului c oamenii navigheaz subcontient, lund de-a gata aceste abiliti.ns, a scrie o procedur de navigare formal pentru a duplica aceasta abilitate este dificil. Trebuie avut in vedere c roboii ntr-o zi vor nlocui activitile oamenilor, cum ar fi curenia sau ofatul.Cupa Robo a fost un obiectiv ambiios ca n 2050 o echipa de roboi s nving echipa campioan mondial FIFA la fotbal.Toate aceste cerine depind de navigarea in jur cu succes ntr-o lume real, de aceea navigarea cu succes este o cerin in cazul roboilor autonomi, independei. Aceast tez examineaz diferii algoritmi de navigare utiliznd simulatorul EyeSim.Admind teoria, accentul este pe partea practic.n particular, problemele de implementare vor fi discutate

i iar reyultatele importante vor fi folosite pentru a trage concluzii despre utilitatea practic a algoritmului. Prima dat, obiectivele sunt prezentate i algoritmul introdus.Apoi, implementarea fiecrui algoritm este discutat impreun cu problemele cauzate de implementare care au aprut.n final,rezultatele si analizele sunt prezentate.

Obiective
Un mediu 2D este pregtit cu un start i un obiectiv(final).Un numr finit de obiecte de form arbitrar, fiecare de arie finit,sunt plasate in cadrul mediului.Aceste obstacole nu pot interfera cu startul sau obiectivul. Robotul ncepe la start i obiectivul lui este de a gsi un drum continuu, fr obstacole de la start la finish.

Figura 2.1. Exemple de medii de navigare Iniial robotului i se ofer distana i direcia pana la atingerea scopului.Nu i se ofer nici un detaliu referitor la hart nainte de a ncepe.Robotul este echipat cu senzori de poziie care returneaz distana de la cel mai apropiat obstacol in poziia in care e indicat.Robotul este modelat ca fiind un punct care nu are mrime si poate s cltoreasc prin orificii de orice fel. Un algoritm de succes trebuie s fie convergent, adic trebuie s gseasc o cale la obiectiv, dac aceasta exist, iar dac nu, atunci s informeze utilizatorul c inta este inaccesibil i s se opreasc.Dac un algoritm este convergent, atunci trebuie s ndeplineasc urmtoarele atribuii: Lungimea cii. Distana cii de la start la finish.Aceasta trebuie s fie ct mai scurt posibil. Timpul de calcul. Timpul total de execuie a algoritmului exceptnd timpul dedicat mersului.Acesta ar trebui s fie ct mai scurt posibil i este condus de urmtoarele subatribute:

-Timpul de calcul pentru fiecare pas fcut.Algoritmii care au o lungime scurtp a cii prezint acest avantaj.Calculnd timpul pentru fiecare pas reduce acest avantaj. Rotaiile.Cantitatea de ntoarceri care au loc de la start la finish trebuie s fie ct mai puine posibil. Robustee.Abilitatea algoritmului de a suporta erorile cauzate de senzorii de poziie, cele cauzate de conducere i cele cauzate de rotaii. Aceasta trebuie s fie ct mai mare posibil. Cerinele de memorie.Cantitatea de memorie global rezervat de algoritm. Trebuie s fie ct mai sczut posibil. Simplitate.Aceasta este msurat de liniile de cod necesare pentru implementare.Trebuie s fie ct mai sczut.

Cu siguran, implementarea algoritmului va influena msurtorile, de aceea este imperativ ca, conceptul de implementare sa fie neles nainte ca, concluziile sa fie formulate.

Algoritmi convergeni
Aceast seciune introduce algoritmii care au fost implementai si simulai.n primul rnd este mai convenabil s introducem notaii comune pentru toi algoritmii: Hi al n-lea punct int.Este primul contact dupa ce robotul depete primul obstacol. S poziia de start T poziia obiectivului, de asemenea numit finish sau target. X actuala poziie a robotului. d(a,b) distana Euclidian ntre 2 puncte arbitrare a i b d.path(a,b) lungimea cii robotului ntre punctele arbitrare a i b r intervalul maxim de sesizare a senzorilor r(teta) spaiul liber ntr-o direcie dat teta. F spaiul liber in direcia intei.

Algoritmul bug1
Algoritmul bug1 a fost primul algoritm de tip bug creat de Lumelsky i Stepanov n 1986. n figura 3.1 este de reprezentat diagrama, care funcioneaz in felul urmtor: 0) Iniializeaz variabila 0 la i 1) Incrementeaz i i descrie o micare de naintare nspre int pn se ntmpl una din urmtoarele: - inta este atins . Stop - Este ntmpinat un obstacol. Eticheteaz acest punct Hi i procedeaz la pasul 2. 2) Menine obstacolul pe partea dreapt i urmeaz marginea obstacolului.n timpul acesta, nregistreaz punctul unde d(x,T) este minim. Eticheteaz acest punct Li. Procedeaz in continuare pn ce se ntmpl una din urmtoarele: - Este atins punctul Hi.Mergi la pasul 3.

- Dac inta este atins, Stop 3) Se testeaz dac inta poate fi atins. Pentru aceasta, Hi=Li. Dac inta nu poate fi atins, Stop. Altfel, se alege direcia de urmarire-perete care minimizeaz dpath(Hi, Li) i se manevreaz spre Li. La Li se trece la pasul 1.

Fig. 3.1. Diagrama de stare a algoritmului Bug1

Algoritmul bug2
Algoritmul bug2 de asemenea a fost creat de Stepanov i Lumelski n 1986.Este mai puin conservativ dect bug1 pentru c introduce un nou concept de linie M.Diagrama lui bug2 este depictat in figura 3.2 si funcioneaz in felul urmtor: 0) Iniial, se traseaz o linie imaginar M,de la start la int iniializnd irul de la 0 la i 1) Se incrementeaz i i se urmrete linia M nspre int pn cnd: - inta este atins, Stop - Este lovit un obstacol. Se eticheteaz acest punct Li, Se merge la pasul 2 2) Menine obstacolul pe partea dreapt i urmeaz marginea obstacolului. Se realizeaz aceasta pn cnd: - Un punct de-a lungul lui M ndeplinete condiia d(x,T)<d(Hi,T).Se etichetez Li, se parcurge pasul 1. - inta este atins, Stop - Robotul se-ntoarce la Hi. inta nu poate fi atins,Stop

Fig. 3.2. Diagrama de stare a algoritmului Bug2

Algoritmul alg1
Algoritmul alg1 este o extensie a algoritmului bug2 inventat de Sankaranarayanan i Vidyasagar n 1990. Vulnerabilitatea lui bug2 este aceea c poate s detecteze aceeai cale de 2 ori.Pentru a evita asta, alg1 memoreaz punctele precedente i le utilizeaz pentru a genera ci mai scurte.Diagrama alg1 este depictat in figura 3.3 i funcioneaz in felul urmtor: 0) Iniial, se traseaz o linie imaginar M,de la start la int iniializnd irul de la 0 la i 1) Se incrementeaz i i se urmrete linia M nspre int pn cnd: - inta este atins, Stop - Este lovit un obstacol. Se eticheteaz acest punct Hi. Se merge la pasul 2. 2) Menine obstacolul pe partea dreapt i urmeaz marginea obstacolului. Se realizeaz aceasta pn cnd: - inta este atins, Stop - Un punct y este gsit astfel nct: - sa fie pe M - d(y,T)<d(x,T) - robotul se poate mica nspre int cu y Se definete acest punct Li si se trece la pasul 2.

- Un punct predefinit nainte Lj sau Hj este ntlnit astfel nct j<i. Rotire si se ntoarce la Hi. Cnd punctul Hi este atins, se urmrete marginea obstacolului avnd zidul n partea stng. Aceast regul nu poate fi aplicat pn cnd Li nu este definit. - Robotul se ntoarce la Hi. inta nu poate fi atins, Stop.

Fig. 3.4. Diagrama de stare a algoritmului Alg1

3.5. Algoritmul Distbug Algoritmul distbug a fost inventat de Kamon i Rivlin n 1997 *6+. Acesta este foarte similar cu algoritmul de Alg2 deoarece are o condiie aproape identic de iesire, cu doar un mic, diferen subtil. A se vedea seciunea 7.2 pentru mai multe detalii. Singura diferen real este c distbug nu menine o list cu punctele precedente, n timp ce Alg2 da. Diagrama distbug este descris n Figura 3-5 i funcioneaz dup cum urmeaz: 0) Iniializeaza I = 0 i Pasul pentru grosimea peretelui. 1) Marete I i mica spre int, pn cnd una dintre urmtoarele are loc: inta este atins. Oprete. Un obstacol este atins. Indica acest punct Max. Du-te la pasul 2. 2) ntoarce spre stnga i urmai limitele obstacolului, n acelai timp, actualizeaza valoarea minim al lui d(x, T) si indica aceast valoare dmin(T). Continuai acelai lucru pn cnd una dintre urmtoarele are loc: inta este vizibil: d (x, T) - F 0. Indica acest punct Li. Du-te la pasul 1. Coniia de ieire din algoritm: d (x, T) - F d (T) - Pasul min. Indica acest

punct Li. Du-te la pasul 1. Robotul a completat o bucl i a ajuns la Max. inta este imposibil de gsit. Oprete.

Figura 3-5 Diagrama de stare Distbug 3.6 Algoritmul tangentbug Algoritmul tangentbug a fost inventat de Kamon, Rivlin i Rimon n 1995 *7+. De atunci, tangentbug a fost recunoscut ca un algoritm care produce ci foarte scurte, fiind furnizate informaii pur locale *8+.

3.6.1 Graful Tangentei Globale Pentru a nelege cum funcioneaz tangentbug, luai n considerare mediul descris n figura 3-6 (a). Apoi, luai n considerare vrfurile convexe ale tuturor obstacolelor care sunt ncercuite cu portocaliu n figura 36 (b). Apoi, unii fiecare pereche de noduri neobstrucionate incluznd i punctele de nceput i de int. Rezultatul este graficul tangentei globale i este descris n figura 3-6 (c). S-a artat faptul c, graful tangentei globale conine ntotdeauna calea optim de la nceput pn la sfrit *9+. Figura 3-6 (d) arat calea optim pentru aceast hart special. 3.6.2 Graful Tangentei Locale Cu toate c robotul nu are cunotine globale, dar tangentbug compenseaz prin generarea grafului tangentei locale (LTG). Un eantion al graficului LTG este prezentat n figura 3-7. TG este generat n prim faz, de colectare a datelor pentru funcia r() i F. r() returneaz distana pn la primul obstacol vizibil ntr-o direcie dat de . Apoi, r () este procesat n conformitate cu urmtoarele reguli: n cazul n care d(x, T) - F 0, tinta este vizibil. Creai un nod, denumit nod-T, pe int. Dac F r, nu exist obstacole vizibile n direcia int. Creai un nod-T n direcia intei. Acest lucru este ilustrat de ctre nod-T n figura 3-7.

 Verificai funcia r() pentru discontinuiti. n cazul n care o discontinuitate este detectat, a creeza un nod in direcia lui . Acest lucru este ilustrat de ctre nodurile 1, 2, 3 i 4 n figura 3-7. Dac r() = R (raza maxim a PSD) i r() scade continuu, f un nod n direcia lui . Acest lucru este ilustrat de nodul 5 n figura 3-7. n mod similar, n cazul n care r() r, i r (), crete ulterior n aa natur nct r() = r, se face un nod n direcia .

Figura 3-6 (a) stnga sus. Mediul. (b) dreapta sus. Toate dreptele verticale convexe sun ncercuite. (c) stnga jos. Graficul de tangentei globale. (d) dreapta jos. Calea optim. Dup identificarea nodurilor, direcia i distana optim este determinat utiliznd urmtoarea procedur: Pentru fiecare nod, s evalueze distana d(Ni, T), unde Ni este nodul al i-lea. Nodul cu cel mai mic d(Ni, T) este etichetat ca fiind nodul optim, N *. Robotul se va duce la nodul N * n acelai timp, actualiznd n mod continuu graful tangentei locale i deplasndu-se la cel mai recent N *. n figura 3-7, N * este nodul T deoarece nodul T este cel mai apropiat de int.

Figura 3-7 Graful tangentei locale 3.6.3 Minime locale Figura 3-8 arat c, uneori, robotul trebuie s cltoreasc departe de int, pentru a ajunge la ea. Acest lucru este definit ca un minim local. Atunci cnd se ntmpl acest lucru, tangentbug merge n modul de urmarire a peretelui. Acest lucru implic alegerea unei directii ce urmarete peretele, i urmrire peretele folosind LTG. n timp ce se urmrete peretele, tangentbug actualizeaz continuu dou variabile: durmrit(T) - Aceast variabil nregistreaz distana minim pn la int de-a lungul minimei care cauzeaza obstacolul. dajuns (T) - Fiecare pas, tangentbug scaneaz mediul vizibil i pentru un punct P pt. care d(P, T) este minim. dajuns(T) i este apoi atribuit lui d(P, T). Modul urmritor de perete persist pn cnd una din urmtoarele are loc: dajuns(T) < durmrit (T). Robotul a ncercuit obstacolul cauzator de minim. inta este imposibil de ajuns. Oprete.

Figura 3-8 Robotul ntr-un minim local

Algoritmul tangentbug poate fi rezumat n figura 3-9.

Figura 3-9 Diagrama Tangentbug 3.7 Algoritmul D* Algoritmul D* a fost inventat de Stentz n 1994 *10+. De la invenia sa, a fost implementat cu succes pe proiecte din lumea reala, cu rezultate foarte satisfctoare *8+. mpreun cu tangentbug, D * este recunoscut ca fiind productoare de drumuri foarte scurte, avnd n vedere caracterul strict local al informaiei*8+. Algoritm D* este foarte diferit de algoritmi de gndac. Acesta este un algoritm Brute Force, care are unele proprieti unice i interesante. Acesta mparte harta n zonele discrete, numite celule. Fiecare celula are un backpointer, reprezentnd direcia optim care deplasare n yona celulei, precum i costuri pentru deplasarea ntre celulele nvecinate. Fostul algoritm low-level poate fi gsit n codul surs i aceste detalii pot fi gsite n scrierile lui Stentz *10+. Un exemplu mai abstract i de nivel nalt este prezentat n 3.7.1 i 3.7.2 3.7.1 Generarea unei ci optime D * este cel mai bine explicat prin exemplu. Fie obiectivul celula (5,3), iar poziia iniial a robotului la (1,3), cum e descris n figura 3-10 (a). Fie costul daplasrii o unitate(1) in direciile orizontal sau vertical; i 2 deplasarea n diagonal. Apoi, D * genereaz tabelul 3-1 pentru celulele din jurul G: Poziie(1) Ca mai apropiat celul cu Costul de la (1) Costul de la (2) la G Total backpointer sau int (2) la (2)

(5,4) (5,2) (4,3) (4,2) (4,4)

G G G G G

1 1 1 1.414 1.414

0 0 0 0 0

1 1 1 1.414 1.414

Tabelul 3-1. Primul tabel generat n algoritmul D*. Tabelul 3-1 arat c celulele (5,4), (5,2) i (4,3) au cel mai mic cost total. Aceste celule i seteaz backpointerele lor n vederea atingerii obiectivului ca descrise n figura 3-10 (b). Apoi, vecinii lui G, (5,4), (5,2) i (4,3) sunt luate n considerare pentru costul total minim dorit n tabelul 3-2:

Poziie(1)

Ca mai apropiat celul cu backpointer sau int (2)

Costul de la (1) la (2)

Costul de la (2) la G

Total

(4,4) (4,2) (3,3) (5,1) (5,5) (3,2) (4,5) (4,1) (3,4)

G G (4,3) (5,2) (5,4) (4,3) (5,4) (5,2) (4,3)

1.414 0 1.414 0 1 1 1 1 1 1 1.414 1 1.414 1 1.414 1 1.414 1 Tabelul 3-2. Al doilea tabel generat de D*

1.414 1.414 2 2 2 1.414 1.414 1.414 1.414

Tabelul 3-2 arat c celulele (4,4) i (4,2) au cel mai mic cost total. Aceste celule i seteaza backpointerele lor fa de poziia intei, iar grila este descris n figura 3-10 (c). Acest proces se repet pn cnd poziia robotului conine un backpointer sau ntreaga reea este umplut. n cazul n care o celul conine un backpointer, ea reprezint cel mai mic cost de deplasare spre obiectiv. Figura 3-10 (d) arat grila de 5x5 cu G i backpointerele care duc la G. Dup cum pot fi verificate, ca urmare a oricrei backpointer dat, va produce o cale cu cel mai redus cost. Acest proces este modul n care D* genereaz cile optime.

Figura 3-10. (a) stnga sus. Grila iniial. (b) n dreapta sus. Grila, dup ce datele de la Tabelul 3-1 sunt nscrise. (c) stnga jos. Grila, dup ce datele din tabelul 3-2 au fost nscrise. (d) dreapta jos. Grila final.

3.7.2 Contabilitatea Obstacolelor D* reprezint obstacole ca fiind costisitoare n deplasare spre ele, dar nu dinspre celulele cu obstacol. Asta n cazul n care exist un obstacol pe o celul O, costurile de cltorie de la celulele vecine lui O pn la O devine valoare predefinit mare. Figura 3-11 (a) arat c un obstacol n (3,3) a fost detectat. Arcurile artate duc spre celula obstacol i costurile asociate acestora devin foarte mari. Odat ce costurile cltoriei sunt modificate, D* recalculeaz backpointerele pentru a se asigura c ele sunt nc optime. D* face acest lucru prin lund n considerare n primul rnd de celulele care au un backpointer la celula (3,3). Aceasta genereaz tabelul 3-3: Poziie(1) Ca mai apropiat celul cu backpointer sau int (2) Costul de la (1) la (2) Costul de la (2) la G Total

(2,2) (2,4) (2,4)

(3,2) (3,4) (3,4)

1 1 1.414

2.414 2.414 2.414

3.414 3.414 3.828

Tabelul 3-3. Primul tabel ntocmit dup ce un obstacol a fost detectat la (3,3). Tabelul 3-3 arat c celulele (2,2) i (2,4), au un nou cost minim i i schimba backpointerele la celula specificat n coloana 2. Grila actualizat este prezentat n figura 3-11 (b). D* repet acest proces din nou, i genereaz tabelul de 3-4. Poziie(1) Ca mai apropiat celul cu backpointer sau int (2) Costul de la (1) la (2) Costul de la (2) la G Total

(2,3) (2,1) (2,5) (1,4) (1,2) (1,3) (S) (1,5) (1,1)

(3,4) (3,2) (3,4) (2,4) (2,2) (2,2) (2,4) (2,2)

1.414 1.414 1.414

1 1

2.414 2.414 2.414 3.414 3.414 3.414 3.414 3.414

3.828 3.828 3.828 4.414 4.414 4.828 4.828 4.828

1.414 1.414 1.414

Tabelul 3-4. Al doilea tabel ntocmit dup ce un obstacol a fost detectat la (3,3) Tabelul 3-4 arat c celulele (2,3), (2,1) i (2,5), schimb backpointerele lor, astfel nct costurile lor pn la a obiectiv sunt reduse la minimum. Prin urmare, grila actualizat este prezentat n figura 3-11 (c). D* repet acest proces pn cnd costul total minim n tabelul generat este mai mare sau egal cu costul robotului la int, urmrind urma backpointerului actual. Odat ce se ntmpl acest lucru, ea semnaleaza faptul c continuarea calculelor nu va rezulta n ci mai puin costisitoare dect calea curent. n urma exemplului, tabelul 3-5 se calculeaz:

Poziie(1)

Ca mai apropiat celul cu backpointer sau int (2)

Costul de la (1) la (2) 1 1 1

Costul de la (2) la G

Total

(1,2) (1,4) (1,3) (S) (1,5) (1,1)

(2,2) (2,4) (2,3) (2,4) (2,2)

3.414 3.414 3.828 3.414 3.414

4.414 4.414 4.828 4.828 4.828

1.414 1.414

Tabelul 3-5. Al treilea tabel ntocmit dup ce un obstacol a fost detectat la (3,3) Condiiile de ncheiere le deine tabelul de 3-6, iar figura 3-11 (d) arat grila final. Poziie(1) Ca mai apropiat celul cu backpointer sau int (2) Costul de la (1) la (2) Costul de la (2) la G Total

(1,3) (S) (1,5) (1,1)

(2,3) (2,4) (2,2)

1 1.414 1.414

3.828 3.414 3.414

4.828 4.828 4.828

Tabelul 3-6. Tabelul al patrulea ntocmit dup ce un obstacol a fost detectat la (3,3) Reinei c, celula (2,3) nu arata napoi spre punctul de la nceput, spre deosebire de tehnica euristic forteren! D* se mentine optimal i evit blocare n minime locale, care ar fi tulburat tehnici similare *9+. Cu toate acestea, dup cum va fi artat mai trziu, aceasta vine cu costul de timp de calcul. n D *, modificarea costurilor se poate face n orice moment. Acest lucru permite algoritmului de a se adapta dinamic la obstacole nevzute i generarea de noi ci optime. Mecanismul de calcul al costurilor al lui D*, permite terenurilor nedorite, dar nu neaprat obstacolelor. Acest lucru este mult mai bun dect algoritmi bug unde terenul este fie traversable fie un obstacol. 3.7.3 Determinarea accesibilitii Imposibilitatea de a ajunge ntr-un punct, este determinat prin compararea costurilor urmelor backpointerelor cu o valoarea mare a pragului de obstacole. n cazul n care costul traseuului backpointerului este mai mare dect pragul de valoare, ea implic faptul c calea optim traverseaz un obstacol i, prin urmare int este imposibil de gsit. Desigur, o valoare mare de prag ar trebui s fie ales astfel nct costul pe orice secven a backpointerelor care nu traverseaz un obstacol n calea sa, nu va depi o valoarea de prag ridicat.

Figura 3-11. (a) stnga sus: O celula obstacol este identificat n poziia (3,3). (b) dreapta sus: Grila, dup ce datele din tabelul 3-3 sunt nscrise. (c) stnga jos: Grila de date dup ce valorile din tabelul 3-4 au fost nscrise. (d) dreapta jos. Grila dup ce datele din tabelul 3-6 au fost nscrise. nc o dat, backpointerele prezint acum optime direcii de deplasare.

4.Implementarea algoritmilor
4.1 module comune De obicei, un algoritm este pus n aplicare n clasa de navigare i solicit module comune. Modulele comune sunt folosite pentru coerena ntre simulri i modularitate. De exemplu, toate algoritmii de navigare au nevoie de timpul finalizare s fie msurat i Modulul Timer ofer metode speciale n acest scop. Figura 4-1 prezint module comune i modul de navigaie, care pot fi modificate pentru punerea n aplicare a algoritmilor specifice.

Figura 4-1 Diagrama de clas a modulelor comune 4.1.1 Modulul timer Funcia acestui modul este de a msura performana algoritmului de temporizare. n special, de a msura timpul de calcul i timpul de conducere care red aceste valori la cerere. Dei timpul de conducere nu se msoar n acest studiu, ar putea fi necesare n viitor. Modulul timer ndeplineste rolul ei prin furnizarea de o interfa abstract la funcia din libajul C, clock(). clock() returneaz timpul (n milisecunde) petrecut n unitatea de prelucrare , de la nceperea procesulului de execuie. Reinei c clock() nu include timpul, n care sistemul stagneaz. 4.1.2 Modulul de help/ajutor Modulul de ajutor ofer sprijin sczut cu alte module. n special, robotul poate lua distanta int i direcia prin apel la metode ce pot fi gsite n modulul de ajutor. n prezent, modulul de ajutor se bazeaz pe logica oarba pentru a genera rspunsuri. ntr-o versiune viitorare, n cazul n care recunoaterea reperelor sau senzorul de reele sunt utilizate, aceste funcii pot fi schimbate, iar restul sistemului nu trebuie s tie de acest lucru. 4.1.3 Modulul de interfa cu utilizatorul Rolul modulul de interfa cu utilizatorul este de a interaciona ntre program i utilizator. Cnd programul pornete, acesta permite utilizatorului s editeze direcia dorit i distana de la obiectiv. Figura 4-2 (a) arat interfaa, care permite utilizatorului s editeze distanta spre obiectiv i Figura 4-2 (b) arat interfaa, care permite utilizatorului s editeze direcia spre obiectiv.

Figura 4-2 (a) stnga: Utilizatorul poate edita distana pn la obiectiv. (b) dreapta: Utilizatorul poate modifica direcia spre obiectiv. Modulul de interfa cu utilizatorul, de asemenea, afieaz rezultatele de navigare pentru utilizator. Figura 4-3 prezint ecranele care apar atunci cnd se realizeaz convergena. Figura 4-3 (a) arat timpul de calcul i timpul de conducere, n milisecunde. Figura 4-3 (b) arat distana de cltorit n metri i de rotaie n radiani. Figura 4-3 (c) arat numrul de apeluri la biblioteca de matematica sau processstate(), n cazul n care D* este rulat.

Figura 4-3 (a) stnga: Calculul i timpi de conducere. (b) centru: Distana total parcurs i rotaiile totale efectuate. (c) dreapta: Apelurile la biblioteca matematic sau process-state() n D*. 4.1.4 Modulul de conducere Scopul modulului de conducere este de a nregistra distana total parcurs i rotaiile totale efectuate. n esen, acesta ofer o interfa simpl la interfaa de conducere i VW extinde funcionalitatea prin urmrirea distanei i a rotaiei. Acesta permite apelantului s precizeze dac dorete s nregistreze o cerere de ntoarcere n total_turn. La fel precum se va vedea i mai tarziu, unele de ntoarceri nu sunt generate n mod inerent de algoritm. n schimb, este dependent de hardware, i poate prezinta interes eliminarea acestei componente din rezultatul de rotaie. Modulul de conducere solicit modulul timer, astfel nct timpul de conducere n mod corespunztor este separat de timpul de calcul. Figura 4-4 prezint funcia de conducere, n modulul de conducere. Acesta solicit end_think_start_drive() pentru a indica faptul c conducerea a nceput i apoi end_drive_start_think() pentru a arta c conducerea a luat sfrit. Reinei c, n timpul de conducere, VWDriveWait() nu este cerut iar o bucl complicat a nlocuit-o. Acest lucru se datoreaz faptului c VWDriveWait() pune Procesul de navigare pe sleep iar acest lucru distorsioneaz rezultatele timpilor de conducere.

void drive(float distance) { total_dist = total_dist + distance; end_think_start_drive(); VWDriveStraight(vw, distance, LINEAR_VELOCITY); while(VWDriveDone(vw) == 0) { KEYRead(); } end_drive_start_think(); VWGetPosition(vw, &pos); }

Figura 4-4 Metod de conducere 4.1.5 Modulul de conducere inteligent Rolul modulului inteligent de conducere este de a oferi funcii de conducere abstracte, n conformitate cu cerinele algoritmul principal de navigare. Cele mai multe dintre metodele sale publice sunt autoexplicative, dar cea mai complicat dintre metode(funcii), follow_the_wall(), este prezentat n Figura 4-5.
void follow_the_wall(bool is_on_right){ if(is_on_right){ if(has_wall_been_reached()){ turn_not_move(FALSE); } else if(PSDGet(psd_right) > WALL_DISTANCE+THRESHOLD){ turn_and_move(TRUE); } else{ follow_wall_straight(TRUE); } } else{ if(has_wall_been_reached()){ turn_not_move(TRUE); } else if(PSDGet(psd_left) > WALL_DISTANCE+THRESHOLD){ turn_and_move(FALSE); } else{ follow_wall_straight(FALSE); } } }

Figura 4-5. Metoda follow_the_wall/urmrete_peretele Iniial, metoda verific daca exist perete n faa robotului. Dac da, robotul execut: turn_not_move() iar robotul se ntoarce pe punctul attat in Figura 4-6(a). Altfel, robotul verific dac exista perete pe partea dreapt a robotului. Dac da, robotul executa funcia: follow_wall_straight() iar robotul urmrete peretele, artat i n figura 4-6(c).

Dac nu, robotul apeleaz turn_and_move, se ntoarce i se mic dup cum arat n figura4-6(b). Apoi, apelnd metodele de mai jos, robotul se aliniaz la zid apelnd metoda orientate_to_wall() , dup cum arat n figura 4-6(d). n prezent, aceasta utilizeaz un controler pentru a se asigura c peretele este urmat ndeaproape. Cu toate acestea, PID mai avansate sau controlerele de logic fuzzy pot fi uor actualizate prin actualizarea modulului de micare inteligent.

Figura 4-6. (a) Stnga sus. Turn_not_move(). (b) Dreapta sus. Turn_and_move() (c) Stnga jos. Follow_wall_straight() (d) Dreapta jos. Orientate_to_wall()

4.2 Implementarea Bug1 Algoritmul bug1 este implementat apelnd metoda din modulele comune dup cum arat n figura 4-7. Se pare c Bug1 implementeaz ipostazele drive to target i follow the wall prescrise n figura 3-1 folosind metodele drive_to_target() respectiv follow_wall_Bug1(). O alt metoda, Bug1(), este folosit pentru a coordona ipostazele de tranziie prescrise n figura 3-1.
/*funcia orienteaz eyebot-ul spre int i nainteaz pn cnd inta este atins sau zidul este lovit.*/ int drive_to_target(){ face_target(); while(TRUE){ if(has_goal_been_reached()){ face_original(); return TARGET_REACHED; } else if(has_wall_been_reached()){ return WALL_HIT; } drive(STEP); } } /*funcia urmeaz zidul n concordan cu algoritmul Bug1*/ int follow_wall_Bug1(){ PositionType leave; //closest position to the target PositionType hit; //the current hit point float min_dist; //the closest displacement to the target float dist_to_min=0; //the number of steps to leave float begin_dist = get_total_dist();

initialize_PD(); VWGetPosition(vw, &leave); min_dist = get_targ_dist(); VWGetPosition(vw, &hit); orientate_to_wall(FALSE); while(TRUE){ if(get_dist(&hit, &pos)<=TARG_ERROR && (get_total_dist()-begin_dist)>TARG_ERROR){ break; } follow_the_wall(TRUE); if(get_targ_dist()<min_dist){ min_dist = get_targ_dist(); VWGetPosition(vw, &leave); dist_to_min = get_total_dist()-begin_dist; } } /*Verific condiia de neatingere dac adevrat atunci termin*/ if(get_dist(&leave, &hit)<=TARG_ERROR){ face_original(); return TARGET_UNREACHABLE; } /*Determin ruta cea mai scurta la punctul min i se ntoarce la stnga sau Dreapta n concordan.Apoi urmeaz zidul pn n punctul minim*/ if(dist_to_min < (get_total_dist()-begin_dist)/2){ while(get_dist(&leave, &pos)>=TARG_ERROR){ follow_the_wall(TRUE); } else{ } turn(M_PI); while(get_dist(&leave, &pos)>=TARG_ERROR){ follow_the_wall(FALSE); } } return MIN_REACHED; } /*funcia merge spre int, folosind algoritmul Bug1*/ void Bug1(){ int state = STEP1; int response; initialize_driving(); initialize_timers(); init_helper(); while(TRUE){ if(state==STEP1){ response = drive_to_target(); if(response==TARGET_REACHED){ end_timers(); print_stats(TRUE, get_time_thinking(), get_time_driving(), get_total_dist(), get_total_turn(), num_sqrt, num_pow, num_geom); break; } else if(response==WALL_HIT){ LCDPrintf("Wall Hit\n"); state = STEP2; continue; } } else if(state==STEP2){ response = follow_wall_Bug1(); if(response==MIN_REACHED){ LCDPrintf("Minimum Point\n"); state=STEP1; continue;

} else if(response==TARGET_UNREACHABLE){ end_timers(); print_stats(FALSE, get_time_thinking(), get_time_driving(), get_total_dist(), get_total_turn(), num_sqrt, num_pow, num_geom); break; } } } }

Figura 4-7. Modulul de Navigare Bug1

4.3 Implementarea Bug2 Clasa de navigare bug2 solicit module comune ntr-un mod similar cu bug1 descris n seciunea 4.2.1Cu toate acestea, Bug2 necesit o extensie a modulului inteligent de micare pentru a include o metod care stabilete dac acesta este pe linia M. O nou metod a fost creat n modulul inteligent de micare numit is_on_M_. Diagrama de clas actualizat este afiat n figura 4-8.
Smart Moving
old_error : Double has_goal_been_reached() : Boolean has_wall_been_reached() : Boolean orientate_to_wall(bool isClock) turn_not_move(bool isClock) turn_and_move(bool isClock) face_target() face_original() initialize_PD() follow_wall_straight(bool isClock) follow_the_wall(bool isClock) is_on_M_line() : Boolean

Figura 4-8 Modulul Smart Moving extins pentru bug2

Pentru a implenta funcia is_on_M_line (), luai n considerare diagrama din figura 4-9. Fie T un vector la int, P, un vector la poziia curent a robotului i nite scalari astfel nct vectorii P-AT i T sunt perpendiculari.

Figura 4-9 Vectorii P-aT and T sunt perpendiculari

Rezult din produsul punct c:

(Tx )(Px  x ) (T y )(Py  y ) 0 aT aT

Rearanjnd pentru a rezult: T P T P a

x x y 2 x y 2

T y T

aT poate fi calculat i distana la P poate fi determinat. n cazul n care aceast distan este mai puin dect o valoare prag, robotul este pe linia M. Figura 4-10 arat implementarea a is_on_M_line ()

/* Funcia determin dac punctul dat este pe linia M * / bool is_on_M_line(){ PositionType closest; float t = (targ.y*pos.y + targ.x*pos.x)/(pow(targ.x,2.0)+pow(targ.y,2.0)); num_pow = num_pow+2; if(t<0 || t>1){ return false; } else{ closest.x = t*targ.x; closest.y = t*targ.y; closest.phi = 0; return (get_dist(&closest, &pos) <= TARG_ERROR); } }

Figura 4-10 Metoda is_on_M_line() 4.4 Implementarea Alg1 Alg1 necesit dou prelungiri la modulul inteligent de micare. Ea trebuie s tie dac robotul este pe linia M i freespace(), F. Metoda is_on_M_line (), descris la punctul 4.3, este refolosit. Cu toate acestea, o metod nou, freespace (), trebuie s fie creata pentru a determina F. Figura 4-11 arat actualizat modulul Smart Moving care include cele dou metode noi.
Smart Moving
old_error : Double has_goal_been_reached() : Boolean has_wall_been_reached() : Boolean orientate_to_wall(bool isClock) turn_not_move(bool isClock) turn_and_move(bool isClock) face_target() face_original() initialize_PD() follow_wall_straight(bool isClock) follow_the_wall(bool isClock) is_on_M_line() : Boolean freespace() : Integer

Figura 4-11 Algoritmul Smart Moving extins pentru Alg1 Metoda freespace returneaz F. n cazul n care metoda este invocat, directia tintei fa de robot este determinat n primul rnd.Apoi,robotul se invrte astfel inct PSD este cu faa la inta. Ulterior,

robotul se rotete astfel nct PSD este cu faa la inta i msoar F folosind acel PSD. Dup aceea, se ntoarce la orientarea sa iniial.Aceast metod este pus n aplicare n figura 4-12.
/* Funcia returneaz freespace n direcia intei funia presupune c PSD-urile sunt n mod egal spaiate*/ int freespace(){ float direction = get_rel_targ_dire(); int index=0; int answer; /* determin cel mai apropiat PSD spre direcia relativ */ while(direction < -M_PI/NUM_PSD){ direction = direction + 2*M_PI/NUM_PSD; index--; } while(direction > M_PI/NUM_PSD){ direction = direction - 2*M_PI/NUM_PSD; index++; } index = (index + NUM_PSD/2)%NUM_PSD; /* se intoarce spre inta i ia freespace */ turn(direction, FALSE); answer = PSDGet(psd[index]); turn(-direction, FALSE); return answer; }

Figura 4-12 Metoda freespace

n acest robot, exist 8 senzori PSD. Figura 4-13 arat c fiecare PSD se refer la un sector de 45 de grade. Prin urmare, suma maxim pe care robotul trebuie s se roteasc pentru a gsi F este 22.5 grade. Aa cum era de ateptat, creterea numrului de PSDs duce la scderea rotaiei maxime pentru a gsi F i acest lucru trebuie s fi inclus n costul mpotriva deciziilor de performan.

Figura 4-13 Fiecare PSD acoper un sector de 45 de grade. Rotatia maxim este 22.5 grade. Algoritmul alg1, de asemenea, trebuie s nregistreze toate loviturile i s lase puncte ntlnite. Se face acest lucru prin implementarea unui modul de structura de date, care este descris n figura 4-14.

Figura 4-14 Modulul Structur de date Structura de date este pus n aplicare ca un vector de PositionTypes. Numrul de elemente este prestabilit i un bloc fix de memorie este alocat n cazul n care programul este pornit.Figura 4-15 (a) arat structura de date imediat dup initialize_data () este apela. Cnd list_enqueue () este apelat, un PositionType este stocat n elementul aratat de poziie.Figura 4-15 (b) arat structura de date, dup un astfel de apel. Cnd is_at_previous_point () este apelat, structura de date verific dac poziia robotului actual este aproapierea punctelor stocate.

Figura 4-15 (a) Stnga. Structura de date dup iniializare. (b) Dreapta. Structura de date dup apelarea list_enqueue() .

4.5 Implementarea Alg2

Algoritmul Alg2 este implementat prin utilizarea de module comune i extensii implementate anterior. n particular, Alg2 refolosete freespace () i modulele de structura de date discutate n seciunea 4.2.3. De asemenea, folosete module comune pentru a implementa ipostazele de navigare similare la implemebtarea Bug1 n seciunea 4.2.1 4.6 Implementarea Distbug Algoritmul distbug este mai simplu dect algoritmul Alg2 n msura n care nu are nevoie de modulul de structura de date. n afar de asta, este foarte similar cu Alg2 i, prin urmare, implementarea lui este, de asemenea, foarte asemntoare.

4.7 Implementarea Tangentbug Algoritmul tangentbug a fost modificat de la articolul original. n tangentbug original se genereaz LTG continuu, atunci cnd se deplaseaz. n aceast implementare, tangentbug doar genereaz LTG atunci cnd a ajuns la pozitiile nod. Aceast schimbare este necesar pentru a evita rotaie excesiv i a nu scdea performanele pe cele trei hri. Algoritmul tangentbug este cu mult mai complicat dect oricare dintre algoritmii din bug-ul anterior. A modificat module comune extensiv. O diagram redesenat de clas este prezentat n figura 4-16.

4-16 Diagrama de clasa tangentbug 4.7.1 Modulul data Algoritmul tangentbug necesit colecie extins de date pentru r () precum i freespace spre un anumit punct. Modulul de date PSD colecteaz date i le stocheaz pentru utilizarea de ctre restul sistemului. Pentru a realiza acest lucru ntr-o manier optim i eficient, datele modulul mpart n mod egal sarcina de scanare dintre cele opt PSDs. Prin urmare, fiecare PSD este responsabil pentru colectarea de date cu privire la un sector de grad 45. Fiecare culoare din figura 4-17 arat divizia de sectoare.

Figure 4-17 Fiecare PSD colecteaza data in sectorul propriu Apoi, acest sector de 45 de grade este eantionat n conformitate cu o valoare definit de utilizator DEG_BET_SAMPLES. Default-ul este de 3 grade, dar acest lucru poate fi modificat pentru o mai mare precizie. Prin urmare, fiecare PSD va eantiona sectorul su de 15 ori, intorcandu-se 3 grade ntre fiecare prob. Figura 4-18 arat codul surs care implementeaz culegere de date i figura 4-19 (a) i 4-19 (b) arat robotul care colecionnd date.
void generate_r(){ int reading_index; int psd_index; int readings_per_psd = 360/(NUM_PSD*DEG_BET_SAMPLES); for(reading_index=0; reading_index<readings_per_psd; reading_index++){ for(psd_index=0; psd_index<NUM_PSD; psd_index++){ r_of_theta[readings_per_psd*psd_index+reading_index] = PSDGet(psd[psd_index]); } turn(deg_to_rad(DEG_BET_SAMPLES), FALSE); } turn(-deg_to_rad(360/NUM_PSD), FALSE); }

Figura 4-18 Metoda generate_r Datele din eantion sunt stocate public ntr-o matrice. Numrul de elemente din matrice depinde de DEG_BET_SAMPLES, creia i se atribuie o valoare standard de 3. Dac acest lucru implicit este utilizat, exist 120 elemente n matrice. Elementul 0th conine distana de drept nainte a robotului i elementul i-lea conine distana pe un DEG_BET_SAMPLES * unghi msurat invers acelor de ceasornic de la drept nainte.

Figura 4-19 (a) Stnga. Robotul adun date de la toate cele 8 senzori PSD (b) Dreapta. Dup o rotaie de gradul 3, robotul adun date de la 8 senzori PSD din nou.

4.7.2 Modulul node

Dup ce datele au fost colectate, sunt procesate pentru noduri. Modulul de nod identific i proceseaz nodurile, care ulterior sunt stocate ntr-un vector public. n plus, nodul optim, N *, i nodul de perete sunt identificate. Din cauza r () natura discret, de detectare a discontinuitaii trebuie s fie efectuat prin compararea valorilor de r () .Un nod este identificat n cazul n care:

 diferena dintre cele dou valori succesive de r () este mai mare dect un prag predefinit, sau  Una si numai una din cele dou valori succesive de r () este egala cu r, sau  F > d(x, T), ceea ce inseamn c inta este vizibil  F = r, ceea ce inseamn c nu sunt obstacole vizibile in calea intei. Dup ce toate nodurile sunt identificate, fiecare nod este prelucrat prin calcularea d (Ni, T). Apoi, nodul optim este identificat prin gsirea nodului cu cea mai mic valoare a d (Ni, T). Ulterior, nodul de perete este identificat prin gsirea nodului cu cel mai sczut n r (). Acest lucru se datoreaz faptuluiui c r () nregistreaz msurtori n sens anti-orar in cazul n care 0 este drept nainte. Avnd n vedere c nodurile sunt prelucrate prin creterea , nodul de perete este ntotdeauna nodul identificat pentru prima dat. Acest proces este rezumat n diagrama din figura 4-20.

Figura 4-20 Algoritmul de procesare a nodului

4.7.3 Modulul minimum

n cazul n care algoritmul tangentbug detecteaz c robotul este c ntr-un minim local, se solicit modulul minimum. Rolul acestui modul minimum este de a determina dac robotul a ndeplinit sau nu condiia de a pleca, dreach (T) <dfollowed (T). Aceast evaluare trebuie s se fac utiliznd valoarea de resurse de calcul posibile. n acest sens, o strategie a fost creat pentru a evalua dreach (T) i dfollowed (T) i codul su surs este prezentat n figura 4-21. n primul rnd, modulul minim i cere modulului de nod s gseasc indicele perete a nodului n r () .Indica acest index W. Indicii de la 0 la W reprezent obstacolul minim i este utilizat pentru a evalua dfollowed (T). Indicii rmai reprezint sectorul care trebuie s fie scanat pentru a evalua dreach (T). Pentru a evalua dfollowed (T), pentru fiecare index de la 0 la W se determina distana pn la sfaritul intei. n figura 4-22, aceti indici sunt indicai prin linii roii i punctele folosite pentru distana pn la calculele intei sunt indicate prin ptrate negre. Cel mai scurt a acestor distane, de cnd modulul Wallurmtor a nceput, este nregistrat n dfollowed (T). Pentru a evalua dreach (T), pentru indicii w 1 i 360/num_psd, se determin distana pn la int la intervale regulate. Pentru indicii rmai, se determin distana pn la int numai la sfrit de puncte. n figura 4-22, aceti indici sunt indicai prin linii verzi i punctele folosite pentru distana pn la calculele intei sunt indicate prin patrate Orange. Cel mai scurt a acestor distane, de cand robotul a reactualizat ultima dat r () ,este nregistrat n dreach (T). Aceast strategie poate prea greit, deoarece inta ar putea fi vizibile, dar dreach (T), nu ar nregistra 0. Acest lucru poate fi uor remediat prin includerea metodei freespace (). Dac f> d (x, T), inta este vizibil i robotul merge direct spre ea.
bool leaving_condition_holds(){ int num_samples = 360/DEG_BET_SAMPLES; int wall_index = nodes[wall_node].small_index; int i; float test, dreach; /*update (global) dfollowed, if necessary*/ for(i=0; i<=wall_index; i++){ test = dist_to_targ(i); if(test<dfollowed){ dfollowed = test; } } /*evaluate dreach*/ dreach = check_all_points_on_line(i); i++; for(; i<num_samples-1; i++){ test = dist_to_targ(i); if(test<dreach){ dreach = test; } } test = check_all_points_on_line(i); if(test<dreach){ dreach=test; } /*evaluate leaving condition*/ return dreach < dfollowed; }

Figura 4-21 Metoda leaving_condition_holds()

Figura 4-22. (a) Stnga sus. Scanarea s-a efectuat la poziia sa iniial. (b)Dreapta sus. Scanarea s-a efectuat dup trecerea prin 1 nod. (c) stnga jos. Scanarea s-a efectuat dup trecerea prin dou noduri. (d) dreapta jos. Freespace identific o int vizibil.

4.8 Implementarea algoritmului D* Algoritmul D * doar reutilizeaz modulul de contor de timp, pentru c este fundamental diferit dect ali algoritmi. Implementarea este puternic orientat spre obiect, datorit complexitii mrite considerabil. Figura 4-23 arat diagrama de clas D * .

Figura 4-23 Diagrama de clas D *

4.8.1 Clasa celul O celul reprezint o zon care este tratat ca o locaie discret. Cu toate c aceast zon poate fi de form arbitrar, a fost implementat ca un ptrat de 100mm lungime. Fiecare celula nregistreaz:

 poziia sa pe grtar. Acest lucru este pur pentru identificare, celulele nu au nevoie s cunoasc poziia lor i s se comporte n acelai mod, indiferent de poziie.  valoarea sa h, aa cum se specific de ctre articolul original. Aceasta reprezint costul de atingere a obiectivului urmnd traseul backpointer curent a celulei.  valoarea sa k, aa cum se specific de ctre articolul original. Aceasta reprezint cele mai mici costuri de atingere a obiectivului nregistrate vreodat de ctre celul.  sfrsitul arcului. Fiecare celula are 8 arc-obiecte capt pentru a nregistra costurile de tranziie i backpointers  Dac obstacolul exist. Dac da, blocked va fi true.  tag-ul su, aa cum se specific de ctre articolul original. Acest lucru poate fi una din cele trei valori posibile:

nchis, deschis i nou.

o C nchis nseamn c procesul-de stat () a fost rulat pe acea celul. Acest lucru implic faptul c celula are un backpointer i un cost minim pentru obiectivul stabilit. o Deschis nseamn c celula este un vecin de celul scop sau o celul, care este nchis .Celule deschise sunt continuu evaluate pentru un cost minim pentru a ncpea n tabelul de moda descrise n seciunea 3.7. Odat ce o celul are costul minim, procesul-de stat () este numit i devine o celul nchis.cost on the table, processstate() is called and it becomes a closed cell.

O Nou este starea iniial de celule i se refer la celulele care nu au fost prelucrate i nu sunt vecini cu celule nchise.Clasa de celule pune n aplicare trei funcii prevzute de

articolul original. H () i t () metodele de a reveni valoarea celulei h i, respectiv, tagul. Metoda insert() actualizeaz tag-urile, k i valorile h. Clasa de celule pune n aplicare trei funcii prevzute de articolul original. Metodele H () i t () returneaza valoarea celulei h i, respectiv, tag-ul. Meroda insert() actualizeaz de tag-urile, k i valorile h. 4.8.2 Clasa arc-end Fiecare celula are 8 obiecte arc-end, cte unul pentru fiecare direcie: nord, nord-est, est, sud-est, sud, sud-vest, vest i nord-vest. Fiecare obiect arc-end nmagazineaz costul de a trece de la acea celul special ntr-o direcie specificat. n plus, arc-end nmagazineaz dac direcia specificat este backpointer pentru celula care o deine. 4.8.3 Clasa open-list Clasa open-list menine un tabel de celule deschise sortat dupa ascensiunea valorii k similar cu tabelele de la punctul 3.7. Acesta este pus n aplicare ca o gama larga de indicatori de celule cu numrul de elemente egal cu numrul de celule pe grilaj. Atunci cnd o celul nou este apelat, este sortat n funcie de valoarea sa k. Clasa open-list pune n aplicare min-state () i get_kmin () apeluri prescrise de ctre articolul original. min_state () readuce ipostaza cu valoarea k minim i este implementat readucnd un un pointer la celula din partea de sus a listei. get_kmin () returneaz valoarea minim k i este implementat de interogarea i revenirea valoarea K din celule n partea de sus a listei. Funcia delete(cell x) este, de asemenea, pus n aplicare de aceast clas. Dei se presupune c aceast funcie elimin orice celula dat din open-list, punerea n aplicare ncalc parametrul i pur i simplu terge celula cu k-valoare minim. Acest lucru se datoreaz faptului c doar proces-state() solicit aceast funcie de timp i numai atunci cnd procesul-state() apeleaz delete()celula se terge cu k minim-valoare. 4.8.4 Clasa grid

Clasa grid este compus din toate celulele ntr-o formaie gril similar cu schemele reelei n seciunea 3.7. Din moment ce fiecare celul nu este constient de orice alt celul, clasa de reea servete ca o interfa atunci cnd un apelant necesit operaiuni desfurate ntre dou sau mai multe celule.Acest lucru este deosebit de important atunci cnd interfam cu funcii prevzute de articolul original.

O funcie prevzut de articolul original este c (destinaie de celule, celule de origine), care returneaz costurile de cltorie de la celula int la celula destinaie. Figura 4-24 arat modul n care clasa grila manevreaz apelrile.

Figura 4-24 Secvena de diagram pentru c call. O alt funcie prevzut de articolul original este b (destinaie, origine), care stabilete originea backpointerului n direcia de destinaie. Figura 4-25 arat modul n care clasa grila manevreaz apelul.

Figura 4-25 Secvena diagram pentru b call.

4.8.5 Clasa vecin Clasa vecin este o mic structura de date menit s faciliteze transferul de vecini valizi din jurul unei celule int.

4.8.6 Clasa discrepan

Rolul clasei discrepan este de a utiliza senzori PSD, pentru a detecta orice diferene ntre harta robotului i mprejurimile reale. Dac se detecteaz o discrepan, acesta calculeaz poziia celulei bazate pe lectur PSD. Apoi, se stabilete atributul celulei blocat la TRUE i apeleaz modify-cost () pentru a genera noul traseu backpointer optim n conformitate cu procedura menionat n seciunea 3.7.2. 4.8.7 Clasa algoritm Clasa algoritm pune n aplicare process-state() si modify-cost() funcii exact aa cum se specific n articolul lui Stentz. process-state() si modify-cost()apeleaz* funcii implementate n modulele discutate anterior. Metoda main() este, de asemenea, inclus n algoritmul clas i coordoneaz navigarea n ansamblul su. Figura 4-26 arat metoda main().

num_calls=0; generate_target_coords(); initialize_timers(); init_driving(); initialize_grid(g_r,g_c); do{ kmin = process_state(); } while(get_tag(get_current_row(), get_current_column()) != CLOSED && kmin!=NONE); while(!(get_current_row()==g_r && get_current_column()==g_c)){ process_surroundings(); drive(get_direction(get_current_row(), get_current_column())); } face_north(); end_timers(); print_stats(TRUE, get_time_thinking(), get_time_driving(),get_total_dist(), get_total_turn(), num_calls);

Figura 4-26 Metoda principala

4.9 Probleme de implementare

4.9.1 Evaluarea conditiilor de evaluare Evaluarea const n verificarea condiiilor de navigaie specificate de ctre algoritmul de navigare. De exemplu, actualiznd F prin apel la freespace () sau prin verificare dac robotul a ajuns la linia de M. n teorie, verificarea ar trebui s apar n mod continuu. Aceasta este, de ndat ce o condiie de plecare ramne, robotul ar trebui s realizeze instantaneu aceasta i s ia msurile corespunztoare. Evident, acest lucru nu poate aprea n practic. n practic, condiiile de navigaie chestionate sunt n mod regulat, pentru c este imposibil pentru a genera o ntrerupere, care nu se bazeaz pe o votare la un anumit nivel fundamental, deoarece

aceasta este de msurare a mediului extern. Problema care trebuie rezolvat este ct de des (n termeni de distan sau de timp) robotul evalueaz condiiile de navigaie. n figura 4-27 (a) robotul voteaz prea rar i nu utilizeaz comenzi rapide pentru obiectiv. n figura 427 (b) sondajele de robot atunci cnd aceasta este peste decalaj, i permit s utilizeze comenzi rapide. Cu toate acestea, votarea de prea multe ori este de calcul scump. Prin urmare, echilibrul corect trebuie s fie gsit ntre cele dou extreme.

Figura 4-27 Cercurile verzi reprezint locaii de votare. (a stnga). Robotul nu profita de o comand rapid, pentru c sondajele sunt prea rare. (b) dreapta. Robotul profit de o comand rapid, dar sondajele sunt prea frecvente. n aceast implementare, robotul ia un pas de 40mm ntre fiecare evaluare. S-a constatat, prin numeroase iteraii funcionale c aceast valoare a realizat un echilibru bun, cu toate acestea, nu este deloc perfecta. Ea poate fi modificat folosind macro STEP. n lumina acestei probleme de implementare, algoritmii care sunt mai degrab proactivi dect reactivi ar trebui s fie favorizai. Asta este, algoritmi care decid cu privire la destinatii de deplasare fixe, de cltorie la ei, s colecteze date i apoi s decid cu privire la destinaia urmtoare ar trebui s fie favorizat n faa celor care reacioneaz la mediul extern in mod spontan. Bug1, bug2, alg1, alg2 i algoritmii distbug sunt toi reactivi, deoarece iau toi msurtori ale mediului extern n funcie de dimensiunea pas. Algoritmul de modificare tangentbug este pro-activ, pentru c navigheaz la noduri i apoi evalueaz condiiile de navigaie. D * evalueaz condiiile de la fiecare celul i doarme n timpul micarii. Prin urmare, tangentbug i D * sunt cele mai de dorit din cauza naturii lor proactive.

4.9.2 Recunoaterea punctelor iniiale Bug1, bug2, alg1, alg2 i algoritmi distbug toate necesit recunoaterea de puncte vizitate anterior. Acest concept este bine pus n teorie, dar se pune problema implementrii n practic. n practic, atunci cnd robotul ntlnete prima dat un punct de interes, acesta nregistreaz coordonatele sale actuale. Problema este c robotul este foarte puin probabil de a vizita cele mai exact coordonate din nou, din dou motive. n primul rnd, traseul este foarte puin probabil s fie aceelai pentru orice dou traversale limita din cauza controlerului PD. n al doilea rnd, robotul conduce o mic distan mai departe, "pas", nainte de evaluarea condiiilor de navigaie aa cum este descris n seciunea4.9.1. Acest lucru nseamn c, chiar dac este acelai traseu, robotul

trebuie s fac sondaje de opinie, de asemenea, atunci cnd este exact peste punctul nregistrat anterior. Din cauza acestei probleme, toate punctele nregistrate sunt date pe o raz aa cum se arat n figura 4-28. n cazul n care robotul realizeaz c este n raza unui punct anterior, consider c acesta este n punctul anterior. Evident, raza trebuie s fie aleas astfel nct pozitivele false sunt reduse la minimum, precum i toate punctele autentice anterioare sunt maximizate. n cazul n care raza este prea mare, alarme false pot fi generate. De exemplu, n figura 4-28 raza robotului se extinde dincolo de perete. n cazul n care robotul cltorete pe partea opus, s-ar putea crede greit c este la o lovitura anterioar sau s prsesc punctul. n schimb, n cazul n care raza este prea mic, puncte anterioare autentice pot fi ratate.

Figure 4-28 Raza este prea mare si se extinde in afara zidului. n implementare, raza este setat la 80mm n interiorul TARG_ERROR macro. Aceast valoare a fost stabilit prin iteraii numeroase. Cu toate acestea, ea nu este deloc o soluie perfect. Avnd n vedere implementarea aceastei probleme, algoritmii care se bazeaz foarte puin la punctele anterioare ar trebui s fie favorizate de algoritmi care se bazeaz pe punctele anterioare puternic. Alg1 si Alg2 stocheaz toate punctele anterioare i le face deosebit de nedorite. Bug1, Bug2 i Distbug se bazeaz pe punctele anterioare ntr-o msur mai mic. n schimb, D * stabilete poziia robotului n cadrul reelei i nu necesit recunoaterea punctelor anterioare ceea ce l face foarte de dorit. Tangentbug se bazeaz foarte puin cu privire la recunoaterea punctul anterior, numai folosind-o pentru a stabili dac robotul a ncercuit completo bstacolul. Cu toate acestea, spre deosebire de ali algoritmi de bug, Tangentbug utilizeaz msurtori PSD pentru a determina dac se poate vedea un punct . Acest lucru este de dorit, deoarece dimensiunea razei poate fi mult mai mic i nu se bazeaz pe votare. 4.9.3 Cerine hardware Din punct de vedere practic, costurile de hardware ar trebui s fie reduse la minimum. Algoritmi bug1 i bug2 pot opera la performane de vrf folosind doar senzori tactili. PSDs nu a mbuntit performana. n mod evident, aceasta este cea mai ieftin opiune. Algoritmi alg1 i alg2 au o cerin minim de senzori tactili. Atunci cnd urmeaz peretele, au nevoie s tie dac robotul poate cltori n direcia int. Acesta este posibil cu senzori tactil; cu toate acestea el poate mbunti performana n cazul n care PSD-uri mai multe sunt folosite pentru a

msura F astfel cum e descris n figura 4-13. Chiar mai bine este un PSD montat pe un servo care ntotdeauna arat spre direcia int. Algoritmul distbug are cerinte destul de similare cu alg1 i alg2 cu excepia faptului c trebuie s aib cel puin un PSD, s funcioneze. Un PSD montat pe un servo-ar fi ideal, dar dac nu, PSD multiplii, ar trebui s fie folosii pentru a msura F. Tangentbug i D * necesit cel puin un PSD de a opera, si mai multe PSD pentru mbuntirea performanelor. Gama de PSD este, de asemenea, un factor important n acesti algoritmi pentru c nu folosesc pur i simplu pentru a determina F. n tangentbug, un interval mai lung OSD rezult intr un grafic mai mare LTG, iar acest lucru poate duce la drumuri mai scurte. n D *, un interval mai lung PSD permite robotului s detecteze obstacolele mai de departe care s permit harii s fie construit mai eficient. 4.9.4 Colectare de date a Tangentbug n mod ideal, r () ar fi o funcie continu. Cu toate acestea, citirile PSD poate msura distana doar ntr-o direcie fix i, prin urmare, r () trebuie s fie discret eantionat. Din pcate, aceasta duce la eroare.Pentru a reduce eroarea, gradele ntre probe pot fi sczute n detrimentul de cretere a timpului de colectare de date, creterea cerinelor de memorie i a scderea robusteii, pentru c este eroare predispus s se roteasc n unghiuri mici Aceast problem se manifest n cazul n care robotul este plasat lng un perete. Figura 4-29 demonstreaz faptul c tangentbug identific nodurile din greel. Pentru a reduce aceast eroare, robot verific dac afl n apropierea unui perete nainte de colectarea datelor. Dac este aa, merge napoi uor, ceea ce face mai puin probabil c va exista o identificare eronat. Acest comportament este demonstrat n figura 4 --30.

Figura 4-29 Robotul identific nodurile din greeal.

Figura 4-30 Robotul se indeprteaz de zid cnd este prea aprope. Tehnica de culegere de date poate fi mbuntit. De exemplu, un prag de variabile poate fi pus n aplicare, care crete atunci cnd diferenele devin mai mari. O alt tehnic posibil este de a varia unghiul dintre citirile PSD, n funcie de diferena relativ. Meritele acestor tehnici sunt lsate pentru studiu in continuare 4.3.5 Marimea hrii limitat n D* Din cauza dependenei sale asupra celulelor, D * are o problem unic cu zonele harii out-ofbound. Luai n considerare mediul descris n figura 4-31. inta este accesibil, cu toate acestea D * ajunge la concluzia c obiectivul este imposibil de gsit, deoarece nici o celul nu acoper zonele din jurul peretelui. n mod clar, strategiile trebuie s fie dezvoltate pentru a trata aceste situaii

Figura 4-31 folosind un grilaj 5x5 , robotul nu poate atinge inta. O posibil abordare la rezolvarea acestei probleme este de a oferi o celul pentru fiecare poziie posibil dup cum s-a sugerat pe hrtia original *10+ a lui Stentz . Cu toate acestea, mai multe

probleme apar atunci cnd acest lucru se ntmpl . n primul rnd, ea implic faptul c dimensiunea harii este cunoscut nainte de plecare. n mod cert, acest lucru nu este permis n declaraia problemei definite n seciunea 2. n al doilea rnd, ea implic, de asemenea, c mrimea harii este finit, dei acest lucru nu poate fi neaprat cazul. n al treilea rnd, n cadrul acestui sistem, utilizarea memoriei lui D * ar fi mult mai mare dect este deja. O abordare mai bun ar fi de a aloca celule dinamic in timp ce robotul este n micare. Exact cum acest sistem este pus n aplicare este lsat pentru activiti de cercetare viitoare.

5. Simulri
5.1 Atributele de msurare
Simulrile au fost efectuate pe simulator Eyesim pentru a ndeplini obiectivele menionate n Seciunea 2. Convergena este verificat i apoi atributele sunt msurate. Lungimea de cale, de rotaie, PSD limit, limita liniar VW i limita de rotaie VW sunt constante pe tot parcursul a 10 simulri. Cu toate acestea, calculul i timpul de conducere variaz ntre simulri. Prin urmare, fiecare algoritm este simulat de 10 ori, iar media este luat pentru calculul de timp. De asemenea, este important de menionat c clock() msoar timpul petrecut n procesor de firul apel. Acesta nu ia n considerare simulare-la-raport de timp. Prin urmare, n cazul n care simulare-la-raportul de timp este crescut pentru unele simulri, i nu altele, rezultatele vor fi inexacte. Pentru a ine seama de acest lucru, toate simulrile sunt rulate pe setrile raiei maxime a simulation-to-time. Fiecare algoritm este simulat pe trei hari diferite, care sunt concepute pentru a ilustra punctele forte i punctele slabe individuale

5.2 Hrile de simulare

5.2.1 Harta1 Map1 este prezentat n figura 5-1 n cazul n care coordonatele sunt n milimetri din partea de jos stnga.Acesta este conceput pentru a testa algoritmi ntr-un decor nchis. n setrile nchise, algoritmi necesita capacitatea de a alege puncte de plecare bune i de perete corecte ca urmare a deciziilor rele.Ea a fost utilizat n studiile anterioare *3, 4+

Figura 5-1 Harta1 testeaz un algoritm ntr-un sistem nchis Pentru informare i n scopuri de comparaie, lungimea ideala a cii i rotaia au fost calculate:

5.2.2 Harta2 Harta 2 este prezentat n figura 5-2. Este considerat ca o setare deschis. ntr-un cadru deschis, capacitatea algoritmului de a cuta i urma lcomos, cile optime la nivel local sunt testate. Aceast hart a fost folosit de Lumelsky n demonstrarea algoritmilor bug1 original i bug2 *5+.

Figura 5-2 Harta2 testeaz algoritmul unui sistem deschis Lungimea cii ideale i de minimul de rotaie au fost calculate:

5.2.3 Harta3

Harta3 este prezentat n figura 5-3. Testeaz o capacitate foarte important pentru toi algoritmii convergeni,de a scpa de un minim local

Figura 5-3 Harta3 testeaz un algoritm ntr-un minim local Lungimea cii ideale i rotaia au fost calculate:

5.3 Generatorul podelii

Aspectul de ptrate verzi i roii poate fi observat n fundal de hri de simulare. Acestea reprezint nceputul i, respectiv, obiectivul. Acesta este produs prin generarea unui fiier bitmap pe care Eyesim l utilizeaz ca fundal. Generatorul Podea a fost scris special pentru a genera fiierul de fundal bitmap si GUI prezentat n figura 5-4. Programul este orientat pe obiecte i scrise n C #. Net. Este nevoie de input de la utilizator i de la lumea ntreag. Utilizatorul specific mrimea dorit bitmap,distana pn la int i direcia spre int. Generatorul Podea extrage poziia de porinire i mrimea lumii, din fiierul lume. Apoi, acesta creeaz un bitmap la caietul de sarcini.

Figura 5-4 Generatorul podea GUI

6. Rezultate i discuii
6.1 Verificri de convergen
Primul obiectiv este de a verifica convergenele. Rezultatele simulrii arat c toi algoritmii sunt convergeni. 6.1.1 Bug1

Figura 6-1(a) Bug1 pe Harta1

Figura 6-1(b) Bug1 pe Map2/Harta2

Figura 6-1(c) Bug1 pe Map3/Harta3

6.1.2 Bug2

Figura 6-2(a) Bug2 pe Map1/Harta1

Figura 6-2(b) Stnga. Bug2 pe Map2/Harta2. (c)Dreapta. Bug2 pe Map3/Harta3.

6.1.3 Alg1

Figura 6-3(a) Alg1 pe Map1/Harta1

Figura 6-3(b) Stnga. Alg1 pe Map2/Harta2. (c) Dreapta. Alg1 pe Map 3/Harta3.

6.1.4 Alg2

Figura 6-4(a) Stnga. Alg2 pe Map1/Harta1. (b) Dreapta. Alg2 on Map2/Harta2.

Figura 6-4(c) Alg2 pe Map3/Harta3.

6.1.5 Distbug

Figura 6-5(a) Stnga Distbug pe Map1/Harta1. (b) Right. Distbug pe Map2/Harta2

Figura 6-5(c) Distbug pe Map3/Harta3

6.1.6 Tangentbug

Figura 6-6(a) Stnga. Tangentbug pe Map1/Harta1. (b) Dreapta. Tangentbug pe Map2/Harta2.

Figura 6-6(c) Tangentbug pe Map3/Harta3.

6.1.7 D*

Figura 6-7(a) Stnga. D* pe Map1/Harta1. (b)Dreapta. D* pe Map2/Harta2.

Figura 6-7(c) algoritmu D* pe Map3/Harta3

6.2 Lungimea Cii

O lungime sczuta este cel mai de dorit atribut, deoarece permite robotului s ajung la int ct mai repede. De asemenea, roboii trebuie ntreinui i necesit o surs de combustibil. n mod evident, o cale sczut n lungimea reduce ambele cheltuielile. Lungimea cii depinde de hart, dar figura 6-8 arat c n general ordinea este descresctoare: Bug1, Bug2, Alg1, Alg2, Distbug, Tangentbug i D *. Rezultatele arat c bug1 a depit bug2 pe Map1, dar bug2 a depit bug1 pe Map2 i Map3. n mod evident, algoritmi bug1 i bug2 sunt adaptate la anumite tipuri de hri. Algoritmul bug1 este potrivit pentru hri nchise, pentru c adun toate datele nainte de a decide cu privire la punctul de plecare. Algoritmul bug2 mai puin conservator, va prsi obstacol ndat ce ntmpin M-line. Acest lucru l face potrivit pentru a deschide hriile, cum ar fi Map2 i Map3. Apoi, rezultatele arat c Alg1 depeste bug1 i bug2 pe toate cele trei hri. Acest lucru este pentru c Alg1 combin cele mai bune caracteristici ale lui bug1 i bug2. , Pstrnd avantajul din M-line pentru harti deschise, Alg1 si poate aminti lovituri anterioare i puncte de plecare. Aceast caracteristic permite de a genera drumuri scurte pe hri nchise, cum ar fi Map1. Dup aceea, rezultatele arat c Alg2 i Distbug s-a comportat mai bine dect alg1, bug2 i bug1. Acest lucru se datoreaz alegerii superioare punctelor de plecare, generate de condiiile de plecare. Alg2 i Distbug ngreuneaz punctele de plecare de pe hrile anexate, care d avantaje similare cu bug1. Cu toate acestea, Alg2 i Distbug fac mai timpuriu punctele de plecare pe hri deschise care ofer avantaje similare cu bug2. Rezultatele arat c Alg2 i Distbug au fost chiar destul de asemntoare pe toate cile hri. Acest lucru este din cauza asemnrii n condiiile lor de plecare. A lsa condiie pentru Distbug este d (X, T) - F d (T) - Pasul min. Compara acest lucru cu condiiilor de plecare pentru Alg2: 1) un punct de y este descoperit astfel c este mai aproape de int dect orice punct vreodat vizitat de catre un robot anterior i 2) robot poate cltori spre punctul in. S presupunem c F = 0 i robot este la Y. n Alg2, un punct de plecare nu poate fi generat. n distbug, F = 0 implic faptul c d (x, T) d (T) - Pasul min. Avnd n vedere c robotul este la y, (,) () Min d X T = D T. Apoi, deviaiilor STEP constant sunt comparate, astfel nct ele nu pot fi adevrate. S presupunem c F> STEP i c robot este la Y. n Alg2, un punct de plecare ar fi definit. n Distbug, (,) () min d XT = d T, cu toate acestea F> STEP, fcnd condiie adevrate. Prin urmare, Distbug implicit precizeaz c F trebuie s fie mai mare de STEP. Alg2 pur i simplu prevede c robotul trebuie s poat s se deplaseze n direcia obiectivului de la Y, dar figura 6-8 arat faptul c punerea sa n aplicare necesit un prag, FS_THESHOLD. Acest prag este, n principiu nu cu mult diferit de STEP n distbug.
while(TRUE){ fs = freespace(); if(fs==OUT_OF_RANGE){ fs = MAX_RANGE; } if(is_at_y && fs>=FS_THRESHOLD){ return LEAVE_POINT; } }

Figura 6-8 Alg2 necesit FS_THRESHOLD valuare

Condiiile de plecare Alg2 i Distbug sunt foarte similare, dar acestea difer ntr-un aspect subtil. Cnd F> STEP i robotul nu a ajuns destul de y, distbug permite un punct de plecare pentru a putea fi definit, n timp ce Alg2 impune robotului s- ajung la Y. Aceast diferen este cel mai bine ilustrat prin compararea cifrele 6-4 (a) i 6-5 (a). Se observ punctul de plecare 3 n Alg2 i se las la punctul 4 din distbug. Este diferen subtil, care a permis distbug-ului s- genereze lungimi de cale mai sczute pe toate cele trei hri. Performana Tangentbug i D * a fost superioar de Bug1, Bug2, Alg1, Alg2 i Distbug pe toate cele trei hri. De fapt, acestea au fost n imediata apropiere calea ideal in lungime. D * ovie uor pe Map3, prin urmarea vulnerabilitii sale n minime locale, dar este nc competitiv.

Figura 6-8(a) Partea de sus. Lungimea Cii pe Map1. (b) Centru Lungimea Cii pe Map2. (c) Partea de jos. Lungimea Cii pe Map3.

6.3 Rotaia Figura 6-9 arat c, n general, rotaia este legat de lungimea de cale. Aceasta este, cea mai lung cale algoritmica generata, iar micarea de rotaie este efectuat. Acest rezultat este intuitiv satisfcut. Alg2 i Distbug sunt vzute ca aberante majore. Rotaia lor a crescut foarte mult, probabil, prin urmarea apelurilor ctre freespace (), care sunt realizate n acelai timp, cu peretele. Acest apel este efectuat la fiecare 40mm i rotaia total pe chemare este de 0 - 45 de grade. Dac un servo a fost montat, care ntotdeauna are puncte n direcia obiectivului sau PSDs i mai multe sunt disponibile, atunci aceast rotaie va scdea. Aceasta poate fi interesant daca s-ar elimina ntreinerea hardware de rotaie din rezultatele de rotaie. Rezultatele vor afia atunci rotaia, care este n mod inerent generat de algoritm. Figura 6-10 arat c rotaiile inerente sunt n legtur cu lungimiile cale. Aceast constatare este valabil i pentru Alg2 i deDistbug i arat c Alg2 i Distbug vor beneficia de un servo sau PSDs mai mult. Numai algoritmul care nu se potrivete cu aceast tendin este D *. Acest lucru se datoreaz segmentrii hrii n celule. Ca rezultat, robotul se poate mica doar n miscri rotative de pna la 45 de grade. Luai n considerare figuriile 6-6 (a) i 6-7 (a). Tangentbug se poate manevra far a avea proeminene successive de rotaie, dar D * neaprat are nevoie de o micare de 45 de grade la rndul su, de fiecare dat cnd acesta se deplaseaz cu proeminene succesive.

Figura 6-9(a) Partea de sus. Rotaie pe Map1. (b) Centru. Rotaie pe Map2. (c) Partea de jos. Rotaie pe Map3.

Figura 6-10(a) Partea de sus. Rotaie pe Map1. (b) Centru. Rotaie pe Map2. (c) Partea de jos. Rotaie pe Map3.

6.4 Timpul mediu de calcul Evaluare timpului de calcul este o msur obiectiv de utilizare a CPU n procesul de navigare. Timpul de conducere nu este la fel de important, deoarece aceasta depinde de viteza de deplasare a robotului i n acelai timp, robotul este cele care lucreaz, iar partea de navigare este n adormire. Figura 6-11 arat rezultatele msurtorilor de timp de calcul. Funcie de complexitate au crescut aproximativ la fel sau au sczut n timp de evaluare! Acest lucru este rezultatul, cel mai probabil a deplasrilor scurte si a cilor ideale. Singurul care iese din cadru este D * 's pe Map3 din cauza vulnerabilitii fa de minimele locale. Ar fi interesant s se investigheze ct timp de calcul este nevoie pe metru parcurs. Acest lucru elimin avantajul lungimii de cale din algoritmurile complexe. Aceast statistic pentru toate cele 3 hri este prezentat n figura 6-12. Tendina variaz n funcie de tipul de hart. Pe Map1 si Map2, n cazul n care nu exist minime locale, D * necesit cel mai mic timp de calcul pe metru, chiar peste bug1 i bug2! Apoi, Bug1 i Bug2 sunt urmtorii algoritmi, deoarece acetea sunt relativ simplii. Destul de surprinzator, Tangentbug va fi urmat de distbug, alg2 i apoi alg1. D *, probabil, are cel mai redus timp de calcul pe metru datorit segmentrii sale pe hart. Acest lucru permite D * s abandoneze apelul la biblioteca de matematica i, n plus, nu apar calcule intensive de multiplicare sau de operaiuni de divizare cu virgul mobil. n schimb, exist procese de starea relativ ieftin, metoda rezultat ducnd la timpi de calcul sczui. Tangentbug este surprinztor de competitiv. Acest lucru este cel mai probabil, datorita naturii sale proactive discutate n seciunea 4.9.1. n timp ce poate fi costisitor pentru calculul LTG, n procesul de conducere timpul de calcul este redus. O alt statistic interesant este c apelurile tangentbug la biblioteca matematica l situeaz pe ultimul loc ca numr. Aceti doi factori ar putea explica de ce tangentbug's are asa un timp sczut de calcul pe metru. Alg1 i Alg2 sunt cele mai scumpe din cauza verificriilor, pentru toate punctele anterioare, la fiecare pas. Distbug, care este foarte similar cu Alg2 dar arat economii de calcul pentru c nu face un control la fiecare pas. Cu toate acestea, se observ modul n care se schimb tendinele pe map3 cu un minim local. Acum, bug1 i bug2 sunt mai ieftine, urmate de alg1, alg2, distbug, tangentbug, precum i de departe cel mai scump: D *. Figura 6-12 (c) arat faptul c o mai mare complexitate conduce la timp de calcul pe metru. La D * timpul de calcul este excesiv de mare. Acesta solicit un proces-de stare de () 83,855 de ori n minime locale conducnd la timp de calcul foarte mare. Din pcate, acest lucru este necesar din cauza recalculrii la calea optim i este o slbiciune motenit de la strmoul su, tehnica cmpurilor de for. Timpul de calcul Tangentbug's este, de asemenea, foarte mare. Acesta solicit biblioteca de matematica de23,080 ori. Acest lucru se datoreaz faptului c aceasta trebuie s proceseze mediile vizibile pentru a determina dreach (T). Suma mare de apeluri Tangentbug's, la biblioteca de matematica nu a dus la o mare creterea a timpului de calcul peste ali algoritm proporionali. Probabil din cauza mediului hardware pe care a fost rulat simularea, care proceseaz in paralel. Pe un robot real cu un singur procesor mai lent, rezultatele ar putea fi foarte diferite. Procesarea paralel n tangentbug este posibil numai datorita naturii sale proactive. Tangentbug adun toate datele de la un punct. Metodele nod de prelucrare ulterioar pot fi reluate n mod independent, ceea ce permite s apar n procesare paralel. Ali Algoritmii solicita ca robotul s se mute cu un mic pas nainte spre a lua msurtori. Aceste msurtori sunt n mod inerent secveniale i sunt prelucrate ca atare. Din pcate, D * nu este n msur a exploata paralelismul, deoarece traseul optim backpointer trebuie s fie calculat succesiv de la inta explicat i la pct. 3.7. D * este n mod inerent un algoritml

secvenial de prelucrare. Un subiect de cercetare viitoare s-ar putea axa pe ntrebarea daca D * poate deveni un algoritm paralel i, dac da, sa se realizeze modificarea acestuia.

Figura 6-11(a) Sus. Timpul de calcul pe Map1/Harta1. Centru Timpul de calcul pe Map2/Harta2. Jos Timpul de calcul pe Map3/Harta3

Figura 6-12(a) Sus. Timpul de calcul pe metru parcurs pe Map1/Harta1. Centru Timpul de calcul pe metru parcurs pe Map2/Harta2. Jos Timpul de calcul pe metru parcurs pe Map3/Harta3

Figura 6-13(a) Sus. Apeluri pe Map1/Harta1. Centru Apeluri pe Map2/Harta2. Jos Apeluri pe Map3/Harta3

6.5 Robusteea Robusteea este esenial pentru orice aplicaie multi-robot practic. Nici un algoritm nu a fost conceput cu. robustee,la fel implementarile particulare nu folosesc la tehnici robustness-enhancing. Prin urmare, rezultatele vor identifica algoritimi care iau n calcul robusteea. Figura 6-14 arat c, n general, algoritmi nu au fost robusti la zgomot. Se descurca mai bine mpotriva zgomotului PSD, dect impotriva zgomotului de conducere. Algoritmi au rezultate slabe mpotriva zgomotului de conducere liniar cu excepia D *, care nu a avut robustee mpotriva zgomotului de rotatie de conducere. Dead-reckoning conduce la localizari false si probabil are o contributie majora la robusteea slaba impotriva zgomotului de conducere. Aceast cauz a eecului a fost indicat atunci cnd algoritmi sunt prea departe de int. Folosind purley dead-reckoning un algoritm nu poate corecta un algoritm de localizare fals. n acest sens, algoritmi nu sunt responsabili de robustee slaba, pentru c acesata depaete modul lor de control. Singura modalitate de a corecta localizarile false este recunoaterea unui reper sau reele de senzori. Robusteea depinde de asemenea de harta. Comparnd figura 6-14 (a) cu 6-14 (b) i 6-14 (c) observam c robusteea pe map1 a fost mai rea dect pe map2 i map3. Aceasta implic faptul c algoritmi sunt mai robuti pe hri deschise dect pe hri nchise. Probabil datorit unei precizii mai mari avem nevoie de navigaie mai buna n spaii nchise. In spatii deschise, este loc mult mai mult pentru erori nainte de producerea unui veritabil eec. De asemenea, exista algoritmi care se bazeaza pe recunoaterea de puncte vizitate anterior. Figura 6-14 arat c Bug1 este foarte slab pe toate cele 3 harti, pentru c trebuie s tie cnd robotul a ocolit obstacolul. Bazndu-se pe punctele anterioare este dificil chiar i fr eroare din cauza motivelor discutate n seciunea 4.9.1 si 4.9.2. Tangentbug a fost un alt realizator de robustee sczut. Din nou, acest lucru sa datorat faptului sa erorile de conducere duc la localizarea fals, pentru c au fost convergente prea departe de obiectiv. Tangentbug se comporta mai bine mpotriva eroarii PSD, deoarece criteriul de parcurs pe nodul identificat tolereaz cantiti mici de zgomot PSD. D * a fost cel mai performant din cauza segmentarii sale din gril care impune robotului s se deplaseze n pasi mici discreti. Pe distane mari, varianta asta de pai miciduce la o distan parcurs mai precis. D * este de asemenea, cel mai robust mpotriva erorii de conducere la rotaie. Acest lucru este cel mai probabil din cauza gradelor de libertate limitate ale robotului. Prin urmare, atta timp ct rotaia este aproape de una din cele opt direcii prefereniale, algoritmul poate continua. n cazul n care este solicitat un algoritm robust, D * este singurul candidat.

Figura 6-14(a) Sus. Robustetea pe Map1/Harta1. Centru Robustetea pe Map2/Harta2. Jos Robustetea pe Map3/Harta3

6.6 Complexitatea Dintr-o perspectiv de dezvoltare software, este dorit un algoritm mai putin complicat. Complexitatea minima reduce costurile de dezvoltare software i este mai puin probabil s eueze. Complexitatea este subiectiv i depinde foarte mult de hotrrea pronunat de implementator. Msuratoarea cea mai obiectiva este alcatuita din cele mai multe linii de cod pentru punerea n aplicare, care este prezentat n Figura 6-15. Conform rezultatelor, clasamentul de la cel mai simplu la cel mai complicat este: Bug2, Bug1, Distbug, Alg1, Alg2, Tangentbug i D *. Acest clasament este concurent cu experien de punerea n aplicare. Bug2 i Bug1 sunt cele mai puin complicate. Distbug este puin mai complicat ,din cauza sale lasam condiia care impune freespace (). Alg2 este foarte similar cu Distbug dar este nevoie de un date-modul de structur, care il face un pic mai complicat. Alg1 este foarte similar cu Alg2 i, prin urmare, complexitatea Alg1 este foarte similar cu Alg2. Tangentbug este moderat complicat din cauza colectrii de date i prelucrarea LTG. n cele din urm, D * este cel mai complicat din cauza etapelor necesare pentru punerea n aplicare a reelei.

Figura 6-15 Linii de cod pentru fiecare algoritm 6.7 Cerinte de memorie Cerinele de memorie ar trebui s fie ct mai sczute posibil. Figura 6-16 arat clasamentul de la cele mai scumpe la cele mai ieftine: D *, tangentbug, alg2, alg1, distbug, bug2 i bug1. Aa cum era de asteptat, algoritmii simpli necesit mai puin memorie dect cei complicati. Bug1, Bug2 i distbug au fost cele mai ieftine, deoarece ele necesit doar module comune. n continuare, alg1 necesit modulul de structura de date. Alg2 necesit o suplimentare de 4 octei pentru a urmri d (y, T). Tangentbug este urmtoarul cel mai scump, deoarece are nevoie pentru a stoca R (), noduri i moduluri minime. n cele din urm, D * necesit cea mai mare cantitatea de memorie, deoarece are nevoie pentru a stoca o reea complet de celule. Este important de remarcat faptul c numai la nivel global de memorie a fost msurat. Unii algoritmi de apel, funcii care necesit o mulime de memorie pentru o perioad scurt de timp. Cerinele de memorie ar trebui

s fie privite ca cerina minim de memorie. n comparaie cu cantitatea de memorie disponibile pe majoritatea roboilor, cerinele de memorie pentru algoritmii de bug-ul sunt destul de mici. Algoritmul numai, care necesit o sum substanial de memorie este D *

Figura 6-16 Cerine globale de memorie pentru fiecare algoritm

7. Concluzii Teza discut aspectele practice ale algoritmilor concepui pentru a rezolva problemele de navigare robotizate. apte algoritmi au fost selectai pentru studiu: bug1, bug2, alg1, alg2, distbug, tangentbug i D *. Aceti algoritmi au fost pui n aplicare cu ajutorul simulatorului Eyesim. Punerea n aplicare a fost modular i mai multe module comune au fost identificate i puse n aplicare separat. O dat ce modulele au fost gata, fiecare algoritm de navigare a fost pus n aplicare separat apelnd modulele comune de a conduce vehiculele. Excepie de la acest lucru este D *, radical diferit de celelalte. Au aprut mai multe probleme de punere n aplicare. n primul rnd, exist problema de verificare a condiiilor de navigare. Tangentbug i D * s-au comportat bine, din cauza naturii lor proactive. n al doilea rnd, exist problema razei de ocolire la puncte anterioare. Tangentbug i D * s-au dovedit cele mai bune pentru acest aspect pentru c au mecanisme intrinseci spre a evita problema. n al treilea rnd, la Tangentbug persist o problem de identificare a discontinuitii atunci cnd este aproape de perei. n al patrulea rnd, D * are o problem n cazul n care celulele sale nu sunt n msur s acopere ntreaga hart. n cele din urm, n termeni de costuri hardware, bug1 i bug2 sunt mai ieftini, deoarece necesit doar senzori tactili. Trei harti au fost create pentru a testa algoritmii pui n aplicare. Fiecare harta testeaz un alt aspect de navigare. Map1 a testat capacitatea unui algoritm de a naviga ntr-un spaiu nchis. Map2 a testat capacitatea unui algoritm de a naviga ntr-un mediu n aer liber. Map3 a testat algoritmii prin capacitatea de a naviga n afara-unui minim local.

Zece teste au fost executate pentru fiecare algoritm de pe fiecare hart. Rezultatele au fost generate pentru lungime de cale, rotaie, rotaie inerente, timpul de calcul, timpul de calcul pe metru, apelurile la funcii matematice, robustee, simplitate i cerine de memorie. Tabelul 7-1 prezint parametrii de performan relativ a fiecrei algoritm pentru fiecare atribut. Acetia au fost calculai mediind ordinea de clasare a algoritmilor aferent celor 3 hri. Prin urmare, un scor mai mic nseamn o performan mai bun.

Tabelul 7-1. Parametrii de performan reevaluati pentru fiecare algoritm

Tabelul 7-1 arat n mod clar punctele forte dominante la algoritmi diferii. Pentru lungime de cale i rotaie, tangentbug i D * sunt n mod clar cei mai performanti. Pentru timp de calcul, bug1 i bug2 sunt cele mai ieftine; dar surprinztor, tangentbug i D * sunt foarte competitive. Pentru robusteea, D * este algoritmul singurul care posed n mod inerent acest lucru. Pentru simplitate i Cerinele de memorie, bug1 i bug2 sunt n mod clar cei mai buni. Folosind aceste constatri, o metod/strategie de selecie poate fi conceput pentru a selecta algoritmul care se potriveste cel mai bine cerinelor utilizatorului. Figura 7-1 prezint o astfel de posibil strategie. De reinut c aceast Politic de selecie este ajutat de cunotine de tip hart. Strict vorbind, tipul de hart nu ar trebui cunoscut nainte de execuie. Cu toate acestea, n cazul n care aceast cunoatere este disponibil, acesta poate ajuta la luarea deciziilor.

Figura 7-1. O posibil strategie de selecie bazat pe tabelul 7-1

8. mbuntiri viitoare 8.1 Ierarhizarea algoritmilor de bug-uri n prezent, algoritmii de bug au grade de libertate nelimitate i nu au o structura de tip reea. Ar fi interesant pentru a investiga algoritmi de bug pe o gril de tip D *. Acest lucru ar trebui s oferi o mai mare robustee n detrimentul unei ci mai lungi i a cerinelor mai mari de memorie. 8.2 Localizare Luarea n considerare a cauzelor de localizare false, duce la non-robustee mpotriva erorilor de conducere. Dei acest lucru poate fi mascat de eantionrile multiple, cel mai bun mod de a depi eroarea este feedback. O form posibil de feedback este recunoaterea punctelor de reper prin imagini ale unei camere-foto. Dac se utilizeaz aa ceva, trebuie s scris un modul de procesare de imagini. Unele tehnici pentru aceasta exist deja n literatura de specialitate *11+ i pot fi ncorporate n versiunile viitoare. O alt form de feedback ar putea fi utilizarea tehnicii de reea senzor de interaciune pentru localizare [12, 13]. n aceste modele, o reea de senzori este ncorporat n mediu i acioneaz sub forma indicatoarelor de direcie pentru robot. O mbuntire nregistrat n domeniul tehnologiei radio a facut, de asemenea, posibil s se msoare doar distana dintre balize i robot *14+. Linia de vizare nu este necesar, iar costurile sunt semnificativ mai mici dect sistemele de senzori convenionale.

Dezavantajul reelelor de senzori priveaz ns robotul de autonomie real. Dar reeaua de senzori e necesar pentru navigare. Argumentul contra este c oamenii, care sunt , n general, considerai a fi autonomi, se bazeaz de asemenea, pe indicatoare la intrarea ntr-un mediu necunoscut, pentru prima dat. ntr-adevr, cele mai multe cldiri publice afieaz numere de camer i panouri de semnalizare la grupuri sanitare, cantin etc ... O mbuntire ar putea implica un robot care utilizeaz reeaua de senzori. Cu toate acestea, n cazul n care nu exist reea cu senzori, se revine la puncte de reper, recunoaterea cu camera/aparatul de fotografiat. 8.3 mbuntiri la D * Parametri algoritmului D * pot fi, de asemenea, investigai n continuare pentru a produce o performan mai bun. Dimensiunea celulei este un factor foarte important prin impactul asupra resurselor de calcul. Structura celulelor poate fi modificat i efectele investigate. Figura 8-1 prezint o celul de structura compus din triunghiuri n loc de patrate. La D *, de asemenea, e nevoie de soluie la problema discutat n seciunea 4.3.5 privind reelele de mici, cnd nu se gsete o cale optim. Alocare dinamic de celule ar putea fi o soluie posibil

Figura 8-1 n loc de utilizarea patratelor, la D * s-ar putea utiliza triunghiuri

8.4 Robot de nvare Un alt domeniu care poate fi mbuntit este cel de nvare pentru robot. n cazul n care robotul a traversat traseul nainte, este posibil s pstreze unele date i s mbunteasc performanele la un parcurs ulterior. De exemplu, n cazul n care robot a folosit Alg1 sau Alg2, s-ar putea reine structura de date- spre a o mbunti la parcursurile ulterioare. 8.5 Toleran la deranjamente O alt mbuntire ar putea fi s pun n aplicare tolerana la erori n timpul navigrii. Aceast implementare particular, a fost programat fr a lua n considerare posibilitatea de eroare. n viitor, tehnicile tolerante la eroare ar putea fi incluse pentru a oferi un grad mai mare de securitate. De exemplu, tripla redundan modular cu un selector poate fi folosit la senzori/ PSDs spre a media erorile. O busol, un giroscop sau, n aer liber chiar i GPS, pot fi utilizate pentru a reduce eroarea de rotaie. 8.6 mbuntire Tangentbug

S-ar putea, de asemenea, aduce o mbuntire algoritmului tangentbug. Considernd iniial calculul efectuat pe map2 n conformitate cu algoritmul tangentbug, robotul a parcurs traseul la node1 deoarece node1 este mai aproape de inta dect node2. Cu toate acestea, figura 5-2 arat c calea mai scurt este n direcia de node2. Singurul indiciu c modulului Node2 produce o cale mai scurt dect node1 este citirea PSD, semnalizat cu rou n figura 9-2.

Figura 9-2. Tangentbug poate fi mbuntit dac se alege node2 peste node1 Tangentbug poate fi de asemenea mbuntit lund n considerare costuriel de teren, similar cu D *. Ceea ce ar fi relativ dificil deoarece nu are implementat prin cod niciun criteriu de cost.. 8.7 Clasificare a hrilor O anumit form de clasificare cantitativ pentru hart ar putea fi, de asemenea, proiectat. n acest studiu, termenii de minim nchis, deschise i local au fost folosite pentru a clasifica n prim faz map1, map2 i respectiv map3. Totui, aceasta a fost o clasificare subiectiv i nu a avut vreo baz obiectiv. O modalitate posibil ar putea exista prin conceptul de cale securizat/sigur, introdus de Kamon i Rivlin [6] n cazul n care se determin distana medie a acestuia de la cel mai apropiat obstacol. Ar fi de ateptat c hrile nchise s aibe o calea securizat mai mic dect hrile deschise.