Reaali Robootika.COM

NXT robotimaailm ja programmeerimine C-keeles

Juhend: Andurite defineerimine ja lugemine

Roboti juures andurite kasutamine on seotud kahe tegevusega: a) defineerimine b) lugemine.
Selleks, et programmis andureid kasutada (lugeda), tuleb robotile kõigepealt selgeks õpetada millised andurid ja kus pordis asuvad.

Alljärgnevas tabelis on andurite initsialiseerimisega seotud funktsioonid. Erinevaid andureid tuleb erineval moel initsialiseerida.

SetSensorLight("port");

SetSensorLight(S1);
Valgussensori initsialiseerimine pordis 1.

SetSensorTouch("port")

SetSensorTouch(S1);
Puuteanduri initsialiseerimine pordis 1.

SetSensorSound("port");

SetSensorSound(S1);
Helianduri initsialiseerimine pordis 1.

SetSensorHTEOPD("port");

SetSensorHTEOPD(S1);
Hitechnic EOPD sensori initsialiseerimine.

SetSensorHTGyro("port");

SetSensorHTGyro(S1);
Hitechnic Gyro sensori initsialiseerimine.

SetSensorLowspeed("port");

SetSensorLowspeed(S1);
Ultrasonic ja Hitechnic IRSeeker, Color, Compass sensori initsialiseerimine pordis 1.

Anduritelt andmete lugemiseks kasutatavad funktsioonid on alljärgnevas tabelis. Jällegi tuleb tähele panna, et osade andurite jaoks saab kasutada sama funktsiooni lugemiseks, kuid osade jaoks on spetsiifilised funktsioonid.

Sensor("port");

Sensor(S1);
Andmete lugemine Touch, Light, Sound sensorist.

SensorUS("port");

SensorUS(S1);
Andmete lugemine Ultrasonic sensorist.

SensorHTGyro("port", “Offset”);

SensorHTGyro(S1, 2);
Andmete lugemine Gyro sensorist. Ette on antud offset ehk nulli hälve.

SensorHTEOPD("port");

SensorHTEOPD(S1);
Andmete lugemine EOPD sensorist.

SensorHTCompass("port");

SensorHTCompass(S1);
Andmete lugemine Compass sensorist.

SensorHTIRSeekerDir("port");

SensorHTIRSeekerDir(S1);
IR Seeker sensorist suuna lugemine.

SensorHTColorNum("port");

SensorHTColorNum(S1);
Värviandurist vastava värvi numbri lugemine.

Robotid 2 osa jätk

Nüüd ma kirjutan sama päeva roboteid edasi.

Täna ma tegin veel kaugus, värvi, valgus ja puute anduri lugemis ehk nende numbrite mis neil seal on kuvamis testi. Need numbrid mis saavad sealt tulla kuvasin ma ekraanile ja sealt siis lugesin.

Kaugus anduri kuvamis test:

task main(){
SetSensorLowspeed(S2);
while(true){
NumOut(50, LCD_LINE3, SensorHTColorNum(S2));
Wait(500);
ClearScreen();
}
}

SetSensorLowspeed(S2); defineerin kaugus anduri
NumOut(50, LCD_LINE3, SensorHTColorNum(S2)); kirjutan ekraanile kaugus anduri kauguse sellest asjast mida kaugus andur praegu näeb kõige lähedamal.
Wait(500); ClearScreen(); Ootamine selles et jõuaksin lugeda numbrit ja ClearScreen, et ekraanilt kustuks eelmine number ja oleks parem lugeda.
Valgus anduril tegin ma SetSensorLowspeedi asemel SetSensorLight värvi anduril oli sama ja puute anduril tegin SetSensorTouch. Viimane ning kõige pikem ja raskem oli robot mis läheb siis käima kui kahte puuteandurit korraga vajutada ja siis kui on vajutatud läheb parema nupuga paremale vasaku nupuga vasakule ja kui uuesti vajutada kahte korraga jääb seisma:

task main(){
bool Bumped2Buttons;
//defineerin nuppude vajutuseks muutuja
SetSensorTouch(S1);
SetSensorTouch(S2);
while(true){
  Bumped2Buttons = FALSE;
  //algväärtustan muutuja et teine tsükkel käivituks
  Wait(500);
  //Robot ootab pool sekundit et robot jääks seisma
  until(Sensor(S1)== 1);
  until(Sensor(S2)== 1);
  until(Sensor(S1)== 0);
  until(Sensor(S2)== 0);
  //vajutan mõlemat sensorit ja lasen lahti samal ajal et 
robot hakkaks sõitma
  while(!Bumped2Buttons){
    if (Sensor(S1)== 1){
       OnRevSync(OUT_BC, 50, -10);
       //Robot keerab kergelt paremale
    }
    else if(Sensor(S2)== 1){
       OnRevSync(OUT_BC, 50, 10);
       //Robot keerab kergelt vasakule
    }
    else{
       OnRev(OUT_BC, 50);
    }
    if(Sensor(S1)== 1 && Sensor(S2)== 1){

//Robot jääb siis seisma kui on vajutatud kahte nuppu korraga Bumped2Buttons = TRUE;

    }

  }
 

Off(OUT_BC);

}

}

Meil tekkis selle programmiga igasuguseid probleeme. Üks oli näiteks see, et kui ma vajutasin kahte nuppu korraga siis jäi robot alles siis seisma kui nupud olid all ehk kui ma oleksin tahtnud, et robot jääks seisma siis kui ma olen vajutanud nupud alla ja lahti lasknud siis ma oleksin pidanud olema väga kiire. Kui mu isa mõtles et see peab ootama enne kui see lahti laseb siis mulle kohe turgatas et me peaksime selle Waiti sinna panema. Tegime ära ja töötas väga hästi.
Kui meil veel seal alguses alguses ei olnud algväärtustamist vaid oli kohe muutuja juures siis ei jäänud see seisma. Mu isa sai kohe aru milles probleem kuid mina pidin natuke mõtlema ja alles siis turgatas mullegi pähe.

Robotid: teine blogi osa

Niisiis teine päev mil teen blogi ja kirjutan siis mis ma täna tegin.

Täna ma tegin roboti mis liigub või jääb seisma puuteanduri vajutuse peale ehk vajutan nuppu siis robot kas sõidab edasi või jääb seisma.
Programm kus robot liigub edasi nupu vajutuse peale:
task main(){
SetSensorTouch(S1);   //defineerin puute sensori
while (true){   //lõpmatu tsükkel
if(
Sensor(S1)== 1){     //if else tsükkel ehk kui sensor 1 = 1 siis läheb if-i peale ja kui ei siis else-i peale
OnRev(OUT_BC, 100);    //Robot sõidab senikaua edasi kuni ma hoian nuppu all
}
else{    //if else tsükli else pool kui ei hoia nuppu all
Off(OUT_BC);    //kui ma ei hoia nuppu all Robot seisab
}
}
}

Teine asi mis ma täna tegin oli siis see kui ma tegin nupu vajutuse peale seisma jäämise. See on sama mis esimene programm ainult et if(Sensor(S1)== 1){ oli hoopiski: if(Sensor(S1)== 0){.

Kolmas ja viimane asi mis mu isa mul täna teha laskis oli Robot mis sõitis siis edasi kui vajutad ühe korra nuppu ja siis jäi seisma kui teist korda nuppu vajutada. Programm ise nägi väja selline:
task main(){
SetSensorTouch(S1);    //defineerin puute sensori
while(true){   //lõpmatu tsükkel
until(
Sensor(S1)== 1);     //ootab nupule vajutamist
until(
Sensor(S1)== 0);     //ootab nupu lahti laskmist
OnRev(OUT_BC, 100);     //sõidab maksimum kiirusel edasi
until(
Sensor(S1)== 1);     //ootab nupule vajutamist
until(
Sensor(S1)== 0);     //ootab nupu lahti laskmist
Off(OUT_BC

);     //mõlemad mootorid seiskuvad
}
}

Robotid: eelmise sisestuse järgnev osa

Ma jätkan nüüd seda sisestust mis ma eelmine kord pooleli jätsin.
Kolmas ja viimane ülesanne mille mu isa mu andis oli viisnurga sõitmine selle programm näeb välja selline:
task main(){
repeat(5){                                                           //Robot teeb järgnevat 5 korda järjest
RotateMotorEx(OUT_BC, 50, -700, 0, TRUE, TRUE);   //Robot sõidab 700 kraadi edasi
RotateMotorEx(OUT_BC, 17, 266, , TRUE, TRUE); //Robot keerab 266 kraadi vasakule
(10);                                                             //Robot ootab 10 ms et mootorid vussi ei läheks
}
}

Juhend: Lego rattad ja matemaatika

Alljärgnevalt juhis, kuidas arvutada erinevate Lego rataste korral välja otseliikumiseks või pööramiseks vajalik rattanurk kraadides.
 
Need kolm on peamised rattad mida kasutatakse Lego Mindstorm robotite ehitamisel.
Ratas
Diameeter
Ümbermõõt
Väike ratas
clip_image002
43,2 mm
135,7 mm
Keskmine ratas
clip_image004
56 mm
175,9 mm
Suur ratas
clip_image006
82 mm
257,6 mm
Alljärgnevalt on ära kirjeldatud moodused, kuidas arvutada välja mootori pöörded kraadides kui robot peab a) kindla maa edasi liikuma b) pöörama teatud nurga võrra nii, et üks ratas seisab c) pöörama teatud nurga võrra kohapeal.
Kraadides on tarvis tulemust seetõttu, et NXC-s ehk C-keeles programmeerides saab kasutada funktsiooni RotateMotorEx, mille abil saab roboti väga täpselt liikuma panna.
Huvitav nüanss on see, et peale keeramist funktsiooniga RotateMotorEx on vaja panna kasvõi 10ms pikkune wait, kuna muidu lähevad mootorid peast segi.
Kui näiteks alljärgnevas näites Wait lõpust ära võtta on tulemuseks mõõdetamatu segadus. Õigupoolest üritab robot oma mootorid sünkroonis panna liikuma esialgses suunas. Seega peale kolmandat repeati robot ainult keerleb kohapeal.

repeat(4){
RotateMotorEx(OUT_AB, 50, 500, 0, TRUE, TRUE);
RotateMotorEx(OUT_AB, 50, 365, 0, TRUE, TRUE);
Wait(MS_10);
}

 

Otseliikumine

Roboti otseliikumise korral teepikkuse väljendamine mootori pöörded kraadides.
image
Distants - vahemaa, mille robot peab läbima. Näiteks 200 mm (20 cm)
Ümbermõõt – roboti ratta ümbermõõt
x kraadi – mootori pöörded kraadides
 

Pööramine ühe rattaga

clip_image010Roboti keeramisel ühe rattaga (st. teine ratas on paigal) liikumise väljendamine mootori pööretes mis on antud kraadides.
image
Roboti pööramise nurk – see on kraadides väljendatud nurk, mille robot peab pöörama. Näiteks 90*
Rataste vahe – rataste keskkohast mõõdetud nende omavaheline kaugus. Näiteks 135 mm
x kraadi – mootori pöörded kraadides
 

Pööramine kohapeal

clip_image014Roboti keeramisel mõlema rattaga (st. rattad liiguvad vastassuundades) liikumise väljendamine mootori pööretes mis on antud kraadides.
image
Roboti pööramise nurk – see on kraadides väljendatud nurk, mille robot peab pöörama. Näiteks 90*
Rataste vahe – rataste keskkohast mõõdetud omavaheline kaugus. Näiteks 135 mm
x kraadi – mootori pöörded kraadides

Robotid

Ma alustan siis uue blogiga robotitest.
Täna ma tegin ühe boti endale kui keegi ei tea on botid lihtsalt robotid mis sõidavad ringi.

Isa andis ülesanded ja neid ma ka tegingi esimene ülesanne oli see et 1m edasi 180 kraadi pöörata ja siis jälle tagasi tulla ja uuesti 180 kraadi pöörata.
Ma tegin selle roboti jaoks programmi c-keeles. Kui keegi ei tea siis see on põhiline keel programmeerimises. Mu programm näeb välja selline:

 

 

 

 

 

task

main(){
repeat (2){                                                                        //Robot teeb kaks korda järjest ühte tsüklit
RotateMotorEx(OUT_BC, 50, -1400, 0, TRUE, TRUE);               //Robot sõidab 1400 kraadi edasi ehk 1m
RotateMotorEx(OUT_BC, 17, 333, 100, TRUE, TRUE);              //Robot pöörab 333 kraadi ehk 180 kraadi
Wait(50);                                                                          //Robot ootab 50 millisekundit et mootorid vussi ei läheks
}
}

 Teine ülesanne oli ruudu sõitmine:
task main()
{
repeat(4)
{
RotateMotorEx
(OUT_BC, 50, -420, 0, TRUE, TRUE);
RotateMotorEx(OUT_BC, 17, 166, 100, TRUE, TRUE);
Wait(10);
}
}

2 tund: Ratta läbimõõt ja mootori pöörete arv

Eelmisel tunnil õppisime arvutama roboti pööramiseks vajalikku mootori pöördenurka. Täna tuleb seda kasutada praktikas.

Kasutatavad materjalid:
Juhend- Lego rattad ja matemaatika
Juhend- Mootorite peamised käsud NXC-s

Tunni sisu:

Igaühel oli vaja endale BOT teha. Mõni oli juba valmis ja puuduolevad valmisid kiirelt.

Edasi oli vaja mõõta roboti andmed, ratta diameeter (lasin kõigil BOT-del erinevate suurustega rattad panna) ning ratastevaheline kaugus.

Enne programmeerimise juurde asumist tuli välja arvutada ülesandes vajaminevad numbrid.

Kõige rohkem tekitas probleeme viimase ülesande nurga arvutus. Antud on sisenurk, kuid robot pidi tegelikkuses keerama 180’ – 36’ = 144’

Lisaks tekitas probleeme funktsioon RotateMotorEx, mille keeramise järele tuli kirjutada Wait(10), kuid sellest on täpsemalt juttu pööramise arvutamise juhendis. Sisuliselt oli nende kolme ülesande lahendamisega poistel tegemist terveks tunniks (2h).


Arvuta välja ning kirjuta programm roboti liigutamiseks.

Roboti andmed.

·         Roboti ratta diameeter DR = ….   cm

·         Rataste vahe LR = ….  cm

Kirjuta alati välja valem arvutuskäigu kohta ja arvuta roboti liikumine.

Ülesanne 1.

Robot sõidab mööda joont edasi tagasi. Joone pikkus on 1m.

image

Esimese ülesande lahendus, numbrid sõltuvad konkreetsest BOT-st:

task main(){
repeat(2){                                     
RotateMotorEx(OUT_BC, 50, -1400, 0, TRUE, TRUE);
RotateMotorEx(OUT_BC, 17, 333, 100, TRUE, TRUE);
Wait(10);
} }

imageÜlesanne 2.

Robot sõidab ruudu, mille küljepikkus on 30cm. Nurk = 90’

 

Teise ülesande lahendus, kolmanda oma on analoogiline.

task main(){
repeat(4){
RotateMotorEx(OUT_BC, 50, -420, 0, TRUE, TRUE);
RotateMotorEx(OUT_BC, 17, 166, 100, TRUE, TRUE);
Wait(10);
}
}

image

Ülesanne 3.

Robot sõidab viisnurga, mille küljepikkus on 50cm. Nurk = 36’

 

 

 

.

Juhend: Loogika kasutamine

Loogikalülitused omavad NXT-maailmas alati ja ainult kahte väärtust: true või false (1 või 0).
1 ja 0 abil saab teha hulgaliselt tehteid ning lahendada erinevaid ülesandeid. Programmis tähistatakse seda tüüpi muutujat sõnaga bool (tuletatud sõnast Boolean ehk kahendmuutuja).
C-keeles muutuja defineerimine ja algväärtustamine:
bool ShootBall = FALSE;
Enimkasutatavad kahendmuutujatega tehtavad tehted on AND (JA), OR (VÕI), XOR (välistav VÕI), NOT (EI).
Kahendmuutujate tabelid
Loogikatehete vasted NXC-s:
AND tehte korral kasuta kahte ja märki &&
Alltoodud avaldistes muutub if lause tõeseks ainult siis kui mõlemad muutujad on tõesed. Kõik toodud kolm kombinatsiooni on õiged, kuid soovituslik on kasutada esimest kui kõige lühemat varianti.
if(ShootBall && ShootButton)
if(ShootBall == TRUE && ShootButton == TRUE)
if(ShootBall == 1 && ShootButton == 1)

OR tehte korral kasuta kahte püstist kriipsu ||
Alltoodud avaldistes muutub if lause tõeseks juba siis kui vaid üks muutuja on tõene ja jääb ka tõeseks kui mõlemad on 1-d. Kõik toodud kolm kombinatsiooni on õiged, kuid soovituslik on kasutada esimest kui kõige lühemat varianti.
if(ShootBall || ShootButton)
if(ShootBall == TRUE || ShootButton == TRUE)
if(ShootBall == 1 || ShootButton == 1)

NOT tehte korral kasuta hüüumärki !
Alltoodud avaldise sees muudab hüüumärk muutuja väärtuse vastupidiseks. If lause muutub tõeseks sel juhul kui muutuja on FALSE ehk 0. Kuigi kõik alljärgnevad avaldised annavad sama tulemuse, on soovituslik kasutada esimest kui lühimat.
if(!ShootBall)
if(ShootBall == FALSE)
if(ShootBall == 0)

1 tund: Roboti pööramine ja nurga arvutus

Tunni eesmärk on anda teadmine, kuidas on võimalik puhtalt matemaatika abil välja arvutada roboti edasiliikumiseks või keeramiseks vajalik nurk, mille peavad täitma mootorid.

Praktiliselt robotite katsetamiseni ei jõudnudki, terve tund kulus näidetele ja arusaamisele.

Sisuliselt said poisid teadmise kuidas välja arvutada kolme erinevat liikumist:

1. Roboti otseliikumine

2. Roboti pööramine nii, et üks ratas seisab

3. Roboti pööramine nii, et rattad pöörlevad erinevates suundades.

Kõik said praktilist tööd, mõõdeti joonlauaga üle rataste ümbermõõdud ning arvutasime nende järgi keskmise tõenäolise ümbermäädu ja diameetri.

Kogu tunni sisu sai kirja siia juhendisse: Juhend- Lego rattad ja matemaatika

Robomiku võistluse video 2011 jaanuar

Alljärgnevalt video 7.jaanuaril 2011 toimunud Robomiku võistlusest.

Parima koha sai tiim, kes kasutas pallide viskamiseks tennisepalli loopimise põhimõtet. Võrreldes tavaliste laskjatega kes lasid meetri kanti, lasid meie robot ning võitja ca 5m. Kaotus on valus, kuna meie robot jäi vaid 5cm-ga võitjale alla. NB! Tartus osalemise korral oleksime meie võitjad olnud Naeratus 

Kuna olime võitjast veidike maas, otsustasime oma robotile panna ühe kollase lisakummi juurde. Selle käigus aga selgus, et teised kummid (punased), mis robotit koos hoiavad on pisut välja veninud ning robot ei püsi enam koos.

Ühe proovilasu tegime ning see oli vähemalt 6m peale, seega raudne võidulask. Finaal-võistluse voorus ei pidanud meie robot siiski pingele vastu ning võidulasu tegi teine robot.

Kokkuvõtteks: Lego Mindstorm NXT võiks jääda nö. nutikate lahenduste jaoks. Tehtud palliviskamise ülesande korral jääb roboti piiriks alati Lego plastmassosade füüsiline vastupidavus.