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);

}

}

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
}
}

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
}
}

Ratas	Diameeter	Ümbermõõt
Väike ratas	43,2 mm	135,7 mm
Keskmine ratas	56 mm	175,9 mm
Suur ratas	82 mm	257,6 mm

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

Otseliikumine

Pööramine ühe rattaga

Roboti keeramisel ühe rattaga (st. teine ratas on paigal) liikumise väljendamine mootori pööretes mis on antud kraadides.

Pööramine kohapeal

Roboti keeramisel mõlema rattaga (st. rattad liiguvad vastassuundades) liikumise väljendamine mootori pööretes mis on antud kraadides.

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

 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);
}
}

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 D_R = ….   cm

·         Rataste vahe L_R = ….  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.

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);                                                               
}
}

Ü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);
}
}

Ülesanne 3.

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

.

bool ShootBall = FALSE;

if(ShootBall && ShootButton)

if(ShootBall == TRUE && ShootButton == TRUE)

if(ShootBall == 1 && ShootButton == 1)

if(ShootBall || ShootButton)

if(ShootBall == TRUE || ShootButton == TRUE)

if(ShootBall == 1 || ShootButton == 1)

if(!ShootBall)

if(ShootBall == FALSE)

if(ShootBall == 0)

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

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  

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.

Siin video robotist millega käisime seekord Robomikul võistlemas. Parimates katsetes saime palliviskekauguseks 6,5 meetrit.