setup
void setup(){}
A kód legelején definiáljuk benne a változókat (inicializálás), pin módókat,
könyvtár használatát, stb. Csak egyszer fut le.
void setup() {
Serial.begin(9600);
pinMode(buttonPin, INPUT);
}
loop
void loop(){}
A setup után jön, folyamatosan azaz többször lefut, lehetővé teszi hogy
a program változzon és reagáljon.
void loop()
{
if (digitalRead(buttonPin) == HIGH)
serialWrite('H');
else
serialWrite('L');
delay(1000);
}
VEZÉRLÉS
if
Feltétel és összehasonlító operátorok (mint nevük is sugallja, két érték
összehasonlítására szolgálnak).
Megvizsgálja, hogy az egyes feltételek teljesülnek-e, mint pl. hogy a
bemeneti szám a megadott számérték felett marad-e. Ha a feltétel
teljesül lefut a kód, ha nem akkor átugorja a program.
if (Változó > 50) {
// csináld ezt
}
A kapcsos zárójel elhagyható, a következő szintaxisok mind helyesek:
a)
if (x > 120) digitalWrite(LEDpin, HIGH);
b)
if (x > 120) digitalWrite(LEDpin, HIGH);
c)
if (x > 120){ digitalWrite(LEDpin, HIGH); }
d)
if (x > 120){
digitalWrite(LEDpin1, HIGH);
digitalWrite(LEDpin2, HIGH);
}
if - else
Ha az if-feltétel nem teljesül, akkor az else-feltétel fut le.
Az else folytatódhat egy másik if vizsgálattal, így összetettebb
vizsgálatokat futtathatunk ugyanazon időben végtelen számú
else if-feltételek vizsgálatával.
if (pin5Bemenet < 500) {
// csináld A-t
} else if (pin5Bemenet >= 1000) {
// csináld B-t
} else {
// csináld C-t
}
for
Amíg a feltétel igaz, addig folyamatosan ismétlődve futnak le a kapcsos
zárójelben lévő állítások. Az inicializálás csak egyszer fut le, onnantól
mindig az aktuális állapotra vizsgálja meg a program, hogy igaz-e a feltétel,
ha igen elvégzi az érték növelését vagy csökkentését, lefutnak az állítások.
A folyamat akkor ér véget, amikor hamis lesz a feltétel.
Gyakran array-jel együtt használjuk.
szintakszis:
for (inicializálás; feltétel; növekedés értéke) {
//statement(s);
}
példa:
for (int i=0; i <= 255; i++){
analogWrite(PWMpin, i);
delay(10);
}
switch case
Az if-hez hasonlóan különböző feltételek végrehajtásához használjuk.
A switch állítás változó értékeit hasonlítja össze a case állításban
részletezett értékekkel, ha a két érték megyegyezik akkor lefut a case
állításban szereplő kód. Minden case álljtás végét a break kulcsszóval
adjuk meg, enélkül a következő kifejezés végrehajtása következne.
switch (var) {
case 1:
//csináld ezt ha a változó 1
break;
case 2:
//csináld ezt ha a változó értéke egyenlő 2-vel
break;
default:
// ha semelyik nem egyezik, csináld az alapértelmezett
// állítást
// az alapértelmezett állítás opcionális
}
A var a változó értéke, amiket a különböző case állításokhoz hasonlítunk.
A label az érték amivel a változót összehasonlítjuk.
case címke:
// utasítások
break;
while
Mindaddig folyamatosan fut le, amíg a kerek zárójelben lévő kifejezés hamissá
nem válik. Valaminek változnia kell a vizsgált változóban, különben a folyamat
soha nem ér véget. Ez történhet változó bevezetésével.
szintaxis:
while(kifejezés){
// utasítás
}
példa:
var = 0;
while(var < 200){
// 200-szor lefutnak a ciklusban lévő utasítások
var++;
}
do - while
A do a while-hoz hasonlóan működik, de a ciklus végén lévő feltételt vizsgálja,
ezért a do ciklus mindig lefut legalább egyszer.
Szintaxis:
do {
// utasítás blokk
} while (feltétel vizsgálata);
Példa:
do
{
delay(50); // várakozás a szenzorra
x = readSensors(); // kiolvassa a szenzorból az értéket
} while (x < 100); // amit összehasonlít
break
A do, for, while ciklusokból és a switch állításból való kilépésre használjuk. Példa:
for (x = 0; x < 255; x ++)
{
digitalWrite(PWMpin, x);
sens = analogRead(sensorPin);
if (sens > threshold){ // bail out on sensor detect
x = 0;
break;
}
delay(50);
}
continue
Átugorja az ismétlések lefuttatását a ciklusokban (do, for, while) majd a
feltétel vizsgálatával és a további ismétlésekkel (a példában for ciklus)
folytatja. Példa:
for (x = 0; x < 255; x ++)
{
if (x > 40 && x < 120){ // ugrik az érték
continue;
}
digitalWrite(PWMpin, x);
delay(50);
}
return
Befejezi a függvényt és visszaállítja a függvényből származó értéket a
meghívott értékre, ha kell. Ebben az esetben az érték származhat bármilyen
változóból vagy állandóból.
Szintaxis, mindkettő forma érvényes:
return;
return value; //value=érték, lehet bármilyen változó vagy állandó
Példa: A következő függvény a szenzorból kiolvasott értéket hasonlítja össze a
küszöbértékkel:
int checkSensor(){
if (analogRead(0) > 400) {
return 1; //érték nagyobb 400-nál, 1-re állítja (be)
else{
return 0; //kisebb, 0-ra állítja az értéket (ki)
}
}
goto
A program lefolyását áthelyezi a programban (általunk elnevezett) cimkével megjelölt ponthoz a következő paranccsal goto label; Ezután visszatér és tovább futtatja a többit.
Szintaxis:
label:
goto label; // a programfutást a címkéhez küldi
Példa:
for(byte r = 0; r < 255; r++){
for(byte g = 255; g > -1; g--){
for(byte b = 0; b < 255; b++){
if (analogRead(0) > 250){ goto kisegites;}
// kisegites: általunk elnevezett
// többi állítás ...
}
}
}
inicializálás: Kezdőérték adást jelent a deklarációban.
deklaráció: Ebben az esetben egyfajta definiálást jelent, közöljük a
programmal hogy az általunk magadott névvel létrehoztunk pl. egy
változót, aminek értékét később definiáljuk.
szintaxis: "A számítástechnikában egy programozási nyelv szintaxisa azt a szabályrendszert jelenti, amely meghatározza, hogy az adott nyelvben hogyan lehet az egyes nyelvi elemeket, utasításokat létrehozni. A szintaxis meghatározza a nyelv tágabb értelem vett ábécéjét, a használható szavakat – ez a nyelv kulcsszókészlete –, és megadja a nyelvi elemek felépítési szabályait (amelyeket a nyelv fordítójának szintaktikai elemzője ellenőriz). A nyelv szintaxisának leírására a metanyelvek szolgálnak." http://hu.wikipedia.org/wiki/Szintaxis
