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 }
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
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 }
A funkció az analóg bemenethez használt referenciafeszültséget (azaz a bemeneti tartomány maximális értékét) állítja be.
analogReference (type)
type | Leírás |
---|---|
DEFAULT | az 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) |
INTERNAL | beé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) |
INTERNAL1V1 | beépített 1.1V referencia (csak az Arduino Mega board-on működik) |
INTERNAL2V56 | beépített 2.56V referencia (csak az Arduino Mega board-on működik) |
EXTERNAL | az AREF pinre kötött feszültség (0V..5V), mely referenciaként szolgá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 analogReference(INTERNAL); analogRead(0);
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 }
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ó.
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 }
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); }
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.
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
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.
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 }
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 }
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 }
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 }
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 }
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(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
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
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:
// 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
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); }
pow (alap, exponens)
alap (float): alap
exponens (float): exp
A funkció visszatérési értéke: double.
sqrt (x)
x(bármely típus): bemeneti érték
A funkció visszatérési értéke x négyzetgyöke (double).
sin (rad)
rad (float): a szög a radianban
A funkció visszatérési értéke (double) a sin(rad) eredménye lesz.
cos (rad)
rad (float): a szög a radianban
A funkció visszatérési értéke (double) a cos(rad) eredménye lesz.
tan (rad)
rad (float): a szög a radianban
A funkció visszatérési értéke (double) a tan(rad) eredménye lesz.
isAlphaNumeric (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
isAlpha (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
isAscii (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
isWhitespace (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
isControl (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
isDigit (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
isGraph (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
isLowerCase (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
isPrintable (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
isPunct (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
isSpace (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
isUpperCase (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
isHexadecimalDigit (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
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 }
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 }
A funkció a karakterlánc (char array) aktuális hosszával tér vissza.
size_t strlen(const char *str)
str: char array
size_t: a char array lánc aktuális hossza
// példaprogram: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference char str[] = "A kiindulási karakterlánc"; // create a string char out_str[40]; // output from string functions placed here int num; // general purpose integer void setup() { Serial.begin(9600); } void loop() { Serial.println(str); // (get the length of the string (excludes null terminator) num = strlen(str); Serial.print("String length is: "); Serial.println(num); delay(10000); }
A funkció karakterlánc (char array) másolására alkalmazható.
char *strcpy(char *dest, const char *src)
out_str: a kimeneti (már másolt) karakterlánc
str: a másolandó karakterlánc
A funkcióhoz hasonló működésű az strncpy(), ebben az esetben csak n-számú karakter kerül másolásra, ennek szintaktikája:
char *strncpy(char *dest, const char *src, size_t n)
A funkcióval a karakterlánc értékadása jelentősen leegyszerüsíthető, például:
char book_title[4]; .. strcpy( book_title, "ABC");
// példaprogram: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference char str[] = "A kiindulási karakterlánc"; // create a string char out_str[40]; // output from string functions placed here int num; // general purpose integer void setup() { Serial.begin(9600); } void loop() { Serial.println(str); // copy a string strcpy(out_str, str); Serial.println(out_str); delay(10000); }
Karakter-lánc másolása a memóriában.
void *memcpy(void *str1, const void *str2, size_t n)
str1: a cél karakter-lánc első elemre mutató pointer
str2: a másolandó karakter-lánc első elemre mutató pointer
n: másolandó byte-ok száma
Az eljárásnak visszatérési értéke az str1 pointere.
// OB121.com példaprogram - Vámos Sándor (2019) // Tömb sorbarendezés alkalmazása az Arduino-n const char src[50] = "https://www.ob121.com"; char dest[50]; void setup() { Serial.begin(9600); } void loop() { strcpy(dest,"ezt_felülírja"); memcpy(dest, src, strlen(src)+1); Serial.println(dest); Serial.println(src); delay(10000); }
A funkció karakterlánc (char array) hozzáfűzésére alkalmazható.
char *strcat(char *dest, const char *src)
*dest: a kimeneti (összefűzött) karakterlánc
*src: a hozzáfűzésre kerülő karakterlánc
A funkcióval a karakterlánc értékadása jelentősen leegyszerüsíthető, például:
// példaprogram: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference char str[] = "A kiindulási karakterlánc"; // create a string char out_str[40]; // output from string functions placed here int num; // general purpose integer void setup() { Serial.begin(9600); } void loop() { Serial.println(str); // add a string to the end of a string (append) strcat(out_str, " vége."); Serial.println(out_str); delay(10000); }
A funkció karakterláncok (char array) összehasonlítására alkalmazható.
int strcmp(const char *str1, const char *str2)
str1: az első karakterlánc
str2: a második karakterlánc
A funkció visszatérési értékei:
// példaprogram: OB121, http://www.ob121.com/doku.php?id=hu:arduino:reference char str1[] = "Az egyik karakterlánc"; // create a string char str2[] = "Meg a másik"; // create another string int num; // general purpose integer void setup() { Serial.begin(9600); } void loop() { Serial.println(str1); Serial.println(str2); num = strcmp(str1, str2); Serial.println(num); delay(10000); }
A funkció egy karakter első előfordulását vizsgálja a karakterláncban (char array).
char *strchr(const char *str, int c)
ch1: a keresett karakter
str2: a vizsgált karakterlánc
A funkció visszatérési értéke egy char pointer, ami a karakter első előfordulására mutat.
// példaprogram: OB121, https://www.ob121.com/doku.php?id=hu:arduino:reference const char str[] = "https://www.ob121.com"; const char ch = '.'; char *ret; void setup() { } void loop() { ret = strchr(str, ch); delay(10000); }
A funkció egy karakterlánc első előfordulását vizsgálja a karakterláncban (char array).
char *strstr(const char *haystack, const char *needle)
needle: a keresett karakterlánc
haystack: a vizsgált karakterlánc
A funkció visszatérési értéke egy char pointer, ami a karakter első előfordulására mutat.
// példaprogram: OB121, https://www.ob121.com/doku.php?id=hu:arduino:reference const char haystack[] = "https://www.ob121.com"; const char needle[] = 'ob121'; char *ret; void setup() { } void loop() { ret = strstr(haystack, needle); delay(10000); }
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(x)
x: bármely változó
A funkció visszatérési értéke (byte) az felső byte tartalma.
Lásd a lowByte()-ná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 }
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 }
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ó
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ó
bit(n)
n: bitpozíció
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:
board | int: 0 | int: 1 | int: 2 | int: 3 | int: 4 | int: 5 |
---|---|---|---|---|---|---|
Uno, Ethernet | pin 2 | pin 3 | ||||
Mega2560 | pin 2 | pin 3 | pin 21 | pin 20 | pin 19 | pin 18 |
32u4 alapú (pl. Leonardo, Micro) | pin 3 | pin 2 | pin 0 | pin 1 | pin 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:
mode | leírás |
---|---|
LOW | a funkció meghívásra kerül, ha a pin állapota alacsony (LOW) |
CHANGE | a funkció meghívásra kerül, ha a pin állapota változik |
RISING | a funkció meghívásra kerül a pin felfutóélére |
FALLING | a funkció meghívásra kerül a pin lefutóélére |
HIGH | a 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é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
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.
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 }
Lásd fent: 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ó.