Reaali Robootika.COM

Kuidas meil tuli välja FLL-Il roboti võistlus.

Meil käisid mardipäeval mardisandid otse siin kus me teeme robootikat. Alguses tulid nad meil trepikotta ning pärast ka akna alla. Need kes tulid trepikotta laulsid ja tantsisid meile, meie andsime neile natuke õunu ja küpsiseid. Peale seda läksid nad üles teisele korrusele. Kui nad alla tulid küsis Tomi kas nad võiksid meile veel esineda et seda filmida ning selle peale öeldi: “Mingi pervo oled vä!?”. Peale seda läksid nad välja ja me nägime veel rohkem mardisante õues ja andsime neilegi õunu ja küpsiseid. Nemad ainult lollitasid seal akna all. Kuid vähemalt sai Tomi neid filmida. Nad viskasid helbeid meile tuppa ja pärast me pidime need tolmuimejaga üles koristama.

Täna (pühapäeval) oli meil robootika ring. Mina ärkasin kell 4:50 ja mul läks vähemalt 15 minutit et olla nii värske kui võimalik. Tomi ja Marko ärkasid mõlemad väga vara. Marko jõudis kusagil 5:50 ja Tomi jõudis 6:00. Pilt meist kolmest hommikul kella 6-e paiku.

Igal FLL-I võistlusel on tarvis teha mitmeid asju. Üks neist on projekt. Projekti peab tegema sellel teemal mis on tänavuse aasta FLL-I teema milleks on Food Factor.

Meie tiim otsustas valida jäätise ning selle säilitamise. Kui sa ostad paki jäätist ning lähed siis koju mingi mõni tund siis võib jäätis ära sulada. Aga meie mõtlesime sellele lahenduse. Meil on kaks mõtet. Üks idee on pakend teha selline—> Kile tekstiga|Õhk|Foolium|Kile|Õhk|Kile||Foolium|Jäätis|. Teine idee on teha pappkarp, seest fooliumiga vooderdada, väljapoole trükkida etikett ja siis kiletada. Sellest tuleks pandipakend, seda saaks hästi taaskasutada. Üks meist ka arvutas välja kui palju need pakendid siis maksaksid.

(Kui te sellest pildist aru saate, seletage meile ka )

Ma tegin ühe roboti mis ronib kahe seina vahel üles-alla. Seda ehitades mul polnud mitte mingit probleemi. Kuid kui ma jõudsin programmeerimise juurde siis tekkis mul küll mõningaid probleeme. Kuid enne räägin milline oli mu roboti programmeerimise järjekord. Kõigepealt kui robot oli valmis siis polnud mingit muret esimese kolmandikuga alustada. Esimeses kolmandikus ma panin ta lihtsalt üles sõitma seni kuni ta näeb lähedamal kui 10 cm lage. Sellega erilisi probleeme ei tekkinud kuna see oli üpriski lihtne programm. Teise kolmandiku programmist ma panin roboti sõitma küll pikema programmiga kuid mõne algaja jaoks ka kergem ning seekord sõitis robot lõpmatuseni üles-alla. Minu viimane kolmandik programmist sõitis robot ka muidugi lõpmatusein üles alla kuid nüüd on see lühem ja kergem kui eelmine kord.

Mu isa tegi sellest ka video:

Programm näeb välja selline:

/*
Autor:Ramses Sepp 09.02.2011
See programm võimaldab robotil sõita kahe seina vahelt üles
*/

//See alamprogramm juhib roboti mootoreid üles-alla sõidul
void Liikumine(bool Yles, int KiirusSeinal){
	//Järgnev if lause peatab ühe või teise mootori kui robot on balansist väljas
	//Siin if-i lauses korrgeerib balanssi robot siis kui ta näeb oranþi
	if (Sensor(S2) > 50){
		//Need kaks järgmist rida suunavad kumb mootor peatub 
		//siis kui läheb üles-alla ja näeb oranþi
		if (Yles) Off(OUT_B);
		else Off(OUT_C);
		until(Sensor(S2) < 50);
		}
	//Siin else if-i lauses korrigeerib balanssi robot siis kui ta näeb musta
	else if(Sensor(S2) < 40){
		//Need kaks järgmist rida suunavad kumb mootor peatub 
		//siis kui läheb üles-alla ja näeb musta
		if (Yles) Off(OUT_C);
		else Off(OUT_B);
		until(Sensor(S2) > 40);
		}
	else{
		//Muidu sõidab robot lihtsalt kahe seina vahelt alla
		OnRevReg(OUT_BC, KiirusSeinal, OUT_REGMODE_SPEED);
		OnRev(OUT_A, 20);
		}
}
task main(){
SetSensorLowspeed(S4);
SetSensorLight(S2);
SetSensorLowspeed(S3);
bool TOP;
//Järgnev mootori programmi osa laiendab mõlemad mootorid seinte vastu
OnFwd(OUT_A, -75);
Wait(1000);
while (TRUE){
	//Siin vaatab kas lagi on lähedamal kui 10 cm
	if(SensorUS(S4) < 10){
		Off(OUT_BC);
		TOP = TRUE;
		}
	//Siin vaatab kas põrand on lähedamal kui 10 cm
	if(SensorUS(S3) < 10){
		Off(OUT_BC);
		TOP = FALSE;
		}
	//See pool paneb roboti alla sõitma
	if(TOP){
		Liikumine(FALSE, -15);
	}
	//See pool paneb roboti üles sõitma
	else{
		Liikumine(TRUE, 30);
	}
}
}

Noh mida siin veel rääkida peale selle, et mis robotid ma seekord tegin.

Seekord ma tegin “Explorer” robotid ehk “Maadeavastajad”. Ühe Exploreri tegin ainult kinni oleva sonariga ehk kaugus anduriga. Peale seda ma tegin ainult puuteanduriga. Kolmanda ma tegin mootoriga sonariga ja viimase tegin mootoriga sonariga ja puuteanduriga.
Esimese programm nägi välja selline:

task main(){
/*
DIRECTION muutuja abil määratakse kas robot

sõidab edasi või tagasi
DIRECTION = true: sõidab tagasi
DIRECTION = false: sõidab edasi
KAUGUS muutuja abil määrab robot kas peab 

tagasi sõitma
RAND muutuja abil määrab robot kas ta sõidab 

paremale või vasakule
*/
SetSensorLowspeed(S4);
bool DIRECTION;
int KAUGUS = 38;
int RAND;
while (true){
  if (SensorUS(S4) < KAUGUS){ //Kui robot näeb seina lähedamal

 kui 38 cm siis ta sõidab tagasi
    DIRECTION = true;
    if (DIRECTION){
      RAND = Random(2);
      switch (RAND)
      {
        case 0:               //Robot sõidab paremale
        RotateMotorEx(OUT_BC, 100, 332, -50, TRUE, TRUE);
        break;
        case 1:               //Robot sõidab vasakule
        RotateMotorEx(OUT_BC, 100, 332, 50, TRUE, TRUE);
        break;
        }
      }
    }
  else {
    DIRECTION = false;        //Muidu sõidab robot edasi
    OnRevSync(OUT_BC, 100, 0);
  }
}
}

Selle programmiga eriliselt raskusi e tulnud kuna ma sain abi oma ühest eelmisest programmist.

Nüüd tuleb siis teise roboti programm ehk ainult lülitiga:

task main(){
/*
muutuja DIRECTION määrab kas robot sõidab 

edasi või tagasi
muutuja RAND määrab suvaliselt kas robot 

pöörab tagurdades paremale või vasakule
*/
SetSensorTouch(S1);
bool DIRECTION;
int RAND;
while(true){
  if (Sensor(S1)== 1){
    DIRECTION = true;
    if(DIRECTION){
      RAND = Random(2);            //määratakse kummale poole 

sõidetakse kui tagurdatakse.
      switch (RAND)
      {
        case 0:                   //robot pöörab vasakule
        RotateMotorEx(OUT_BC, 100, 332, -50, TRUE, TRUE);
        break;
        case 1:                   //robot pöörab paremale
        RotateMotorEx(OUT_BC, 100, 332, 50, TRUE, TRUE);

        break;
        }
    }
  }
else {
     DIRECTION = false;           //robot sõidab edasi
     OnRevSync(OUT_BC, 100, 0);
     }
}
}

Selle programmiga mul ka erilisi raskusi ei tekkinud kuna jällegi sai kasutada eelneva programmi abi.
Minu kolmas programm oli siis pöörleva sonariga:

task main(){
SetSensorLowspeed(S4);

int VASAK; Selle muutujaga salvestan vasakule poole vaatamise kauguse
int PAREM; Selle muutujaga salvestan paremale poole vaatamise kauguse
while(true){
  if(SensorUS(S4) < 38){
  Off(OUT_BC);
    RotateMotor(OUT_A, 50, 90); robot vaatab vasakule
    VASAK = SensorUS(S4);
    RotateMotor(OUT_A, 50, -180); robot vaatab paremale
    PAREM = SensorUS(S4);
    RotateMotor(OUT_A, 50, 90); robot läheb omale kohale tagasi

    if(VASAK < PAREM){ kui vasakule vaatamise kaugus on väiksem kui 

paremale siis läheb robot paremale
      RotateMotorEx(OUT_BC, 50, -332, 50, TRUE, TRUE);
      }
    else{ kui vasak on suurem kui parem siis vasakule
      RotateMotorEx(OUT_BC, 50, -332, -50, TRUE, TRUE);
      }
    }
else{ muidu sõidab robot lihtsalt edasi
  OnRevSync(OUT_BC, 100, 0);
  }
}
}

Selle programmiga tekkisid mõned raskused näiteks kuidas salvestada sonari praegust näitu muutujasse.

Nüüd tuleb viimane programm mis ma tegin ehk liikuva sonari ja puuteanduriga see on umbes sama mis ainult liikuva sonariga ainult mõndades kohtades on lisatud juurde:

task main(){
SetSensorLowspeed(S4);
SetSensorTouch(S1);
int VASAK;
int PAREM;
while(true){
  if(SensorUS(S4) < 38 || Sensor(S1) == 1){
  Off(OUT_BC);
      if(Sensor(S1)==1){
        RotateMotor(OUT_BC, 50, 360);
      }
        RotateMotor(OUT_A, 50, 90);
        VASAK = SensorUS(S4);
        RotateMotor(OUT_A, 50, -180);
        PAREM = SensorUS(S4);
        RotateMotor(OUT_A, 50, 90);
        if(VASAK < PAREM){
          RotateMotorEx(OUT_BC, 50, -332, 50, TRUE, TRUE);
      }
      else{
        RotateMotorEx(OUT_BC, 50, -332, -50, TRUE, TRUE);
      }
    }
    else{
      OnRevSync(OUT_BC, 100, 0);
    }
}
}

Selle programmiga erilisi raskusi ei tekkinud ja sellele programmile ma filmisin ka video juurde:

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

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