fizikai számítástechnika, arduino

&& (logikai és) Akkor teljesül ha mindkét állítás igaz.

if (digitalRead(2) == HIGH  && digitalRead(3) == HIGH) { 
  // csináld ezt
  // ...
} 

if (x > 0 || y > 0) {
  // ...
} 

! (nem) Akkor igaz ha az állítás hamis. Tagadás.

if (!x) { 
  // ...
} 

Az egyenlőségjel jobb oldalán található értéket eltárolja az egyenlőségjel bal oldalán lévő változóban. Kezdőérték megadásánál használjuk. Nem összetévesztendő a matematikai egyenlőség megadásával ami a dupla egyenlőségjel: ==

+ összeadás

- kivonás

* szorzás

/ osztás

szintaxisok:

eredmény = érték1 + érték2;

eredmény = érték1 - érték2;

eredmény = érték1 * érték2;

eredmény = érték1 / érték2; 

Az érték bármilyen állandó vagy változó lehet: int, float, double.

példa:

y = y + 3;

x = x - 7;

i = j * 6;

r = r / 5;

% moduló

Amikor egy egész számot elosztunk egy másikkal megmondja a maradék értékét. Nem működik float-tal csak int-tel.

szintaxis:

eredmény = osztandó % osztó

példa:

x = 7 % 5;   // x 2-t tartalmaz

x = 9 % 5;   // x 4-t tartalmaz

x = 5 % 5;   // x 0-t tartalmaz

x = 4 % 5;   // x 4-t tartalmaz

 x == y (x egyenlő y-nal)

 x != y (x nem egyenlő y-nal)

 x <  y (x kisebb mint y)  

 x >  y (x nagyobb mint y) 

 x <= y (x kisebb vagy egyenlő y-nal) 

 x >= y (x nagyobb vagy egyenlő y-nal)

http://arduino.cc/en/Reference/If

Az állítások végén használjuk, lezárjuk vele.

http://arduino.cc/en/Reference/SemiColon

{ } kapcsos zárójel

A C programnyelv legfőbb eleme, különböző konstrukciókban használjuk. 

Ha van egy nyitó kapcsos zárójel akkor mindig kell hogy legyen egy hozzá tartozó záró is! Az Arduino fejlesztőkörnyezetébe be van építve hogy megmutassa melyik zárójelek tartoznak össze, amikor kijelölöd az egyiket. Az egyszerűség kedvéért, hogy ne felejds el bezárni a zárójelet tedd ki egyből mind a kettőt és utána írj be közé.

Függvényeknél, ciklusoknál és feltételeknél használjuk.

http://arduino.cc/en/Reference/Braces

// megjegyzés

Két darab perjel mögé beírhatsz magadnak megjegyzéseket a programsorba, ezeket a fordítóprogram figyelmen kívűl hagyja, nem tölti fel őket az Atmega chip-re.

Ez a kommentezés csak egy sorra vonatkozik. Ha több sort akarsz írni használhatod a csillagos perjeleket:

/* ide jön

több sor 

megjegyzés */

http://arduino.cc/en/Reference/Comments

#define

Egy állandó értékéhez hozzárendelhetünk nevet. Ez a könyebb átláthatóságot segíti. A fordítóprogram ezeket a háttérben behelyettesíti az állandó értékével. 

szintaxis, nincs a végén pontosvessző:

példa:

Haszálható helyette a const kulcsszó is állandók megadására.

http://arduino.cc/en/Reference/Define

#include

Ezzel hívunk meg külső könyvtárakat (library).

Bővebben: Library használata c. alatt.

Így néz ki a programban: 

http://arduino.cc/en/Reference/Include

"Fordítóprogram (angol: compiler): olyan program, amely magasabb számítógépes nyelvi utasításokat dekódol és egy assembly language programot produkál (számítástechnika)" http://meszotar.hu/keres/compiler

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

  }

http://arduino.cc/en/Reference/Setup

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

}

http://arduino.cc/en/Reference/Loop

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

   } 

http://arduino.cc/en/Reference/If

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

  } 

http://arduino.cc/en/Reference/Else

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

       } 

 http://arduino.cc/en/Reference/For

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;

http://arduino.cc/en/Reference/SwitchCase

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

} 

http://arduino.cc/en/Reference/While

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

http://arduino.cc/en/Reference/DoWhile

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

}

http://arduino.cc/en/Reference/Break

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

}

 http://arduino.cc/en/Reference/Continue

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)

    }

} 

http://arduino.cc/en/Reference/Return

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 ... 

        }

    }

}

http://arduino.cc/en/Reference/Goto

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.