Programovací jazyk NXC

Obsah práce

1.	Základné časti stavebnice LEGO Mindstorms NXT
2.	Programovací jazyk NXC
3.	Lego mindstorm - Robot triedič
4.	Možnosti využitia vyšších programovacích jazykov pri tvorbe LEGO robotov

NXC znamená Not eXactly C, teda „nie celkom C“. Je to jednoduchý jazyk založený na syntaxe jazyka C, slúžiaci k programovaniu stavebníc LEGO Mindstorms NXT. Programy je možné vytvárať v rôznych vývojových prostrediach, z ktorých jedno je voľne k stiahnutiu zo stránky: http://bricxcc.sourceforge.net. NXT podporuje paralelný výpočet viacerých vlákien. Jedna úloha v NXC priamo zodpovedá jednému výpočtovému vláknu NXT. Úloha sa definuje pomocou kľúčového slova task. Každý program musí obsahovať aspoň jednu úlohu , ktorá je pomenovaná „main“ a je spustená pri štarte programu.

task main ( ) 
{
  // telo úlohy
}

Operácie a premenné

K vytvoreniu programu v jazyku NXC je potrebné poznať niektoré základné operácie (tab. 1).

Tab. 1. Základné operácie v jazyku NXC

Operácia	Význam
a+b	sčítanie
a-b	odčítanie
a*b	násobenie
a/b	delenie
a%b	modulo
a=b	priradí b do a
a-=b	a=a-b
a*=b	a=a*b
a/=b	a=a/b
a%=b	a=a%b
a++	zvýši hodnotu premennej a o 1
a--	zníži hodnotu premennej a o 1
a==b	porovná či a je rovné b
a!=b	a je rôzne od b
a>b	a je väčšie ako b
a>=b	a je väčšie, alebo rovné ako b
a<b	a je menšie ako b
a<=b	a je menšie, alebo rovné ako b
||	logický OR
&&	logický AND

V NXC sa používajú nasledovné typy premenných: bool, byte, char, unsigned int, short int, unsigned long, long, mutex, string, struct a Arrays. NXC podporuje dva druhy komentárov – blokové a jednoriadkové. Blokové komentáre začínajú /* a končia */. Jednoriadkové komentáre začínajú // a končia na novom riadku.

Deklarácia premenných je rovnaká ako v jazyku C:

   int a;  //  deklarácia premennej a
  int a,b,c=4;  /* deklarácia premenných a, b, c, inicializácia c */

Premenné môžu byť lokálne, alebo globálne. Globálne premenné sú viditeľné v celom programe.

Polia, štruktúry, funkcie, podmienky, cykly

NXC podporuje tiež prácu s poľami. Deklarácia polí je rovnaká ako u bežných premenných, pričom za menom premennej nasleduje ľavá a pravá hranatá zátvorka.

   int pole[];  // deklarácia poľa
   int pole[]={0,1,2}; // deklarácia poľa a následná inicializácia
   int pole[][];  // deklarácia dvojrozmerného poľa

Ak chceme inicializovať pole mimo miesta kde ho deklarujeme je potrebné použiť funkciu ArrayInit v tvare:

   ArrayInit(meno_poľa, obsah, počet_prvkov);

Štruktúry sú deklarované obdobne ako v jazyku C. Najskôr je potrebné zadefinovať štruktúru a jej obsah.

struct osoba
{
   string meno;
   int vek; 
};

Po zadefinovaní štruktúry môžeme deklarovať premennú.
<source lang="c">
   osoba ja;  // deklarujeme premennú ja typu osoba

Prvky štrukturovaného typu sú prístupné cez bodkovú notáciu. Pre naplnenie štruktúry použijeme nasledovný zápis.

ja.meno=”Peter”;
ja.vek=20;

Pri programovaní často potrebujeme použiť tie isté príkazy na viacerých miestach. NXC podporuje funkcie s argumentami a návratovými hodnotami. Funkcie majú nasledovnú syntax:

typ_návratovej_hodnoty meno_funkcie (zoznam_argumentov)
{ 
   // telo funkcie
}

Ak funkcia nevracia žiadnu hodnotu, ako návratový typ používame void. Príklad odovzdávania argumentov hodnotou:

void zmen (int b)
{
   b=1;  /* zmení hodnotu argumentu na 1, nemá vplyv na premennú             
          a v hlavnej úlohe */
}
task main ( )
{ 
   int a=0;
   zmen (a);  // volanie funkcie zmen 
}

Príklad odovzdávania argumentov odkazom:

void zmen (int &b)
{ 
   b=1;  // má za následok zmenu hodnoty premennej a v hlavnej úlohe
}

task main ( )
{ 
   int a=0;
   zmen (a);  // volanie funkcie zmen 
}

Základným príkazom pre riadenie toku informácií je podmienka. Ak je podmienka splnená, vykoná sa prvá vetva príkazu. Podmienka môže obsahovať aj druhú vetvu, ktorá sa vykoná vtedy, keď podmienka nie je splnená.

if (a==0)  b=1;  // ak a je 0, tak b nastav na 1
if (a==0) b=2; else b=3;  // ak a je 0, tak b nastav na 2, ináč b nastav na 3 
if (a==0) {b=1; c=2;}  // ak a je 0, tak nastav b na 1 a c na 2

Ak je potrebné ošetriť viacero hodnôt jednej premennej, je vhodné použiť príkaz switch.

switch (a)
{   
   case 1:  b=0; break;  // ak a je 1, tak nastav b na 0
   case 2:  b=1; break;  // ak a je 2, tak nastav b na 1
   case 3:  b=2; break;  // ak a je 3, tak nastav b na 2
   default: b=3; // ak a je rôzne od 1,2,3, tak nastav b na 3
}

Príkaz cyklu while sa používa na zápis cyklov s podmienkou opakovania. Slučka sa vykonáva dovtedy pokiaľ výraz v zátvorke je pravdivý.

int a=0;
while(a<3){
   a=a+1;
}

Ak chceme aby vyhodnocovanie podmienky nebolo na začiatku, ale na konci slučky, môžeme použiť do-while cyklus.

int a=0;
do {
   a=a+1;
} while (a<3);

Iný druh cyklu je cyklus for. Zväčša sa používa pri známom počte opakovaní. Prepis predchádzajúceho príkladu pomocou príkazu for vypadá nasledovne:

	 
for (a=0;a<3;a+=1){ 
   // telo cyklu
   }

Funkcie jazyka NXC

Jazyk NXC, ktorý je viazaný na stavebnicu LEGO Mindstorms NXT obsahuje množstvo preddefinovaných funkcií, ktoré pracujú s hardwarovými časťami programovateľnej NXT kocky a jej periférnymi zariadeniami. V nasledujúcej časti sú popísané základné funkcie pre prácu s motormi a snímačmi.

Motory

NXT kocka obsahuje 3 porty (A,B,C), ku ktorým je možné pripájať výstupné zariadenia. Funkcie pre prácu s motormi majú jeden z argumentov meno portu, ku ktorým sú motory pripnuté. Tieto pomenovania sú v tvare: OUT_A, OUT_B, OUT_C, OUT_AB, OUT_AC, OUT_BC, alebo OUT_ABC. Na roztočenie motora sa používa príkaz OnFwd v tvare:

	
OnFwd (meno_portu, rýchlosť_otáčok);

Rýchlosť otáčok musí byť z intervalu -100 až 100. Podobný príkaz, ale s opačným pôsobením je príkaz OnRev.

OnFwd (OUT_A, -50);  /* motor na porte A sa bude točiť dozadu rýchlosťou  50 */ 
OnRev (OUT_A, 50);  // druhý spôsob zápisu

Ak chceme motor okamžite zabrzdiť, použijeme príkaz Off (meno_portu); pokiaľ chceme aby sa samovoľne dotočil: Coast (meno_portu); Pre otočenie motora o presne špecifický uhol sa používa funkcia:

RotateMotor(meno_portu, rýchlosť, uhol) ;

Snímače

Porty, ku ktorým sa snímače pripájajú sú definované ako: IN_1, IN_2, IN_3, IN_4.

Príklad použitia tlakového senzora

int a;  // deklarujeme premennú a
SetSensorTouch (IN_1);  /* nastaví premenné tak, že na porte IN_1 sa nachádza tlakový senzor */
a=SENSOR_1;  // stav senzora priradíme do nami zadefinovanej premennej a

Príklad použitia zvukového senzora

int a;  // deklarujeme premennú a
SetSensorSound (IN_2);  /* nastaví premenné tak, že na porte IN_2 sa nachádza zvukový senzor */
a=SENSOR_2;  // nameranú hodnotu zapíšeme do premennej a

Príklad použitia svetelného senzora

int a;  // deklarujeme premennú a
SetSensorLight (IN_3);  /* nastaví premenné tak, že na porte IN_3 sa nachádza svetelný senzor */
a=Sensor (IN_3);  // nameranú hodnotu zapíšeme do premennej a

Príklad použitia ultrazvukového senzora

int a;  // deklarujeme premennú a
SetSensorLowspeed (IN_4);  /* nastaví premenné tak, že na porte IN_4 sa nachádza ultrazvukový senzor */
a=SensorUS (IN_4);  // nameranú vzdialenosť v centimetroch zapíšeme do a