Arduino funkciók

Digital I/O funkciók

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.

Szintaktika

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)

Példa

// 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
}

Kapcsolódó témakörök

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.

Szintaktika

digitalWrite (pin, value)

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

Példa

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

Kapcsolódó témakörök

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.

Szintaktika

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.

Példa

// 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
}

Kapcsolódó témakörök

Analóg I/O funkciók

analogReference()

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.

Szintaktika

analogReference (type)

typeLeírás
DEFAULTaz alapértelmezett 5 voltos analóg referenciaérték (5V-os Arduino board-okon) vagy 3.3 volt (a 3.3V-os Arduino board-okon)
INTERNALbeépített referencia, amely 1.1V az ATmega168/ATmega328 esetén és 2.56V az ATmega8-nál (nem érhető el az Arduino Mega-n)
INTERNAL1V1beépített 1.1V referencia (csak az Arduino Mega board-on működik)
INTERNAL2V56beépített 2.56V referencia (csak az Arduino Mega board-on működik)
EXTERNALaz AREF pinre kötött feszültség (0V..5V), mely referenciaként szolgál

Példa

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

Kapcsolódó témakörök

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.

Szintaktika

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.

Példa

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
}

Kapcsolódó témakörök

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:
PWM az Arduino-n

Szintaktika

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

Példa

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
}

Kapcsolódó témakörök

Bővített I/O funkciók

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() hangszóróval

Szintaktika

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

Példa

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

Kapcsolódó témakörök

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

Szintaktika

noTone (pin)

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

Kapcsolódó témakörök

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

Szintaktika

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.

Példa

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 

Kapcsolódó témakörök

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

Szintaktika

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.

Kapcsolódó témakörök

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

Szintaktika

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.

Példa

// 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 
}

Kapcsolódó témakörök

Időfunkciók

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.

Szintaktika

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)

Példa

// 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
}

Kapcsolódó témakörök

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.

Szintaktika

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)

Példa

// 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
}

Kapcsolódó témakörök

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.

Szintaktika

delay (ms)

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

Példa

// 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
}

Kapcsolódó témakörök

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.

Szintaktika

delayMicroseconds(us)

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

Példa

// 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      
}

Kapcsolódó témakörök

Matematikai funkciók

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

Szintaktika

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

Példa

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

Kapcsolódó témakörök

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

Szintaktika

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

Példa

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

Kapcsolódó témakörök

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

Szintaktika

abs (x)

x: szám

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

Példa

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

Kapcsolódó témakörök

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

Szintaktika

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

Példa

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

Kapcsolódó témakörök

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

map()

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

Szintaktika

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

Példa

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

Kapcsolódó témakörök

Exponenciális számítása.

Szintaktika

pow (alap, exponens)

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

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

Kapcsolódó témakörök

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

Szintaktika

sqrt (x)

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

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

Kapcsolódó témakörök

Trigonometriai funkciók

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

Szintaktika

sin (rad)

rad (float): a szög a radianban

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

Kapcsolódó témakörök

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

Szintaktika

cos (rad)

rad (float): a szög a radianban

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

Kapcsolódó témakörök

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

Szintaktika

tan (rad)

rad (float): a szög a radianban

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

Kapcsolódó témakörök

Karakter-funkciók

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

Szintaktika

isAlphaNumeric (ezAChar)

ezAChar (char): egy karakter

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

Kapcsolódó témakörök

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

Szintaktika

isAlpha (ezAChar)

ezAChar (char): egy karakter

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

Kapcsolódó témakörök

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

Szintaktika

isAscii (ezAChar)

ezAChar (char): egy karakter

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

Kapcsolódó témakörök

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

Szintaktika

isWhitespace (ezAChar)

ezAChar (char): egy karakter

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

Kapcsolódó témakörök

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

Szintaktika

isControl (ezAChar)

ezAChar (char): egy karakter

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

Kapcsolódó témakörök

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

Szintaktika

isDigit (ezAChar)

ezAChar (char): egy karakter

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

Kapcsolódó témakörök

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

Szintaktika

isGraph (ezAChar)

ezAChar (char): egy karakter

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

Kapcsolódó témakörök

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

Szintaktika

isLowerCase (ezAChar)

ezAChar (char): egy karakter

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

Kapcsolódó témakörök

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

Szintaktika

isPrintable (ezAChar)

ezAChar (char): egy karakter

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

Kapcsolódó témakörök

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

Szintaktika

isPunct (ezAChar)

ezAChar (char): egy karakter

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

Kapcsolódó témakörök

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

Szintaktika

isSpace (ezAChar)

ezAChar (char): egy karakter

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

Kapcsolódó témakörök

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

Szintaktika

isUpperCase (ezAChar)

ezAChar (char): egy karakter

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

Kapcsolódó témakörök

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

Szintaktika

isHexadecimalDigit (ezAChar)

ezAChar (char): egy karakter

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

Kapcsolódó témakörök

Véletlenszám funkciók

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.

Szintaktika

randomSeed (kezdőérték)

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

Példa

// 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
}

Kapcsolódó témakörök

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.

Szintaktika

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

Példa

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
}

Kapcsolódó témakörök

Bit és bájtfunkciók

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

Szintaktika

lowByte(x)

x: bármely változó

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

Példa

// 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
}

Kapcsolódó témakörök

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

Szintaktika

highByte(x)

x: bármely változó

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

Példa

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

Kapcsolódó témakörök

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

Szintaktika

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élda

// 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
}

Kapcsolódó témakörök

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

Szintaktika

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élda

// 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
}

Kapcsolódó témakörök

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.

Szintaktika

bitSet(x, n)

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

Kapcsolódó témakörök

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.

Szintaktika

bitClear(x, n)

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

Szintaktika

Példa

Kapcsolódó témakörök

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

Szintaktika

bit(n)

n: bitpozíció

Kapcsolódó témakörök

Külső megszakítások

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.

Szintaktika

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:

boardint: 0int: 1int: 2int: 3int: 4int: 5
Uno, Ethernetpin 2pin 3
Mega2560pin 2pin 3pin 21pin 20pin 19pin 18
32u4 alapú (pl. Leonardo, Micro)pin 3pin 2pin 0pin 1pin 7

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:

modeleírás
LOWa funkció meghívásra kerül, ha a pin állapota alacsony (LOW)
CHANGEa funkció meghívásra kerül, ha a pin állapota változik
RISINGa funkció meghívásra kerül a pin felfutóélére
FALLINGa funkció meghívásra kerül a pin lefutóélére
HIGHa funkció meghívásra kerül, ha a pin állapota magas (HIGH), csak az Arduino Due, Zero, MKR1000 board-okon működik

Az interruptot alkalmazó példaprogramok esetén ügyelni kell arra, hogy azonos board-on futtassuk ezeket, vagy először a fenti "interrupt paraméter táblázat"-nak megfelelően átírjuk a portot vagy az interrupt számát.

Példa

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

Kapcsolódó témakörök

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

Szintaktika

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

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

Kapcsolódó témakörök

Megszakítások

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.

Szintaktika

interrupts()
noInterrupts()

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

Példa

// 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
}

Kapcsolódó témakörök

Lásd fent: interrupts().

Kapcsolódó témakörök

Kommunikációs funkciók

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

Kapcsolódó témakörök

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

Kapcsolódó témakörök