RoboWiki - User contributions [en]

Vianoce s robotnackou

2008-12-16T21:24:06Z

Tomas: /* Obrazky robene imaginom */

=== Obrazky robene imaginom ===

= VLOCKA =

to vlocka :r :d :u
if :u >=1
[repeat :r [fd :d
vlocka :r :d/3 :u-1
pu
bk :d
pd
if :u=1 [fd :d*2/3
lt 45
fd :d/3
pu
bk :d/3
pd
rt 90
fd :d/3
pu
bk :d/3
lt 45
bk :d*2/3
pd
]
lt 360/:r
]
]

'''r''' - koľko "cípa je vločka" 
'''d''' - základná dĺžka vločky 
'''u''' - hustota vločky 
Odporúčam zadať: '''vlocka 8 150 2''' 

= STROM =

to strom :d :n
fd :d
repeat :n[lt 90 fd :d rt 135 fd sqrt(:d*:d*2) lt 45]
lt 180
repeat :n[lt 45 fd sqrt(:d*:d*2) rt 135 fd :d lt 90]
end

'''strom 50 3'''

= STROM 2 =

to binstrom :d :n
if :n=0
[
fd :d
bk :d
]
if :n>0
[
fd :d
lt 60
binstrom :d*2/3 :n-1
rt 120
binstrom :d*2/3 :n-1
lt 60
bk :d
]
end

'''binstrom 150 4'''

= hviezda =
to 5hviezda :d
repeat 5
[
fd :d
lt 144
]
end

'''5hviezda 100'''

Vianoce s robotnackou

2008-12-16T21:18:37Z

Tomas: New page: === Obrazky robene imaginom === VLOCKA to vlocka :r :d :u if :u >=1 [repeat :r [fd :d vlocka :r :d/3 :u-1 pu bk :d pd if :...

=== Obrazky robene imaginom ===

VLOCKA

to vlocka :r :d :u
if :u >=1
[repeat :r [fd :d
vlocka :r :d/3 :u-1
pu
bk :d
pd
if :u=1 [fd :d*2/3
lt 45
fd :d/3
pu
bk :d/3
pd
rt 90
fd :d/3
pu
bk :d/3
lt 45
bk :d*2/3
pd
]
lt 360/:r
]
]

'''r''' - koľko "cípa je vločka" 
'''d''' - základná dĺžka vločky 
'''u''' - hustota vločky 
Odporúčam zadať: '''vlocka 8 150 2''' 

STROM

to strom :d :n
fd :d
repeat :n[lt 90 fd :d rt 135 fd sqrt(:d*:d*2) lt 45]
lt 180
repeat :n[lt 45 fd sqrt(:d*:d*2) rt 135 fd :d lt 90]
end
strom 50 3

Krúžok Robotiky na GJH

2008-12-16T21:16:23Z

Tomas: /* Stretnutie 5.12.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

= Súťaž 14.11.2008 =

FLL - FIRST LEGO League

V tento piatkový deň sme na zúčastnili turnaja FLL. V UPC vládla súťaživá atmosféra a boli sme vystavený vysokej konkurencii. Vyhodnotenie bolo pre nás priaznivé: 3. miesto v kategórii Robot-Game. Zo súťaže sme odchádzali s novými skúsenosťami.
{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1L.jpg|(+)]]
| [[Media:FLL2L.jpg|(+)]]
| [[Media:FLL3L.jpg|(+)]]
| [[Media:FLL4L.jpg|(+)]]
|}

P.S. Prišli sme s "ničím" a odišli sme s "niečim"

== Stretnutie 27.11.2008 ==

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

== Stretnutie 2.12.2008 ==

Kolegovia fyzici nás oslovili s požiadavkou zostrojiť experimentálny model na testovanie opotrebovania vozovky pod tlakom pneumatík - t.j. úlohou bolo vymyslieť koleso ;).
Presnejšie povedané - koleso, ktoré stále jazdí do kola, je poháňané motorom a dá sa zaťažiť závažím. Jazdniť bude na povrchu nejakého mäkkého materiálu (mokrý piesok, plastelína) a tím bude pozorovať plastickú deformáciu modelovanej vozovky. Využili sme špeciálne sústredné pohonné koleso (turntable) poháňané jedným motorom, ktorý
zároveň meria otáčky. Rýchlosť je možné prispôsobiť pomocou tlačidiel na kocke NXT.

[[Image:model_opotrebovania_vozovky.jpg]] 
''Obrázok. Model opotrebovania vozovky.''

Program, ktorý riadi rýchlosť kolesa: [[Media:koleso.nxc]].
__notoc__
== Stretnutie 5.12.2008 ==

Úloha pre robotnačku: nakresliť snehovú vločku v imagine.
[[Vianoce s robotnackou]]

== 12.12.2008: ==

Zaregistrovali sme ďalšie tri tímy na súťaž RCJ Rakúsko: [[Team Bratislava Rescue 2009]], [[Team Bratislava Soccer 2009]] a [[Team Bratislava Dance 2009]].

Krúžok Robotiky na GJH

2008-12-16T14:08:24Z

Tomas: /* Stretnutie 5.12.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

= Súťaž 14.11.2008 =

FLL - FIRST LEGO League

V tento piatkový deň sme na zúčastnili turnaja FLL. V UPC vládla súťaživá atmosféra a boli sme vystavený vysokej konkurencii. Vyhodnotenie bolo pre nás priaznivé: 3. miesto v kategórii Robot-Game. Zo súťaže sme odchádzali s novými skúsenosťami.
{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1L.jpg|(+)]]
| [[Media:FLL2L.jpg|(+)]]
| [[Media:FLL3L.jpg|(+)]]
| [[Media:FLL4L.jpg|(+)]]
|}

P.S. Prišli sme s "ničím" a odišli sme s "niečim"

== Stretnutie 27.11.2008 ==

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

== Stretnutie 2.12.2008 ==

Kolegovia fyzici nás oslovili s požiadavkou zostrojiť experimentálny model na testovanie opotrebovania vozovky pod tlakom pneumatík - t.j. úlohou bolo vymyslieť koleso ;).
Presnejšie povedané - koleso, ktoré stále jazdí do kola, je poháňané motorom a dá sa zaťažiť závažím. Jazdniť bude na povrchu nejakého mäkkého materiálu (mokrý piesok, plastelína) a tím bude pozorovať plastickú deformáciu modelovanej vozovky. Využili sme špeciálne sústredné pohonné koleso (turntable) poháňané jedným motorom, ktorý
zároveň meria otáčky. Rýchlosť je možné prispôsobiť pomocou tlačidiel na kocke NXT.

[[Image:model_opotrebovania_vozovky.jpg]] 
''Obrázok. Model opotrebovania vozovky.''

Program, ktorý riadi rýchlosť kolesa: [[Media:koleso.nxc]].
__notoc__
== Stretnutie 5.12.2008 ==

Úloha pre robotnačku: nakresliť snehovú vločku v imagine.

to vlocka :r :d :u
if :u >=1
[repeat :r [fd :d
vlocka :r :d/3 :u-1
pu
bk :d
pd
if :u=1 [fd :d*2/3
lt 45
fd :d/3
pu
bk :d/3
pd
rt 90
fd :d/3
pu
bk :d/3
lt 45
bk :d*2/3
pd
]
lt 360/:r
]
]

'''r''' - koľko "cípa je vločka" 
'''d''' - základná dĺžka vločky 
'''u''' - hustota vločky 
Odporúčam zadať: '''vlocka 8 150 2''' 

12.12.2008:

Zaregistrovali sme ďalšie tri tímy na súťaž RCJ Rakúsko: [[Team Bratislava Rescue 2009]], [[Team Bratislava Soccer 2009]] a [[Team Bratislava Dance 2009]].

Krúžok Robotiky na GJH

2008-12-16T14:06:52Z

Tomas: /* Stretnutie 5.12.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

= Súťaž 14.11.2008 =

FLL - FIRST LEGO League

V tento piatkový deň sme na zúčastnili turnaja FLL. V UPC vládla súťaživá atmosféra a boli sme vystavený vysokej konkurencii. Vyhodnotenie bolo pre nás priaznivé: 3. miesto v kategórii Robot-Game. Zo súťaže sme odchádzali s novými skúsenosťami.
{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1L.jpg|(+)]]
| [[Media:FLL2L.jpg|(+)]]
| [[Media:FLL3L.jpg|(+)]]
| [[Media:FLL4L.jpg|(+)]]
|}

P.S. Prišli sme s "ničím" a odišli sme s "niečim"

== Stretnutie 27.11.2008 ==

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

== Stretnutie 2.12.2008 ==

Kolegovia fyzici nás oslovili s požiadavkou zostrojiť experimentálny model na testovanie opotrebovania vozovky pod tlakom pneumatík - t.j. úlohou bolo vymyslieť koleso ;).
Presnejšie povedané - koleso, ktoré stále jazdí do kola, je poháňané motorom a dá sa zaťažiť závažím. Jazdniť bude na povrchu nejakého mäkkého materiálu (mokrý piesok, plastelína) a tím bude pozorovať plastickú deformáciu modelovanej vozovky. Využili sme špeciálne sústredné pohonné koleso (turntable) poháňané jedným motorom, ktorý
zároveň meria otáčky. Rýchlosť je možné prispôsobiť pomocou tlačidiel na kocke NXT.

[[Image:model_opotrebovania_vozovky.jpg]] 
''Obrázok. Model opotrebovania vozovky.''

Program, ktorý riadi rýchlosť kolesa: [[Media:koleso.nxc]].
__notoc__
== Stretnutie 5.12.2008 ==

Úloha pre robotnačku: nakresliť snehovú vločku v imagine.

to vlocka :r :d :u
if :u >=1
[repeat :r [fd :d
vlocka :r :d/3 :u-1
bk :d
if :u=1 [fd :d*2/3
lt 45
fd :d/3
bk :d/3
rt 90
fd :d/3
bk :d/3
lt 45
bk :d*2/3
]
lt 360/:r
]
]

'''r''' - koľko "cípa je vločka" 
'''d''' - základná dĺžka vločky 
'''u''' - hustota vločky 
Odporúčam zadať: '''vlocka 8 150 2''' 

12.12.2008:

Zaregistrovali sme ďalšie tri tímy na súťaž RCJ Rakúsko: [[Team Bratislava Rescue 2009]], [[Team Bratislava Soccer 2009]] a [[Team Bratislava Dance 2009]].

Krúžok Robotiky na GJH

2008-12-09T17:36:20Z

Tomas: /* Stretnutie 5.12.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

= Súťaž 14.11.2008 =

FLL - FIRST LEGO League

V tento piatkový deň sme na zúčastnili turnaja FLL. V UPC vládla súťaživá atmosféra a boli sme vystavený vysokej konkurencii. Vyhodnotenie bolo pre nás priaznivé: 3. miesto v kategórii Robot-Game. Zo súťaže sme odchádzali s novými skúsenosťami.
{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1L.jpg|(+)]]
| [[Media:FLL2L.jpg|(+)]]
| [[Media:FLL3L.jpg|(+)]]
| [[Media:FLL4L.jpg|(+)]]
|}

P.S. Prišli sme s "ničím" a odišli sme s "niečim"

== Stretnutie 27.11.2008 ==

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

== Stretnutie 2.12.2008 ==

Kolegovia fyzici nás oslovili s požiadavkou zostrojiť experimentálny model na testovanie opotrebovania vozovky pod tlakom pneumatík - t.j. úlohou bolo vymyslieť koleso ;).
Presnejšie povedané - koleso, ktoré stále jazdí do kola, je poháňané motorom a dá sa zaťažiť závažím. Jazdniť bude na povrchu nejakého mäkkého materiálu (mokrý piesok, plastelína) a tím bude pozorovať plastickú deformáciu modelovanej vozovky. Využili sme špeciálne sústredné pohonné koleso (turntable) poháňané jedným motorom, ktorý
zároveň meria otáčky. Rýchlosť je možné prispôsobiť pomocou tlačidiel na kocke NXT.

[[Image:model_opotrebovania_vozovky.jpg]] 
''Obrázok. Model opotrebovania vozovky.''

Program, ktorý riadi rýchlosť kolesa: [[Media:koleso.nxc]].
__notoc__
== Stretnutie 5.12.2008 ==

Úloha pre robotnačku: nakresliť snehovú vločku v imagine.

to vlocka :r :d :u
if :u >=1
[repeat :r [fd :d
vlocka :r :d/3 :u-1
bk :d
if :u=1 [fd :d*2/3
lt 45
fd :d/3
bk :d/3
rt 90
fd :d/3
bk :d/3
lt 45
bk :d*2/3
]
lt 360/:r
]
]

'''r''' - koľko "cípa je vločka" 
'''d''' - základná dĺžka vločky 
'''u''' - hustota vločky 
Odporúčam zadať: '''vlocka 8 150 2'''

Krúžok Robotiky na GJH

2008-12-09T17:35:55Z

Tomas: /* Stretnutie 5.12.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

= Súťaž 14.11.2008 =

FLL - FIRST LEGO League

V tento piatkový deň sme na zúčastnili turnaja FLL. V UPC vládla súťaživá atmosféra a boli sme vystavený vysokej konkurencii. Vyhodnotenie bolo pre nás priaznivé: 3. miesto v kategórii Robot-Game. Zo súťaže sme odchádzali s novými skúsenosťami.
{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1L.jpg|(+)]]
| [[Media:FLL2L.jpg|(+)]]
| [[Media:FLL3L.jpg|(+)]]
| [[Media:FLL4L.jpg|(+)]]
|}

P.S. Prišli sme s "ničím" a odišli sme s "niečim"

== Stretnutie 27.11.2008 ==

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

== Stretnutie 2.12.2008 ==

Kolegovia fyzici nás oslovili s požiadavkou zostrojiť experimentálny model na testovanie opotrebovania vozovky pod tlakom pneumatík - t.j. úlohou bolo vymyslieť koleso ;).
Presnejšie povedané - koleso, ktoré stále jazdí do kola, je poháňané motorom a dá sa zaťažiť závažím. Jazdniť bude na povrchu nejakého mäkkého materiálu (mokrý piesok, plastelína) a tím bude pozorovať plastickú deformáciu modelovanej vozovky. Využili sme špeciálne sústredné pohonné koleso (turntable) poháňané jedným motorom, ktorý
zároveň meria otáčky. Rýchlosť je možné prispôsobiť pomocou tlačidiel na kocke NXT.

[[Image:model_opotrebovania_vozovky.jpg]] 
''Obrázok. Model opotrebovania vozovky.''

Program, ktorý riadi rýchlosť kolesa: [[Media:koleso.nxc]].
__notoc__
=== Stretnutie 5.12.2008 ===

Úloha pre robotnačku: nakresliť snehovú vločku v imagine.

to vlocka :r :d :u
if :u >=1
[repeat :r [fd :d
vlocka :r :d/3 :u-1
bk :d
if :u=1 [fd :d*2/3
lt 45
fd :d/3
bk :d/3
rt 90
fd :d/3
bk :d/3
lt 45
bk :d*2/3
]
lt 360/:r
]
]

'''r''' - koľko "cípa je vločka" 
'''d''' - základná dĺžka vločky 
'''u''' - hustota vločky 
Odporúčam zadať: '''vlocka 8 150 2'''

Krúžok Robotiky na GJH

2008-12-09T17:25:54Z

Tomas: /* Stretnutie 5.12.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

= Súťaž 14.11.2008 =

FLL - FIRST LEGO League

V tento piatkový deň sme na zúčastnili turnaja FLL. V UPC vládla súťaživá atmosféra a boli sme vystavený vysokej konkurencii. Vyhodnotenie bolo pre nás priaznivé: 3. miesto v kategórii Robot-Game. Zo súťaže sme odchádzali s novými skúsenosťami.
{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1L.jpg|(+)]]
| [[Media:FLL2L.jpg|(+)]]
| [[Media:FLL3L.jpg|(+)]]
| [[Media:FLL4L.jpg|(+)]]
|}

P.S. Prišli sme s "ničím" a odišli sme s "niečim"

== Stretnutie 27.11.2008 ==

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

== Stretnutie 2.12.2008 ==

Kolegovia fyzici nás oslovili s požiadavkou zostrojiť experimentálny model na testovanie opotrebovania vozovky pod tlakom pneumatík - t.j. úlohou bolo vymyslieť koleso ;).
Presnejšie povedané - koleso, ktoré stále jazdí do kola, je poháňané motorom a dá sa zaťažiť závažím. Jazdniť bude na povrchu nejakého mäkkého materiálu (mokrý piesok, plastelína) a tím bude pozorovať plastickú deformáciu modelovanej vozovky. Využili sme špeciálne sústredné pohonné koleso (turntable) poháňané jedným motorom, ktorý
zároveň meria otáčky. Rýchlosť je možné prispôsobiť pomocou tlačidiel na kocke NXT.

[[Image:model_opotrebovania_vozovky.jpg]] 
''Obrázok. Model opotrebovania vozovky.''

Program, ktorý riadi rýchlosť kolesa: [[Media:koleso.nxc]].
__notoc__
=== Stretnutie 5.12.2008 ===

Uloha pre robotnacku: nakreslit snehovu vlocku

to vlocka :r :d :u
if :u >=1
[repeat :r [fd :d
vlocka :r :d/3 :u-1
bk :d
if :u=1 [fd :d*2/3
lt 45
fd :d/3
bk :d/3
rt 90
fd :d/3
bk :d/3
lt 45
bk :d*2/3
]
lt 360/:r
]
]

Krúžok Robotiky na GJH

2008-12-09T17:24:34Z

Tomas: /* Stretnutie 5.12.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

= Súťaž 14.11.2008 =

FLL - FIRST LEGO League

V tento piatkový deň sme na zúčastnili turnaja FLL. V UPC vládla súťaživá atmosféra a boli sme vystavený vysokej konkurencii. Vyhodnotenie bolo pre nás priaznivé: 3. miesto v kategórii Robot-Game. Zo súťaže sme odchádzali s novými skúsenosťami.
{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1L.jpg|(+)]]
| [[Media:FLL2L.jpg|(+)]]
| [[Media:FLL3L.jpg|(+)]]
| [[Media:FLL4L.jpg|(+)]]
|}

P.S. Prišli sme s "ničím" a odišli sme s "niečim"

== Stretnutie 27.11.2008 ==

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

== Stretnutie 2.12.2008 ==

Kolegovia fyzici nás oslovili s požiadavkou zostrojiť experimentálny model na testovanie opotrebovania vozovky pod tlakom pneumatík - t.j. úlohou bolo vymyslieť koleso ;).
Presnejšie povedané - koleso, ktoré stále jazdí do kola, je poháňané motorom a dá sa zaťažiť závažím. Jazdniť bude na povrchu nejakého mäkkého materiálu (mokrý piesok, plastelína) a tím bude pozorovať plastickú deformáciu modelovanej vozovky. Využili sme špeciálne sústredné pohonné koleso (turntable) poháňané jedným motorom, ktorý
zároveň meria otáčky. Rýchlosť je možné prispôsobiť pomocou tlačidiel na kocke NXT.

[[Image:model_opotrebovania_vozovky.jpg]] 
''Obrázok. Model opotrebovania vozovky.''

Program, ktorý riadi rýchlosť kolesa: [[Media:koleso.nxc]].
__notoc__
=== Stretnutie 5.12.2008 ===

Uloha pre robotnacku: nakreslit snehovu vlocku

to vlocka :r :d :u
if :u >=1
[repeat :r [fd :d
vlocka :r :d/3 :u-1
bk :d
if :u=1 [fd :d*2/3
lt 45
fd :d/3
bk :d/3
rt 90
fd :d/3
bk :d/3
lt 45
bk :d*2/3
]
lt 360/:r
]
]

Krúžok Robotiky na GJH

2008-12-09T17:22:11Z

Tomas: /* Stretnutie 5.12.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

= Súťaž 14.11.2008 =

FLL - FIRST LEGO League

V tento piatkový deň sme na zúčastnili turnaja FLL. V UPC vládla súťaživá atmosféra a boli sme vystavený vysokej konkurencii. Vyhodnotenie bolo pre nás priaznivé: 3. miesto v kategórii Robot-Game. Zo súťaže sme odchádzali s novými skúsenosťami.
{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1L.jpg|(+)]]
| [[Media:FLL2L.jpg|(+)]]
| [[Media:FLL3L.jpg|(+)]]
| [[Media:FLL4L.jpg|(+)]]
|}

P.S. Prišli sme s "ničím" a odišli sme s "niečim"

== Stretnutie 27.11.2008 ==

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

== Stretnutie 2.12.2008 ==

Kolegovia fyzici nás oslovili s požiadavkou zostrojiť experimentálny model na testovanie opotrebovania vozovky pod tlakom pneumatík - t.j. úlohou bolo vymyslieť koleso ;).
Presnejšie povedané - koleso, ktoré stále jazdí do kola, je poháňané motorom a dá sa zaťažiť závažím. Jazdniť bude na povrchu nejakého mäkkého materiálu (mokrý piesok, plastelína) a tím bude pozorovať plastickú deformáciu modelovanej vozovky. Využili sme špeciálne sústredné pohonné koleso (turntable) poháňané jedným motorom, ktorý
zároveň meria otáčky. Rýchlosť je možné prispôsobiť pomocou tlačidiel na kocke NXT.

[[Image:model_opotrebovania_vozovky.jpg]] 
''Obrázok. Model opotrebovania vozovky.''

Program, ktorý riadi rýchlosť kolesa: [[Media:koleso.nxc]].
__notoc__
=== Stretnutie 5.12.2008 ===

<ref>
Uloha pre robotnacku: nakreslit snehovu vlocku:
to vlocka :r :d :u
if :u >=1
[repeat :r [fd :d
vlocka :r :d/3 :u-1
bk :d
if :u=1 [fd :d*2/3
lt 45
fd :d/3
bk :d/3
rt 90
fd :d/3
bk :d/3
lt 45
bk :d*2/3
]
lt 360/:r
]
]

</ref>

Krúžok Robotiky na GJH

2008-12-05T15:02:40Z

Tomas: /* Stretnutie 5.12.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

= Súťaž 14.11.2008 =

FLL - FIRST LEGO League

V tento piatkový deň sme na zúčastnili turnaja FLL. V UPC vládla súťaživá atmosféra a boli sme vystavený vysokej konkurencii. Vyhodnotenie bolo pre nás priaznivé: 3. miesto v kategórii Robot-Game. Zo súťaže sme odchádzali s novými skúsenosťami.
{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1L.jpg|(+)]]
| [[Media:FLL2L.jpg|(+)]]
| [[Media:FLL3L.jpg|(+)]]
| [[Media:FLL4L.jpg|(+)]]
|}

P.S. Prišli sme s "ničím" a odišli sme s "niečim"

== Stretnutie 27.11.2008 ==

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

== Stretnutie 2.12.2008 ==

Kolegovia fyzici nás oslovili s požiadavkou zostrojiť experimentálny model na testovanie opotrebovania vozovky pod tlakom pneumatík - t.j. úlohou bolo vymyslieť koleso ;).
Presnejšie povedané - koleso, ktoré stále jazdí do kola, je poháňané motorom a dá sa zaťažiť závažím. Jazdniť bude na povrchu nejakého mäkkého materiálu (mokrý piesok, plastelína) a tím bude pozorovať plastickú deformáciu modelovanej vozovky. Využili sme špeciálne sústredné pohonné koleso (turntable) poháňané jedným motorom, ktorý
zároveň meria otáčky. Rýchlosť je možné prispôsobiť pomocou tlačidiel na kocke NXT.

[[Image:model_opotrebovania_vozovky.jpg]] 
''Obrázok. Model opotrebovania vozovky.''

Program, ktorý riadi rýchlosť kolesa: [[Media:koleso.nxc]].
__notoc__
=== Stretnutie 5.12.2008 ===
Uloha pre robotnacku: nakreslit snehovu vlocku
[[Media:vlocka.imp]]

Krúžok Robotiky na GJH

2008-12-05T15:02:07Z

Tomas: /* Stretnutie 5.12.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

= Súťaž 14.11.2008 =

FLL - FIRST LEGO League

V tento piatkový deň sme na zúčastnili turnaja FLL. V UPC vládla súťaživá atmosféra a boli sme vystavený vysokej konkurencii. Vyhodnotenie bolo pre nás priaznivé: 3. miesto v kategórii Robot-Game. Zo súťaže sme odchádzali s novými skúsenosťami.
{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1L.jpg|(+)]]
| [[Media:FLL2L.jpg|(+)]]
| [[Media:FLL3L.jpg|(+)]]
| [[Media:FLL4L.jpg|(+)]]
|}

P.S. Prišli sme s "ničím" a odišli sme s "niečim"

== Stretnutie 27.11.2008 ==

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

== Stretnutie 2.12.2008 ==

Kolegovia fyzici nás oslovili s požiadavkou zostrojiť experimentálny model na testovanie opotrebovania vozovky pod tlakom pneumatík - t.j. úlohou bolo vymyslieť koleso ;).
Presnejšie povedané - koleso, ktoré stále jazdí do kola, je poháňané motorom a dá sa zaťažiť závažím. Jazdniť bude na povrchu nejakého mäkkého materiálu (mokrý piesok, plastelína) a tím bude pozorovať plastickú deformáciu modelovanej vozovky. Využili sme špeciálne sústredné pohonné koleso (turntable) poháňané jedným motorom, ktorý
zároveň meria otáčky. Rýchlosť je možné prispôsobiť pomocou tlačidiel na kocke NXT.

[[Image:model_opotrebovania_vozovky.jpg]] 
''Obrázok. Model opotrebovania vozovky.''

Program, ktorý riadi rýchlosť kolesa: [[Media:koleso.nxc]].
__notoc__
=== Stretnutie 5.12.2008 ===
Uloha pre robotnacku: nakreslit snehovu vlocku

Krúžok Robotiky na GJH

2008-12-05T15:01:25Z

Tomas: /* Stretnutie 2.12.2008 */

File:Koleso.nxc

2008-12-03T17:19:08Z

Tomas:

Krúžok Robotiky na GJH

2008-12-01T08:18:53Z

Tomas: /* Súťaž 14.11.2008 */

Krúžok Robotiky na GJH

2008-12-01T08:17:08Z

Tomas: /* Súťaž 14.11.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

= Súťaž 14.11.2008 =

FLL - FIRST LEGO League

V tento piatkový deň sme na zúčastnili turnaja FLL. V UPC vládla súťaživá atmosféra a boli sme vystavený vysokej konkurencii. Vyhodnotenie bolo pre nás priaznivé: 3. miesto v kategórii Robot-Game. Zo súťaže sme odchádzali s novými skúsenosťami.
{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1L.jpg|(+)]]
| [[Media:FLL2L.jpg|(+)]]
| [[Media:FLL3L.jpg|(+)]]
| [[Media:FLL4L.jpg|(+)]]
|}

== Stretnutie 27.11.2008 ==

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

__notoc__

Krúžok Robotiky na GJH

2008-12-01T08:12:38Z

Tomas: /* Stretnutie 27.11.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

= Súťaž 14.11.2008 =

FLL - FIRST LEGO League

{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1L.jpg|(+)]]
| [[Media:FLL2L.jpg|(+)]]
| [[Media:FLL3L.jpg|(+)]]
| [[Media:FLL4L.jpg|(+)]]
|}
----

== Stretnutie 27.11.2008 ==

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

__notoc__

Krúžok Robotiky na GJH

2008-12-01T08:11:59Z

Tomas: /* Stretnutie 13.10.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

= Súťaž 14.11.2008 =

FLL - FIRST LEGO League

{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1L.jpg|(+)]]
| [[Media:FLL2L.jpg|(+)]]
| [[Media:FLL3L.jpg|(+)]]
| [[Media:FLL4L.jpg|(+)]]
|}
----

=== Stretnutie 27.11.2008 ===

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

__notoc__

Krúžok Robotiky na GJH

2008-12-01T08:11:50Z

Tomas: /* Súťaž 14.11.2008 = */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

----
= Súťaž 14.11.2008 =

FLL - FIRST LEGO League

{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1L.jpg|(+)]]
| [[Media:FLL2L.jpg|(+)]]
| [[Media:FLL3L.jpg|(+)]]
| [[Media:FLL4L.jpg|(+)]]
|}
----

=== Stretnutie 27.11.2008 ===

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

__notoc__

Krúžok Robotiky na GJH

2008-12-01T08:11:11Z

Tomas: /* Súťaž 14.11.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

----
= Súťaž 14.11.2008 ==

FLL - FIRST LEGO League

{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1L.jpg|(+)]]
| [[Media:FLL2L.jpg|(+)]]
| [[Media:FLL3L.jpg|(+)]]
| [[Media:FLL4L.jpg|(+)]]
|}
----

=== Stretnutie 27.11.2008 ===

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

__notoc__

Krúžok Robotiky na GJH

2008-12-01T08:10:49Z

Tomas: /* Súťaž 14.11.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

----
== Súťaž 14.11.2008 ==
----
FLL - FIRST LEGO League

{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1L.jpg|(+)]]
| [[Media:FLL2L.jpg|(+)]]
| [[Media:FLL3L.jpg|(+)]]
| [[Media:FLL4L.jpg|(+)]]
|}
----

=== Stretnutie 27.11.2008 ===

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

__notoc__

Krúžok Robotiky na GJH

2008-11-29T17:44:23Z

Tomas: /* Súťaž 14.11.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

----
=== Súťaž 14.11.2008 ===

FLL - FIRST LEGO League

{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1L.jpg|(+)]]
| [[Media:FLL2L.jpg|(+)]]
| [[Media:FLL3L.jpg|(+)]]
| [[Media:FLL4L.jpg|(+)]]
|}
----

=== Stretnutie 27.11.2008 ===

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

__notoc__

File:FLL4L.jpg

2008-11-28T22:52:49Z

Tomas:

File:FLL3L.jpg

2008-11-28T22:52:17Z

Tomas:

File:FLL2L.jpg

2008-11-28T22:51:46Z

Tomas:

File:FLL1L.jpg

2008-11-28T22:50:59Z

Tomas:

Krúžok Robotiky na GJH

2008-11-28T22:50:34Z

Tomas: /* Súťaž 14.11.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

----
=== Súťaž 14.11.2008 ===
{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1L.jpg|(+)]]
| [[Media:FLL2L.jpg|(+)]]
| [[Media:FLL3L.jpg|(+)]]
| [[Media:FLL4L.jpg|(+)]]
|}
----

=== Stretnutie 27.11.2008 ===

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

__notoc__

File:FLL4.jpg

2008-11-28T22:50:01Z

Tomas:

File:FLL3.jpg

2008-11-28T22:49:46Z

Tomas:

File:FLL2.jpg

2008-11-28T22:49:32Z

Tomas: uploaded a new version of "Image:FLL2.jpg"

File:FLL1.jpg

2008-11-28T22:49:13Z

Tomas: uploaded a new version of "Image:FLL1.jpg"

File:FLL2.jpg

2008-11-28T22:47:07Z

Tomas:

File:FLL1.jpg

2008-11-28T22:46:47Z

Tomas: uploaded a new version of "Image:FLL1.jpg"

File:FLL1.jpg

2008-11-28T22:43:05Z

Tomas:

Krúžok Robotiky na GJH

2008-11-28T22:42:17Z

Tomas: /* Súťaž 14.11.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

----
=== Súťaž 14.11.2008 ===
{|
|-
| [[Image:FLL1.jpg]]
| [[Image:FLL2.jpg]]
| [[Image:FLL3.jpg]]
| [[Image:FLL4.jpg]]
|-
| [[Media:FLL1.jpg|(+)]]
| [[Media:FLL2.jpg|(+)]]
| [[Media:FLL3.jpg|(+)]]
| [[Media:FLL4.jpg|(+)]]
|}
----

=== Stretnutie 27.11.2008 ===

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

__notoc__

Krúžok Robotiky na GJH

2008-11-28T22:39:43Z

Tomas: /* Súťaž 14.11.2008 */

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

=== Súťaž 14.11.2008 ===
[[Image:Príklad.jpg]]

=== Stretnutie 27.11.2008 ===

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

__notoc__

Krúžok Robotiky na GJH

2008-11-28T22:26:33Z

Tomas:

Krúžok robotiky sa zaoberá stavbou a programovaním robotov zo stavebníc LEGO NXT.
Učíme sa programovací jazyk NXC. V máji sa chceme zúčastniť na turnaji
RoboCup Junior Slovensko v Banskej Bystrici a na jeseň na súťaži First LEGO League.

Pozri stránku [http://skse.6com.sk/sse-files/html/aktivity/ROBOCUP2008/propozicie.html RoboCup Junior Slovensko], kde sú aj
pravidlá súťažných kategórií Záchranár, Futbal a Tanec robotov.

[[Media:kruzok.png|plagatik]]

= Stretnutie 22.4.2008 =

* Nainštalovali sme si programovací jazyk NXC s prostredím [http://bricxcc.sourceforge.net/ BricX]
(treba stiahnuť súbor test_release.zip, rozbaliť ho a spustiť). USB driver: [http://cache.lego.com/upload/contentTemplating/MindstormsUpdate/otherfiles/2057/upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip download]

* Napísali sme prvý program pre robota, pomocou ktorého prejde o kúsok vpred:

task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
Float(OUT_AC);
}

Prvý riadok zapne motory na portoch A a C na rýchlosť 75 (najväčšia rýchlosť je 100).
Druhý riadok počká 1 sekundu (ale motory sú už zapnuté, takže robot ide 1s vpred).
Tretí riadok vypne motory na portoch A a C.

* Potom si krúžkari sami zmenili program tak, aby robot prešiel do štvorca, použili sme
pritom príkaz:

OnRev(OUT_AC, 75);

ktorý zapne motor v spätnom chode (rýchlosťou 75 - tú môžeme samozrejme meniť).

Videli sme, že bolo zložité vyladiť dĺžku čakania pri zatáčaní a preto sme využili príkaz

RotateMotor(OUT_A, 75, 45);

ktorý spôsobí, že motor na porte A sa otočí len o 45 stupňov a potom zastane - využíva
pritom otáčkové snímače, ktoré sú zabudované do motorov.

* Napokon sme na papieri fixkou nakreslili čiaru a naprogramovali sme robota tak, aby
chodil do kola po čiare (keď sme konečne našli správne príkazy :). Tu je výsledný program:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LIGHT_ACTIVE);
SetSensorMode(S1, SENSOR_MODE_PERCENT);
ResetSensor(S1);

while (1)
{
if (Sensor(S1) < 48)
{
OnFwd(OUT_A, 75);
Float(OUT_C);
}
else
{
OnFwd(OUT_C, 75);
Float(OUT_A);
}
}
}

Program najskôr nastaví typ senzora na porte 1 (čiže S1) na aktívny svetelný senzor.
Potom opakuje donekonečna (lebo podmienka 1 je vždy splnená) jeden jednoduchý test:
ak je intenzita odrazeného svetla menšia ako 45, robot je na čiernej čiare a má zatáčať
vpravo. V opačnom prípade je robot na bielom papieri a má zatáčať vľavo. Takto robot
sleduje hranu čiary medzi bielou a čiernou...
Tento program treba prispôsobiť podľa toho, aká tmavá je čiara (hodnota 48 v podmienke)
a podľa toho, na ktorých portoch má robot pripojené motory a ktorým smerom sú otočené
(t.j. vymeniť časti podmienok).

[[Image:kruzok_gjh_sledovanie_ciary.jpg]]

Spoločné stretnutia pre všetkých zaújemcov budú pokračovať každý týždeň v utorok o 14.

= Stretnutia 24. - 27. 4. 2008 =

Nasledujúci program vypisuje hodnoty ultrazvukového snímača na porte 1 na meranie vzdialenosti
na LCD:

int s;
task main()
{
SetSensorType(S1, SENSOR_TYPE_LOWSPEED);
ClearScreen();
while(1)
{
ClearScreen();
NumOut(10,10,SensorUS(S1));
Wait(500);
}
}

Typy senzorov:

SENSOR_TYPE_TOUCH tlakový snímač (tlačidlo)
SENSOR_TYPE_TEMPERATURE tepelný snímač (doplnkový senzor)
SENSOR_TYPE_LIGHT svetelný snímač zo stavebnice RCX
SENSOR_TYPE_ROTATION otáčkový snímač zo stavebnice RCX
SENSOR_TYPE_LIGHT_ACTIVE svetelný NXT snímač v aktívnom režime
SENSOR_TYPE_LIGHT_INACTIVE svetelný NXT snímač v pasívnom režime (dióda nesvieti)
SENSOR_TYPE_SOUND_DB zvukový snímač
SENSOR_TYPE_SOUND_DBA zvukový snímač (iné jednotky)
SENSOR_TYPE_LOWSPEED ultrazvukový snímač

Snímače sa v programe čítajú pomocou funkcíí Sensor(S1) - Sensor(S4), 
ale ultrazvukový snímač sa číta pomocou SensorUS(S1) - SensorUS(S4).

Na začiatku programu treba snímače nastaviť pomocou príkazu:

SetSensorType(S1,jeden_z_tychto_typov);
SetSensorMode(S1,SENSOR_MODE_PERCENT);
ResetSensor(S1);

Ak nechceme hodnoty 0-100, môžeme použiť iný mód, jeden z nasledujúcich:

SENSOR_MODE_RAW priama "surová" hodnota od 0 do 1023
SENSOR_MODE_BOOL 0 alebo 1
SENSOR_MODE_EDGE počíta koľkokrát prejde senzor z 0 do 1 alebo z 1 do 0
SENSOR_MODE_PULSE počíta koľkokrát prejde senzor z 0 do 1 a naspäť
SENSOR_MODE_PERCENT hodnota 0 až 100
SENSOR_MODE_FAHRENHEIT jednotky F (pre tepelný snímač)
SENSOR_MODE_CELSIUS stupne C (pre tepelný snímač)
SENSOR_MODE_ROTATION počet otáčok (pre RCX otáčkový snímač)

Senzory HiTechnic na snímanie IR lotpy, farby, naklonenia a smeru (kompasový) sa nastavujú
ako keby boli ultrazvukový senzor. Ak potrebujeme čítať hodnoty aj z iných I2C adries, ako
42H (pozri dokumentáciu k senzorom), môžeme použiť takýto program: [[Media:accel.nxc|accel.nxc]] - číta
presné hodnoty naklonenia akceleračného snímača podľa troch osí X,Y,Z.

Podobne nasledujúci program číta presné hodnoty R,G,B zo svetelného senzora: [[Media:color.nxc|color.nxc]], a nasledujúci prečíta hodnoty pre všetkých 5
IR senzorov zabudovaných do IRSeeker senzora vrátane smeru 1-9: [[Media:irseeker.nxc|irseeker.nxc]]

----

Nasledujúca funkcia prikáže motorom urobiť zadaný počet otáčok v zadanom výkone:

void go(int powerA, int powerB, int rotations)
{
SetOutput(OUT_A,
TachoLimit, rotations,
Power, powerA,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );

SetOutput(OUT_B,
TachoLimit, rotations,
Power, powerB,
OutputMode,
OUT_MODE_MOTORON,
RunState,
OUT_RUNSTATE_RUNNING,
UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED + UF_UPDATE_TACHO_LIMIT );
while( GetOutput ( OUT_A, RunState ) != OUT_RUNSTATE_IDLE);
}

napríklad:

go(75,75,1000); - prejdi 1000 krokov (stupňov otočenia motora) vpred rýchlosťou 75
go(-75,-75,1000); - prejdi 1000 krokov vzad...
go(75,-75,1000); - otáčaj sa jedným smerom...
go(-75,75,1000); - otáčaj sa druhźm smerom...

Nasledujúci program zapne motory v spätnom chode a ked robot narazí na prekážku,
t.j. motory sa začnú prešmykovať, tak začne pískať:

task main ()
{
int rot0, x;

OnRev(OUT_BC,100);

do
{
rot0 = GetOutput(OUT_C, TachoCount);
Wait(15);
x = GetOutput(OUT_C, TachoCount);
if ((x - rot0) > -7) PlayTone(200,200);
}
while (true);
}

{|
|-
| [[Image:stavba_rcj1_s.jpg]]
| [[Image:stavba_rcj2_s.jpg]]
| [[Image:stavba_rcj3_s.jpg]]
| [[Image:stavba_rcj4_s.jpg]]
| [[Image:stavba_rcj5_s.jpg]]
|-
| [[Media:stavba_rcj1.jpg|(+)]]
| [[Media:stavba_rcj2.jpg|(+)]]
| [[Media:stavba_rcj3.jpg|(+)]]
| [[Media:stavba_rcj4.jpg|(+)]]
| [[Media:stavba_rcj5.jpg|(+)]]
|}

Nasledujúca funkcia využíva kompasový senzor na porte 1 a vráti uhol 0-180 - smer oproti začiatočnému smeru pri odštartovaní programu.

int r;
int uhol()
{
int u, mensi, vacsi, roz1, roz2;
u = SensorUS(S1);
if (u > r) { mensi = r; vacsi = u; }
else { mensi = u; vacsi = r; }

roz1 = vacsi - mensi;
roz2 = mensi + 180 - vacsi;

if (roz1 < roz2) return 2*roz1;
return 2*roz2;
}

Môžeme ju v programe použiť takto:

task main ()
{
SetSensorType(S1,SENSOR_TYPE_LOWSPEED); // compass
Wait(1000); // pocka 1 sekundu

r = (SensorUS(S1)); // nacita pociatocnu hodnotu snimaca
while(ButtonPressed(BTN2,true) == false); // pocka na stlacenie sipky vpravo
PlayTone(2000,500); // potom zapiska

...
if (uhol() < 90)
{
// robot je otoceny spravnym smerom
}
else
{
// robot je otoceny opacnym smerom
}
}

V dňoch 1. a 2. mája sme sa zúčastnili Súťaže v stavbe a programovaní robotov RoboCup Junior Slovensko 2008 v Banskej Bystrici
s týmami v kategóriách Futbal 2-na-2 a Záchranár. Hoci náš záchranársky robot nedopadol veľmi dobre - keďže sme mali na prípravu
menej ako 2 týždne, futbalové roboty boli postavené a naprogramované spoľahlivo a získali pekné 3. miesto (2. v kategórii stredných
škôl). Tu sú súťažné roboty:

[[Image:futbalista1.jpg]] [[Image:futbalista2.jpg]]

Záchranárske roboty odvtedy vylepšujeme/staviame odznova. Tu sú dve verzie z polovičky mája, ktoré čoskoro otestujeme:

[[Image:zachranar1.jpg]] [[Image:zachranar2.jpg]]

Staviame i novú verziu futbalistických robotov, ktoré v prototypoch vyzerajú takto:

[[Image:novy_futbal.jpg]] [[Image:novy_futbal2.jpg]]

= Stretnutie 20.5.2008 =

Prvý dnešný program hľadá ľudí dookola a keď niekoho nájde, ide za ním, až kým nepríde bližšie, keď zastane: [[Media:hladac.nxc|hladac.nxc]].

Druhý program naopak chodí vpred dokiaľ nepríde k prekážke, ktorej sa vyhne a pokračuje ďalej:[[Media:vyhybac.nxc|vyhybac.nxc]].

A takto vyzerá zábava s robotom:

[[Image:nahanac1.jpg]] [[Image:nahanac2.jpg]] [[Image:nahanac3.jpg]]

= Stretnutie 24.6.2008 =

Tvoríme 3D model zachranárskych robotov v programe [http://www.lego.com/ldd/ LEGO Digital Designer].
Tu je skoro kompletný model robota:

[[Image:rescue_robot_model.jpg]]

Vymýšľame algoritmus pre futbalistické roboty:

1.Nacitanie vstupnych udajov
kam som otoceny
na ktorej som polke(svetla/tmava)
cakanie na stlacanie startovneho tlacidla

nekonecny cyklus(do vypnutia programu):
{
2. Ak nevidim loptu :
Hladanie :
Otocka na mieste 360 deg
ked ju stale nevidi pojde na svoju polku kontrolujuc
prekazku (ktore obide) natoci sa na supera
a bude pozerat po lopte

ak vidi loptu :
a)je otoceny na svoju polku:
- obide ju: skusi ju obist nalavo,
ak je tam prekazka tak ju obide napravo
pocas obchadzania kontroluje prekazku
// a pojde na superovu branku

b)je otoceny na supera- utoci:
- ak je lopta daleko (t.j. prekazkovy senzor dava hodnotu > 5 cm):
nastavi motory tak, aby sa robot tocil na loptu
- ak je lopta blizko, plnou rychlostou vpred na kratku vzdialenost,
a potom zastavit na chvilku
}

3.spracovanie prekazky : ak je predo mnou prekazka a
nie je to lopta treba sa jej vyhnut:
zastat,
vratit sa o kusok spat
otocit sa smerom k superovej strane (vlavo alebo vpravo o 60 stupnov)

Tu je program, ktorý otočí robotom na mieste o 360 stupňov, pričom počas otáčania beží
cyklus while a tak robot môže priebežne reagovať na vnemy zo snímačov: [[Media:otocka.nxc|otocka.nxc]]

{|
|-
| [[Image:futbal1s.jpg]]
| [[Image:futbal2s.jpg]]
| [[Image:futbal3s.jpg]]
| [[Image:futbal4s.jpg]]
| [[Image:futbal5s.jpg]]
|-
| [[Media:futbal1.jpg|(+)]]
| [[Media:futbal2.jpg|(+)]]
| [[Media:futbal3.jpg|(+)]]
| [[Media:futbal4.jpg|(+)]]
| [[Media:futbal5.jpg|(+)]]
|}

=== Stretnutie 13.10.2008 ===

Marek: [[Navrh robota pre RoboCup 2009]]

Miso, Miro, Lubo: [[Balancujuci robot]]

=== Súťaž 14.11.2008 ===
=== Stretnutie 27.11.2008 ===

Pripravuje sa robot na RoboCup Rescue, pozri osobitnú stránku: [[Team GJH Rescue 2009]] a roboty na RoboCup Soccer, pozri
stránku [[Team GJH Soccer 2009]].

# M&Ms začali robit na projekte kontroly kvality výrobkov pomocou ultrazvukového senzora - zobrazili sme si pekne nameraný profil v grafe. Naprogramovali sme prvú verziu merania profilov pomocou ultrazvukového senzora: [[Media:kontrola.nxc|kontrola.nxc]]
# Tomáš pripravil ružicu pre Sbota, takže teraz budeme musieť naprogramovať riadenie rýchlosti servomotorov, lebo doteraz vieme len zapnúť/vypnúť a zmeniť smer. Toto treba naštudovať v manuáli o ATmega128 a upraviť firmware...
# Preskúmali sme novú hračku - robota iSobot, ktorý ako sa ukázalo nechcel ísť, lebo je vyberavý - potebuje veľmi silné batérie - ani alkalické mu nestačia!! (ale už funguje, takže ho nabudúce prinesiem)
# Chalani pracovali na svojom Rescue robotovi.

__notoc__