Jalgpallirobot

Järgnev õpetus on koostatud TTÜ avatud ülikooli ja MTÜ TTÜ Robotiklubi koostöös eesmärgiga aidata Robotexil osalevaid või seda plaanivaid võistkondi.

Robotex on eesti suurim ja populaarseim võistlus, mis leiab aset igal aastal novembris või detsembris Tallinnas. Võistlusel on ette antud lähteülesanne, mis tavaliselt muutub igal aastal. Täpsemat infot võistluse ja reeglite kohta saab aadressilt http://www.robotex.ee

Käesolev juhend sisaldab täielikku dokumentatsiooni ja praktilisi näpunäiteid ühe Robotex 2010 reeglitele vastava roboti ehitamiseks. Robot on oma ülesehituselt ja võimetelt ette nähtud juuniorite klassis osalemiseks, kus robotitel pole kasutada kalleid ja kiireid mootoreid, pisikesi arvuteid ning kaameraid. Sellesse klassi on oodatud gümnaasiumiõpilased ja robootikaga alles tutvust tegevad huvilised.

Juhendi baasil loodud platvormi eesmärgiks on olla lihtne ning odav esimene katsetus robotite ehitamise vallas. Sellest lähtuvalt kasutatakse laialt saadaolevaid konstruktsioonimaterjale ning elektroonikakomponente. Roboti baaskomponentideks on valitud Kodulabori komplektis sisalduvad moodulid. Kuna kõiki komponente kodulaborites siiski ei leidu, lisanduvad mõningad spetsiifilised osad. Tänu moodularhitektuurile võib iga soovija robotit muuta vastavalt oma äranägemisele.

Kuna ilma pilditöötluseta ja kallite laserkaugumõõdikuteta on pallide leidmine väljakult tehniliselt üsna keerukas, tuleb minna lihtsama vastupanu teed ja kaugelt avastamise asemel palle aktiivselt ringi sõites otsida. Selleks on roboti algoritmis ette nähtud väljakul edasi-tagasi sõitmine ja pallide juhuslik avastamine.

Liikumine väljakul

Robot kasutab pallide leidmiseks ultraheli kaugusandurit. Andur on asetatud mõõtma kaugust roboti parema külje peale. Pallide otsimiseks sõidab robot väljaku keskel ühe värava juures teise juurde ja mõõdab pidevalt temast paremale jäävate objektide kaugust. Kui roboti ja seina vahele jääb pall siis kauguse näit väheneb ja robot võtab hoo maha, et vaikselt liikudes pallist mööduda nii, et kaugusanduri näit jälle suureneks. Sedasi saab robot üpris täpselt palli kõrvale sõita.

Palli otsimine paremale suunatud ultrahelianduri abil

Edasi on põhimõtteliselt lihtne - robotil tuleks keerata 90 kraadi paremale ja sõita pallini, kuid paraku ei ole palli kõrvale seisma jäämine ja pööre nii täpne, et robot saaks kätte poole meetri kaugusel oleva palli. Selleks on pärast palli avastamist kaks varianti: kohe palli püüdma minek või selle lähemalt otsimine. Kui pall asub robotist kuni 30 cm kaugusel pöörab robot kohe palli poole ja üritab selle kätte saada nii nagu on näidatud ka järgneval skeemil:

Lähedal seisnud palli püüdmine

Kui pall asub kaugemal kui 30 cm siis robot sõidab esmalt edasi veel 10 cm, siis pöördub 90 kraadi paremale ja hakkab otse seina suunas sõites ultrahelianduriga otsima palli mis peaks robotist taaskord paremat kätt olema. Nii kui ultraheliandur näeb lähedal olevat objekti, sõidab robot natuke edasi, pöördub teist korda 90 kraadi paremale ja saab palli üsna nina alt kätte. Seda kauge palli leidmise algoritmi iseloomustab järgnev skeem:

Kaugel seisnud palli püüdmine

Robot saab pallianduri abil aru kas ta on palli kätte saanud või mitte. Palli püüdmiseks on roboti ninas V-kujuline lehter ja selle kohal pöörlev kummist rull mis paneb lehtrisse sattunud palli pöörlema roboti suunas. Palli pööritamine takistab selle minema veeremist roboti liikumise ajal.

Pärast palli kättesaamist hakkab robot otsima vastase väravat kuhu pall toimetada. Värava leidmiseks on väravate kohal infrapuna (IR) majakad mis kiirgavad väljaku suunas RC5 protokolliga signaale, ehk põhimõtteliselt on saatjad justkui telekapuldid. Värava leidmiseks on robotil kahe kanaliga RC5 vastuvõtja millel on kahe infrapuna detektori vahel sein. Kui vastuvõtja on suunatud majaka suunas, kiirgab majakas mõlemasse detektorisse; kui vastuvõtja on majaka suhtes viltu, siis signaal jõuab ainult ühte detektorisse. Vastavalt sellele milline detektor majakat “näeb” saab robot aru värava suunast. Kui suund on õige saab robot otse värava suunas sõita.

Värava suuna leidmine RC5 vastuvõtja abil

Roboti ees on ~8 cm kõrgusel infrapuna kaugusandur, mis mõõdab takistuste kaugust. Takistuseks võivad võistlusel olla vastase robot või seinad. Sellesama anduriga saab robot ka aru väravast kuna väravate tagumise seina alumises 10 cm osas on riie millelt infrapuna kiirgus peegeldub. Sõites värava suunas ja jõudes värava seinast ~20 cm kaugusele lõpetatakse palli kinnihoidmine ja lükatakse see väravasse. On oht, et värava suunas sõites võib robot värava seina asemel märgata vastast - selleks ootab robot enne palli lahti laskmist natukese, lootuses, et vastane liigub eest ära.

Takistustest hoidumine ja värava leidmine infrapuna kaugusanduri abil

Löögimehhanism pallide kaugel väravasse löömiseks puudub, kuna see on tehniliselt keerukas ja otseselt pole seda vaja. Pärast palli vastase väravasse lükkamist hakkab robot palle otsima oma värava suunas liikudes.

Jalgpalliroboti keskseks osaks on Pololu RP5 lintidega veermik sellele kinnitatava alusplaadiga. Alusplaadi külge kinnitatakse omakorda rullimehhanism, elektroonikamoodulid, andurid, koodrid, jms. Jalgpalliroboti konstruktsiooni väljatöötamisel on lähtutud sellest, et robot oleks võimalikult kompaktne, lihtne ja käepäraste vahenditega ehitatav. Materjalide ja erinevate detailide valikul on arvestatud nende kättesaadavusega.

Pololu RP5 veermik

Alusplatvormina kasutatakse Pololu RP5 lintidega veermikku. Veermikuga on kaasas kaks alalisvoolumootorit, kummagi lindi jaoks üks. Nende abil suudab veermik liikuda kiirusega kuni 15 cm/s. Lindid tagavad platvormile hea manööverdamisvõime. Lisaks on platvormiga kaasas ka patareihoidik 6 AA suuruses patarei jaoks. Platvormi mõõtmed on 180 mm x 140 mm x 60 mm. Augud alusplaadi kinnitamiseks on platvormil algselt juba olemas, kuid need tuleb siiski veel keermestada. Rohkem informatsiooni veermiku ja selle tellimise kohta saab järgnevalt aadressilt: http://www.pololu.com/catalog/product/1060

Alusplaat

Alusplaat seob omavahel jalgpalliroboti kõiki detaile. Erinevate komponentide kinnitamiseks on alusplaadile puuritud vajalikud augud. Kõik komponendid on seejuures kinnitatud M3 polte ja mutreid kasutades. Alusplaat ise kinnitatakse veermiku külge nelja poldi abil. Lisaks poldiaukudele on alusplaadil auk patareihoidiku lihtsamaks väljavõtmiseks ning kaks auku koodrite kaablite jaoks. Alusplaadile tuleb teha ka kaks painutust (vt pilti). Alusplaadi materjali valikul tuleb arvestada sellega, et materjali oleks võimalik painutada.

Rullimehhanism

Rullimehhanism koosneb haaratsist, rullist, rulli kummirõngastest, rulli käitavast alalisvoolumootorist ja hingest, mille abil mehhanism alusplaadi külge kinnitatakse. Haaratsile kinnitatakse ka kahepoolse teibiga optiline andur. Alalisvoolumootorina kasutatakse Kodulabori Micro motors L149.6.10 reduktoriga mootorit.

Haarats

Haarats seob omavahel rullimehhanismi kõiki komponente. Haaratsi külge kinnitatakse alalisvoolumootor, optiline andur ning hing. Lisaks sellele on haaratsi üheks põhiülesandeks golfipalli fikseerimine rulli ette. Haarats on konstrueeritud nii, et golfipalli sattumisel haaratsi ette suunatakse see rulli pindade poole. Haaratsi antud ehitus takistab ka golfipalli minema veeremist roboti pööramisel. Kuna haaratsile tuleb teha mitmeid painutusi, peab materjali valikul sellega arvestama.

Rull ja kummirõngad

Rulli tööpõhimõte seisneb palli sellisel viisil pöörlema panemises, et see kogu aeg roboti poole veereks . Rulli diameeter on 20 mm ja laius 50 mm. Rulli ühte otsa on puuritud auk mootori võlli jaoks ning sellega risti on puuritud ja keermestatud teine auk, mille kaudu poldi abil rull võlli külge fikseeritakse.

Rullile kinnitatakse kaks kummirõngad siseläbimõõduga 19 mm ja välisläbimõõduga 30 mm, kummide laius on 15 mm. Kummidevaheline kaugus rullil on 10 mm. Kummid tagavad parema kontakti rulli ja golfipalli vahel ja seega golfipalli parema püsimise rulli ees.

IR andur, RC5 vastuvõtja kinnitusega

Infrapuna kaugusanduri ning RC5 vastuvõtja kinnitamiseks on lihtne U-kujulise profiiliga kinnitus. Kinnitusele on puuritud augud infrapuna kaugusanduri ja kinnituse enda alusplaadi külge kinnitamiseks. RC5 vastuvõtja fikseerimiseks kasutatakse kahepoolset teipi. Kuna tehakse painutusi, peab sellega ka kinnituse materjali valikul.

Kodulabori moodulid puksidel

Patareihoidiku väljavõtmise võimaldamiseks on Kodulabori moodulid paigaldatud alusplaadile puksidega. Alusplaadil on moodulite kinnitamiseks puuritud vastavad augud. Moodulid paiknevad kihiliselt ning on omavahel kergesti ühendatavad.

Roboti ehitamiseks kasutatakse Kodulabori täiskomplekti, mis sisaldab järgnevaid mooduleid (eraldi plaate):

• AVR ATmega128 arendusplaat (kontroller)
• Kasutajaliides ehk sisend-väljundmoodul (nupud, valgusdioodid, 2 x LCD väljund, 7-segment-indikaator)
• Mootorite moodul
• Andurite moodul

Moodulite pikema kirjelduse koos pistikute piikide täpse kirjeldusega leiab leheküljelt

http://home.roboticlab.eu/et/hardware/homelab

Järgneval pildil on toodud lihtsustatud ülevaade andurite jms ühendamisest.

Robotil vajab toitepinget nii kontrolleri moodul kui ka mootorite moodul. Mõlemad kasutavad energiaallikana sama akupatareid. Kasutatakse kaheks hargnevat juhet. MOotorite mooduli toitepistiku ühendamise õpetus on lehel

http://home.roboticlab.eu/et/hardware/homelab/motor

NB! Standardse akupatarei fikseeritud pinge tõttu peab kontrolleri plaadil lühistama dioodsilla. Silla funktsioon plaadil on pöörata toitepinge polaarsus alati ühte pidi. See tähendab, et silda kasutades pole toitepinge polaarsus tähtis. Paraku jääb sillal u 1,5V pingelangu, mis on lubamatult palju.

Lühistades silla on toitepinge õige polaarsus tähtis! Pistiku keskmine piik on positiivne ja välime äär negatiivne.

Optokatkesti

Roboti veermikul on mõlema lindi ülekandes 2 aukudega hammasratast. Asetades optokatkesti niimoodi hammasratta kohale, et see jääb optokatkesti pilu vahele saab optokatkestiga registreerida hammasrattas olevaid auke. Kui optokatkesti vahele jääb auk, siis optokatkesti ühes otsas oleva valgusdioodi valgus kiirgab teises otsas oleva fototransistori peale ja viimane hakkab voolu juhtima. Lugedes pöörlevas hammasrattas olevaid auke saab selle info põhjal välja arvutada läbi teepikkuse. Originaalis on mõlemas veermiku hammasrattas üks auk, kuid sinna tuleb sümmeetriliselt juurde puurida 2 auku, et koodri täpsust parandada. Sedasi saab lindi läbitud teepikkust mõõta ligikaudu 1 cm täpsusega.

Koodrid on ühendatud Kodulabori Mootorite mooduli “encoder” pistikupesas. Vasaku poole kooder on ülemises, parema poole kooder alumises pesas. Koodrite impulside lugemiseks kasutatakse tarkvara Kodulabori teegi koodrite moodulit.

RC5 vastuvõtja

Robotexil on väravate kohale paigutatud infrapuna signaali saatjad, mis edastavad PHILIPS’i RC5 protokolli abil kanaleid 1 kuni 4. Nende signaalide vastuvõtmiseks on tehtud eraldiseisev moodul. Vastuvõtumoodul ühendatakse kodulabori kommunikatsioonimooduliga kaabliga, mille ühendusskeem on välja toodud plokkskeemis. Samas on välja toodud info vastuvõtja olulisemate komponentide kohta.

Vastuvõtumoodulile on paigutatud kaks signaali vastuvõtjat/demoduleerijat. Tänu sellele on võimalik paika panna roboti asend väravate suhtes.

Vastuvõtja saadab välja UART pakette, milles sisaldub infrapunavastuvõtja indeks ning vastuvõetud kanal. Väljasaadetavate UART pakettide kirjeldused on välja toodud allpol olevates tabelites

Vastuvõtja indeksiga 0

RC5 vastuvõtja plokkskeem

Vastuvõtja indeksiga 1

Palli tuvastamiseks rulliku all kasutatakse infrapuna peegeldusandurit. Saatajalt peegeldunud kiirgus jõuab vastuvõtjasse ja selle kiirguse intensiivsuse järgi saab määrata objekti kauguse. Intensiivsus sõltub lisaks kaugusele ka objekti pinna värvist ja siledusest. Robotexi ülesande golfipall on alati ühesugune ja seega vastab igale intensiivuse tasemele kindel kaugus andurist.

Pallianduri skeem

Kuna võistlusel on alati palju välklampe, kaameraid, valgusteid jms infrapunakiirguse allikaid, siis kasutatakse moduleeritud signaali, st saatja kiirgab teatud sagedusel ja vastuvõtja reageerib ainult sellel sagedusel olevale signaalile. Kõik selle teeb ära üks integraallülitus - Hamamatsu S4282-51. Ainsaks väliseks komponendiks on infrapunakiirgur (diood) ning tundlikkust reguleeriv takisti jadamisi dioodiga.

Pallianduri skeem on näidatud pildil. U1 on Hamamatsu S4282-51 andur. Kondensaator C1 silub toitepinge kõikumist. Kuna IP-diood võtab üsna palju voolu, siis selle sisse-välja lülitamise hetketel muutub voolutugevus anduri juhtmetes. Juhtmete induktiivsuse tõttu ei saa muutus toimuda hetkeliselt ja kondensaator täidab lühiajalise energiaallika osa. Kondensaatori parameetrid pole kriitilised. Peaasi, et nimipinge ületab 5V ja mahtuvus 1uF või rohkem.

Takisti R1 määrab anduri tundlikkuse. Ilma takistita oleks anduri reageermiskaugus u 5cm (sõltub ka IP-dioodi valikust). Takisti valimine käib katse-eksituse meetodil (vahemik 0 - 30 oomi).

Peegeldusandur

Dioodi valimisel tuleb lähtuda S4282-51 andmelehel märgitud lainepikkusest (800nm), kus andur on kõige tundlikum. Dioodi kiirgusnurk peaks olema võimalikult väike, et palliandur näeks ainult otse ette. Suure nurgaga dioodi puhul võib andur reageerida juba siis, kui pall pole täpselt otse anduri ees. Dioodi kiirgusnurk 11 kraadi ja alla selle tagab hea tulemuse.

Pistik JP1:

1. Signaal, madal kui andur tuvastab palli
2. Toide +5V
3. Maa (0V)

Roboti tarkvara on kirjutatud AVR Studios C keeles. Tarkvara kasutab kodulabori teeki ja AVR-GCC kompilaatorit mis tuleb kaasa WinAVR-iga. Programm on jagatud funktsioonide järgi mitmeks failiks - näiteks on sõitmise funktsioonide ja andurite näitude lugemiseks erinevad failid. Põhifailis asub main funktsioon mis käivitab kõik juhtimis- ja tagasiside protsessid ja kus asub ka roboti algoritm.

Programm on üles ehitatud võimalikult lihtsal kujul. Kui hea praktika kohasel on soovitatav teha juhtalgoritmid olekumasina põhjal, siis siin tulnuks olekuid ja olekute vahelisi siirdeid nii palju, et programmikood oleks liiga segaseks läinud. Seepärast on kogu algoritm kirjutatud järjestikuse koodijadana. Selleks, et algoritmis saaks kiirelt ja mugavalt lugeda andurite näite, juhtida mootoreid ja kuvada infot, on kõik muud protsessid toimima pandud katkestuste pealt. Katkestuste pealt töötades ei sega mõõtmis- ja juhtimisprotsessid algoritmi tööd ja vastupidi - need toimuvad paralleelselt.

Järgnevalt on toodu roboti main funktsioon kus käivitatakse kõik katkestustel toimuvad protsessid ja alustatakse algoritmi täitmist. Selleks, et robotit saaks peatada toimub tsüklites ja pausi funktsioonides (mis on samuti tsüklid) programmi töötamist näitava muutuja kontroll. Nii kui katkestuses töötav programmiosa tuvastab stopp-nupu vajutamise, nullitakse ka töötamist näitav muutuja ja algoritm hüppab goto käsuga uuesti algusesse. goto on jällegi üpris harv nähtus, aga siinkohal on see üpris asjakohane käsk.

//
// Main program.
//
int main(void)
{
    unsigned short ball_distance;
    unsigned short wall_distance;
    signed char dir;
    bool goal_to_search = false;
    bool goal_timeout_activated = false;
 
     // Initialize hardware.
    init();
 
    // Endless loop.
    while (true)
    {
 
start:
 
        // Display mode
        segment_display_write(0);
 
        // Stop motors.       
        chassis_stop();
        chassis_use_roller(0);
 
        // Clear LEDs.
        pin_set(led_red);
        pin_set(led_yellow);       
 
        // Wait until start button pressed.
        while (pin_get_value(button_start));
        working = true;       
 
        // Drive to the center
        wall_distance = sensors_ultrasonic_distance();
        chassis_step_drive(100, 0, MM_TO_STEPS(50));
        work_step_wait();
        chassis_step_drive(100, -100, 20);
        work_step_wait();
        chassis_step_drive(100, 0, MM_TO_STEPS(1000 - wall_distance));
        work_step_wait();
        chassis_step_drive(-100, 100, 21);
        work_step_wait();
 
        chassis_stop();
        work_delay(300);
 
search:
 
        // Display mode
        segment_display_write(1);
 
        // Stop the roller
        chassis_use_roller(0);
 
        // Search by driving.
        chassis_drive(90, 0);
 
        // Wait until any object close enough.
        while (true)
        {
            WORK_CHECK;
 
            // Stumbled upon a random ball ?
            if (sensors_is_ball())
            {
                goal_to_search = false;
                chassis_use_roller(1);
                chassis_step_drive(90, 0, MM_TO_STEPS(50));
                work_step_wait();
                goto search_goal;
            }
 
            // Something on the right ?           
            if (sensors_ultrasonic_distance() < 600)
            {
                goto precise_search;
            }
 
            // Something in front ?
            if (sensors_infrared_distance() < 200)
            {
                goal_to_search = !goal_to_search;
                goto turn_around;
            }
 
            chassis_drive(90, 0);
        }
 
precise_search:
 
        // Display mode
        segment_display_write(2);
 
        // Drive slowly for 3s.
        chassis_drive(50, 0);
        timeout_start(5000);
        ball_distance = 10000;
 
        // Drive until distance begins to increase.       
        while (true)
        {
            WORK_CHECK;
 
            // Something in front ?
            if (sensors_infrared_distance() < 200)
            {
                goal_to_search = !goal_to_search;
                goto turn_around;
            }
 
            // Timeout ?
            if (timeout_done())
            {   
                if(sensors_ultrasonic_distance() < 600)
                {
                    wall_distance = sensors_ultrasonic_distance();
                    chassis_step_drive(0, -100, 10);
                    work_step_wait();
                    chassis_step_drive(90, 0, MM_TO_STEPS(750 - wall_distance));
                    work_step_wait();
                    chassis_step_drive(0, 100, 10);
                    work_step_wait();
                }
                else
                    goto search;
            }
 
            // Remember closest distance.
            ball_distance = min(ball_distance, sensors_ultrasonic_distance());
 
            // Robot passed the ball ?
            if (sensors_ultrasonic_distance() > 600 && timeout_get_counter() > 500)
            {
                goto turn_to_ball;
            }
        }
 
turn_to_ball:
 
        // Light LED.
        pin_clear(led_yellow);               
 
        // Ball close enough or far away ?
        if (ball_distance < 300)
        {
            // Display mode
            segment_display_write(3);
 
            // Stop.
            chassis_stop();
            work_delay(300);
 
            // Turn chassis to the right 90 degrees.
            chassis_step_drive(-100, 100, 19);
            work_step_wait();       
 
            // Start roller.
            chassis_use_roller(1);
 
            // Approach ball
            chassis_step_drive(90, 0, MM_TO_STEPS(ball_distance + 150));
 
            while (!chassis_is_step_drive_complete() && !sensors_is_ball())
            {
                WORK_CHECK;               
            }           
 
            // Got the ball ?
            if (sensors_is_ball())
            {
                chassis_step_drive(90, 0, MM_TO_STEPS(50));
                work_step_wait();
                chassis_stop();
                work_delay(300);
                goto search_goal;
            }
            // Drive back
            else
            {
                chassis_step_drive(-90, 0, MM_TO_STEPS(ball_distance + 50));
                work_step_wait();
                chassis_step_drive(0, -100, 10);
                work_step_wait();
                goto search;
            }
        }
        // Ball far away ?
        else
        {
            // Display mode
            segment_display_write(4);
 
            // Drive bit more
            chassis_step_drive(90, 0, MM_TO_STEPS(150));
            work_step_wait();   
 
            // Turn chassis to the right 90 degrees.
            chassis_step_drive(0, 100, 10);
            work_step_wait();   
 
            // Start driving towards the border.
            chassis_drive(75, 0);       
 
            // Stumbled upon a random ball ?
            if (sensors_is_ball())
            {
                goal_to_search = false;
                chassis_use_roller(1);
                chassis_step_drive(90, 0, MM_TO_STEPS(50));
                work_step_wait();
                goto search_goal;
            }
 
            // Drive until something close enough.
            while (true)
            {
                WORK_CHECK;                   
 
                // See the ball ?
                if (sensors_ultrasonic_distance() < 300)
                {
                    ball_distance = sensors_ultrasonic_distance();
                    // Drive bit more
                    chassis_step_drive(75, 0, MM_TO_STEPS(50));
                    work_step_wait();
 
                    chassis_stop();
                    work_delay(300);
 
                    // Turn chassis to the right 90 degrees.
                    chassis_step_drive(-100, 100, 18);
                    work_step_wait();       
 
                    // Start roller.
                    chassis_use_roller(1);
 
                    // Approach ball
                    chassis_step_drive(90, 0, MM_TO_STEPS(ball_distance + 50));
 
                    while (!chassis_is_step_drive_complete() && !sensors_is_ball())
                    {
                        WORK_CHECK;               
                    }
 
                    // Got the ball ?
                    if (sensors_is_ball())
                    {
                        chassis_step_drive(90, 0, MM_TO_STEPS(50));
                        work_step_wait();
                        chassis_stop();
                        work_delay(300);
                        goto search_goal;
                    }
                    else
                    {
                        // Go back to search
                        wall_distance = sensors_ultrasonic_distance();
                        chassis_step_drive(0, 100, 10);
                        work_step_wait();
                        if(wall_distance > 800)
                        {
                            chassis_step_drive(90, 0, MM_TO_STEPS(wall_distance - 800));
                            work_step_wait();
                        }
                        chassis_step_drive(0, 100, 10);
                        work_step_wait();
                        goto search;
                    }                   
                }
 
                // Too close to wall ?
                if (sensors_infrared_distance() < 150)
                {
                    // Reverse drive back to the center and turn left to resume searching
                    chassis_stop();
                    work_delay(300);
                    chassis_step_drive(0, 100, 20);
                    work_step_wait();
                    chassis_step_drive(90, 0, MM_TO_STEPS(700));
                    work_step_wait();
                    chassis_step_drive(0, 100, 10);
                    work_step_wait();
                    goto search;
                }
            }           
        }   
 
search_goal:
 
        // Display mode
        segment_display_write(5);
        goal_timeout_activated = false;
 
        // Search for goal.       
        while (true)
        {
            WORK_CHECK;
 
            // Locate opponent goal.
            dir = beacon_smart_locate_opponent_goal();
 
            // Got direction ?
            if (dir != -128)
            {
                // Goal on left ?
                if (dir < 0)
                {
                    pin_set(led_yellow);
                    chassis_drive(0, -70);
                }
                // Goal on right ?
                else if (dir > 0)
                {
                    pin_set(led_yellow);
                    chassis_drive(0, 70);
                }
                // Goal straight ahead ?
                else
                {
                    pin_clear(led_yellow);
                    chassis_drive(100, 0);
                    // Start timeout
                    if(!goal_timeout_activated)
                    {
                        timeout_start(1000);
                        goal_timeout_activated = true;
                    }
                }
            }
            // Can't see goal ?
            else
            {
                chassis_drive(0, -70);
            }
            // We're headed straight for goal
            if(goal_timeout_activated && timeout_done() && dir == 0)
            {
                goal_timeout_activated = false;
                goto score_goal;
            }
            // Something's in front of us
            if(sensors_infrared_distance() < 250)
            {
                chassis_step_drive(-70, 0, MM_TO_STEPS(200));
                work_step_wait();
            }
        }
 
 
score_goal:
 
        // Display mode
        segment_display_write(6);
 
        chassis_drive(90, 0);
 
        // Reached the goal ?
        while (sensors_infrared_distance() > 300)
        {
            WORK_CHECK;
        }
 
        //if (!pin_get_value(button_mode))
        if (sensors_infrared_distance() < 300)
        {
            chassis_use_roller(0);
            goal_to_search = true;
            pin_set(led_yellow);
            goto turn_around;
        }
 
turn_around:
 
        // Display mode
        segment_display_write(7);
 
        chassis_step_drive(0, 100, 20);
        work_step_wait();
        chassis_stop();
        work_delay(300);
 
        goto search;
    }
}

Esimese sammuna kinnitatakse alusplaadile koodrid. Selleks läheb vaja:

• 4 M3x10 polti
• 8 mutrit

Kõigepealt kinnitatakse poldid mutritega alusplaadi külge, seejärel paigutatakse koodrid poltidele ning kinnitatakse need mutritega. Sel viisil tagatakse, et optokatkesti on piisavalt lähedal hammasrattale ja suudab registreerida hammasrattas olevaid auke.

1a. Alusplaat

1b. Koodrite kinnitamine alusplaadile

Koodrite täpsuse parandamiseks on hammasrattale sümmeetriliselt juurde puuritud 2 auku.

1c. Augud hammasrattas koodri jaoks

Teise sammuna kinnitatakse alusplaadi külge ultraheli kaugusandur. Selleks läheb vaja:

• 2 10 mm kõrgust puksi (M3 keere).
• 2 M3 polti (väikse peaga)
• 2 mutrit

2. Ultraheli kaugusanduri kinnitamine

Kolmandana pannakse kokku rullimehhanism. Rullimehhanismi kokkupanekuks on vaja:

• 6 M3x6 polti, 2 mootori kinnitamiseks haaratsi külge, 2 hinge kinnitamiseks haaratsi külge, 2 hinge kinnitamiseks alusplaadi külge.
• 4 seibi, 2 mootori kinnitamisel ja 2 hinge kinnitamisel haaratsi külge.
• 4 mutrit
• kahepoolne teip

Esmalt kinnitatakse hing haaratsi külge. Haaratsi ja hinge vahel kasutatakse seibe, tagades sel viisil hinge vaba liikumise. Hilisem kinnitamine on raskendatud, kuna rull jääks ette.

3a. Hinge kinnitamine haaratsi külge

Järgmise sammuna kinnitatakse haaratsi külge mootor (3b). Peale seda kinnitatakse kahepoolse teibi abil haaratsi külge optiline palliandur (3c).

3b. Mootori kinnitamine haaratsi külge

3c. Optilise anduri kinnitamine

Nüüd kinnitatakse mootorivõlli otsa rull, mis fikseeritakse võllile poldiga (3d). Seejärel pannakse rullile peale kummirõngad (3e). Rullimehhanism on nüüd kokku pandud.

3d. Rulli kinnitamine võllile

3e. Kummirõngaste paigaldamine rullile

Lõpuks kinnitatakse rullimehhanism alusplaadi külge.

3f. Rullimehhanismi kinnitamine alusplaadi külge

Neljanda sammuna paigaldatakse alusplaadi külge andurite kinnitus koos infrapuna kaugusanduriga ja puksid, millele Kodulabori moodulid paigaldatakse. RC5 vastuvõtja paigaldatakse alles peale alusplaadi kinnitamist veermiku külge, kuna enneaegsel paigaldamisel saab ligipääs kruvikeerajaga raskendatud olema. Kinnituse ja pukside paigaldamiseks läheb vaja:

• 2 M3x6 polti, andurite kinnituse paigaldamiseks
• 4 20 mm kõrgust puksi (M3 keere).
• 6 mutrit.

4a. Andurite kinnituse paigaldamine alusplaadile

4b. Pukside kinnitamine

Viies samm on alusplaadi kinnitamine veermikule ja RC5 vastuvõtja paigaldamine andurite kinnitusele. Selleks läheb vaja:

• 4 M3x6 polti.
• Kahepoolne teip.

5a. Alusplaadi kinnitamine platvormile.

5b. RC5 vastuvõtja paigaldamine.

Kuuendana kinnitatakse puksidele Kodulabori moodulid. Kinnitamiseks on vaja:

• 4 M3x6 polti.

6. Kodulabori moodulite kinnitamine puksidele

Seitsmenda sammuna ühendatakse roboti elektroonikaosade vahel kõik juhtmed. Alustada võiks toite harukaablist mis jagab Kontrollermoodulisse minema toite kaheks millest teine pistik tuleb ühendada Mootoite mooduliga.

7a. Toitepistikute ühendamine mootori ja kontrolleri moodulile

RC5 vastuvõtja tuleb ühendada Kommunikatsioonimooduli välisesses EXT_UART pesasse:

7b. RC5 vastuvõtja ühendamine

Roomiku kaks mootorit tuleb ühendada Mootoritemooduli DC3 ja DC4 pesadesse. Koodrid lähevad sinnasamasse kõrvale ENC1 ja ENC2 pesadesse:

7c. Roomikute mootorite ja koodrite ühendamine

Edasi tuleks ühendada ultraheli- ja infrapuna kaugusandurid ning palliandur. Infrapuna kaugusanduri ja pallianduri jaoks on tarbis servode pikenduskaablit. Täpsemalt on pesad näidatud piltidel:

7d. Ultraheli- ja infrapunaanduri ühendamine. Ultraheli toide ja signaal käivad eraldi pistikutesse

7e. Pallianduri ühendamine

Viimasena on jäänud ühendada LCD kus kuvatakse programmi töö ajal kõiki andurite näitusid:

7f. Kõik moodulid omal kohal

Kaheksas ja viimane etapp on robotisse akude või patareide laadimine ning selle tööle panek. Akud käivad spetsiaalsesse alusplatvormiga kaasatulevasse rakisesse. Ühendades toitekaabli ja akuploki läheb robot tööle ja sinna saab peale laadida programmi.

8a. Akupatarei paigaldamine

8b. Roboti pingestamine

Töövalmis robot

• Rull teha võimalikult lai, et paremini palle kätte saada. Samas tuleb siis ka palliandur ümber teha nii, et LED ja vastuvõtja on haaratsi otses suunatud üksteise vastu ja nad jälgivad kas nende vahele satub pall.
• Alusplaadi, rullimehhanismi haaratsi ja andurite kinnituse tegemiseks on soovitatav kasutada materjali, mille painutamisega ei oleks probleeme ning mille puhul ei oleks ohtu, et see painutamisel murdub või paindekohast praguneb. Prototüübi valmistamisel kasutatati 1 mm paksust alumiiniumi, mis antud detailide tegemiseks suurepäraselt sobis.
• Alusplaadi, rullimehhanismi haarasti ja andurite kinnituse tegemiseks on soovitatav kasutada CNC-tööpinki. Sellega tagatakse detailide valmistamisel võimalikult väike eksimisvõimalus (nt avade puurimisel).
• Programmi kirjutada meetod vastase robotist möödumiseks. Samas eeldab see rohkem andureid, näiteks peegeldusandurit allpool väljaku taset oleva väravapõhja tuvastamiseks.

• Mudelid ja joonised
• Programm

© TTÜ, MTÜ TTÜ Robotiklubi

~~DISCUSSION~~