Reaali Robootika.COM

23-24.märtsil Viinis toimuval robootika Euroopa meistrivõistlusel RobotChallenge osalevad ka Eesti põhikooliõpilaste robootikaringi Robootika.COM liikmed.

Robootika.COM osaleb võistlusel kolmel alal: robotsumo, joonejälgimise võistlusel ja erivärviliste nööpide kogumisel - PuckCollect.

“Sügistalvisel Robotexi võistlusel näitas Robootika.COM joonejälgija robot head tulemust, olles kiireim Lego NXT joonejälgija. Poisid on seda nüüd veelgi edasi arendanud ja seega on meil joonejälgija võistlusel ehk päris head šansid,” hindas Robootika.COM juhendaja Leivo Sepp. “Konkurents on kõikidel aladel muidugi ülikõva, 500 osalejat 25 riigist kokku 400 robotiga.”

Robot-sumol osaleb Robootika.COM LEGO robotiga, sest sellel alal on spetsiaalne legorobotite võistlusklass. Joonejälgimises osaletakse samuti LEGO robotiga, kus on samuti vastav võistlusklass. Nööpide korjamiseks aga kasutatakse eelmisel aastal hõbemedali võitnud isetehtud roboti edasiarendust. Parendati sorteerimist, väravate mehhaanikat ning ehitati lisaks nööpide kogumissalvest väljatuleku takistamiseks spetsiaalne ribikardin.

See robot on vineerist saetud alusraami ja metallist kogumissahkadega, kasutades värvide eristamiseks erinevaid andureid, suunamääramiseks güroskoopi ja juhikutes spetsiaalseid servomootoreid.

Robootika.COM koondab robootikahuvilisi põhikooliõpilasi Tallinna erinevatest koolidest, hetkeseisuga on õpilasi Tallinna Reaalkoolist, Nõmme Põhikoolist, Tallinna Tehnikagümnaasiumist ja 21. Koolist.

RobotChallenge võistlusele minekut toetab Nutilabor ja Microsoft.

RobotChallenge kohta saab lähemalt lugeda siit: http://www.robotchallenge.org/www.robotchallenge.org

Laupäeval, 2. märtsil Tartu AHHAA Keskuses toimunud  First Lego League'i (FLL) finaalis toimunud robotimängu võitis Robootika.COM võistkond, kelle ehitatud robot täitis spetsiaalsel väljakul enim ülesandeid ja kogus suurima arvu punkte.

Robootika.COM võistkonda kuuluvad Jaan Roop (Nõmme Põhikool), Rao Zvorovski (Tallinna Reaalkool), Ramses Sepp, Peter Alex Mahhov, Marko-Raul Peetersoo ja Raimond Lume (kõik Tallinna 21.Kooli õpilased) ning Tomi-Andre Priimets, Karl Jakob Levin, Kirte Katrin Sarevet, Petra Brit Põhjakas (kõik Tallinna Tehnikagümnaasiumi õpilased).

FLL-i võistlus koosneb kolmest osast: robotiehitus, uurimustöö/projekt ja meeskonnatöö. Tänavune võistlus oli teemal „Lahendused eakatele“ (Senior Solutions).

Kõige keerukam ja  vaatemängulisem osa võistluse juures ongi robot, mis peab täitma spetsiaalsel väljakul kahe ja poole minuti jooksul iseseisvalt hulga ülesandeid. Robootika.COM robot sai hakkama vanuritele tekkide kohaletoimetamisega, ravimi toomisega, ümberkukkunud tooli põrandalt koristamisega ning suutis edukalt täita ka platsi ühe keerukaima ülesande, kiikuva platvormi ületamise.

Uurimustöö raames tuli valida eakate inimestega seotud probleem ning sellele innovaatiline lahendus välja pakkuda. Robootika.COM ideeks oli interaktiivne ravimikapp, mis aitab eakatele meelde tuletada ravimite võtmise või protseduuride aega ning on ühtlasi ühenduses apteegiga, et vajalikul ajal ravimeid operatiivselt juurde tellida.

Meeskonnatöö osas hinnatakse FLL-i põhiväärtusi, mis aitavad arendada õpilasi koos töötama ja ühiselt probleemidele lahendusi otsida.

Kõikide alade koondarvestuses saavutas Robootika.COM teise koha. Esimese koha võitis Kristiine võistkond Öökullid.  Tegu oli FLL-I finaalvõistlusega, kus osalesid Eesti ja Läti noorrobootikud vanuses 9-16 aastat. Eelnevalt olid toimunud FLL-I Põhja-Eesti ja Lõuna-Eesti voorud ning neist edasi pääsenud 20 parimat võistkonda kohtus omavahel finaalis.

Robootika.COM on üks 36 tehnoloogia huviringist, kes tänavu valiti Vaata Maailma SA, EMT, Elioni ja Microsofti Nutilabori projekti. Samuti on Robootika.COM pälvinud tiitli „Eesti Parim Robootikakool 2012“.

Igal aastal on FLL-I laua sisse peidetud üks saladus. See tuleb osalejatel endal üles leida, korrladajad selle kohta ühtegi vihjet ei anna.

Käesoleva aasta saladus seisneb selles, laual on 12 väikest märki, mille kohta arvatakse, et need on sinna juhuslikult pandud ning ei tähenda midagi. Kuid tegelikkuses on nende näol tegemist indikaatori tärkidega, millest moodustub kokku 60.

Miks just 60?

Aga seetõttu, et käesoelva aasta teema on Senior Solutions ning antud projekti kohaselt algab seniori vanus alates 60-st eluaastast.

Vaata videot.

Siit raamatust leiad näited, kuidas ehitada ja programmeerida häid Sumo-roboteid ning väga kiireid LEGO joonejärgijaid.

Robootika?… See on imelihtne!

Kui Sa oled 12-13 aastane või vanem ja tahaksid alustada programmeerimisega päris algusest, siis see raamat on täpselt Sulle. Sa võid lihtsalt võtta siit programmi ja panna oma LEGO roboti selle abil tööle, mõtlemata alguses, kuidas see programm täpselt töötab.

Kui aga ajapikku tekib huvi, miks üks või teine programm töötab just nii ja kuidas seda oma roboti vajadustega paremini kohandada, on siin raamatus ka see lihtsal viisil ära seletatud.

Oled aga 17-18 aastane, siis Sina leiad siit raamatust seletused, kuidas kasutada koolitundides nii igava ja lihtsana tundunud täisnurkse kolmnurga trigonomeetriat praktilistes roboti liikumisülesannetes.

Tõelise väljakutse heidab Sulle aga viimane projekt, kus on joonejärgija robot PID kontrolleriga. Käesolevas raamatus on see esitatud võimalikult lihtsal moel, kuid päriselt õpitakse integreerimist ja tuletiste võtmist alles ülikoolis.

Raamat kirjeldab peamisi funktsioone ja algoritme LEGO MINDSTORMS NXT roboti programmeerimiseks, sisaldades praktilisi nõuandeid matemaatika kasutamiseks robootikas. Siin on kirjeldused ja rakendamisjuhised kõikide andurite kohta, mis sisalduvad LEGO MINDSTORMS NXT robootika baaskomplektis (http://mindstorms.lego.com).

Raamatus kirjeldatud programmeerimiskeel on NXC (Not eXactly C), ehk eesti keeles „peaaegu C-keel“. Seega toimub programmeerimine sisuliselt C-keele põhimõtete järgi. Erinevused on väikesed, mistõttu siit platvormilt C-keele või ka kõrgemate keelte peale (näiteks C#) edasi liikumine on lihtne. Sa omandad siit C-keele kasutamise parimad praktikad ja õpid programmeerimist robootika kaudu.

NB! Raamatu “Robootika?... See on imelihtne!” saab endale osta siit: http://shop.robootika.com/robootika-see-on-imelihtne 

Kiire ja turvaline teenus on kindel, ja ma ise hoolitsen et raamat võimalikult ruttu teieni jõuaks!

Ja nagu President raamatu tagakaanel märgib, et “Mõnest põnevast robotist võib sündida oluline leiutis”.

Just leiutajad on need, kelle abiga Eesti riik edukamaks ning tulevik kindlamaks!

2011 a. kevad, Robomiku võistlus ja karu päästmine, III koht.

2011 a. sügis, Eestisisene FLL (FIRST LEGO League) võistlus, II koht

2012 a. kevad, robootika Euroopa meistrivõistlus RobotChallenge, II koht

2012 a. kevad, Eesti parim robootika kool 2012, Robomiku I koht

2012 a. kevad, Eesti parim robootika kool, rändkarikas

2012 a. sügis, Põhja-Eesti FLL võistluse I koht

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 kaugus­eanduriga 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

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.

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

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.

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

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.

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

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.

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

    }

  }

}

See materjal on loodud Tiigrihüppe Sihtasutuse programmi ProgeTiiger raames.

Nii master kui ka slave Bluetooth programmide juures tuleb faili algusesse lisada järgmine rida.

#include "BluetoothCheck.nxc"

Master seadme programmis tuleb lisada programmi algusesse globaalsed muutujad ja task maini sees peab esmalt käivitama Bluetooth ühenduse algatamise.

//MASTER

#include "BluetoothCheck.nxc"

const byte BTconn=1;

const string SlaveNXTName = "NXT5";

task main()

{

  //käivitatakse BT ühenduse kontroll ja/või loomine

  //kui ühendamine ei õnnestunud siis väljutakse programmist

  if(!BluetoothConnect(BTconn, SlaveNXTName)==NO_ERR)

       Stop(TRUE);

  //kuvame kasutajale ühe sekundi jooksul teate

  Wait(SEC_1);

  //siit järgneb programmikood mida soovitakse pärast

  //Bluetooth ühnduse loomist käivitada

}

Slave NXT programmis pole vaja globaalseid muutujaid, kuid task maini sees asub Bluetooth-ühenduse kontroll. Fail BluetoothCheck.nxc on tehtud universaalne, st. seda saab kasutadanii masteri kui ka slave’i juures.

//SLAVE

#include "BluetoothCheck.nxc"

task main ()

{

//käivitatakse BT ühenduse kontroll

//kui ühendamine ei õnnestunud siis väljutakse programmist

if(!BluetoothCheck()==NO_ERR)

       Stop(TRUE);

  //siit järgneb programmikood mida soovitakse pärast

  //Bluetooth ühnduse loomist käivitada

}

//See on abifail BluetoothCheck.NXC, mida kasutatakse

//NXT-de vahelise ühenduse loomiseks ja kontrollimiseks

const int YhenduseOotamine = 7;

//alamprogramm NXTtootab kuvab kasutajale ootamise lõpuni jäävaid

//sekundeid ning üle ekraani liigub joon vasakult paremale,

//väljendades kasutajale seda, et NXT ikka töötab

task NXTtootab()

{

  long Start=CurrentTick();

  long Finish;

  int i, j, k;

  //muutuja speed määrab joone liikumise kiiruse

  int speed=20;

  while(TRUE)

  {

    j++;

    //k määrab joone lõpppunkti koordinaadi, joone pikkus 20px

    k=j-20;

    //i määrab joone alguspunkti koordinaadi

    i=j%100;

    k%=100;

    //joone alguspunktid

    PointOut(i, 25);

    PointOut(i, 27);

    PointOut(i, 29);

    //joone lõpp-punktid

    PointOut(k, 25, DRAW_OPT_CLEAR);

    PointOut(k, 27, DRAW_OPT_CLEAR);

    PointOut(k, 29, DRAW_OPT_CLEAR);

    //ekraanil kuvatakse yhenduse loomise lõpuni jäävad sekundid

    NumOut(50, LCD_LINE4, YhenduseOotamine-j/(1000/speed));

    //oodatakse ajahetk speed, mis on joone liikumise kiirus

    Wait(speed);

    //arvutatakse välja seni kulunud alamprogrammi aeg

    Finish = (CurrentTick()-Start)/1000;

    //kui alamprogramm on käinud kauem kui programmi

    //ootamine ette näeb, siis katkestatakse alamprogrammi töö

    if(Finish>YhenduseOotamine)

    {

      ClearScreen();

      break;

    }

  }

}

//Funktsioon Bluetooth paaristab master ja slave NXT-d

//seda funktsiooni kasutatakse MASTER NXT korral

int BluetoothConnect(int conn, string name)

{

  //ühenduse loomiseks vajalik struct-muutuja

  CommBTConnectionType args;

  //Slave NXT nimi millega paaristatakse

  args.Name = name;

  //Bluetooth ühenduse pordi number

  args.ConnectionSlot = conn;

  //kas ühendame (TRUE) või mitte (FALSE)

  args.Action = TRUE;

  //kontrollitakse kas NXT on paaristatud, kui ei ole,

  //siis käivitatakse alljärgneva if-lause esimene pool

  if (!BluetoothStatus(conn) == NO_ERR)

  {

    //käivitatakse alamprogramm NXTtootab

    StartTask(NXTtootab);

    //ekraanil kuvatakse kiri Yhenduse loomine

    TextOut(0, LCD_LINE1, "Yhenduse");

    TextOut(0, LCD_LINE2, "loomine...");

    //Bluetooth paaristamise loomine

    SysCommBTConnection(args);

    //ühenduse õnnestumiseks ootame 7 sekundit

    Wait(YhenduseOotamine*1000);

    //ühenduse loomine õnnestumise kohta kuvatakse teade

    if (BluetoothStatus(conn) == NO_ERR)

    {

      TextOut(0, LCD_LINE1, "Yhendatud");

      TextOut(0, LCD_LINE2, "edukalt!   ");

      TextOut(0, LCD_LINE3, name);

      return NO_ERR;

    }

    //kui ühendumine ei õnnestunud, kuvatakse Yhenduses viga

    else

    {

      ClearLine(LCD_LINE2);

      TextOut(0, LCD_LINE1, "Yhenduses viga");

      NumOut(0, LCD_LINE2, args.Result);

      Wait(SEC_1);

      return -1;

    }

  }

  //kui ühendus oli juba olemas, kuvatakse Yhendus olemas

  else

  {

    TextOut(0, LCD_LINE1, "Yhendus olemas");

    TextOut(0, LCD_LINE2, BTConnectionName(conn));

    return NO_ERR;

  }

}

//alljärgnev protseduur kontrollib programmi käivitamisel,

//kas Bluetooth ühendus on initsialiseeritud

//seda funktsiooni kasutatakse SLAVE NXT korral

int BluetoothCheck()

{

  //SLAVE korral on BTconn alati 0

  const byte BTconn=0;

  if (!BluetoothStatus(BTconn)==NO_ERR)

  {

    TextOut(0, LCD_LINE1, "Kaivita esimesena");

    TextOut(0, LCD_LINE2, "teine NXT.");

    Wait(SEC_3);

    return -1;

  }

  else

  {

    return NO_ERR;

  }

}

See materjal on loodud Tiigrihüppe Sihtasutuse programmi ProgeTiiger raames.

Selle projekti juures saame teada, kuidas nxt-d omavahel üle bluetoothi reaalajas suhtlevad ja kuidas arvutada palli põrkumine ekraanil juhuslikult etteantud arvu põhjal.

Ping-pong mäng kahe NXT vahel toimub üle Bluetooth ühenduse, nii et mängijad võivad asuda teineteisest kuni 30 m kaugusel. Kummalgi mängijal on oma NXT, mille ekraanilt saab jälgida kogu mängu kulgu.

Mõlemad mängijad saavad liigutada oma väravat NXT külge ühendatud mootori abil. Mängu alustava mängija NXT-l on küljes ka teine mootor, millest saab sujuvalt muuta mängu kiirust.

Roboti ehitus

NXT külge peab olema mugaval viisil ühendatud mootor koos rattaga, mille abil saab väravat juhtida. Ühel NXT-l peab olema lisatud ka teine mootor, mille abil saab muuta mängu kiirust.

Programmeerimine

Kummagi NXT jaoks on omaette programm, kuid neil on ka mõned ühised programmiosad. Nagu näiteks Bluetooth ühenduse loomine, värava liigutamine ja info kuvamine ekraanil. Seetõttu koosneb antud mängu programm neljast eraldi failist.

1)       NXT 1 ehk mängija 1 programm master_gamer.nxc

2)       NXT 2 ehk mängija 2 programm slave_gamer.nxc

3)       Mõlema NXT jaoks ühised funktsioonid CommonFunctions.nxc

4)       Bluetooth ühenduse programm BluetoothCheck.nxc

Iga fail on jagatud omakorda alametappideks, et lihtsustada arendust ja mängu toimimise põhimõttest arusaamist. Bluetooth ühenduse programmi pole siinkohal eraldi välja toodud ega kirjeldatud, kuna tegemist on standardse ühenduse loomisega, mis on kirjeldatud käesoleva raamatu juhendi Bluetoothi alapeatükis.

Mängija 1 programm ehk master_gamer.nxc fail koosneb järgmistest peamistest funktsioonidest:

1)       Bluetooth ühenduse loomine kahe NXT vahel

2)       Mängu loogika GameLoop

3)       Palli põrkumise ja võitja tuvastamise funktsioon BallCollide

4)       Palli liigutamise protseduur MoveBall

5)       Mängu kiiruse juhtimine ChangeGameSpeed

6)       Bluetooth info saatmine/vastuvõtmine SendReceiveBluetoothInfo

7)       Mängu alginfo initsialiseerimine InitData

8)       Mängu võitja kuvamine ShowWinner

Mängija 2 programm ehk slave_gamer.nxc fail koosneb järgmistest peamistest funktsioonidest:

1)       Bluetooth ühenduse loomine kahe NXT vahel

2)       Mängu loogika GameLoop

3)       Bluetooth info saatmine/vastuvõtmine SendReceiveBluetoothInfo

Ühised funktsioonid ehk CommonFunctions.nxc fail koosneb järgmistest funktsioonidest

1)       Värava liigutamise funktsioon PlayerPosition

2)       Ekraanile kuvamise funktsioon Render

Mängija 1 mängu loogika

Mängu käivitamisel kontrollitakse Bluetoothi kaudu teise mängija olemasolu. Kui ka teine mängija on mängu käima pannud, saadetakse teisele mängijale info palli suuruse BallWidth ja värava laiuse GateWidth kohta ja algväärtustatakse mängu parameetrid protseduuriga InitData.  Seejärel pannakse käima mäng protseduuriga GameLoop ja kui mängus tekib võitja, kuvatakse tulemus ekraanil funktsiooniga ShowWinner.

Protseduur GameLoop käib while-tsükli sees seni, kuni tingimus on tõene while(!Winner), ehk kuni võitjat ei ole selgunud. Winner muutuja on vaikimisi võrdne nulliga. Kui tekib võitja, on selle väärtus vastavalt 1 või 2, sõltuvalt võitjast.

Protseduuri GameLoop sees omistatakse muutujale Winner võitja väärtus, mis on palli põrkamise ja võitja tuvastamise funktsiooni BallCollide tagastatav väärtus. Pärast seda käivitatakse palli liigutamise protseduur MoveBall, mille ülesandeks on uute palli koordinaatide omistamine globaalsele muutujale BallPos. Seejärel käivitatakse funktsioon PlayerPosition(GateWidth), mis liigutab väravat ja tagastab väärtuse mängija 1 värava koordinaadiga, mis omistatakse muutujale Player1Pos. Funktsiooni sisendparameeter on värava laius.

Pärast seda omistatakse muutujale GameData kolm erinevat väärtust, palli x ja y koordinaadid ning mängija 1 värava koordinaat. Kuna Bluetooth on kahe NXT vahel võrdlemisi aeglane, siis eelnimetatud parameetrid pannakse kokku üheks muutujaks GameData, et minimeerida Bluetooth ühenduste arvu kahe NXT vahel. Et mängija 2 NXT programmis oleks andmeid lihtsam „lahti võtta“, on koordinaatide x ja y vahele pandud eraldajana kaldkriips ning värava koordinaadi ette sidekriips.

Seejärel käivitatakse funktsioon SendReceiveBluetoothInfo(GameData), mis saadab äsja loodud faili teisele NXT-le ja tagastab väärtuse mängija 2 värava koordinaadiga, mis omistatakse muutujale Player2Pos. Funktsiooni sisendparameeter on GameData.

Viimasena käivitatakse protseduur Render(Player1Pos, Player2Pos, BallPos, GateWidth, BallWidth), mille ülesanne on joonistada ekraanile mõlema värava asukohad ja pall. Selle sisendparameetriteks on esimese ja teise mängija väravate koordinaadid, palli koordinaadid ning palli ja värava laiused.

Seejärel oodatakse 40 ms, mis on ühtlasi ka mängu kiiruseks, ning kogu tsükkel algab uuesti algusest, kuni võitjat ei ole selgunud.

void GameLoop()

{

  //muutujasse Winner salvestatakse mängu staatus

  Winner = BallCollide();

  //liigutatakse palli

  MoveBall();

  //CommonFunctions failist käivitatakse funktsioon

  //mis liigutab player1 värava asukohta, sisendiks värava laius

  Player1Pos = PlayerPosition(GateWidth);

  //luuakse string kolmest parameetrist: palli x ja y

  //koordinaadid ning player1 mängija värava koordinaat

  GameData = StrCat(NumToStr(BallPos.x), "/",

            NumToStr(BallPos.y), "-",

            NumToStr(Player1Pos));

  //vahetatakse Bluetooth infot, edastatakse mängu info

  //tagasi saadakse player2 mängija värava koordinaat

  Player2Pos = SendReceiveBluetoothInfo(GameData);

  //CommonFunctions failist käivitatakse palli ja

  //väravate kuvamise protseduur

  Render(Player1Pos, Player2Pos,BallPos, GateWidth, BallWidth);

  Wait(MS_40);  //oodatakse 40ms, mängu kiirus

}

Mängija 1 palli põrkumine ja võitja tuvastamine

Funktsioon BallCollide kannab hoolt selle eest, et pall saaks alati ekraani servadest tagasi põrgatatud ning tuvastatud väravate olemasolu ja palli põrkumine vastu väravat. See funktsioon tagastab võitja numbri. Kui võitjat ei ole, tagastab see funktsioon alati nulli. Kui võitja on mängija 1, tagastab funktsioon vastavalt ühe ja kui võitja on mängija 2, siis kahe.

Käesolevas projektis toimub palli põrkamise kontrollimine täpselt samal viisil, nagu projektis Ping-Pong ühele. Tingimus (BallPos.y > DISPLAY_HEIGHT – BallWidth) saab tõeseks siis, kui pall on jõudnud ekraani ülemisse serva. Kuna pallil on teatud suurus, tuleb kontrollimiseks lahutada palli suurus ekraani kõrgusest. Kui seda mitte teha, kontrollitaks palli alumist serva ekraani kõrgusega ja siis on visuaalselt enamus palli ekraani taha kadunud. Ka parema serva vastu põrkumist kontrollitakse tingimusega (BallPos.x > DISPLAY_WIDTH - BallWidth),kus lahutatakse ekraani laiusest palli laius, et pall ei kaoks põrkumisel ekraani serva taha. Vaata ülemise ja alumise põrke kohta joonist.

Samal moel toimub ka palli kontrollimine vastu alumist (BallPos.y <= 0) ja vasakut serva (BallPos.x <= 2), need on lihtsamad kontrollid, kuna koordinaadid on nii pallil kui ka ekraanil samas kohas. Vasaku serva korral kontrollitakse palli x-koordinaati number 2 suhtes, et jätta väravale 1 piksel ruumi liikumiseks.

Vasaku ja parema serva kontrollile lisandub alati ka järgmine kontroll, palli võrdlus värava koordinaadiga (BallPos.y < Player1Pos + GateWidth && BallPos.y > Player1Pos - BallWidth). Palli koordinaate kontrollitakse värava ülemise ja alumise serva suhtes, kuid alumise serva kontrolli korral lahutatakse palli laius, et pall saaks ka ülemise nurgaga väravalt tagasi põrgata. Kui seda lahutamistehet ei kasutaks, oleks pall väravas isegi juhul, kui pool palli on värava kohal. Vaata selle põrke kohta allolevat joonist.

Joonisel on kujutatud kaks palli positsiooni, üks kujutab seda kui pall põrkub vastu ülemist värava serva ja teine, kui palll põrkub vastu alumist värava serva. Mõlemal juhul on tegemist palli nö. viimase piksli põrkumisega.

Kui värava tingimuse kontroll pole täidetud, siis kaotas mängija, kelle poolelt pall välja kukkus, ning funktsioon tagastab võitnud mängija numbri:  return 2.

Peale palli põrkumist muudetakse palli liikumise suund ja omistatakse talle uus koordinaat. Uus koordinaat on ühe piksli võrra suunatud ekraani keskele, et järgmise tsükli käigus ei tuvastataks palli jätkuvalt seina vastas olevaks.

Kui pall on põrganud alumiselt või ülemiselt servalt, siis muudetakse palli liikumise nurk vastupidiseks. Kui enne oli 60 kraadi, siis peale põrkumist on -60 kraadi. Kui aga põrkumine on toimunud parema-vasaku külje suunas, lahutatakse palli põrkumise nurk 180-st. Saadud numbrit kasutatakse palli liikumise protseduuri juures ning selle tehte vajaduse selgitamine toimub seal.

//palli põrkumise funktsioon, tagastab väärtused 0, 1, 2

short BallCollide()

{

  //pall põrkub vastu ülemist serva

  if(BallPos.y > DISPLAY_HEIGHT - BallWidth)

  {

    BallAngleDeg = -BallAngleDeg;

    BallPos.y = DISPLAY_HEIGHT - BallWidth - 1;

  }

  //pall põrkub vastu alumist serva

  else if(BallPos.y <= 0)

  {

    BallAngleDeg = -BallAngleDeg;

    BallPos.y = BallWidth;

  }

  //pall põrkub vastu vasakut serva (Player1)

  if(BallPos.x <= 2)

  {

    //kontrollitakse, kas palli põrkekohal on värav ees

    if (BallPos.y < Player1Pos + GateWidth &&

        BallPos.y > Player1Pos - BallWidth)

    {

      BallAngleDeg = 180 - BallAngleDeg;

      BallPos.x = BallWidth;

    }

    //kui väravat ees ei olnud, siis on mäng läbi

    else

    {

      return 2; //võitis mängija 2

    }

  }

  //pall põrkub vastu paremat serva (Player2)

  else if(BallPos.x > DISPLAY_WIDTH - BallWidth)

  {

    //kontrollitakse, kas palli põrkekohal on värav ees

    if(BallPos.y < Player2Pos + GateWidth &&

      BallPos.y > Player2Pos - BallWidth)

    {

      BallAngleDeg = 180 - BallAngleDeg;

      BallPos.x = DISPLAY_WIDTH - BallWidth - 1;

    }

    //kui väravat ees ei olnud, siis on mäng läbi

    else

    {

      return 1; //võitis mängija 1

    }

  }

  return 0;  //mäng jätkub

}

Mängija 1 pallile uute koordinaatide andmine

Protseduur MoveBall on programmi üks lühemaid, kuid vaatamata sellele kõige olulisem palli korrektse liikumise seisukohast. Antud protseduuri tulemuseks on palli x ja y koordinaadid.

Alguses kutsutakse välja funktsioon ChangeGameSpeed, mille abil saab jooksvalt mängu kiirust muuta. ChangeGameSpeed tagastab ujukomaarvu vahemikus 0,1 kuni lõpmatus. Algne palli liikumise kiirus on 1.

Pall pannakse liikuma täisnurkse kolmnurga siinus ja koosinus funktsioone kasutades. X-telje koordinaat ehk lähiskaatet saadakse koosinuse abil ning y-telje koordinaat ehk vastaskaatet siinuse abil. Vaadates alltoodud valemeid, on hüpotenuus siin programmis kasutusel kiiruse muutujana nimega Speed, mis mängu alguses on võrdne ühega.

Tuletame siinkohal meelde vajalikud valemid.

Täisnurkse kolmnurga lähiskaateti pikkuse arvutamine teravnurga ning hüpotenuusi abil

Täisnurkse kolmnurga vastaskaateti pikkuse arvutamine teravnurga ning hüpotenuusi abil

Valemis toodud tähis teravnurk vastab programmis muutujale BallAngleDeg ehk see on suurus, mis saadakse mängu alguses juhusliku valiku teel ning võib olla vahemikus -60..60 (pall liigub paremale) ja 120..240 (pall liigub vasakule). Need vahemikud tulenevad mängu parameetrite algväärtustamisest ja sellised suurused on valitud seetõttu, et välistada mängujuhuste tekkimine, kus pall hakkab otse üles-alla põrkama ja ei jõuagi seeläbi mängija väravani.

Järgnev joonis näitab, kuidas mängu alghetkel liikumissuunda määrav koordinaatteljestik ekraani suhtes paikneb. Viirutatud alad on need, millistes suundades pall kunagi ei stardi. Palli liikumist toetav joonis on toodud edaspidi, pärast kirjeldusi.

Palli liikumine sirgjooneliselt

Võtame eelduseks, et mängu alguses startis pall keskelt ja suunaga 60 kraadi, seega üles-paremale täpselt punase viirutatud ala servas. Esimese tsükli käigus

x-koordinaat =1 * cos(60) = 0,5 ja

y-koordinaat = 1 * sin(60) = 0,86

ning kuna palli liikumise kiirus on alguses 1, siis jätame selle edaspidi kirjutamata. Ekraani keskkoht on 50x32 pikslit, seega tegelikult on pärast esimest tsüklit x=50,5 ja y=32,86.

Järgmise tsükli käigus (ehk 40 ms pärast) liidetakse kummalegi väärtusele juurde uuesti 0,5 ja 0,86 ja siis on tulemuseks:

x=51

y=33,52

Kuna ekraani koordinaadid on täisarvud, siis programm ümardab eelnimetatud numbrid täisarvudeks ja pall kuvatakse ekraanil koordinaatidega x= 51 ja y= 34.

Palli põrkumine ekraani ülemisest servast

Jätkates eelmist rida, saame ekraani serva jõudnud palli koordinaatideks:

x=68,5

y=64

Nüüd rakendub tehe, mis muudab palli liikumise nurga märgi vastupidiseks -BallAngleDeg = -60. Järgmise tsükli käigus on palli koordinaatide arvutamise nurgaparameetriks -60. Arvutades selle numbriga pallile järgmised koordinaadid, saame:

x=x+cos(-60)=68,5+0,5=69

y=y+sin(-60)=64+(-0,86)=63,13

Seega näeme, et x koordinaat suureneb jätkuvalt, aga y hakkab vähenema. See tähendab, et pall liigub nüüd alla paremale.

Palli põrkumine ekraani paremast servast

Jätkates eelmist rida, tuleb meil arvutada, kas pall jõuab enne alla või põrkub vastu paremat seina. Kuna eelmise näite lõpus oli pall 68,5 piksli kaugusel, jääb sealt ekraani parema servani 31,5 pikslit. Võttes selle aluseks x-telje suunalise kolmnurga küljepikkusena, saame välja arvutada, kui kaugele alla pall selle jooksul jõuab. Tulemus on x=100 (ekraani parem serv) ja y=9,5. Seega põrkub pall enne alumise servani jõudmist vastu paremat serva. Ekraani kõrgus on 64 pikslit, st. pall jõuab paremasse serva 9 piksli juures. Nüüd tuleb palli põrkamise hetk, seega 180-st lahutatakse palli nurk 180-(-60)=240. Pannes selle numbri palli asukoha koordinaatide arvutamise tehtesse, saame:

x=x+cos(240)=100-0,5=99,5

y=y+sin(240)=9,5+(-0,86)=8,6.

Seega saame numbrite põhjal öelda, et pall liigub nüüd jätkuvalt alla, kuid on vahetanud x-teljel suunda ja liigub vasakule.

Palli põrkumine ekraani alumisest servast

Palli x-telje koordinaat on 100 ja y koordinaat 9,5, seega ekraani alumise servani on 9 pikslit. Arvutades välja ekraani allserva jõudva palli x koordinaadi, saame x=94,5 kui y=0, st. pall on alla jõudnud. Nüüd on taas märgimuutmise arvutustehe ja uueks nurga väärtuseks on -240. Kuna positiivseid arvusid on lihtsam mõista, siis võime öelda ka et -240 kraadi = 120 kraadi. Vaata jooniselt.

Palli koordinaadid on:

x=x+cos(120)=94,5+(-0,5)=94

y=y+sin(120)=0+0,86=0,86

Tulemus näitab, et x väheneb ja y suureneb, seega pall liigub üles vasakule.

Sarnase arvutuse kohaselt saab leida ka liikumise pärast vasakpoolse seina vastu põrkumist.

void MoveBall()

{

  //esmalt käivitatakse funktsioon, mille vahendusel

  //saab kiiruse, ehk kolmnurga hüpotenuusi

  Speed = ChangeGameSpeed();

  //arvutatakse x-telje koordinaat

  BallPos.x += cosd(BallAngleDeg) * Speed;

  //arvutatakse y-telje koordinaat

  BallPos.y += sind(BallAngleDeg) * Speed;

}

Mängija 1. Mängu kiiruse juhtimine

Kui mäng tundub liiga lihtne, saab jooksvalt mängu käigus muuta palli liikumise kiirust. Funktsioon ChangeGameSpeed kasutab mängu alguses initsialiseeritud mootor B väärtust MootorCenterB, seda kasutatakse mootori algse positsiooni määramiseks. Sellest lahutatakse mootori hetke pöörded, mis on mängu alguses sama kui algne positsioon, seega tulemus on null. Liidetakse juurde 100, et anda mängule esmane baaskiirus.

Kui keerata mootorit kiiruse vähendamise suunas, siis järgnev if-lause ei võimalda muutujal Kiirus minna väiksemaks kui 10. Enne tagastamist jagatakse väärtus 100-ga, et mootori pööramisel oleks kiiruse muutuse vähim samm 0,1 ühikut return Kiirus/100.

float ChangeGameSpeed()

{

  long Mootor;

  float Kiirus;

  Mootor = MotorRotationCount(OUT_B);

  //muutuja Kiirus arvestab mootori algset asukohta

  //+100 liidetakse selleks, et anda mängule baaskiirus

  Kiirus = MootorCenterB - Mootor + 100;

  if (Kiirus <= 10)

    {

      MootorCenterB = Mootor;

      Kiirus = 10;

    }

  //tagastatav kiirus jagatakse 100-ga,

  //et kiiruse muutus oleks võimalikult väike

  return Kiirus/100;

}

Mängija 1. Bluetooth info saatmine/vastuvõtmine

Funktsiooni SendReceiveBluetoothInfo sisendiks on tekstitüüpi muutuja Data, milles sisaldub nii palli kui ka värava koordinaatide info. Funktsioon tagastab vastasmängija värava koordinaadi.

Saadetav andmestik edastatakse teisele NXT-le käsuga SendRemoteString(BTconn, MAILBOX5, Data).  Saatmine toimub aga alles pärast seda, kui ollakse mängija 2 käest korrektselt vastu võtnud värava koordinaatide info. Vastuvõtmise käsk on while-tsükli sees, mis käib seni, kuni tingimus on tõene. Tingimuseks on Bluetoothi kaudu info lugemise käsu ReceiveRemoteNumber tagastatav väärtus null (parametriseeritult ka kui NO_ERR) lugemise õnnestumise korral. Seni, kuni postkastis pole midagi, tagastab ReceiveRemoteNumber väärtuse, mis on nullist erinev (näiteks 64 tähistab tühja postkasti). Seejärel kontrollitakse tingimust 64 != 0, mis on tõene, sest 64 ju ei võrdu nulliga. Kui aga info saadakse, on tingimuseks 0 != 0, mis on väär, sest 0 on võrdne 0-ga. Selle tulemuse saamisel oleme kindlad, et vastasmängija värava koordinaat saadi kätte ning programmikood suundub järgmist käsku täitma.

int SendReceiveBluetoothInfo(string Data)

{

  //MASTER kirjutab ja loeb alati SLAVE mailboxidest

  //saadame info stringina, et kogu pakett korraga saata

  //seeläbi on BT ühendusi vähem ja mäng kiirem

  int PlayerPos;

  //ootab, kuni saab korrektselt teise mängija väravainfo

  while(ReceiveRemoteNumber

        (MAILBOX4, TRUE, PlayerPos)!=NO_ERR);

  //saadab oma värava ja palli info teisele poole

  SendRemoteString(BTconn, MAILBOX5, Data);

  //tagastab teise mängija värava koordinaadi

  return PlayerPos;

}

Mängija 1. Mängu alginfo initsialiseerimine

Protseduur InitData käivitatakse iga kord enne mängu käivitumist. Esmalt algväärtustatakse palli ja väravate koordinaadid, mis sätitakse alati keskele. Mootorite pöörded salvestatakse muutujatesse, et neid hiljem kasutada värava ja kiiruse juhtimiseks.

Seejärel luuakse muutuja RandomStart millele omistatakse juhuslik väärtus vahemikus 0..119 Random(120).  Pärast seda tehakse kaks uut muutujat RandomRight ja RandomLeft, mis omakorda väljendavad kraadide vahemikku paremale-vasakule, kuhu pall võib alustades startida. Vaata selle kohta selgitavat joonist käesolevas projektis, kus punasega märgitud ala viitab piirkondadele, kuhu pall ei saa startida. Seejärel tehakse taas juhuslikkuse alusel valik, kas pall stardib paremale või vasakule. Seda valik toimub ternary-tingimusega,  mille kontrolliks on käsk Random(2) väärtustega 0 või 1 ja vastavalt sellele otsustab programm, kas valida parem või vasak.

Viimase tegevusena saadetakse vastasmängijale info „RESET“, mida teise mängija programm käsitleb kui mängu alustamise käsklus.

void InitData()

{

  Winner = 0;

  BallPos.x = DISPLAY_WIDTH/2;

  BallPos.y = DISPLAY_HEIGHT/2;

  Player1Pos = DISPLAY_HEIGHT/2 - GateWidth/2;

  Player2Pos = DISPLAY_HEIGHT/2 - GateWidth/2;

  MootorCenter=MotorRotationCount(OUT_A);

  MootorCenterB=MotorRotationCount(OUT_B);

  //luuakse juhuslik arv vahemikus 0..119

  int RandomStart = Random(120);

  //juhulikust arvust tehakse vahemik -60..60,

  //see vastab ekraani parempoolsele suunale

  int RandomRight = RandomStart - 60;

  //juhulikust arvust tehakse vahemik 120..240

  //see vastab ekraani vasakpoolsele suunale

  int RandomLeft = RandomStart + 120;

  //valitakse juhuslikult, kas alustada parem-vasakule

  BallAngleDeg = Random(2) ? RandomRight : RandomLeft;

  //saadetakse Player2-le info mängu alsutamise kohta

  SendRemoteString(BTconn, MAILBOX6, "RESET");

}

Mängija 1. Mängu võitja kuvamine

Protseduur ShowWinner käivitatakse pärast seda, kui funktsioon BallCollide tagastab väärtuse 1 või 2, mille järel väljutakse mängu käigus hoidvast while-tsüklist, kuna muutuja Winner omab nullist erinevat väärtust.

ShowWinner kontrollib muutujat Winner. Kui see on võrdne 1-ga, saadetakse mängija 2 postkasti teade, et ta kaotas ja iseendale kuvatakse teade „Sa võitsid“ ning „Vajuta nuppu jätkamiseks“. Vastupidise võidu korral saadetakse mängijale 2 teade „Sa võitsid“ ning iseendale kuvatakse teade „Sa kaotasid“ ning „Vajuta nuppu jätkamiseks“.

void ShowWinner()

{

  string Win = "Sa voitsid";

  string Lose = "Sa kaotasid";

  //kui võitja oli Player1

  if(Winner==1)

  {

    //saadetakse Player2-le teade kaotuse kohta

    SendRemoteString(BTconn, MAILBOX6, Lose);

    TextOut(10, LCD_LINE4, Win);

    TextOut(10, LCD_LINE6, "Vajuta nuppu");

    TextOut(10, LCD_LINE7, "jatkamiseks");

  }

  //kui võitja oli Player2

  else if(Winner==2)

  {

    //saadetakse Player2-le teade võidu kohta

    SendRemoteString(BTconn, MAILBOX6, Win);

    TextOut(10, LCD_LINE6, "Vajuta nuppu");

    TextOut(10, LCD_LINE7, "jatkamiseks");

    TextOut(10, LCD_LINE4, Lose);

  }

  while(!ButtonPressed(BTNCENTER, FALSE));

  while(ButtonPressed(BTNCENTER, FALSE));

}

Mängija 2 mängu loogika

Mängu käivitamisel kontrollitakse, kas Bluetooth töötab. Seejärel oodatakse mängija 1 NXT käest tegevuse sünkroniseerimise teadet Handshake. Kui see on kätte saadud, edastatakse teade OK.

Pärast seda jääb mängija 2 programm ootama while(!BallWidth || !GateWidth), kuni on kätte saanud palli ja värava suuruse info. Antud while-tsükli tingimuses kontrollitakse palli ja värava infot. Mõlemad on alguses võrdsed nulliga, kuid tingimuse kontrollis muudetakse hüüumärgiga nende väärtus vastupidiseks ehk üheks. Seega tingimuse kontroll näeb välja selline: „kas 1 või 1 on võrdne 1-ga“. See on ilmselgelt tõene ja tsükkel käivitatakse. Kui aga üks neist on väärtuse saanud, näeb kontroll välja järgmine „kas 1 või 0 on võrdne 1-ga“, mis on samuti tõene. Kui aga mõlemad muutujad on saanud väärtuse, on kontroll stiilis „kas 0 või 0 on võrdne 1-ga“, mis muidugi pole tõene ja väljutakse tsüklist.

Seejärel käivitub lõpmatult mängu loogika protseduur GameLoop. Esmalt käivitatakse funktsioon PlayerPosition(GateWidth), mis liigutab väravat ja tagastab väärtuse mängija 2 värava koordinaadiga, mis omistatakse muutujale Player2Pos. Sisendparameetriks on värava laius. Pärast seda käivitatakse Bluetooth postkastidest lugemise funktsioon SendReceiveBluetoothInfo. Selle sisendparameetriks on mängija 2 värava koordinaat, muutuja Player2Pos, mis edastatakse mängijale 1. Funktsioon tagastab väärtuse palli ja mängija 1 värava koordinaatidega ja omistab selle muutujale GameData.

Muutujast GameData saadakse stringitöötlusega kätte kõik koordinaadid. Esiteks omistatakse muutujale t kaldkriipsu asukoha väärtus antud stringi sees. Järgmise käsuga SubStr(GameData, 0, t) loetakse muutujast GameData kõik kohad kuni kaldkriipsuni ja tulemus salvestatakse palli x-koordinaadiks. Järgmisele muutujale u omistatakse sidekriipsu asukoha väärtus. Käsuga SubStr(GameData, t+1, u-t) loetakse muutjast GameData kõik kohad alates kaldkriipsu positsioonist kuni sidekriipsuni. Parameeter t+1 tähendab seda, et lugemist alustatakse üks koht pärast kaldkriipsu ning parameeter u-t väljendab loetava stringi pikkust. Värava koordinaat saadakse kätte samuti käsuga SubStr(GameData, u+1, v-u), kuid muutuja v tähistab siin kogu stringi pikkust.

Pärast seda käivitatakse protseduur Render(Player1Pos, Player2Pos, BallPos, GateWidth, BallWidth), mille ülesanne on joonistada ekraanile mõlema värava asukohad ja pall. Selle sisendparameetriteks on esimese ja teise mängija väravate koordinaadid, pallikoordinaadid ja palli ning värava laiused.

Viimase käsuna kuvatakse ekraanil võitja info, kuid alles seejärel, kui üks või teine pool võitis.

void GameLoop()

{

  //CommonFunctions failist käivitatakse funktsioon,

  //mis liigutab värava asukohta, sisendiks värava laius

  Player2Pos = PlayerPosition(GateWidth);

  //vahetatakse Bluetooth infot, edastatakse värava info

  //tagasi saadakse player1 värava ja palli koordinaadid

  GameData = SendReceiveBluetoothInfo(Player2Pos);

  //stringitöötluse abil taastatakse

  //värava ja palli koordinaadid 

  int t = Pos("/", GameData);

  BallPos.x = StrToNum(SubStr(GameData, 0, t));

  int u = Pos("-", GameData);

  BallPos.y = StrToNum(SubStr(GameData, t+1, u-t));

  int v = StrLen(GameData);

  Player1Pos = StrToNum(SubStr(GameData, u+1, v-u));

  //CommonFunctions failist käivitatakse palli ja

  //väravate kuvamise protseduur

  Render(Player1Pos, Player2Pos,

        BallPos, GateWidth, BallWidth);

  //võitja info kuvatakse ekraanil

  TextOut(10, LCD_LINE4, ShowWinner);

  Wait(40);

}

Mängija 2. Bluetooth info saatmine/vastuvõtmine

Funktsiooni SendReceiveBluetoothInfo sisendparameetriks on mängija 2 positsioon, mis saadetakse mängijale 1 ning see tagastab väärtuseks Data, milles sisalduvad palli ja mängija 1 värava koordinaadid.

Postkastist 6 loetakse võitja info. Kui antud postkastis sisaldub info, kontrollitakse tingimust TempShowWinner != "" ja sõnumi sisu kuvatakse mängijale. Kui aga sealt saabub info „RESET“, ei kuvata ekraanil mängijale ühtegi sõnumit.

string SendReceiveBluetoothInfo(int PlayerPos)

{

  string Data;

  //slave loeb oma lokaalsest mailboxist

  //palli ja värava koordinaadid

  ReceiveRemoteString(MAILBOX5, FALSE, Data);

  //SLAVE kirjutab oma värava koordinaadi MAILBOX4-a

  SendResponseNumber(MAILBOX4, PlayerPos);

  string TempShowWinner = "";

  //SLAVE loeb mailbox6-st võitja info

  ReceiveRemoteString(MAILBOX6, TRUE, TempShowWinner);

  //kui saadi võitja info, kuvatakse see ekraanil

  if(TempShowWinner != "")

    ShowWinner = TempShowWinner;

  //kui saadi nullimise info, siis

  //ei kuvata võitja infot ekraanil

  if(TempShowWinner == "RESET")

    ShowWinner = "";

  return Data;

}

Ühised funktsioonid, CommonFunctions

Funktsioon PlayerPos liigutab väravat, selle sisendparameetriks on värava laius ning see tagastab väärtuse värava koordinaat. Selle funktsiooni kirjeldus on esitatud ping-pong ühele mängu juures, seega siin seda enam kordama ei hakata.

Protseduuri Render kasutatakse selleks, et ekraanile joonistada pall ja väravad. Sisendparameetriteks on palli ja väravate koordinaadid ning palli ja värava laiused. Nii pall kui väravad joonistatakse ekraanile nelinurkadena, funktsiooni RectOut abil. Kui selle funktsiooni laiuseks on 0, siis tulemuseks joonistatakse 1 piksli laiune ristkülik.

int MootorCenter;

//funktsioon PlayerPosition liigutab väravat

//antud funktsiooni sisendiks on värava laius ning

//tagastatav väärtus on värava koordinaat

int PlayerPosition(byte Gate)

{

  int PlayerPos;

  //pöörded jagatakse kahega,

  //et värava liikumine poleks nii tundlik

  int Mootor=MotorRotationCount(OUT_A)/2;

  //algsest mootori väärtusest lahutatakse mootoripöörded

  //pööretele liidetakse pool ekraani kõrgusest,

  //et mängu alguses asuks värav keskel

  PlayerPos = (MootorCenter-Mootor)+DISPLAY_HEIGHT/2;

  //kui värav on jõudnud ekraani ulatusest välja

  //omistatakse mootori algväärtusele uus suurus

  //värav jõuab ekraani alumisest serva juurest välja

  if (PlayerPos<=0)

  {

    MootorCenter = Mootor-DISPLAY_HEIGHT/2;

    PlayerPos = 1;

  }

  //värav jõuab ekraani ülemise serva juurest välja

  if (PlayerPos>=DISPLAY_HEIGHT-Gate)

  {

    MootorCenter = Mootor+DISPLAY_HEIGHT/2-Gate;

    PlayerPos = DISPLAY_HEIGHT-Gate;

  }

  return PlayerPos;

}

//struktuurne muutuja palli koordinaatide hoidmiseks

struct Position

{

  float x;

  float y;

};

//ekraanil kuvamise protseduur, sisendiks on

//*mängijate värava koordinaadid

//*palli koordianaadid

//*palli ja värava suurused

void Render(int PlayerPosition1,

      int PlayerPosition2, Position BallPos,

      byte Gate, byte Ball)

{

  ClearScreen();

  //ekraanile joonistatakse player1 värav

  RectOut(0, PlayerPosition1, 0, Gate);

  //ekraanile joonistatakse player2 värav

  RectOut(DISPLAY_WIDTH - 1, PlayerPosition2, 0, Gate);

  //ekraanile joonistatakse pall

  RectOut(BallPos.x, BallPos.y, Ball, Ball);

}

Mängija 1 programmikood

Mängija 1 jaoks kirjeldatud funktsioonid ja protseduurid kokku panduna annab esimese mängija NXT programmikoodi. See NXT on mängu juht, esimängija, info edastaja ja Bluetooth master.

//Bluetooth mäng, MASTER NXT, Mängija 1

#include "BluetoothCheck.nxc"

#include "CommonFunctions.nxc"

const byte BTconn=1;

const string SlaveNXTName = "NXT2";

const byte GateWidth = 10;  //värava laius

const byte BallWidth = 3;   //palli suurus

int Player1Pos;     //värava koordinaat

int Player2Pos;     //värava koordinaat

int BallAngleDeg;   //palli põrkenurk

float Speed;        //palli põrkekiirus

string GameData;    //paarilisele saadetavad andmed

Position BallPos;   //palli positsioon

//0: no winner, 1: winner Player1, 2: winner Player2

byte Winner;

long MootorCenterB; //mängu kiiruse muutmise mootor

//SendReceiveBluetoothInfo saadab ja võtab vastu infot

//funktsioni sisendiks on palli ja värava info

//mis edastatakse teisele NXT-le

//funktsioon tagastab teise mängija värava koordinaadi

int SendReceiveBluetoothInfo(string Data)

{

  //MASTER kirjutab ja loeb alati SLAVE mailboxidest

  //saadame info stringina, et saata kogu pakett korraga

  //seeläbi on BT ühendusi vähem ja mäng kiirem

  int PlayerPos;

  //ootab, kuni saab korrektselt teise mängija väravainfo

  while(ReceiveRemoteNumber

        (MAILBOX4, TRUE, PlayerPos)!=NO_ERR);

  //saadab oma värava ja palli info teisele poole

  SendRemoteString(BTconn, MAILBOX5, Data);

  //tagastab teise mängija värava koordinaadi

  return PlayerPos;

}

//mängu kiiruse muutmise funktsioon

float ChangeGameSpeed()

{

  long Mootor;

  float Kiirus;

  Mootor = MotorRotationCount(OUT_B);

  //muutuja Kiirus arvestab mootori algset asukohta

  //+100 liidetakse selleks, et anda mängule baaskiirus

  Kiirus = MootorCenterB - Mootor + 100;

  if (Kiirus <= 10)

    {

      MootorCenterB = Mootor;

      Kiirus = 10;

    }

  //tagastatav kiirus jagatakse 100-ga,

  //et kiiruse muutus oleks võimalikult väike

  return Kiirus/100;

}

//palli liikumise ja nurga arvutamine

void MoveBall()

{

  //esmalt käivitatakse funktsioon, mille vahendusel

  //saab kiiruse, ehk kolmnurga hüpotenuusi

  Speed = ChangeGameSpeed();

  //arvutatakse x-telje koordinaat

  BallPos.x += cosd(BallAngleDeg) * Speed;

  //arvutatakse y-telje koordinaat

  BallPos.y += sind(BallAngleDeg) * Speed;

}

//palli põrkamise funktsioon, tagastab väärtused 0, 1, 2

//0: mäng jätkub, 1: Player1 võitis, 2: Player2 võitis

short BallCollide()

{

  //pall põrkab vastu ülemist serva

  if(BallPos.y > DISPLAY_HEIGHT - BallWidth)

  {

    BallAngleDeg = -BallAngleDeg;

    BallPos.y = DISPLAY_HEIGHT - BallWidth - 1;

  }

  //pall põrkub vastu alumist serva

  else if(BallPos.y <= 0)

  {

    BallAngleDeg = -BallAngleDeg;

    BallPos.y = BallWidth;

  }

  //pall põrkab vastu vasakut serva (Player1)

  if(BallPos.x <= 2)

  {

    //kontrollitakse, kas palli põrkekohal on värav ees

    if (BallPos.y < Player1Pos + GateWidth &&

        BallPos.y > Player1Pos - BallWidth)

    {

      BallAngleDeg = 180 - BallAngleDeg;

      BallPos.x = BallWidth;

    }

    //kui väravat ees ei olnud, siis on mäng läbi

    else

    {

      //võitis mängija 2

      return 2;

    }

  }

  //pall põrkab vastu paremat serva (Player2)

  else if(BallPos.x > DISPLAY_WIDTH - BallWidth)

  {

    //kontrollitakse, kas palli põrkekohal on värav ees

    if(BallPos.y < Player2Pos + GateWidth &&

        BallPos.y > Player2Pos - BallWidth)

    {

      BallAngleDeg = 180 - BallAngleDeg;

      BallPos.x = DISPLAY_WIDTH - BallWidth - 1;

    }

    //kui väravat ees ei olnud, siis on mäng läbi

    else

    {

      //võitis mängija 1

      return 1;

    }

  }

  //mäng jätkub

  return 0;

}

//mängu funktsioonide väljakutsumine

void GameLoop()

{

  //muutujasse Winner salvestatakse mängu staatus

  Winner = BallCollide();

  //liigutatakse palli

  MoveBall();

  //CommonFunctions failist käivitatakse funktsioon,

  //mis liigutab värava asukohta, sisendiks värava laius

  Player1Pos = PlayerPosition(GateWidth);

  //luuakse string kolmest parameetrist:

  //palli x ja y koordinaadid ning player1 värava koordinaat

  GameData = StrCat(NumToStr(BallPos.x), "/",

            NumToStr(BallPos.y), "-",

            NumToStr(Player1Pos));

  //vahetatakse bluetooth infot, edastatakse mängu info

  //tagasi saadakse player2 mängija värava koordinaat

  Player2Pos = SendReceiveBluetoothInfo(GameData);

  //CommonFunctions failist käivitatakse palli

  //ja väravate kuvamise protseduur

  Render(Player1Pos, Player2Pos,

          BallPos, GateWidth, BallWidth);

  //oodatakse 40ms

  Wait(MS_40);

}

//võitja kuvamise protseduur

void ShowWinner()

{

  string Win = "Sa voitsid";

  string Lose = "Sa kaotasid";

  //kui võitja oli Player1

  if(Winner==1)

  {

    //saadetakse Player2-le teade kaotuse kohta

    SendRemoteString(BTconn, MAILBOX6, Lose);

    TextOut(10, LCD_LINE4, Win);

    TextOut(10, LCD_LINE6, "Vajuta nuppu");

    TextOut(10, LCD_LINE7, "jatkamiseks");

  }

  //kui võitja oli Player2

  else if(Winner==2)

  {

    //saadetakse Player2-le teade võidu kohta

    SendRemoteString(BTconn, MAILBOX6, Win);

    TextOut(10, LCD_LINE6, "Vajuta nuppu");

    TextOut(10, LCD_LINE7, "jatkamiseks");

    TextOut(10, LCD_LINE4, Lose);

  }

  while(!ButtonPressed(BTNCENTER, FALSE));

  while(ButtonPressed(BTNCENTER, FALSE));

}

//algse andmestiku initsialiseerimine

void InitData()

{

  Winner = 0;

  BallPos.x = DISPLAY_WIDTH/2;

  BallPos.y = DISPLAY_HEIGHT/2;

  Player1Pos = DISPLAY_HEIGHT/2 - GateWidth/2;

  Player2Pos = DISPLAY_HEIGHT/2 - GateWidth/2;

  MootorCenter=MotorRotationCount(OUT_A);

  MootorCenterB=MotorRotationCount(OUT_B);

  //luuakse juhuslik arv vahemikus 0..119

  int RandomStart = Random(120);

  //juhulikust arvust tehakse vahemik -60..60,

  //mis vastab ekraani parempoolsele suunale

  int RandomRight = RandomStart - 60;

  //juhulikust arvust tehakse vahemik 120..240,

  //mis vastab ekraani vasakpoolsele suunale

  int RandomLeft = RandomStart + 120;

  //valitakse juhuslikult, kas algus on parem-vasak

  BallAngleDeg = Random(2) ? RandomRight : RandomLeft;

  //saadetakse Player2-le info mängu alustamise kohta

  SendRemoteString(BTconn, MAILBOX6, "RESET");

}

task main()

{

  //käivitatakse BT ühenduse kontroll ja/või loomine

  //kui ühendamine ei õnnestunud, väljutakse programmist

  if(!BluetoothConnect(BTconn, SlaveNXTName)==NO_ERR)

    Stop(TRUE);    

  //kuvame kasutajale ühe sekundi jooksul teate

  Wait(SEC_1);

  string shakemessage = "";

  while(shakemessage != "GO")

  {

    ReceiveRemoteString(MAILBOX1, TRUE, shakemessage);

    SendRemoteString(BTconn, MAILBOX1, "Handshake");

  }

  Wait(20);

  //saadetakse palli suuruse info

  SendRemoteNumber(BTconn, MAILBOX2, BallWidth);

  Wait(20);

  //saadetakse värava laiuse info

  SendRemoteNumber(BTconn, MAILBOX3, GateWidth);

  while(TRUE)

  {

    //nullitakse mängu andmed

    InitData();

    //mäng käib, kuni võitjat pole selgunud

    while(!Winner)

    {

      GameLoop();

    }

    //kui võitja on selgunud, kuvatakse see ekraanil

    ShowWinner();

  }

}

Mängija 2 programmikood

Mängija 2 jaoks kirjeldatud funktsioonid ja protseduurid kokku panduna on teise mängija NXT programmikood. See NXT on rollis Bluetooth slave ja tegeleb ainult info vastuvõtmise ja kuvamisega.

//SLAVE

#include "BluetoothCheck.nxc"

#include "CommonFunctions.nxc"

byte GateWidth;     //värava laius

byte BallWidth;     //palli suurus

int Player1Pos;     //mängija 1 värav

int Player2Pos;     //mängija 2 värav

string GameData;    //vastuvõetud mänguandmed

string ShowWinner;  //võitja kuvamine

Position BallPos;   //palli positsioon

//SendReceiveBluetoothInfo saadab ja võtab vastu infot

//funktsiooni sisendiks on värava info,

//mis on vaja edastada teisele NXT-le

//funktsioon tagastab mängija1 värava ja palli koordinaadid

//mängu võiduteade omistatakse globaalsele muutujale ShowWinner

string SendReceiveBluetoothInfo(int PlayerPos)

{

  string Data;

  //slave loeb oma lokaalsest mailboxist

  //palli ja värava koordinaadid

  ReceiveRemoteString(MAILBOX5, FALSE, Data);

  //SLAVE kirjutab oma värava koordinaadi MAILBOX4-a

  SendResponseNumber(MAILBOX4, PlayerPos);

  string TempShowWinner = "";

  //SLAVE loeb mailbox6-st võitja info

  ReceiveRemoteString(MAILBOX6, TRUE, TempShowWinner);

  //kui saadi võitja info, kuvatakse see ekraanil

  if(TempShowWinner != "")

    ShowWinner = TempShowWinner;

  //kui saadi nullimise info, ei kuvata võitja infot

  if(TempShowWinner == "RESET")

    ShowWinner = "";

  return Data;

}

//mängu funktsioonide väljakutsumine

void GameLoop()

{

  //CommonFunctions failist käivitatakse funktsioon

  //mis liigutab värava asukohta, sisendiks värava laius

  Player2Pos = PlayerPosition(GateWidth);

  //vahetatakse bluetooth infot, edastatakse värava info

  //tagasi saadakse player1 värava ja palli koordinaadid

  GameData = SendReceiveBluetoothInfo(Player2Pos);

  //stringitöötluse abil taastatakse

  //värava ja palli koordinaadid 

  int t = Pos("/", GameData);

  BallPos.x = StrToNum(SubStr(GameData, 0, t));

  int u = Pos("-", GameData);

  BallPos.y = StrToNum(SubStr(GameData, t+1, u-t));

  int v = StrLen(GameData);

  Player1Pos = StrToNum(SubStr(GameData, u+1, v-u));

  //CommonFunctions failist käivitatakse

  //palli ja väravate kuvamise protseduur

  Render(Player1Pos, Player2Pos,

          BallPos, GateWidth, BallWidth);

  //võitja info kuvatakse ekraanil

  TextOut(10, LCD_LINE4, ShowWinner);

  Wait(40);

}

task main()

{

  //käivitatakse BT ühenduse kontroll

  //kui ühendamine ei õnnestunud, väljutakse programmist

  if(!BluetoothCheck()==NO_ERR)

    Stop(TRUE);

  string shakemessage;

  while(shakemessage != "Handshake")

  {

    ReceiveRemoteString(MAILBOX1, TRUE, shakemessage);

  }

  TextOut(0,LCD_LINE1, "Waiting for bluetooth");

  SendResponseString(MAILBOX1, "GO");

  while(!BallWidth || !GateWidth)

  {

    ReceiveRemoteNumber(MAILBOX2, FALSE, BallWidth);

    ReceiveRemoteNumber(MAILBOX3, FALSE, GateWidth);

  }

  MootorCenter = MotorRotationCount(OUT_A);

  //mäng käib, kuni see katkestatakse

  while(TRUE)