User manual

while (expr2) {
Utasításblokk
expr3;
}
A “for” hurok normál esetben számciklusként alkalmazandó.
for (i = 0; i < n; i++)
. . .
Példa:
#include “asuro.h”
int main(void) {
Init()
int zaehler; // Változó deklarálása számként
for (zaehler=0; zaehler<10; zaehler++) { // tízszer ismételni:
SerWrite(“Mehet!\n”,12); // “Mehet!” küldése
}
MotorDir(FWD,FWD); // Mindkét motor előre
MotorSpeed(120,120); // Mindkét motor kb. félerővel előre
while (1) { // Ezután már semmit nem kell tenni!
} }
“while(1)” ekvivalens a “for(;;)”-vel, egy végtelen ciklus, ami soha nem fejeződik be, mivel a megszakításhoz szükséges
feltétel sohasem lesz hamis (azaz 0).
További hurokfelépítés a “do” ciklus
do
Utasításblokk
while( Feltétel);
A “while” ciklussal ellentétben itt a feltétel igazságtartalma az utasításblokk végén kerül ellenőrzésre. Ez a ciklus legalább
egyszer végigfut.
9.1.6. Függvények
A függvény definícióknak mindig a következő a formátuma:
Függvénytípus FüggvényNév (ParaméterTípus 1 ParaméterNév 1,
ParaméterTípus 2 ParaméterNév 2, ...)
Remek, függvénydefiníciók! De mire jó ez az egész??? Nagyon praktikus, de kicsit bonyolultabb, és és egy kicsit később
olvashatjuk...
Gyakran előfordul, hogy egyes programrészekre a program különböző részein ismét szükségünk van. Ekkor vagy mindig
újraírjuk (nagyon fárasztó és teljesen átláthatatlan), vagy egyszer meghatározunk egy függvényt.
Gyakran szeretnénk egy függvénynek egy vagy több értéket átadni. Például egy (önállóan megírt) MenjEgyKicsitEloere()-
függvény egyszerűen nagyobb örömet okoz, ha meg tudjuk adni a sebességet, időtartamot vagy az útszakaszt. Ezt a
paraméterekkel tehetjük meg.
Esetenként előfordul az is, hogy egy függvény egy értéket visszaad. Könnyen elképzelhető egy HanyGombLettMegnyomva() -
függvény. Ez a függvény visszatérési értékén keresztül történik, ami valahogy és valahol a függvényben keletkezik és a return
utasítással tér vissza. Ezért is minden függvény return-nel; vagy return SZAM; -mal végződik.
Különleges függvényt képez a main () függvény. Ez egy programba történő ugrópont. Az ASURO-nál ez a függvény a
bekapcsolásnál megy végbe. A main ()-függvénynek minden programban benne kell lennie!
Miután megismertük az összes adattípust és beszéltünk egy keveset a függvényekről, megpróbálkozunk egy kis példa
fügvénnyel, ami két 8 bites számot sokszoroz és visszaadja az eredményt.
int Mult(char a, char b)
/* A függvény egy int-értéket ad vissza, aminek a neve Mult és két karaktert ad vissza
paraméterként */
{ // A függvény kezdete
int c; // A c változó int-ként van meghatározva
c = a * b; // c kiszámítása
return c; // visszatér c-vel
} // A függvény vége
Még egy kis rutin, ami az éppen meghatározott függvényt végrehajtja:
int main (void) // A main függvény mindig egy int számot ad vissza,
// és nem nem kap átadott paramétert
{ // A függvény kezdete
char mult1,mult2; // Két karakteres változó definiálása
int erg; // Egy int változó definiálása, aminek eredménye a
// mult1 és mult2 változók szorzata
// lesz
mult1 = 2; // Hozzárendelés
mult2 = 10; // Hozzárendelés
erg = Mult(mult1,mult2); // Az előre meghatározott Mult függvény előhívása
return 0;
} // Vége
9.1.7. Mutatók és vektorok
A mutatókkal és tömbökkel itt csak olyan szinten foglalkozunk, amennyire az ASURO működtetéséhez szükséges.
Amikor a vonalkövető érzékelők ill. az odometriai érzékelők kiolvasásra kerülnek, vektorokra van szükség. Ezek deklarációja
egyszerű:
int lData[2];
int oData[2];
A vonalérzékelőhöz és az odometriához az észlelést két vektor (l Data, o Data) 2 elemmel határozza meg. A [0] elemben az
ASURO megfelelő függvényének (LineData(), OdometrieData ()) előhívása után a bal érzékelő értéke van, az [1] elemben a
jobb érzékelőé.
Ehhez egy kis példa:
Ha mindkét vonalérzékelőnél a jobb oldali jobban meg van világítva, mint a bal, akkor az Utasítás 1-nek kell végrehajtódnia,
egyébként az Utasítás 2-nek.
int lData[2]; // A memória rendelkezésre állítása a mért értékhez
LineData(lData); // A mért érték beolvasása
if (lData[1] > lData[0])
Utasítás1;
else
Utasítás2;
A soros interfész funkcióinak (SerWrite(), SerRead() ) használatához jelsorozatokra van szükség. Ezek a következőképp
vannak meghatározva:
char message [] = “Itt egy szoveg van”;
Egy jelsorozat küldéséhez az ASURO-nál csak a SerWrite() függvényt kell előhívni a megfelelő paraméterekkel. Az első
paraméter adja meg a szöveget ill. a jelsorozat változót, a második paraméter megadja, hány jelet kell átvinnie a
jelsorozatnak.
SerWrite(message,20);
ill.
SerWrite(“Itt egy szoveg van”,20);
Infra porton keresztül küldve “Itt egy szoveg van”.
Ha jeleket szeretnénk fogadni, az ASURO a SerRead () függvényre van definiálva. Az első paraméter a jelsorozat változót
tartalmazza, amiben a fogadott jelek tárolódnak, a második paraméter megadja, hány jelet kell fogadni, a harmadik egy
lefutási időt képez. Ha a beállított időn belül (processzor taktus) nem érkezik adat, a függvény megszakad. Ha itt “0” van
beállítva, a függvény megvárja az összes jel beérkezését.
Ehhez is egy kis példa:
Az ASURO-nak a “Hallo hier bin ich” üzenetet kell fogadnia az infra porton keresztül:
char message [] = ”01234567890123456789”;
A fogadandó szöveg részére a hely készen áll. Az imént előkészített jelsorozatnak elég nagynak kell lennie, hogy a fogadandó
szöveget felvegye.
SerRead(message,18,0);