See siin on loodud Tiigrihüppe Sihtasutuse programmi ProgeTiiger raames.
Maadeavastaja on selline robot, mis suudab ruumis iseseisvalt ringi liikuda sõltumata sealolevatest takistustest. See projekt õpetab, kuidas kauguse- ja puuteandurit kasutada ning muutujatele väärtusi omistada ja neid omavahel võrrelda.
Alljärgnevalt on käsitletud nelja erinevat maadeavastaja robotit. Esimesed on lihtsamad ning järgmised muutuvad keerukamateks.
1. Maadeavastaja puuteanduriga. Robot on varustatud puuteanduriga, mis tuvastab selle, kui robot on millelegi otsa sõitnud.
2. Maadeavastaja kauguseanduriga. Sellel robotil on ees kauguseandur. Kui robot näeb ees 20 cm kaugusel takistust, siis robot tagurdab ja keerab kas paremale või vasakule ning jätkab teekonda.
3. Maadeavastaja pöörava kauguseanduriga. Sellel robotil on peal mootoriga kauguseandur. Kui robot näeb ees 20 cm kaugusel takistust, vaatab robot kauguseanduriga paremale ja vasakule ning valib pöördesuuna sõltuvalt sellest, kummal pool on rohkem ruumi.
4. Maadeavastaja pöörava kauguseanduri ja puuteanduriga. Sellel robotil on peal mootoriga kauguseandur ja madalate ning väikeste objektide tuvastamiseks puuteandur. Kui roboti puuteandur tuvastab madalal takistuse või robot näeb ees 20 cm kaugusel takistust, vaatab robot kauguseanduriga paremale ja vasakule ning valib pöördesuuna sõltuvalt sellest, kummal pool on rohkem ruumi.
Roboti ehituse näol on tegemist tavapärase baasrobotiga, mida tuleb ülesannete edenedes täiuslikumaks ehitada.
Maadeavastaja robot puuteanduriga
![clip_image002[4]](/image.axd?picture=clip_image002%5B4%5D_thumb_3.png "clip_image002[4]")
Robot on ehitatud tavalise sõitva baasrobotina, millele on ette ehitatud puuteanduriga ühendatud tundel. Vähimagi takistuse ilmnemisel peab roboti ees olev tundel vajutama roboti puuteandurit.
Pärast seda, kui puuteandur on vajutatud, peab robot tagurdama ja seejärel juhuslikkuse alusel otsustama, kas keerata paremale või vasakule. Tagurdamine on vajalik, et vastu seina sõitnud robotile ei jääks keeramisel sein ette.
Programmi põhimõte on kõige paremini edasi antav plokkskeemiga, kus rombid tähistavad tsükleid (while, for) või tingimuslauseid (if) ja ristkülikud erinevaid tegevusi.
Programm alustab lõpmatu tsükliga ja puuteandur ei ole esmalt vajutatud. Järgmisena kontrollitakse if-lausega, kas puuteandur on vajutatud: alguses see pole, seega käivitub else-lause ja robot sõidab lihtsalt edasi. Ja programm suundub täitma järgmist tsüklit ehk uuesti kontrollima, kas puuteandur on vajutatud.
Seda tsüklit korratakse ja puuteanduri asendit kontrollitakse 10 000 korda sekundis. Seega võib kindel olla, et siis, kui puuteandur on vajutatud, saab roboti programm sellest väga kiiresti teada ning suundub skeemi järgi paremale ehk JAH suunas (programmis on selleks if-tingimuse esimene pool). Mootorid peatatakse ja tagurdatakse pisut. Seejärel käivitab programm järgmise if-tingimuse, mis kontrollib juhuslikku numbrit 1 või 0 ning vastavalt valikule keerab kas paremale või vasakule.
Näide. Maadeavastaja puuteanduriga
task main()
{
SetSensorTouch(S1);
//muutuja Rand abil valib robot paremale või vasakule keeramise
int Rand;
while (TRUE)
{
//programm valib juhusliku numbri 1 ja 0 vahel
Rand = Random(2);
//Kui puuteandur on vajutatud, siis robot tagurdab ja
//keerab kas paremale või vasakule
//kui puuteandur pole vajutatud, sõidab robot otse
if (Sensor(S1))
{
Off(OUT_BC);
//robot tagurdab
RotateMotorEx(OUT_BC, 100, 360, 0, TRUE, TRUE);
if (Rand)
//robot keerab paremale
RotateMotorEx(OUT_BC, 100, 335, -50, TRUE, TRUE);
else
//robot keerab vasakule
RotateMotorEx(OUT_BC, 100, 335, 50, TRUE, TRUE);
}
else
{
//robot sõidab otse
OnFwdSync(OUT_BC, 100, 0);
}
}
}
Maadeavastaja robot kauguseanduriga
![clip_image004[4]](/image.axd?picture=clip_image004%5B4%5D_thumb_2.png "clip_image004[4]")
Robot on ehitatud tavalise sõitva baasrobotina, millele on lisatud kauguseandur. Kauguseandur võimaldab robotil aru saada, kui see hakkab lähenema takistusele, näiteks seinale. Kui robot on takistusele lähemal kui 20 cm, keerab robot juhuslikkuse alusel kas paremale või vasakule.
Programmi põhimõte on kõige paremini edasiantav järgmise plokkskeemiga. See on väga sarnane eelmisele, puuteanduriga maadeavastaja juhule.
Kui programm alustab ja kauguseandur näeb kaugemale kui 20 cm, suundub programm joonisel EI suunas ning robot alustab otse liikumist. Seda tsüklit korratakse ja kauguseandurit kontrollitakse 10 000 korda sekundis. Seega võib kindel olla, et kui takistus roboti teel ilmneb, saab programm sellest väga kiiresti teada ning suundub joonise järgi paremale ehk JAH suunas. Seejärel keerab robot juhusliku valiku 0 või 1 alusel kas paremale või vasakule.
Näide. Maadeavastaja kauguseanduriga
task main()
{
SetSensorLowspeed(S1);
//muutuja Kaugus abil mõõdab robot kaugust takistuseni
int Kaugus = 20;
//muutuja Rand abil valib parem/vasak keeramise
int Rand;
while (TRUE)
{
//programm valib juhusliku numbri 1 ja 0 vahel
Rand = Random(2);
//Kui robot näeb seina lähemal kui 20 cm,
//siis keerab paremale või vasakule
//kui seina näha pole, siis sõidab robot otse edasi
if (SensorUS(S1) < Kaugus)
{
if (Rand)
//robot keerab paremale
RotateMotorEx(OUT_BC, 100, 335, -50, TRUE, TRUE);
else
//robot keerab vasakule
RotateMotorEx(OUT_BC, 100, 335, 50, TRUE, TRUE);
}
else
{
//robot sõidab otse
OnFwdSync(OUT_BC, 100, 0);
}
}
}
Maadeavastaja robot pöörava kauguseanduriga
![clip_image006[4]](/image.axd?picture=clip_image006%5B4%5D_thumb_1.png "clip_image006[4]")
See robot on eelmise maadeavastaja edasiarendus sellise täiendusega, et kauguseandur peab olema ühendatud lisamootori külge, nii et robot saab „näha“ lisaks ettepoole suunale ka paremale ja vasakule. Kauguseandur peaks asuma vähemalt 10 cm kõrgusel, kuna madalamal olles võib põrandalt peegeldunud signaal hakata andurit segama.
Eelmise näitega võrreldes on siin parandatud roboti keeramist. Robot keerab alati selles suunas, kus on rohkem vaba ruumi. Näiteks kui robot jõuab nurka, siis pöörava kauguseanduriga on täiesti kindel, et ta keerab nurgast välja. Juhusliku valiku alusel eelmise näite baasil võib aga tekkida olukord, kus robot ei pääse mõne aja vältel nurgast välja.
Keerava kaugusanduri tööd on hea selgitada alloleva pildi abil. Kui robot on jõudnud eesolevast takistusest 20 cm kaugusele ja seisma jäänud, vaatab robot kauguseanduriga 90 kraadi paremale ja seejärel 180 kraadi vasakule. Robot salvestab mõlemas asendis mõõdetud kaugused muutujatesse ParemPool ja VasakPool ning võrdleb neid seejärel if-tingimuslauses if(ParemPool > VasakPool). Üks neist on alati suurem ja selle alusel robot otsustabki, kummale poole keerata, et teekonda jätkata. Joonisel on vasakpoolne takistus kaugemal, st. robot pöörab vasakule.
![clip_image008[4]](/image.axd?picture=clip_image008%5B4%5D_thumb.png "clip_image008[4]")
Näide. Pöörava kauguseanduriga maadeavastaja
task main()
{
SetSensorLowspeed(S1);
//muutuja Kaugus abil mõõdab robot kaugust takistuseni
int Kaugus=20;
int ParemPool;
int VasakPool;
while(TRUE)
{
if(SensorUS(S1) < Kaugus)
{
//robot jääb seisma
Off(OUT_BC);
//kauguseandurit mootor 90 kraadi paremale
RotateMotor(OUT_A, 25, 90);
//omistab muutujale ParemPool kauguseanduri väärtuse
ParemPool = SensorUS(S1);
//kauguseanduri mootor 180 kraadi vasakule
RotateMotor(OUT_A, 25, -180);
//omistab muutujale VasakPool kauguseanduri väärtuse
VasakPool = SensorUS(S1);
//robot keerab kauguseanduri jälle keskasendisse
RotateMotor(OUT_A, 25, 90);
//kui ParemPool on suurem kui VasakPool,
//keerab robot paremale
//kui ei ole suurem,keerab vasakule
if(ParemPool > VasakPool)
RotateMotorEx(OUT_BC, 50, 217, 100, TRUE, TRUE);
else
RotateMotorEx(OUT_BC, 50, 217, -100, TRUE, TRUE);
}
else
{
//robot sõidab otse
OnFwdSync(OUT_BC, 100, 0);
}
}
}
Maadeavastaja kauguseanduri ja puuteanduriga
![clip_image010[4]](/image.axd?picture=clip_image010%5B4%5D_thumb_1.png "clip_image010[4]")
See robot on eelmistega võrreldes kõige täiuslikum.
Kõrgemate takistuste korral töötab kauguseandur, kuid madalate takistuste korral, mida kauguseandur ei näe, töötab roboti tundel koos puuteanduriga.
Kasuta eelnevalt ehitatud robotit, millel on kõrgemal mootori peal kauguseandur ning alumises osas tundlaga varustatud puuteandur.
Selle roboti programmi tööpõhimõte on järgmisel plokkskeemil. Robot ootab kas puuteanduri või kauguseanduri rakendumist if-tingimuses if(SensorUS (S1) < Kaugus || Sensor(S2)), nende vahel olevad kaks püstist kriipsu || tähistavad või-märki. See tähendab, et kui ükskõik kumb anduritest rakendub, siis igal juhul muutub if-tingimus tõeseks ja robot jääb seisma.
Seejärel on vaja kindlaks teha, millise anduri rakendumine põhjustas roboti seismajäämise. Siin programmis kontrollitakse puuteandurit: kui see on vajutatud, jäi robot seisma tänu puuteandurile. Robot tagurdab, et keeramisel ei jääks sein segama. Kauguseanduri rakendumise korral robot ei tagurdaks, kuna sel juhul sein roboti keeramist ei segaks. Edasi toimub sarnaselt eelmisele variandile paremale-vasakule kauguseanduriga kauguse mõõtmine ning otsustamine, millises suunas edasi sõita.
Näide. Pöörava kauguseanduri ja puuteanduriga
task main()
{
SetSensorLowspeed(S1);
SetSensorTouch(S2);
//muutuja Kaugus abil mõõdab robot kaugust takistuseni
int Kaugus=20;
int ParemPool;
int VasakPool;
while(TRUE)
{
if(SensorUS(S1) < Kaugus || Sensor(S2))
{
//robot jääb seisma
Off(OUT_BC);
//kui puuteandur on vajutatud, siis robot tagurdab
if(Sensor(S2))
{
//robot tagurdab
RotateMotor(OUT_BC, -50, 360);
}
//kauguseanduri mootor 90 kraadi paremale
RotateMotor(OUT_A, 25, 90);
//omistab muutujale ParemPool kauguseanduri väärtuse
ParemPool = SensorUS(S1);
//kauguseanduri mootor 180 kraadi vasakule
RotateMotor(OUT_A, 25, -180);
//omistab muutujale VasakPool kauguseanduri väärtuse
VasakPool = SensorUS(S1);
//robot keerab kauguseanduri jälle keskasendisse
RotateMotor(OUT_A, 25, 90);
//kui ParemPool on suurem kui VasakPool,
//keerab robot paremale
//kui ei ole suurem,keerab vasakule
if(ParemPool > VasakPool)
RotateMotorEx(OUT_BC, 50, 217, 100, TRUE, TRUE);
else
RotateMotorEx(OUT_BC, 50, 217, -100, TRUE, TRUE);
}
else
{
//robot sõidab otse
OnFwdSync(OUT_BC, 100, 0);
}
}
}