Forrás: https://www.arduino.cc/en/Reference/HomePage

Az utasítással definiálható, hogy az adott pin bementként vagy kimenetként kerül majd felhasználásra. Az Arduino lehetőséget ad az un. belső felhúzóellenállás alkalmazására, erről bővebben itt olvashat: Arduino belső felhúzóellenállás.

Az analóg pin-ek (A0, A1, ..) digitális pinként is definiálhatók és használhatók.

Az utasítás(oka)t a void setup() eljárásban kell meghívni.

pinMode (pin, mode)

pin: a pin száma (int)
mode: INPUT (bemenet), OUTPUT (kimenet), INPUT_PULLUP (bemenet belső felhúzóellenálláson keresztül)

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

int ledPin = 13;                 // pin 13 a legtöbb board-on beépített LED-del

void setup()
{
  pinMode(ledPin, OUTPUT);      // digitális pin kimenetként definiálása
}

void loop()
{
  digitalWrite(ledPin, HIGH);   // LED bekapcsolása
  delay(1000);                  // 1 másodperc várakozás
  digitalWrite(ledPin, LOW);    // LED kikapcsolása
  delay(1000);                  // 1 másodperc várakozás
}

• Arduino belső felhúzóellenállás
• digitalWrite
• digitalRead
• analogWrite() / PWM

A HIGH vagy LOW érték írása a digitális kimenetekre (az analóg kimenetek is definiálhatók digitális portként). A portokat a pinMode() utasítással előzetesen (még a void setup() eljárásban) kimenetként kell definiálni. A kimenti HIGH érték board-tól függően 5V vagy 3,3V lehet, a LOW érték pedig 0V (GND).

Ha az adott pin bemenetnek van definiálva, a digitalWrite() meghívása engedélyezi a belső felhúzóellenállást, erről bővebben itt olvashat: Arduino belső felhúzóellenállás.

Amennyiben digitalWrite() meghívása előtt nem definiálta a portot kimenetre (pinMode()), akkor a kimenet jó eséllyel egy magas belsőellenálláson keresztül lesz kivezérelve, mivel így az utasítás bekapcsolja a belső felhúzóellenállást.

A digitális kimenetek maximum 40 mA áramot tudnak kiadni, ami mondjuk elegendő egy LED világításához, vagy egy kisebb relé meghúzásához, de nagyobb teljesítményfelvételű berendezésekhez már nyilván nem elegendő. Ezekben az esetekben relékkel vagy műveleti erősítőkkel kell áthidalni a problémát.

Rövidzárlattal vagy túlfeszültséggel az Arduino-k könnyedén kiiktathatók. Előfordulhat, hogy csak az adott pin adja meg magát egy ilyen baleset hatására és a board egyébként működőképes marad, de gyakoribb, hogy az egész board lehal ilyenkor.

digitalWrite (pin, value)

pin: a pin száma (int) (előzetesen kimenetnek kell definiálni)
value: HIGH vagy LOW

1. példa, a kimenet alkalmazása:

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

int ledPin = 13;                 // pin 13 a legtöbb board-on beépített LED-del

void setup()
{
  pinMode(ledPin, OUTPUT);      // a pin kimenetként definiálása
}

void loop()
{
  digitalWrite(ledPin, HIGH);   // LED bekapcsolása
  delay(1000);                  // 1 másodperc várakozás
  digitalWrite(ledPin, LOW);    // LED kikapcsolása
  delay(1000);                  // 1 másodperc várakozás
}

2. példa, a belső felhúzóellenállás engedélyezése:

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

pinMode(pin, INPUT);           // a pin bemenetként definiálása
digitalWrite(pin, HIGH);       // a belső felhúzóellenállás bekapcsolása

• Arduino belső felhúzóellenállás
• pinMode
• digitalRead

A HIGH vagy LOW érték olvasása a digitális bemenetekről (az analóg kimenetek is definiálhatók digitális portként). A portokat a pinMode() utasítással előzetesen (még a void setup() eljárásban) bemenetként kell definiálni.

Ha az adott pin bemenetnek van definiálva, a digitalWrite() meghívása engedélyezi a belső felhúzóellenállást, erről bővebben itt olvashat: Arduino belső felhúzóellenállás.

A 13. pin-en (az UNO-n) egy LED található az előtét ellenállásával együtt, így ez a port kissé másként viselkedik, mint a többi. Ha előzetesen engedélyezte a belső felhúzóellenállás-t, az 5V-os betáp helyett csak 1.7V "érkezik" meg a portra (ez többnyire LOW szignál).

Rövidzárlattal vagy túlfeszültséggel az Arduino-k könnyedén kiiktathatók. Előfordulhat, hogy csak az adott pin adja meg magát egy ilyen baleset hatására és a board egyébként működőképes marad, de gyakoribb, hogy az egész board lehal ilyenkor.

digitalRead (pin)

pin: a pin száma (int) (előzetesen bemenetnek kell definiálni)

Az utasítás visszatérési értéke HIGH vagy LOW.

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

int ledPin = 13; // pin 13 a legtöbb board-on beépített LED-del
int inPin = 7;   // nyomógomb csatlakoztatása a 7. pin-re
int val = 0;     // a beolvasott érték tárolása

void setup()
{
  pinMode(ledPin, OUTPUT);      // pin 13 kimenetként definiálása
  pinMode(inPin, INPUT);        // pin 7 bemenetként definiálása
}

void loop()
{
  val = digitalRead(inPin);     // a nyomógomb állapotának az olvasása a pin 7-ról 
  digitalWrite(ledPin, val);    // a pin 13-on a LED beállítása a nyomógomb állapotának megfelelően
}

• Arduino belső felhúzóellenállás
• pinMode
• digitalWrite
• analogWrite() / PWM

A funkció az analóg bemenethez használt referenciafeszültséget (azaz a bemeneti tartomány maximális értékét) állítja be.

• Ne használjon 0V-nál kisebb, vagy 5V-nál nagyobb külső referenciafeszültséget az AREF pin-en.
• Az AREF használata esetén az első analogRead() meghívása előtt a TYPE-ot mindenképpen állítsa EXTERNAL-ra.
• Alternatív megoldás, hogy a a külső referenciafeszültséget az AREF érintkezőhöz egy 5KΩ-os ellenálláson keresztül csatlakoztatja. A belső ellenállás (32KΩ) és az előcsatolt ellenállás (5KΩ) együttesen feszültségosztóként fognak működni, így például egy 2,5V-os külső forrás 2,5 * 32 / (32 + 5) = ~ 2,2V bemeneti feszültséget fog eredményezni az AREF-en.

analogReference (type)

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference
analogReference(INTERNAL);
analogRead(0);

• analogRead()
• analogWrite() / PWM
• AREF pin

A funkció beolvassa a megadott analóg pin értékét. Az Arduino board-ok többnyire 6 csatorna (8 csatornás a Mini és a Nano, 16 csatornás a Mega), 10 bites analóg-digitális átalakítót kezelnek (A0..A5). Ez azt jelenti, hogy a 0 és 5 volt közötti bemeneti feszültségeket a 0 és 1023 közötti egész értékekre képezik le. Így az 5 volt / 1024 egység .0049 volt (4,9 mV) egységenkénti (lépésenkénti) értéket képez. A bemeneti tartomány és ezáltal a felbontás is megváltoztatható az analogReference() funkció használatával.

A funkció nagyjából 100 μs alatt olvas be egy értéket, így a maximális beolvasási sebesség körülbelül 10.000 olvasás másodpercenként (ez az érték nyilván függ a teljes program méretétől ill. összetettségétől).

Ha az analóg pin nincs (vagy nem rendesen lett) csatlakoztatva, a beolvasott érték véletlenszerűen (de jellemzően az alacsony tartományban) ingadozik.

analogRead (pin)

pin: az analóg pin száma, ez a legtöbb board-on 0..5 között lehet, a a Mini-n és a Nano-n 0..7, a Mega-n 0..15.

A funkció visszatérési értéke 0..1023 között lehet.

Potméter állásának küldése a terminálra:

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

int analogPin = 3;     // a potméter középső csatlakozóját az analóg 3.pin-re kell 
                       // előzőleg kötni (a két szélsőt az 5V-ra és a GND-ra)
int val = 0;           // a beolvasott érték tárolása

void setup()
{
  Serial.begin(9600);  //  terminál sebességének a beállítása 
}

void loop()
{
  val = analogRead(analogPin);     // potméter állásának beolvasása
  Serial.println(val);             // a beolvasott érték kiírása a terminálra
}

• analogReference()
• analogWrite() / PWM

Az analóg bemenetek csak olvasni képesek az analóg jeleket, semmi közük nincs ehhez a funkcióhoz, ez ugyanis digitális kimeneteken keresztül PWM-mel (pulse-width modulation) tud analóg kimenetet képezni, így működése közelebb áll a digitalWrite() funkcióhoz. Az Arduino PWM kimeneti frekvenciája a kiemelt pin-eken 980 Hz, minden más pin-en pedig 490 Hz.

Az 5. és 6. pin-eken kivezérelt funkciók várhatóan kicsit "lomhábbak" lesznek, mint a többi porton, mert ezeknek a működésébe bezavar(hat) a millis() és a delay() funkció.

Néhány példa az analogWrite() jelkitöltésére:

analogWrite (pin, érték)

pin: a kimeneti pin száma. Ehhez a funkcióhoz nem muszáj pinMode()-dal előre definiálni a kimenetet. A board-okon "~"-mal jelölt pin-eken 980 Hz érhető el. érték: 0..255, 0: kikapcsolva, 255: folyamatosan bekapcsolva

A példaprogramban a 3.pin-re kötött potméterrel lehet állítani a 9.pin-en keresztül egy LED fényerejét (a LED elé védő-ellenállást kell kötni)

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

int ledPin = 9;      // LED csatlakoztatása a 9.pin-re (egy 1kΩ-os ellenállással sorosan kötve)
int analogPin = 3;   // a potméter középső csatlakozóját az analóg 3.pin-re kell 
                     // előzőleg kötni (a két szélsőt az 5V-ra és a GND-ra)
int val = 0;         // beolvasott érték tárolása

void setup()
{
  pinMode(ledPin, OUTPUT);   // a 9.pin kimenetként deklarálása
}

void loop()
{
  val = analogRead(analogPin);   // potméter állásának a beolvasása
  analogWrite(ledPin, val / 4);  // az analogRead érték 0 és 1023 között kerül beolvasásra, 
                                 // az analogWrite pedig 0..255 tartományban változhat
}

• analogReference()
• analogRead()

A funkcióval egy állandó frekvenciájú 50%-os jelkitöltésű PWM jelet generálhatunk egy adott digitális kimeneten. A elsősorban funkció hang-generásra alkalmas, ha a kimnetre hangszóró vagy buzzer van csatlakoztatva. A funkció alkalmazása (a Mega board kivételével) befolyásolhatja a 3. és 11. pin kimeneteit. A funkció egyszerre csak egy hang(magasság) lejátszására alkalmas, működését a noTone()-nal lehet leállítani, vagy az időtartamát meg kell adni a funkció hívásakor. A tone()-nál bővebb funkciónalitással szolgál a "Tone" könyvtár. A hangszórót a pin-re egy 1KΩ-os ellenállás beiktatásával kell bekötni. A hangmagasság állításához egy 10KΩ-os potméterrel is bővíteni kell a kapcsolást.

tone (pin, frekvencia)
tone (pin, frekvencia, hossz)

pin: a hangkimeneti pin száma
frekvencia (unsigned int): kimeneti frekvencia (Az Uno, Mega és egyéb AVR board-okon a frekvencia 31..65535 Hz között állítható.)
hossz (unsigned long): időtartam (opcionális), ms-ban megadva

void setup() {
}
// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

void loop() {
  // a tone kikapcsolása a pin 2-n:
  noTone(2);
  // egy hangjegy kiadása a pin 2-n 200 ms hosszan:
  tone(2, 440, 200);
  // 200 ms várakozás
  delay(200);
}

• noTone()
• shiftOut()
• shiftIn()
• pulseIn()

A noTone() funkció egyszerűen a tone() leállítására szolgál.

noTone (pin)

pin: a pin száma, ahol a tone() funkciót le kell állítani.

• tone()
• shiftOut()
• shiftIn()
• pulseIn()

A funkció soros átviteli lehetőséget biztosít byte hosszú adatok számára. A funkcióhoz egy adat-pin és egy órajel-pin tartozik. Az adat pinre a byte egy adott bitje kerül ki, mindaddig, míg az órajel-pin állapota nem változik. Az órajel-pin állapotváltása után a következő bit lesz olvasható az adat-pin-ről.

Hasonló, de komplexebb adatátviteli formákat kínál az "SPI" könyvtár, vagy az átvitel manuálisan is lekódolható, például így.

Az írásra alkalmas shiftOut() funkciónak az olvasásra alkalmazható párja a shiftIn().

shiftOut(adatPin, órajelPin, irányBit, érték)

adatPin: adatkimeneti pin száma
órajelPin: órajel-pin száma
irányBit: MSBFIRST vagy LSBFIRST: (Most Significant Bit First, vagy, Least Significant Bit First)
érték (byte): az átvitelre kerülő byte.

Amennyiben egy int-et akarunk küldeni a shiftOut() használatával:

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

// a magas helyiérték felől (MSBFIRST)
int data = 500;
shiftOut(dataPin, clock, MSBFIRST, (data >> 8));  // a highbyte kiküldése 
shiftOut(dataPin, clock, MSBFIRST, data);         // a lowbyte kiküldése

// az alacsony helyiérték felől (LSBFIRST)
data = 500;
shiftOut(dataPin, clock, LSBFIRST, data);         // a lowbyte kiküldése
shiftOut(dataPin, clock, LSBFIRST, (data >> 8));  // a highbyte kiküldése 

• tone()
• noTone()
• shiftIn()
• pulseIn()

A funkció a shiftOut() párja, ugyanazon az elven egy byte információ olvasására alkalmas.

shiftIn(adatPin, órajelPin, irányBit)

adatPin: adatbemeneti pin száma
órajelPin: órajel-pin száma
irányBit: MSBFIRST vagy LSBFIRST: (Most Significant Bit First, vagy, Least Significant Bit First)

A funkció visszatérési értéke a beolvasott "érték" byte.

• tone()
• noTone()
• shiftOut()
• pulseIn()

A funkció az adott pin-en fenálló jel hosszán méri az időt. Ha például a megadott érték a HIGH, akkor először vár a HIGH jelre, majd annak az érkezésével indítja az időmérést mindaddig, míg a pin LOW állapotba kerül. Ha az érték HIGH és indításkor is HIGH jel van a pin-en, akkor először kivár egy LOW-t, majd az ismételt HIGH-ra indítja az időmérést a funkció.

pulseIn (pin, érték) impulzus (pin, érték, időtúllépés)

pin: a figyelt pin száma
érték: HIGH vagy LOW
időtúllépés (unsigned long) (opcionális): a maximális jelhossz µsec-ben, ennek letelte után a funkció visszatérési értéke 0 lesz. A paraméter alapértelmezetten 1 sec.

A funkció visszatérési értéke (unsigned long) a jel hossza µsec-ben, vagy 0 időtúllépés esetén.

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

int pin = 7;
unsigned long duration;

void setup()
{
  pinMode(pin, INPUT);
}

void loop()
{
  duration = pulseIn(pin, HIGH);  // a 7. pin-en a "HIGH" időtartama 
}

• tone()
• noTone()
• shiftOut()
• shiftIn()

A funkció a program indítása óta eltelt ezredmásodpercet adja vissza. A funkció nagyjából 50 naponként túlcsordul, ilyenkor újra nulláról kezdi a számlálást. Nyilván ezzel a programozás során is számolni kell. Hasonló működésű a micros() funkció is, ami a mikromásodpercek számát adja vissza, de nagyjából 70 percenként túlcsordul.

millis()

a funkciónak nincs paramétere

a funkció visszatérési értéke (unsigned long) a program indítása óta eltelt ezredmásodperc (msec)

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

unsigned long time;

void setup(){
  Serial.begin(9600);
}
void loop(){
  Serial.print("Time: ");
  time = millis();
  Serial.println(time);      //a programindítás óta eltelt időtartam küldése a terminálra
  delay(1000);               // a programfutás 1 másodperces felfüggesztése
}

• micros()
• delay()
• delayMicroseconds()

A funkció a program indítása óta eltelt mikromásodpercet adja vissza. A funkció nagyjából 70 percenként túlcsordul, ilyenkor újra nulláról kezdi a számlálást. Nyilván ezzel a programozás során is számolni kell. Hasonló működésű a millis() funkció is, ami a ezredmásodpercek számát adja vissza, de nagyjából csak 50 naponként csordul túl.

micros()

a funkciónak nincs paramétere

a funkció visszatérési értéke (unsigned long) a program indítása óta eltelt mikromásodperc (µsec)

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

unsigned long time;

void setup(){
  Serial.begin(9600);
}
void loop(){
  Serial.print("Time: ");
  time = micros();
  Serial.println(time);       // a programindítás óta eltelt időtartam küldése a terminálra
  delay(1000);                // a programfutás 1 másodperces felfüggesztése
}

• millis()
• delay()
• delayMicroseconds()

A funkció felfüggeszti a program futását a megadott ideig. Alapvetően a LED villogtatásán kívül ezt a funkciót érdemes elkerülni, mert valóban szinte minden egyéb működést felfüggeszt a várakozás ideje alatt. A delay() funkcióval technikailag megegyezik a delayMicroseconds(), ahol a késleltetést µs-ban kell megadni.

Az időzítési funkciókat érdemes a millis() vagy micros() funkciókkal, vagy a "Time", "TimeAlarms" könyvtárak által nyújtott lehetőségekkel megoldani.

delay (ms)

ms (unsigned long): a felfüggesztés ideje ezredmásodpercben

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

int ledPin = 13;                 // pin 13 a legtöbb board-on beépített LED-del

void setup()
{
  pinMode(ledPin, OUTPUT);      // digitális pin kimenetként definiálása
}

void loop()
{
  digitalWrite(ledPin, HIGH);   // LED bekapcsolása
  delay(1000);                  // 1 másodperc várakozás
  digitalWrite(ledPin, LOW);    // LED kikapcsolása
  delay(1000);                  // 1 másodperc várakozás
}

• millis()
• micros()
• delayMicroseconds()

A funkció felfüggeszti a program futását a megadott ideig. A delayMicroseconds() funkcióval technikailag megegyezik a delay(), ahol a késleltetést ezredmásodpercben kell megadni.

delayMicroseconds(us)

us (unsigned int): a felfüggesztés ideje µsec-ben. Maximális értéke 16383.

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

int outPin = 8;                 // digitál pin 8

void setup()
{
  pinMode(outPin, OUTPUT);      // a pin 8 kimenetként definiálása
}

void loop()
{
  digitalWrite(outPin, HIGH);   // 8.pin bekapcsolása
  delayMicroseconds(50);        // 50 µsec várakozás      
  digitalWrite(outPin, LOW);    // 8.pin kikapcsolása
  delayMicroseconds(50);        // 50 µsec várakozás      
}

• millis()
• micros()
• delay()

Megadja a két paraméterként megadott számból a kisebbik értékét.

min (x, y)

x, y: az első és második szám, bármilyen adat-típusúak lehetnek

A funkció visszatérési értéke a kisebbik szám

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

senseVal = min ( sensVal , 100 );     // biztosítja, hogy a senseVal ne vehessen fel 100-nél nagyobb értéket

A funkció zárójelén belül ne hajtasson végre egyéb műveletet, mert ez hibás eredményhez vezethet:

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

min ( a ++, 100 ) ;   // kerülje ezt - hibás eredményhez vezet  

min ( a , 100 ) ; 
a ++;                 // használja helyette így - az egyéb műveleteket a zárójelen kívül deklarálja

• max()
• abs()
• constrain()
• map()
• pow()
• sqrt()

Megadja a két paraméterként megadott számból a nagyobbik értékét.

max(x, y)

x, y: az első és második szám, bármilyen adat-típusúak lehetnek

A funkció visszatérési értéke a nagyobbik szám

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

senseVal = max ( sensVal , 100 );     // biztosítja, hogy a senseVal ne vehessen fel 100-nál kisebb értéket

A funkció zárójelén belül ne hajtasson végre egyéb műveletet, mert ez hibás eredményhez vezethet:

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

max ( a ++, 100 ) ;   // kerülje ezt - hibás eredményhez vezet  

max ( a , 100 ) ; 
a ++;                 // használja helyette így - az egyéb műveleteket a zárójelen kívül deklarálja

• min()
• abs()
• constrain()
• map()
• pow()
• sqrt()

A funkció visszaadja egy szám abszolut-értékét.

abs (x)

x: szám

A funkció visszatérési értéke "x" abszolut-értéke.

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

abs ( a ++ ) ;   // kerülje ezt - helytelen eredményeket hozhat 

abs ( a ) ; 
a ++;           // használja helyette ezt - tagolja a műveleteket

• min()
• max()
• constrain()
• map()
• pow()
• sqrt()

Egy számértéket egy adott tartományon belül korlátoz.

constrain (x, min, max)

x (bármely adattípus lehet): a beérkező számérték
min (bármely adattípus lehet): a korlátozási tartomány alsó értéke
max (bármely adattípus lehet): a korlátozási tartomány felső értéke

A funkció visszatérési értéke:

• Ha min < x < max, akkor: x
• Ha x < min, akkor: min
• Ha x > max, akkor: max

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

sensVal = constrain(sensVal, 10, 150);   // a sensVal értékét 10 és 150 között tartja

• min()
• max()
• abs()
• map()
• pow()
• sqrt()

A bemenő értéket egy bemeneti tartományból átskálázza a kimeneti tartományba.

A minimum és maximum értékek felcserélődhetnek (a minimum lehet nagyobb, mint a maximum), ezesetben a skálázás iránya is megfordul. A funkció konkrétan így működik:

long map(long x, long in_min, long in_max, long out_min, long out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

map (érték, bemenetMin, bemenetMax, kimenetMin, kimenetMax)

érték: a skálázandó érték
bemenetMin: az eredeti értéktartomámy maximuma
bemenetMax: az eredeti értéktartomámy minimuma
kimenetMin: a kimeneti értéktartomámy maximuma
kimenetMax: a kimeneti értéktartomámy minimuma

Analóg érték olvasása, 8 bitesre konvertálása (0..255) és PWM-ben kiadása. Nyilván ebben az esetben a "map" használata alapvetően felesleges, mivel elég volna a "val"-t néggyel osztani.

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

void setup() {}

void loop()
{
  int val = analogRead(0);
  val = map(val, 0, 1023, 0, 255);
  analogWrite(9, val);
}

• min()
• max()
• abs()
• constrain()
• pow()
• sqrt()

Exponenciális számítása.

pow (alap, exponens)

alap (float): alap
exponens (float): exp

A funkció visszatérési értéke: double.

• min()
• max()
• abs()
• constrain()
• map()
• sqrt()

Négyzetgyök számítása.

sqrt (x)

x(bármely típus): bemeneti érték

A funkció visszatérési értéke x négyzetgyöke (double).

• min()
• max()
• abs()
• constrain()
• map()
• pow()

A funkció kiszámítja a szinusz szöget (radianban). Az eredmény -1 és 1 között lesz.

sin (rad)

rad (float): a szög a radianban

A funkció visszatérési értéke (double) a sin(rad) eredménye lesz.

• cos()
• tan()

A funkció kiszámítja a koszinusz szöget (radianban). Az eredmény -1 és 1 között lesz.

cos (rad)

rad (float): a szög a radianban

A funkció visszatérési értéke (double) a cos(rad) eredménye lesz.

• sin()
• tan()

A funkció kiszámítja a tangens szöget (radianban). Az eredmény -végtelen és +végtelen között lesz.

tan (rad)

rad (float): a szög a radianban

A funkció visszatérési értéke (double) a tan(rad) eredménye lesz.

• sin()
• cos()

A funkció megállapítja, hogy a megadott karakter (char) alfanumerikus-e.

isAlphaNumeric (ezAChar)

ezAChar (char): egy karakter

A funkció visszatérési értéke TRUE vagy FALSE.

• isAlpha()
• isAscii()
• isWhitespace()
• isControl()
• isDigit()
• isGraph()
• isLowerCase()
• isPrintable()
• isPunct()
• isSpace()
• isUpperCase()
• isHexadecimalDigit()

A funkció megállapítja, hogy a megadott karakter (char) a görög abc tagja-e.

isAlpha (ezAChar)

ezAChar (char): egy karakter

A funkció visszatérési értéke TRUE vagy FALSE.

• isAlphaNumeric()
• isAscii()
• isWhitespace()
• isControl()
• isDigit()
• isGraph()
• isLowerCase()
• isPrintable()
• isPunct()
• isSpace()
• isUpperCase()
• isHexadecimalDigit()

A funkció megállapítja, hogy a megadott karakter (char) az ASCII eleme-e.

isAscii (ezAChar)

ezAChar (char): egy karakter

A funkció visszatérési értéke TRUE vagy FALSE.

• isAlphaNumeric()
• isAlpha()
• isWhitespace()
• isControl()
• isDigit()
• isGraph()
• isLowerCase()
• isPrintable()
• isPunct()
• isSpace()
• isUpperCase()
• isHexadecimalDigit()

A funkció megállapítja, hogy a megadott karakter (char) üres elem-e.

isWhitespace (ezAChar)

ezAChar (char): egy karakter

A funkció visszatérési értéke TRUE vagy FALSE.

• isAlphaNumeric()
• isAlpha()
• isAscii()
• isControl()
• isDigit()
• isGraph()
• isLowerCase()
• isPrintable()
• isPunct()
• isSpace()
• isUpperCase()
• isHexadecimalDigit()

A funkció megállapítja, hogy a megadott karakter (char) vezérlőelem-e.

isControl (ezAChar)

ezAChar (char): egy karakter

A funkció visszatérési értéke TRUE vagy FALSE.

• isAlphaNumeric()
• isAlpha()
• isAscii()
• isWhitespace()
• isDigit()
• isGraph()
• isLowerCase()
• isPrintable()
• isPunct()
• isSpace()
• isUpperCase()
• isHexadecimalDigit()

A funkció megállapítja, hogy a megadott karakter (char) számjegy-e.

isDigit (ezAChar)

ezAChar (char): egy karakter

A funkció visszatérési értéke TRUE vagy FALSE.

• isAlphaNumeric()
• isAlpha()
• isAscii()
• isWhitespace()
• isControl()
• isGraph()
• isLowerCase()
• isPrintable()
• isPunct()
• isSpace()
• isUpperCase()
• isHexadecimalDigit()

A funkció megállapítja, hogy a megadott karakter (char) grafikusan ábrázolható-e.

isGraph (ezAChar)

ezAChar (char): egy karakter

A funkció visszatérési értéke TRUE vagy FALSE.

• isAlphaNumeric()
• isAlpha()
• isAscii()
• isWhitespace()
• isControl()
• isDigit()
• isLowerCase()
• isPrintable()
• isPunct()
• isSpace()
• isUpperCase()
• isHexadecimalDigit()

A funkció megállapítja, hogy a megadott karakter (char) kisbetű-e.

isLowerCase (ezAChar)

ezAChar (char): egy karakter

A funkció visszatérési értéke TRUE vagy FALSE.

• isAlphaNumeric()
• isAlpha()
• isAscii()
• isWhitespace()
• isControl()
• isDigit()
• isGraph()
• isPrintable()
• isPunct()
• isSpace()
• isUpperCase()
• isHexadecimalDigit()

A funkció megállapítja, hogy a megadott karakter (char) nyomtatható-e.

isPrintable (ezAChar)

ezAChar (char): egy karakter

A funkció visszatérési értéke TRUE vagy FALSE.

• isAlphaNumeric()
• isAlpha()
• isAscii()
• isWhitespace()
• isControl()
• isDigit()
• isGraph()
• isLowerCase()
• isPunct()
• isSpace()
• isUpperCase()
• isHexadecimalDigit()

A funkció megállapítja, hogy a megadott karakter (char) írásjel-e.

isPunct (ezAChar)

ezAChar (char): egy karakter

A funkció visszatérési értéke TRUE vagy FALSE.

• isAlphaNumeric()
• isAlpha()
• isAscii()
• isWhitespace()
• isControl()
• isDigit()
• isGraph()
• isLowerCase()
• isPrintable()
• isSpace()
• isUpperCase()
• isHexadecimalDigit()

A funkció megállapítja, hogy a megadott karakter (char) szóköz-e.

isSpace (ezAChar)

ezAChar (char): egy karakter

A funkció visszatérési értéke TRUE vagy FALSE.

• isAlphaNumeric()
• isAlpha()
• isAscii()
• isWhitespace()
• isControl()
• isDigit()
• isGraph()
• isLowerCase()
• isPrintable()
• isPunct()
• isUpperCase()
• isHexadecimalDigit()

A funkció megállapítja, hogy a megadott karakter (char) nagybetű-e.

isUpperCase (ezAChar)

ezAChar (char): egy karakter

A funkció visszatérési értéke TRUE vagy FALSE.

• isAlphaNumeric()
• isAlpha()
• isAscii()
• isWhitespace()
• isControl()
• isDigit()
• isGraph()
• isLowerCase()
• isPrintable()
• isPunct()
• isSpace()
• isHexadecimalDigit()

A funkció megállapítja, hogy a megadott karakter (char) hexadecimális számként értelmezhető-e.

isHexadecimalDigit (ezAChar)

ezAChar (char): egy karakter

A funkció visszatérési értéke TRUE vagy FALSE.

• isAlphaNumeric()
• isAlpha()
• isAscii()
• isWhitespace()
• isControl()
• isDigit()
• isGraph()
• isLowerCase()
• isPrintable()
• isPunct()
• isSpace()
• isUpperCase()

A szokásos véletlenszám generátor (random()) egy olyan algoritmussal dolgozik, ahol a számképzés időnként ismétlődik, ezért nem igazán mondható el róla, hogy teljesen spontán módon dobálja a véletlenszámokta. Ezen a helyzeten próbál segíteni a randomSeed() funkció, mely egy véletlenszerűen előállított - mondjuk egy analóg portról olvasott - értékkel "inicializálja" a véletlenszám generátort.

randomSeed (kezdőérték)

kezdőérték (long, int): kezdőérték a véletlenszám generáláshoz

// a példaprogram az arduino.cc oldalról származik
// magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

long randNumber;

void setup(){
  Serial.begin(9600);          // terminálfunkció sebességének a beállítása
  randomSeed(analogRead(0)) ;  // amíg az analóg A0 bemenet nincs is csatlakoztatva
                               // az ott olvasott "zaj"-jal a  randomSeed() egy valóban véletlenszerű
                               // kezdést generál a véletlenszám funkció számára.
}

void loop(){
  randNumber = random(300);    // véletlenszám generálása
  Serial.println(randNumber);  // véletlenszám kiadása 0 és 299 között 
  delay(50);                   // 50 ms várakozás
}

• random()

A funkció véletlenszámot generál. A véletlenszám-képzés még spontánabbá tehető a randomSeed() funkció előzetes meghívásával.

random (max)
random (min, max)

min: véletlenszerű érték alsó határa (opcionális)
max: véletlenszerű érték felső határa

A funkció visszatérési értéke a véletlenszám min és max-1 között (long).

a példaprogram az arduino.cc oldalról származik magyar változat: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

long randNumber;

void setup(){
  Serial.begin(9600);

  // amíg az analóg A0 bemenet nincs is csatlakoztatva
  // az ott olvasott "zaj"-jal a  randomSeed() egy valóban véletlenszerű
  // kezdést generál a véletlenszám funkció számára.
  randomSeed(analogRead(0));
}

void loop() {

  randNumber = random(300);       // véletlenszám kiadása 0 és 299 között
  Serial.println(randNumber);  
  randNumber = random(10, 20);    // véletlenszám kiadása 10 és 19 között
  Serial.println(randNumber);
  delay(50);                      // 50 ms várakozás
}

• randomSeed()

Az adott változó (pl. word) alsó (jobboldali) bájtjával tér vissza a funkció.

lowByte(x)

x: bármely változó

A funkció visszatérési értéke (byte) az alsó byte tartalma.

// példaprogram: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

void setup(){
  Serial.begin(9600);
}

void loop() {

  word bemenet = random(65536); 
  
  byte eredmenyH = highByte(bemenet);
  byte eredmenyL = lowByte(bemenet);
  Serial.print("veletlenszám: ");
  Serial.print(bemenet);
  Serial.print(", highByte: ");  
  Serial.print(eredmenyH);
  Serial.print(", lowByte: ");
  Serial.println(eredmenyL);

  delay(5000);                    // 5s várakozás
}

• highByte()
• bitRead()
• bitWrite()
• bitSet()
• bitClear()
• bit()

Az adott változó (pl. word) felső (baloldali) bájtjával tér vissza a funkció.

highByte(x)

x: bármely változó

A funkció visszatérési értéke (byte) az felső byte tartalma.

Lásd a lowByte()-nál.

• lowByte()
• bitRead()
• bitWrite()
• bitSet()
• bitClear()
• bit()

Egy bit kiolvasása egy adott változóból.

bitRead (x, n)

x: a változó, ahonnan a bitet olvassuk
n: a kiolvasandó bit száma, a 0 a legalacsonyabb (jobboldali) bitpozíciót jelöli

A funkció visszatérési értéke a bit, ami 0 vagy 1 lehet.

// példaprogram: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

void setup(){
  Serial.begin(9600);
}

void loop() {

  word bemenet = random(65536); 
  int pozicio = random(16);

  Serial.print("veletlenszám: ");
  Serial.print(bemenet);
  Serial.print(", ");
  Serial.print(pozicio);  
  Serial.print(". pozícióban a bit értéke: ");  
  Serial.println(bitRead(bemenet, pozicio));

  delay(5000);                    // 5s várakozás
}

• lowByte()
• highByte()
• bitWrite()
• bitSet()
• bitClear()
• bit()

Egy bit átírása egy változóban.

bitWrite (x, n, b)

x: manipulált változó
n: a változón belüli bitpozíció
b: a felülírt bit új értéke (0 vagy 1)

// példaprogram: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference

void setup(){
  Serial.begin(9600);
}

void loop() {

  word bemenet = random(65536); 
  int pozicio = random(16);

  Serial.print("véletlenszám: ");
  Serial.print(bemenet);
  Serial.print(", ");
  Serial.print(pozicio);
  Serial.print(". pozíció felülírása '1'-gyel. A változó új értéke: ");   
  Serial.println(bitWrite(bemenet, pozicio, 1));

  delay(5000);                    // 5s várakozás
}

• lowByte()
• highByte()
• bitRead()
• bitSet()
• bitClear()
• bit()

Egy bitpozíció 1-gyel való felülírása egy változóban. Gyakorlatilag egyenértékű a bitWrite(x, n, 1) funkcióval.

bitSet(x, n)

x: manipulált változó
n: a változón belüli bitpozíció

• lowByte()
• highByte()
• bitRead()
• bitWrite()
• bitClear()
• bit()

Egy bitpozíció 0-val való felülírása egy változóban. Gyakorlatilag egyenértékű a bitWrite(x, n, 0) funkcióval.

bitClear(x, n)

x: manipulált változó
n: a változón belüli bitpozíció

• lowByte()
• highByte()
• bitRead()
• bitWrite()
• bitSet()
• bit()

A funkció az adott bitpozícióhoz tartozó értékkel tér vissza, azaz 0 → 1, 1 → 2, 2 → 4, 3 → 8,..

bit(n)

n: bitpozíció

• lowByte()
• highByte()
• bitRead()
• bitWrite()
• bitSet()
• bitClear()

A megszakításkezelés ISR (interrupt service routine) néven is ismert eljárását az Arduino-ban az attachInterrupt() funkcióval deklarálhatjuk és kijelölhetünk egy pin-t a megszakítás-jel fogadására. A megszakításhoz olyan pin-t kell választani, mely alkalmas erre a funkcióra, ezeknek a jegyzéke itt található. A megszakítás lehetőséget teremt arra, hogy a nagyon sűrűn változó, rövid jelhosszúságú impulzusok (pl. Hall-jeladók, szonár-jelek,..) is feldolgozásra kerülhessenek.

Arduino Due, Zero, MKR1000 szintaktika:
attachInterrupt (digitalPinToInterrupt(pin), ISR, mode)

Arduino Uno, Mini, Mega szintaktika:
attachInterrupt (interrupt, ISR, mode)

interrupt (int): a megszakítás száma:

Due, Zero, MKR1000 , 101: a megszakítás száma megegyezik a pin számával.

pin: pin száma (ISR-re kijelölt pin-t kell megadni, csak az Arduino Due, Zero, MKR1000 board-okon működik)
ISR: a megszakítás esetén meghívásra kerülő funkció neve. Nem lehet átadási paramétere és visszatérési értéke (void funkció_neve() {..})
mode: Az ISR-nél megadott funkció híváskritériuma:

YF-S201 áramlásmérés

// példaprogram: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference
// A példaprogram csak az UNO-n fog "rendesen" működni, mert itt tartozik a 
// pin 2-höz a 0.interrupt, lásd: fent; interrupt paraméter táblázat

byte sensorInterrupt = 0;  // 0 = digital pin 2
byte sensorPin       = 2;
volatile byte state  = LOW;


void loop() {
  attachInterrupt(sensorInterrupt, blink, FALLING);
}

void blink() {
  state = !state;
}

A "volatile" típusú véltozók leírását itt találja: volatile

• detachInterrupt()
• interrupts()
• noInterrupts()

Az attachInterrupt() funkció feloldása, az interruphoz rendelt pin felszabadítása. A funkcióleírást lásd fent.

detachInterrupt(interrupt)
detachInterrupt(digitalPinToInterrupt(pin))
detachInterrupt(pin) (Arduino Due, Zero)

A paraméterek leírását lásd fent, az attachInterrupt()-nál.

• attachInterrupt()
• interrupts()
• noInterrupts()

A noInterrupts() / interrupts() funkciópár olyan blokkot jelöl ki a forráskódban, mely például az időérzékenysége miatt nem szakítható meg.

interrupts()
noInterrupts()

A funkcióknak se paraméterük, se visszatérési értékük nincs.

// példaprogram: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference
void setup() {}
void loop()
{
  noInterrupts();
  // kritikus, időérzékeny kód
  interrupts();
  // minden más kód itt
}

• attachInterrupt()
• detachInterrupt()
• noInterrupts()

Lásd fent: interrupts().

• attachInterrupt()
• detachInterrupt()
• interrupts()

Az Arduino soros kommunikáció ezzel a funkcióval deklarálható.

A funkció kifejtése (majd) a "serial" könyvtárnál lesz megtalálható.

• Stream

A funkció kifejtése majd a steam könyvtárban lesz megtalálható.

• Serial