Arduino funkciók
Digital I/O funkciók
pinMode()
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
digitalWrite()
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
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.
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)
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 |
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
analogRead()
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
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ó.
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
tone()
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.
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
noTone()
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
shiftOut()
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
shiftIn()
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
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ó.
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
millis()
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
micros()
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
delay()
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
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.
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
min()
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
max()
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
abs()
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
constrain()
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
map()
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; }
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
pow()
Szintaktika
pow (alap, exponens)
alap (float): alap
exponens (float): exp
A funkció visszatérési értéke: double.
Kapcsolódó témakörök
sqrt()
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
sin()
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
cos()
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
tan()
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
isAlphaNumeric()
Szintaktika
isAlphaNumeric (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
Kapcsolódó témakörök
isAlpha()
Szintaktika
isAlpha (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
Kapcsolódó témakörök
isAscii()
Szintaktika
isAscii (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
Kapcsolódó témakörök
isWhitespace()
Szintaktika
isWhitespace (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
Kapcsolódó témakörök
isControl()
Szintaktika
isControl (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
Kapcsolódó témakörök
isDigit()
Szintaktika
isDigit (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
Kapcsolódó témakörök
isGraph()
Szintaktika
isGraph (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
Kapcsolódó témakörök
isLowerCase()
Szintaktika
isLowerCase (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
Kapcsolódó témakörök
isPrintable()
Szintaktika
isPrintable (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
Kapcsolódó témakörök
isPunct()
Szintaktika
isPunct (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
Kapcsolódó témakörök
isSpace()
Szintaktika
isSpace (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
Kapcsolódó témakörök
isUpperCase()
Szintaktika
isUpperCase (ezAChar)
ezAChar (char): egy karakter
A funkció visszatérési értéke TRUE vagy FALSE.
Kapcsolódó témakörök
isHexadecimalDigit()
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
randomSeed()
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
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.
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
karakterlánc (char array) funkciók
strlen()
A funkció a karakterlánc (char array) aktuális hosszával tér vissza.
Szintaktika
size_t strlen(const char *str)
str: char array
size_t: a char array lánc aktuális hossza
Példa
// 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); }
Kapcsolódó témakörök
- strlen() - karakterlánc (char array) hossza
- strcpy() - karakterlánc (char array) másolása
- memcpy() - karakterlánc (char array) másolása a memóriában
- strcat() - karakterlánc (char array) hozzáfűzés
- strcmp() - karakterláncok (char array) összehasnlítása
- strchr() - egy karakter első előfordulása a karakterláncban (char array)
- strstr() - egy karakterlánc első előfordulása a karakterláncban (char array)
strcpy()
A funkció karakterlánc (char array) másolására alkalmazható.
Szintaktika
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élda
// 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); }
Kapcsolódó témakörök
- strlen() - karakterlánc (char array) hossza
- strcpy() - karakterlánc (char array) másolása
- memcpy() - karakterlánc (char array) másolása a memóriában
- strcat() - karakterlánc (char array) hozzáfűzés
- strcmp() - karakterláncok (char array) összehasnlítása
- strchr() - egy karakter első előfordulása a karakterláncban (char array)
- strstr() - egy karakterlánc első előfordulása a karakterláncban (char array)
memcpy()
Karakter-lánc másolása a memóriában.
Szintaktika
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.
Példa
// 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); }
Kapcsolódó témakörök
- strlen() - karakterlánc (char array) hossza
- strcpy() - karakterlánc (char array) másolása
- memcpy() - karakterlánc (char array) másolása a memóriában
- strcat() - karakterlánc (char array) hozzáfűzés
- strcmp() - karakterláncok (char array) összehasnlítása
- strchr() - egy karakter első előfordulása a karakterláncban (char array)
- strstr() - egy karakterlánc első előfordulása a karakterláncban (char array)
strcat()
A funkció karakterlánc (char array) hozzáfűzésére alkalmazható.
Szintaktika
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élda
// 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); }
Kapcsolódó témakörök
- strlen() - karakterlánc (char array) hossza
- strcpy() - karakterlánc (char array) másolása
- memcpy() - karakterlánc (char array) másolása a memóriában
- strcat() - karakterlánc (char array) hozzáfűzés
- strcmp() - karakterláncok (char array) összehasnlítása
- strchr() - egy karakter első előfordulása a karakterláncban (char array)
- strstr() - egy karakterlánc első előfordulása a karakterláncban (char array)
strcmp()
A funkció karakterláncok (char array) összehasonlítására alkalmazható.
Szintaktika
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:
- n = 0: a két karakterlánc egyezik
- n < 1: str1<str2 (n a rövidebbik lánc hossza)
- n > 1: str1>str2 (n a rövidebbik lánc hossza)
Példa
// 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); }
Kapcsolódó témakörök
- strlen() - karakterlánc (char array) hossza
- strcpy() - karakterlánc (char array) másolása
- memcpy() - karakterlánc (char array) másolása a memóriában
- strcat() - karakterlánc (char array) hozzáfűzés
- strcmp() - karakterláncok (char array) összehasnlítása
- strchr() - egy karakter első előfordulása a karakterláncban (char array)
- strstr() - egy karakterlánc első előfordulása a karakterláncban (char array)
strchr()
A funkció egy karakter első előfordulását vizsgálja a karakterláncban (char array).
Szintaktika
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élda
// 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); }
Kapcsolódó témakörök
- strlen() - karakterlánc (char array) hossza
- strcpy() - karakterlánc (char array) másolása
- memcpy() - karakterlánc (char array) másolása a memóriában
- strcat() - karakterlánc (char array) hozzáfűzés
- strcmp() - karakterláncok (char array) összehasnlítása
- strchr() - egy karakter első előfordulása a karakterláncban (char array)
- strstr() - egy karakterlánc első előfordulása a karakterláncban (char array)
strstr()
A funkció egy karakterlánc első előfordulását vizsgálja a karakterláncban (char array).
Szintaktika
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élda
// 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); }
Kapcsolódó témakörök
- strlen() - karakterlánc (char array) hossza
- strcpy() - karakterlánc (char array) másolása
- memcpy() - karakterlánc (char array) másolása a memóriában
- strcat() - karakterlánc (char array) hozzáfűzés
- strcmp() - karakterláncok (char array) összehasnlítása
- strchr() - egy karakter első előfordulása a karakterláncban (char array)
- strstr() - egy karakterlánc első előfordulása a karakterláncban (char array)
Bit- és byte-funkciók
lowByte()
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
highByte()
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
bitRead()
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
bitWrite()
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
bitSet()
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
bitClear()
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
bit()
Szintaktika
bit(n)
n: bitpozíció
Kapcsolódó témakörök
Külső megszakítások
attachInterrupt()
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:
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élda
// 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
detachInterrupt()
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
interrupts()
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
noInterrupts()
Lásd fent: interrupts().
Kapcsolódó témakörök
Kommunikációs funkciók
Serial
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ó.