SYSTÉMOVÁ PRÍRUČKA - TUKE

TECHNICKÁ UNIVERZITA V KOŠICIACH 

FAKULTA ELEKTROTECHNIKY A INFORMATIKY 

Katedra kybernetiky a umelej inteligencie 

Centrum pre inteligentné technológie 

SYSTÉMOVÁ PRÍRUČKA 

Vedúci diplomovej práce: 

Mária Virčíková 

Košice 2010 

Prof. Ing. Peter Sinčák, PhD.

KKUI FEI 

Obsah 

Obsah ................................................................................................................................ 2 

Zoznam obrázkov ............................................................................................................. 3 

1 Funkcia programu .......................................................................................................... 4 

2 Analýza riešenia ............................................................................................................. 5 

2.1 Jazyk Python ........................................................................................................... 5 

2.2 Jazyk C++ ............................................................................................................... 6 

2.3 Časti navrhnutého systému .................................................................................... 6 

3 Popis funkcií tried programu a výpis častí zdrojových kódov niektorých z nich .......... 7 

3.1 Evolučný algoritmus ............................................................................................... 7 

3.1.1 Selekcia ............................................................................................................ 8 

3.1.2 Kríženie ............................................................................................................ 8 

3.1.3 Mutácia ............................................................................................................ 9 

3.1.4 Vytvorenie novej generácie ........................................................................... 10 

3.2 GUI ....................................................................................................................... 10 

3.2.1 Hlavná funkcia programu .............................................................................. 11 

3.2.2 Vytvorenie hodnotiacej tabuľky .................................................................... 12 

3.2.3 Uloženie hodnôt fitness priradených užívateľom .......................................... 13 

3.2.4 Načítanie súboru s fenotypom ....................................................................... 13 

3.2.5 Zápis fenotypov všetkých tancov do súboru .................................................. 13 

3.2.6 Zápis fenotypov jednotlivých tancov do súboru ............................................ 14 

3.2.7 Normalizácia hodnôt fenotypu ....................................................................... 15 

3.2.8 Vytvorenie počiatočnej populácie ................................................................. 15 

3.2.9 Prevedenie fenotypu do binárnej formy ......................................................... 15 

3.3 Modelovanie robotov a ich prostredia .................................................................. 17 

3.3 Prevedenie tanca ................................................................................................... 20 

3.4 Simulátor Choreographe ....................................................................................... 33 

4 Preklad programu ......................................................................................................... 35 

4.1 Požiadavky na technické prostriedky ................................................................... 35 

4.2 Požiadavky na programové prostriedky ............................................................... 35 

4.3 Technické pozadie ................................................................................................ 36 

5. Zhodnotenie riešenia ................................................................................................... 37 

Príloha D: Systémová príručka 2

KKUI FEI 

Zoznam obrázkov 

Obr. 1 Genetický algoritmus systému, ktorý bol realizovaný v jazyku v Python: schéma 

jednotlivých časti algoritmu .............................................................................................. 7 

Obr. 2 Trieda evolúcia a jej funkcie ................................................................................. 8 

Obr. 3 Súbor pre tvorenie GUI (grafické užívateľské prostredie) a funkcie .................. 11 

Obr. 4 Hodnotiaca tabuľka.............................................................................................. 12 

Obr. 5 Model prostredia robotov ................................................................................... 17 


KKUI FEI 

1 Funkcia programu 

Uvedený programový systém predstavuje implementáciu interaktívneho genetického 

algoritmu pre generovanie tanca robota Naa. 

Tvorenie a navrhovanie tanečných choreografií patrí medzi aplikácie, u 

ktorých je veľmi ťažké, niekedy nemožné hodnotiace funkcie vyjadriť numericky – 

alebo aspoň kvantitatívne. Nevieme špecifikovať optimalizačné parametre procesu, 

pretože kritériá pri takýchto systémoch sú subjektívne, to znamená, že sú závislé od 

konkrétneho posudzovateľa. Výstupy takého systému závisia od preferencií, zmyslov, 

emócií a porozumení človeka. V interaktívnych evolučných výpočtoch je funkcia 

vhodnosti nahradená ľudským užívateľom. 

Implementácia zahŕňa používateľské rozhranie, ktoré umožňuje: 

Proces interaktívnej evolúcie tanečných sekvencií, kde užívateľ predstavuje 

dôležitý faktor ovplyvňujúci budúce generácie tancov. Interaktívny genetický 

algoritmus je optimalizačný nástroj, ktorý využíva kooperáciu človeka a počítača, to 

znamená, že systém sa vyvíja na základe hodnotenia, ktoré predstavuje subjektívne 

hodnotenie získané od človeka (funkcia vhodnosti) ako hodnotenie vzdialenosti medzi 

vlastnou predstavou a výstupom optimalizačného procesu v psychologickom priestore. 


KKUI FEI 

2 Analýza riešenia 

Teoretický základ riešenia a jeho základný framework je popísaný v hlavnej časti 

diplomovej práce. 

2.1 Jazyk Python 

Evolučný algoritmus bol riešený v programovacom jazyku Python. 

Niektoré vlastnosti jazyka Python sú: 

- interpretovaný, 

- interaktívny, 

- objektovo–orientovaný, 

- dynamicky napísaný, 

- flexibilný, 

- expresívny, 

- dobre čitateľný 

- podpora viac programovacích paradigiem – možné použitie 

procedurálneho, funkčného a objektovo–orientovaného programovania 

Viacero výhod hovorilo pre jeho použitie, stačí spomenúť nasledujúce výhody: 

- prehľadnosť zdrojových kódov – elegantná syntax, 

- existujúce podporné knižnice, 

- rýchlu krivku implementácie, 

- ľahko sa učí, 

- vhodný na veľké projekty, 

- prostredie, 

- jazyk k dispozícii ako Open Source, 

- veľké množstvo dostupných vývojových prostredí, 

- veľmi dobre zdokumentované triedy a metódy s dostupným množstvom 

konzultácii a ukážkových zdrojových kódov, 

- veľká komunita ľudí, ktorí sa tomuto jazyku venujú, 

- jeho dobrá podpora u najpopulárnejších operačných systémov. 


KKUI FEI 

2.2 Jazyk C++ 

Realizácia tanca bola riešená priamo v simulátore Webots, ktorý je popísaný v hlavnej 

časti diplomovej práce. Použitý programovací jazyk bol C++. 

V porovnaní z jazykom C, C++ prináša nové vlastnosti, vrátane deklarácii, 

pretypovanie so syntaxou funkcií, new/delete, bool, referencie, inline funkcie, 

implicitné argumenty, preťaženie funkcií, priestory mien, triedy (zo všetkými ich črtami 

ako dedičnosť, členské funkcie, virtuálne funkcie, abstraktné triedy a konštruktory), 

preťaženie operátorov, atď. 

2.3 Časti navrhnutého systému 

Navrhnutý systém robotického tanca sa skladá z dvoch častí. 

1) Prvá časť predstavuje samotný evolučný algoritmus, ktorý je napísaný 

v jazyku Python a výstupom z neho je chromozóm obsahujúci nastavenie 

jednotlivých kĺbov robota. 

2) Druhá časť riešenia návrhu je realizovaná v simulačnom prostredí 

Webots, ktorého podrobnejší popis je uvedený v podkapitole 4.3. 

Výsledný tanec je ukázaný pre sedem robotov, ktorých sekvencia 

tanečných krokov predstavuje sedem najlepších jedincov z evolúcie. 

Celkový postup riešenia je možné zhrnúť do týchto bodov: 

1. implementácia genetického algoritmu, 

2. realizácia simulátora robotov, 

3. realizácia experimentov 


KKUI FEI 

3 Popis funkcií tried programu a výpis častí zdrojových 

kódov niektorých z nich 

3.1 Evolučný algoritmus 

Schéma evolučného algoritmu je na Obr. 1: 

Obr. 1 Genetický algoritmus systému, ktorý bol realizovaný v jazyku v Python: schéma 

jednotlivých časti algoritmu 

Samotný zdrojový kód sa skladá z funkcií, ktoré sú časťami predchádzajúcej 

schémy. Evolučný algoritmus je súbor pod názvom evolution.py. 

Trieda evolúcia class Evolucia je zložená zo šiestich funkcií (Obr. 2): 


KKUI FEI 

3.1.1 Selekcia 

Obr. 2 Trieda evolúcia a jej funkcie 

Vyberieme dvoch náhodných jedincov z populácie a porovnáme ich fitness. Jedinec, 

ktorý má z tejto dvojice vyššiu fitness, vyhráva a stáva sa rodičom. Táto metóda, ako je 

uvedené v hlavnej časti diplomovej práce sa volá binárny turnaj. 

3.1.2 Kríženie 

def selection1(self): 

a = random.randrange(0,len(self.parents),1) 

b = random.randrange(0,len(self.parents),1) 

if self.fitnes[a]>self.fitnes[b]: 

else: 

parent1 = self.parents[a] 

parent1 = self.parents[b] 

return parent1 

def selection(self): 

parent1 = self.selection1() 

parent2 = self.selection1() 

return [parent1, parent2] 

Vytvorí sa maska, čo je vlastne reťazec rovnakej dĺžky ako chromozóm. Na každom 

bite v maske je náhodne generovaná nula alebo jednotka. Jedinec sa vyberá nasledovne: 


KKUI FEI 

- Ak je na príslušnom bite v maske 0, vyberá bit z prvého jedinca. 

- Ak je v maske 1, zoberie sa bit z druhého jedinca. 

Takýto spôsob kríženia sa nazýva uniformné. 

3.1.3 Mutácia 

def crossover(self): 

i = 0 

newparents = self.selection() 

uniMaska = [] 

while (i < self.dlzka): 

i = 0 

a = random.randrange(0,2,1) 

uniMaska.append(a) 

i = i + 1 

child = [] 

for i in range(0,self.dlzka): 

if (uniMaska[i] == 0): 

else: 

return child 

child.append(newparents[0][i]) 

child.append(newparents[1][i]) 

Mutácia je nastavená na 80 percent, to znamená, že toľko jedincov po krížení sa 

zmutuje, ale len v malom okolí toho génu, ktoré je nastavené na 10 percent. 

def mutate(self,children): 

prav_mutacie=80 

for i in range(0,len(children)): 

a = random.randrange(0,100,1) 

if prav_mutacie > a : 

for j in range(0,self.dlzka): 

b=random.uniform(-10,10) 

hodnota=children[i][j]+b 

children[i][j]=hodnota 

if hodnota >1: 

children[i][j]=1.0 

if hodnota < 0: 


KKUI FEI 

return children 

3.1.4 Vytvorenie novej generácie 

3.2 GUI 

def makeChildren(self): 

self.children=[] 

children[i][j]=0.0 

for i in range(0,self.velkost_pop): 

self.children.append(self.crossover()) 

# print self.children 

def createNewPop(self): 

self.makeChildren() 

self.newPopCrossed = [] 

self.newPop = [] 

i = 0 

for i in range(0,len(self.parents)): 

# print a 

a = random.randrange(0,len(self.parents),1) 

x = random.randrange(0,2,1) 

if x == 1: 

else: 

self.newPopCrossed.append(self.children[a]) 

self.newPopCrossed.append(self.parents[a]) 

self.newPop = self.mutate(self.newPopCrossed) 

return self.newPop 

Vytvorenie grafického užívateľského rozhrania je súbor pod názvom gui.py. 

Gui.py obsahuje nasledujúce funkcie (Obr. 3): 


KKUI FEI 

Obr. 3 Súbor pre tvorenie GUI (grafické užívateľské prostredie) a funkcie 

3.2.1 Hlavná funkcia programu 

Keď užívateľ stlačí tlačidlo evolution na hodnotiacej tabuľke, ktorá na obrázku „Obr. 

4“, spustí sa funkcia evol_callback. 

Načítajú sa vhodnosti, ktoré užívateľ priradil jedincom, potom sú chromozómy 

znormované a zapísané do súborov. 

def evol_callback(): 

print 'Old Generation:' 

print initial_pop 

fitnes = fitness(f1,f2,f3,f4,f5,f6,f7) 

parents = chrom2parents() 

print 'New - After Evolution:' 

call = evolution.Evolucia(parents, fitnes).createNewPop() 

jedinci=parents2chrom(call) 

krok = 0 

for i in jedinci: 

krok = krok + 1; 

print 'gen = ' 

print krok 

print i 

zapisAllgene(jedinci) 

zapisEachgene(jedinci) 


KKUI FEI 

3.2.2 Vytvorenie hodnotiacej tabuľky 

Tabuľka, na ktorej užívateľ hodnotí predvedené tance robotov, sa skladá z 

- 1) farebných rámov, na základe ktorých vie, robota akej farby hodnotí a 

- 2) z radiobuttunov, kde im priradí známky od 1 do 5. 

Príklad zdrojových kódov jednotlivých častí: 

1) 

frame0 = Tkinter.Frame(root, 

background="white",borderwidth=5,height=800,width=500) 

frame0.grid(column=0,row=0) 

frame0.pack(side=TOP,expand=NO) 

2) 

Radiobutton(frame1, text='1',font=('times', 12), variable=f1, 

anchor=SW, fill = 'y') 

value=3, background="white").pack(side=LEFT, 

Obr. 4 Hodnotiaca tabuľka 


KKUI FEI 

3.2.3 Uloženie hodnôt fitness priradených užívateľom 

Z hodnotiacej tabuľky sa vyberú priradené hodnoty fitness a uložia sa do premenných. 

def fitness(f1,f2,f3,f4,f5,f6,f7): 

fitnes=[f1.get(),f2.get(),f3.get(),f4.get(),f5.get(),f6.get() 

,f7.get()] 

return fitnes 

3.2.4 Načítanie súboru s fenotypom 

def nacitajGene(): 

nazov='C:\Program 

Files\Webots\projects\contests\\nao_robocup\controllers\\nao_ 

soccer_player_blue\\all_gene.csv' 

a=open(nazov) 

k=a.read() 

a.close() 

zoznam2 = k.split("\n") 

zoznam3=[] 

for i in zoznam2: 

zoznam3.append(i.split(",")) 

zoznam5=[] 

index=0 

for riadok in zoznam3: 

zoznam4=[] 

for clen in riadok: 

zoznam4.append(int(clen)) 

zoznam5 = zoznam5 + [0] 

zoznam5[index] = zoznam4 

index=index+1 

return zoznam5 

3.2.5 Zápis fenotypov všetkých tancov do súboru 

def zapisAllgene(jedinci): 


KKUI FEI 

myfile='C:\Program 

Files\Webots\projects\contests\\nao_robocup\controllers\\nao_ 

soccer_player_blue\\all_gene.csv' 

file = open(myfile,"w") 

krok1=0 

for i in jedinci: 

krok=0 

for j in i: 

if krok

KKUI FEI 

3.2.7 Normalizácia hodnôt fenotypu 

Je dôležité znormalizovať hodnoty fenotypu, ktoré predstavujú hodnoty rozpätia kĺbov 

robota Naa, pretože každý kĺb má iné možné rozpätie udané v uhloch. 

def normalize(x,a1,a2,b1,b2): 

return (float(b1) + ((float(x) - float(a1)) * (float(b2) 

- float(b1))/(float(a2)-float(a1)))) 

def normalize2(x,a1,a2,b1,b2): 

return int(float(b1) + ((float(x) - float(a1)) * 

(float(b2) - float(b1))/(float(a2)-float(a1)))) 

3.2.8 Vytvorenie počiatočnej populácie 

def initial(): 

for i in range(0,velkost_pop): 

initial_pop.append([random.uniform(0,1)]) 

for j in range(0, dlzkajedinca-1): 

return initial_pop 

initial_pop[i].append(random.uniform(0,1)) 

3.2.9 Prevedenie fenotypu do binárnej formy 

def chrom2parents(): 

chromosome = nacitajGene() 

parents = chromosome 

for i in range(0,len(parents)): 

120,120,0.0,1.0) 

45,45,0.0,1.0) 

for j in range(0, dlzkajedinca): 

if j == 0 or j == 10: 

parents[i][j] = normalize(chromosome[i][j],- 

if j == 1 or j == 11: 


if j == 2 or j == 12: 


KKUI FEI 

120,120,0.0,1.0) 


if j == 3 or j == 13: 

parents[i][j] = 

normalize(chromosome[i][j],0,95,0.0,1.0) 

120,120,0.0,1.0) 

90,0,0.0,1.0) 

120,120,0.0,1.0) 

95,0,0.0,1.0) 

120,120,0.0,1.0) 

if j == 4 or j == 14: 


if j == 5 or j == 15: 


if j == 6 or j == 16: 


if j == 7 or j == 17: 


if j == 8 or j == 18: 


if j == 9 or j == 19: 

parents[i][j] = 

normalize(chromosome[i][j],0,90,0.0,1.0) 

return parents 


KKUI FEI 

3.3 Modelovanie robotov a ich prostredia 

#VRML_SIM V6.0 utf8 

WorldInfo { 

} 

info [ 

] 

Obr. 5 Model prostredia robotov 

"Simulation of Robotic Dance" 

"Author: Maria Vircikova" 

"Webpage: http://neuron.tuke.sk/~maria.vircik" 

"Last modification: May, 1, 2010" 

title "Robotdance" 

basicTimeStep 40 

runRealTime TRUE 

Viewpoint { 

} 

fieldOfView 1.2755 

orientation -0.0965735 0.971364 0.217084 2.33838 

position 2.24403 1.47012 -2.34318 

Background { 

skyColor [ 


KKUI FEI 

} 

] 

0.760784 0.894118 0.996078 

DirectionalLight { 

} 

ambientIntensity 1.6 

direction -0.5 -2 -0.5 

intensity 0.3 

castShadows TRUE 

DirectionalLight { 

} 

ambientIntensity 1.6 

direction 0.5 -0.5 0.5 

intensity 0.5 

SoccerField { 

} 

DEF RED_PLAYER NaoV3R { 

} 

translation 0.698051 0.333275 0.139582 

rotation -0.0034669 0.999992 0.0020113 1.56118 

color 1 0 0 

channel 1 

texture [ 

] 

"textures/button_red.png" 

controller "nao_soccer_player_blue" 

controllerArgs "-p 54100" 

synchronization FALSE 

name "Red Nao" 

windowPosition 0 1 

DEF GREEN_PLAYER NaoV3R { 

translation 0.468576 0.33345 -1.84979 

rotation -0.00903998 0.999916 0.00932435 1.57664 

color 0 1 0 

texture [ 

] 

"textures/button_green.png" 




name "Green Nao" 


KKUI FEI 

} 

DEF PURPLE_PLAYER NaoV3R { 

} 

translation 0.995693 0.33317 -0.899636 

rotation -0.00596175 0.999957 0.00715972 1.56125 

color 0.501961 0 1 

texture [ 

] 

"textures/button_purple.png" 




name "Purple Nao" 

DEF YELLOW_PLAYER NaoV3R { 

} 

translation 0.297939 0.333264 -1.00003 

rotation -0.00307572 0.999991 0.00287274 1.5788 

color 1 1 0 

texture [ 

] 

"textures/button_yellow.png" 




name "Yellow Nao" 

DEF MAGENTA_PLAYER NaoV3R { 

} 

translation -0.00180376 0.333257 -0.000237291 

rotation -0.00309718 0.999992 0.0023397 1.57889 

color 1 0.501961 0.752941 

texture [ 

] 

"textures/button_magenta.png" 




name "Magenta Nao" 

DEF BLUE_PLAYER NaoV3R { 

translation -0.201804 0.333317 -1.30072 

rotation -0.00351928 0.999993 0.000959317 1.57746 



KKUI FEI 

} 



name "Blue Nao" 

DEF BLUE_ORANGE NaoV3R { 

} 

translation 1.3982 0.333257 -0.20024 

rotation -0.00312027 0.999992 0.00234169 1.57011 

color 1 0.5 0 

texture [ 

] 

"textures/button_orange.png" 




name "Orange Nao" 

3.3 Prevedenie tanca 

Zdrojový kód obsahuje komentáre, ktoré by mali uľahčiť orientáciu v ňom prípadným 

vývojárom. 

#include "GoalKeeper.hpp" 

#include "NaoCam.hpp" 

//using webots hpp files for inicialization of Servos 

#include 

#include 

#include 

// header file which is used for input/output 

#include 

using std::cerr; 

using std::cout; 

using std::endl; 

// header file for exit function 

#include 


KKUI FEI 

// time header 

#include 

// to read from files 

#include 

using std::ifstream; 

// webots namespace 

using namespace webots; 

//inicialization of variables 

const int SIMULATION_STEP = 200; 

int numheadYaw; 

int numHeadPitch; 

int numleftShoulderPitch; 

int numleftShoulderRoll; 

int numleftElbowYaw; 

int numleftElbowRoll; 

int numrightShoulderPitch; 

int numrightShoulderRoll; 

int numrightElbowYaw; 

int numrightElbowRoll; 

int numheadYaw2; 

int numHeadPitch2; 

int numleftShoulderPitch2; 

int numleftShoulderRoll2; 

int numleftElbowYaw2; 

int numleftElbowRoll2; 

int numrightShoulderPitch2; 

int numrightShoulderRoll2; 

int numrightElbowYaw2; 

int numrightElbowRoll2; 

GoalKeeper::GoalKeeper(int playerID) : Player(playerID) { 

rightStepsCount = 0; 

// load motions 


KKUI FEI 

backwardsMotion = new 

Motion("../motions/Backwards.motion"); 

forwards50Motion = new 

Motion("../motions/Forwards50.motion"); 

sideStepRightMotion = new 

Motion("../motions/SideStepRight.motion"); 

sideStepLeftMotion = new 

Motion("../motions/SideStepLeft.motion"); 

} 

GoalKeeper::~GoalKeeper() { 

} 

delete forwards50Motion; 

delete backwardsMotion; 

delete sideStepLeftMotion; 

delete sideStepRightMotion; 

void GoalKeeper::stepRight() { 

} 

playMotion(sideStepRightMotion); 

rightStepsCount++; 

void GoalKeeper::stepLeft() { 

} 

playMotion(sideStepLeftMotion); 

rightStepsCount--; 

//"main function" 

void GoalKeeper::run() 

{ 

srand((unsigned)time(0)); 

//const int STEP = 100; 

for(int i = 1; i < SIMULATION_STEP; i++) 

{ 

//enabling the Servos (motors used for our motion) 

Servo *HeadYaw = getServo("HeadYaw"); 

Servo *HeadPitch = getServo("HeadPitch"); 


KKUI FEI 

Servo *leftShoulderPitch = getServo("LShoulderPitch"); 

Servo *rightShoulderPitch = getServo("RShoulderPitch"); 

Servo *leftShoulderRoll = getServo("LShoulderRoll"); 

Servo *rightShoulderRoll = getServo("RShoulderRoll"); 

Servo *leftElbowYaw = getServo("LElbowYaw"); 

Servo *rightElbowYaw = getServo("RElbowYaw"); 

Servo *leftElbowRoll = getServo("LElbowRoll"); 

Servo *rightElbowRoll = getServo("RElbowRoll"); 

//this we now dont use, we can comment this part of code 

/*Servo *leftHipRoll = getServo("LHipRoll"); 

Servo *rightHipRoll = getServo("RHipRoll"); 

Servo *leftHipPitch = getServo("LHipPitch"); 

Servo *rightHipPitch = getServo("RHipPitch"); 

Servo *leftKneePitch = getServo("LKneePitch"); 

Servo *rightKneePitch = getServo("RKneePitch"); 

Servo *leftAnklePitch = getServo("LAnklePitch"); 

Servo *rightAnklePitch = getServo("RAnklePitch"); 

Servo *leftHipYawPitch = getServo("LHipYawPitch"); 

Servo *rightHipYawitch = getServo("RHipYawPitch");*/ 

//every robot has its name 

const std::string robot_name = getName(); 

//ifstream provides an interface to read data from files as 

input streams. 

ifstream inFile; 

// every robot opens his file - for orange robot: 

if (robot_name == "Orange Nao") 

{ 

// opening the file 

inFile.open("gene1.csv"); 


KKUI FEI 

} 

// red Nao opening his file 

if (robot_name == "Red Nao") 

} 

{ 

{ 


// magenta Nao opening his file 

if (robot_name == "Magenta Nao") 


} 

// purple Nao opening his file 

if (robot_name == "Purple Nao") 

{ 


} 

// yellow Nao opening his file 

if (robot_name == "Yellow Nao") 

{ 


} 

// blue Nao opening his file 

{ 

if (robot_name == "Blue Nao") 


} 

// green Nao opening his file 

{ 

if (robot_name == "Green Nao") 


} 

// if some file cant be read 

if (inFile.fail()) { 

cerr

KKUI FEI 

} 

exit(1); 

// move to the start of the file 

inFile.seekg(0, ios::beg); 

inFile >> numheadYaw ; 

// forget we hit the end of file 

inFile.clear(); 

// move to the 1st position (2nd number) of the file 


inFile >> numHeadPitch ; 



// move to the 2nd position (3nd number) of the file 


inFile >> numleftShoulderPitch; 



// move to the 3rd position (4th number) of the file 


inFile >> numleftShoulderRoll ; 



// move to the 4th position (5th number) of the file 


inFile >> numleftElbowYaw ; 





inFile >> numleftElbowRoll; 






KKUI FEI 

inFile >> numrightShoulderPitch ; 





inFile >> numrightShoulderRoll ; 





inFile >> numrightElbowYaw ; 





inFile >> numrightElbowRoll ; 





inFile >> numheadYaw2 ; 





inFile >> numHeadPitch2 ; 





inFile >> numleftShoulderPitch2; 



KKUI FEI 




inFile >> numleftShoulderRoll2 ; 





inFile >> numleftElbowYaw2 ; 





inFile >> numleftElbowRoll2; 





inFile >> numrightShoulderPitch2 ; 





inFile >> numrightShoulderRoll2 ; 





inFile >> numrightElbowYaw2 ; 






KKUI FEI 

inFile >> numrightElbowRoll2 ; 



// closing the file 

inFile.close(); 

//here we start the simulation of dance 

// every number in file is a part of fenotype of each robot 

// it means position in angles of each servo 

//first position for head yaw servo 

HeadYaw->setPosition(numheadYaw); 

step(SIMULATION_STEP); 

//first position for head pitch servo 

HeadPitch->setPosition(numHeadPitch); 


HeadYaw->setPosition(0); 

HeadPitch-> setPosition(0); 

//first position for left shoulder pitch servo 

leftShoulderPitch->setPosition(numleftShoulderPitch); 


leftShoulderPitch->setPosition(0); 

//first position for left shoulder roll servo 

leftShoulderRoll->setPosition(numleftShoulderRoll); 


leftShoulderRoll->setPosition(0); 

//first position for left elbow yaw servo 

leftElbowYaw->setPosition(numleftElbowYaw); 


KKUI FEI 


//first position for left elbow row servo 

leftElbowRoll->setPosition(numleftElbowRoll); 


leftElbowRoll->setPosition(0); 

//first position for right shoulder pitch servo 

rightShoulderPitch->setPosition(numrightShoulderPitch); 


rightShoulderPitch->setPosition(0); 

//first position for right shoulder roll servo 

rightShoulderRoll->setPosition(numrightShoulderRoll); 


//first position for right elbow yaw servo 

rightElbowYaw->setPosition(numrightElbowYaw); 


rightElbowYaw->setPosition(0); 

//first position for right elbow roll servo 

rightElbowRoll->setPosition(numrightElbowRoll); 

//new step of simulation 


//second position for head yaw servo 

HeadYaw->setPosition(numheadYaw2); 

//inicialize position of servo (set to 0) 

HeadPitch->setPosition(0); 



KKUI FEI 





leftElbowYaw->setPosition(0); 






rightShoulderRoll->setPosition(0); 




rightElbowRoll->setPosition(0); 



//second position for head yaw servo 

HeadYaw->setPosition(0); 

//second position for head pitch servo 

HeadPitch->setPosition(numHeadPitch2); 






leftElbowYaw->setPosition(0); 


KKUI FEI 










rightElbowRoll->setPosition(0); 



HeadPitch->setPosition(0); 

leftShoulderPitch->setPosition(numleftShoulderPitch2); 

//second position for right shoulder pitch servo 

rightShoulderPitch->setPosition(numrightShoulderPitch2); 






//second position for left shoulder roll servo 

leftShoulderRoll->setPosition(numleftShoulderRoll2); 

//second position for right shoulder roll servo 

rightShoulderRoll->setPosition(numrightShoulderRoll2); 




KKUI FEI 


//second position for left elbow yaw servo 

leftElbowYaw->setPosition(numleftElbowYaw2); 

//second position for left elbow roll servo 

leftElbowRoll->setPosition(numleftElbowRoll2); 

//second position for right elbow yaw servo 

rightElbowYaw->setPosition(numrightElbowYaw2); 

//second position for right elbow roll servo 

rightElbowRoll->setPosition(numrightElbowRoll2); 


//second position for left shoulder pitch servo 

leftShoulderPitch->setPosition(numleftShoulderPitch); 

rightShoulderPitch->setPosition(numleftShoulderPitch); 



leftShoulderPitch->setPosition(numleftShoulderPitch2); 

rightShoulderPitch->setPosition(numleftShoulderPitch2); 

} 

} 



KKUI FEI 

3.4 Simulátor Choreographe 

Pohyb som najprv skúšala implementovať v prostredí Choreographe, ale nevýhoda 

tohto simulátora je, že obsahuje iba model jedného robota. 

Choreographe je simulátor, ktorý bol priamo navrhnutý a vyvinutý v Aldebaran 

Robotics (http://www.aldebaran– robotics.com/en/programmable). Choregraphe je programovací 

softvér, ktorý umožňuje používateľom Naa jednoducho vytvárať a upravovať pohyb a 

interaktívne správanie. Intuitívne grafické rozhranie a knižnice, pomocou ktorých sa 

ľahko naprogramuje správanie robota sú vhodné pre začiatočníkov aj expertov. 

Choregraphe má zabudovaný jazyk Urbi, C+ + a Python. Choregraphe je multi– 

platformový a môže byť ľahko integrovaný do užívateľovho vývojového prostredia, je 

kompatibilný s operačnými systémami Windows, Mac OS aj Linux. 

Podľa Aldebaran Robotics 1 jadrom Naovej inteligencie je NaoQi – modul, ktorý 

v priebehu pár sekúnd registruje každé zariadenie možné nájsť v robotovi, vrátane 

motorov, svetelných diód a podobne. 

NaoQi umožňuje dva spôsoby prepojenia zdrojového kódu: 

1) Zadaním pokynu NaoQi na načítanie vlastných dynamických knižníc. 

2) Napísaním kódu, ktorý sprostredkuje registrovanie vlastných modulov a 

interakciu s NaoQi systémom cez TCP/IP. 

NaoQi obsahuje rôzne knižnice – napríklad na prepojenie so senzormi (pomocou 

ALMemory) alebo riadenie motorov (ALMotion). 

Použitím knižnice ALMotion sa pohyb môže simulovať nasledovne: 

Na úvod inicializujeme všetky kĺby do počiatočnej polohy: 

1) „zabijeme“ všetky procesy, ktoré sa predtým vykonávali príkazom: 

ALMotion.killAll 

2) nastavíme robota do rovnovážnej polohy: 

ALMotion.setBalanceMode(self.pBalanceMode) 

1 http://www.aldebaran-robotics.com/ 


KKUI FEI 

3) môžeme napríklad zmeniť uhol nami vybraného kĺbu príkazom: 

ALMotion.changeAngle(self.pJointName1, self.AngleChange1) 

4) torzo – oblasť pásu robota nastavíme do polohy udaním súradnice x a y 

a času, ako dlho má v tejto polohe ostať: 

ALMotion.gotoTorsoOrientation(self.pX, self.pY, self.pDuration, 

self.pInterpolationType) 

5) chodenie dopredu naprogramujeme príkazom: 

ALMotion.walkStraight(self.pDistance, self.pNumSamplesPerStep) 

kde na vstupe zadáme vzdialenosť, ktorú má robot prejsť a počet vzoriek za krok 

– čo je vlastne rýchlosť pochodu, 

otočenia: 

6) podobne naprogramujeme otočenie robota, kde na vstupe zadáme uhol 

ALMotion.turn(self.pAngle, self.pNumSamplesPerStep) 

7) zmeny ostatných kĺbov môžeme zastaviť, kým sa nedokončí pochod robota: 

ALMotion.waitUntilWalksIsFinished 

Stručná charakteristika simulačného prostredia Webots je uvedená v hlavnej 

časti diplomovej práce. 


KKUI FEI 

4 Preklad programu 

4.1 Požiadavky na technické prostriedky 

Program nemá žiadne špeciálne požiadavky na technické prostriedky. 

Bol testovaný na operačných systémoch: 

- Windows XP Home Edition, 

- Windows Vista Business Edition, 

- Ubuntu 10.04 LTS. 

A na: 

- PC lenovo: Intel Pentium, Pentium (R) Dual-Core CPU, 2GB pamäte 

RAM. 

- Notebooku Eee PC: Intel(R) Atom(TM) CPU N270, 0.99GB pamäte 

RAM. 

Program na generovanie robotického tanca je prenositeľný na akýkoľvek 

operačný systém. 

Simulátor Webots je kompatibilný s operačnými systémami: 

- Linux, min. glibc 2.3, 

- Windows XP, 7 alebo Vista, 

- Mac OS X 10.5 alebo novší. 

4.2 Požiadavky na programové prostriedky 

Aby program fungoval je nutné mať nainštalované: 

- Python 2.6.5, ktorý sa dá stiahnuť zo stránky 

o http://www.python.org/download/ 

- GUI je v Pythone urobené pomocou modulu Tkinter, čo je štandardné rozhranie 

Pythona k Tk GUI toolkit. Sú kompatibilné s väčšinou Unix platformami, ako aj 


KKUI FEI 

s Windows systémami. Samotné Tk nie je časťou jazyka Python, ale nachádza sa 

v tzv. Active State. Viac informácií možné nájsť na stránke: 

o http://docs.python.org/library/tkinter.html 

- Jazyk Tcl/Tk (Command Language), ktorý sa využíva v programe na návrh GUI. 

Je to skriptovací jazyk bežiaci na platformách Windows, Unix aj Macintosh. Tcl 

je jednoduchý a open-source, možný stiahnuť napríklad cez internetovú stránku: 

o http://www.tcl.tk/software/tcltk/ 

- Vývojové prostredie Webots, ktoré je v plnej verzii dostupné na 30 dní a možné 

stiahnuť zo stránky: 

o http://www.cyberbotics.com/products/webots/download.html 

4.3 Technické pozadie 

Systém bol programovaný v jazyku Python, konkrétne vo verzii: 2.6.5, vo vývojovom 

prostredí NetBeans IDE 6.7, ktoré je voľné dostupné na stránke: 

- NetBeans IDE for Python EA2 Download: 

o http://download.netbeans.org/netbeans/6.7/python/ea2/ 


KKUI FEI 

5. Zhodnotenie riešenia 

Tento program predstavuje implementáciu navrhnutého systému pre interaktívnu 

evolúciu tanečnej choreografie robotov Nao. 

Riešenie bolo vhodné na realizáciu potrebných experimentov, ale na ďalšie 

experimenty je nevyhnutné pracovať na reálnych robotoch. 

Tým, ktorí budú v tomto projekte pokračovať, odporúčam preštudovať systémy 

robotického tanca, z ktorých som vychádzala a ktoré sú uvedené v hlavnej časti mojej 

diplomovej práce.

SYSTÉMOVÁ PRÍRUČKA - TUKE

Create successful ePaper yourself

Delete template?

Save as template?