====== Arduino funkciók ======
Forrás: https://www.arduino.cc/en/Reference/HomePage
====== Digital I/O funkciók ======
===== pinMode() =====
{{anchor: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: [[hu:arduino:switch#pullup_intern|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//: [[hu:arduino:variables#input|INPUT]] (bemenet), [[hu:arduino:variables#output|OUTPUT]] (kimenet), [[hu:arduino:variables#input_pullup|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 ===
* [[hu:arduino:switch#pullup_intern|Arduino belső felhúzóellenállás]]
* [[#digitalwrite|digitalWrite]]
* [[#digitalread|digitalRead]]
* [[#analogwrite|analogWrite() / PWM]]
===== digitalWrite() =====
{{anchor: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|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: [[hu:arduino:switch#pullup_intern|Arduino belső felhúzóellenállás]].
Amennyiben //digitalWrite()// meghívása előtt nem definiálta a portot kimenetre ([[#pinmode|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 [[hu:arduino:relay_modul|relék]]kel 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 ===
* [[hu:arduino:switch#pullup_intern|Arduino belső felhúzóellenállás]]
* [[#pinmode|pinMode]]
* [[#digitalread|digitalRead]]
===== digitalRead() =====
{{anchor: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|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: [[hu:arduino:switch#pullup_intern|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 [[hu:arduino:switch#pullup_intern|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 ===
* [[hu:arduino:switch#pullup_intern|Arduino belső felhúzóellenállás]]
* [[#pinmode|pinMode]]
* [[#digitalwrite|digitalWrite]]
* [[#analogwrite|analogWrite() / PWM]]
====== Analóg I/O funkciók ======
==== analogReference() ====
{{anchor: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|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|analogRead()]]
* [[#analogwrite|analogWrite() / PWM]]
* [[hu:arduino:start#aref|AREF pin]]
===== analogRead() =====
{{anchor: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|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 ===
* [[#analogreference|analogReference()]]
* [[#analogwrite|analogWrite() / PWM]]
===== analogWrite() / PWM =====
{{anchor:analogwrite}}
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 [[hu:comm:start#pwm|PWM]]-mel (pulse-width modulation) tud analóg kimenetet képezni, így működése közelebb áll a digitalWrite() funkcióhoz. Az [[hu:arduino:start#arduino_pwm|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: \\
{{:wiki:comm:pwm_arduino.png?300|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 ===
* [[#analogreference|analogReference()]]
* [[#analogread|analogRead()]]
====== Bővített I/O funkciók ======
===== tone() =====
{{anchor: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|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.
{{:wiki:arduino:tone_fc.png|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 ===
* [[#notone|noTone()]]
* [[#shiftout|shiftOut()]]
* [[#shiftin|shiftIn()]]
* [[#pulsein|pulseIn()]]
===== noTone() =====
{{anchor:notone}}
A noTone() funkció egyszerűen a [[#tone|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 ===
* [[#tone|tone()]]
* [[#shiftout|shiftOut()]]
* [[#shiftin|shiftIn()]]
* [[#pulsein|pulseIn()]]
===== shiftOut() =====
{{anchor: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 [[hu:arduino:io_expand#sn74hc165n|így]].
Az írásra alkalmas shiftOut() funkciónak az olvasásra alkalmazható párja a [[#shiftin|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 ===
* [[#tone|tone()]]
* [[#notone|noTone()]]
* [[#shiftin|shiftIn()]]
* [[#pulsein|pulseIn()]]
===== shiftIn() =====
A funkció a [[#shiftout|shiftOut()]] párja, ugyanazon az elven egy byte információ olvasására alkalmas.
{{anchor:shiftin}}
=== 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 ===
* [[#tone|tone()]]
* [[#notone|noTone()]]
* [[#shiftout|shiftOut()]]
* [[#pulsein|pulseIn()]]
===== pulseIn() =====
{{anchor: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 ===
* [[#tone|tone()]]
* [[#notone|noTone()]]
* [[#shiftout|shiftOut()]]
* [[#shiftin|shiftIn()]]
====== Időfunkciók ======
===== millis() =====
{{anchor: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|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|micros()]]
* [[#delay|delay()]]
* [[#delaymicroseconds|delayMicroseconds()]]
===== micros() =====
{{anchor: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|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 ===
* [[#millis|millis()]]
* [[#delay|delay()]]
* [[#delaymicroseconds|delayMicroseconds()]]
===== delay() =====
{{anchor: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|delayMicroseconds()]], ahol a késleltetést µs-ban kell megadni.
Az időzítési funkciókat érdemes a [[#millis|millis()]] vagy [[#micros|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 ===
* [[#millis|millis()]]
* [[#micros|micros()]]
* [[#delaymicroseconds|delayMicroseconds()]]
===== delayMicroseconds() =====
{{anchor:delaymicroseconds}}
A funkció felfüggeszti a program futását a megadott ideig. A delayMicroseconds() funkcióval technikailag megegyezik a [[#delay|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 ===
* [[#millis|millis()]]
* [[#micros|micros()]]
* [[#delay|delay()]]
====== Matematikai funkciók ======
===== min() =====
{{anchor:min}}
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 ===
* [[#max|max()]]
* [[#abs|abs()]]
* [[#constrain|constrain()]]
* [[#map|map()]]
* [[#pow|pow()]]
* [[#sqrt|sqrt()]]
===== max() =====
{{anchor:max}}
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 ===
* [[#min|min()]]
* [[#abs|abs()]]
* [[#constrain|constrain()]]
* [[#map|map()]]
* [[#pow|pow()]]
* [[#sqrt|sqrt()]]
===== abs() =====
{{anchor:abs}}
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 ===
* [[#min|min()]]
* [[#max|max()]]
* [[#constrain|constrain()]]
* [[#map|map()]]
* [[#pow|pow()]]
* [[#sqrt|sqrt()]]
===== constrain() =====
{{anchor:constrain}}
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 ===
* [[#min|min()]]
* [[#max|max()]]
* [[#abs|abs()]]
* [[#map|map()]]
* [[#pow|pow()]]
* [[#sqrt|sqrt()]]
===== map() =====
{{anchor:map}}
A bemenő értéket egy bemeneti tartományból átskálázza a kimeneti tartományba.
{{:wiki:arduino:skalazas.png|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 ===
* [[#min|min()]]
* [[#max|max()]]
* [[#abs|abs()]]
* [[#constrain|constrain()]]
* [[#pow|pow()]]
* [[#sqrt|sqrt()]]
===== pow() =====
{{anchor:pow}}
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 ===
* [[#min|min()]]
* [[#max|max()]]
* [[#abs|abs()]]
* [[#constrain|constrain()]]
* [[#map|map()]]
* [[#sqrt|sqrt()]]
===== sqrt() =====
{{anchor:sqrt}}
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 ===
* [[#min|min()]]
* [[#max|max()]]
* [[#abs|abs()]]
* [[#constrain|constrain()]]
* [[#map|map()]]
* [[#pow|pow()]]
====== Trigonometriai funkciók ======
===== sin() =====
{{anchor:sin}}
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 ===
* [[#cos|cos()]]
* [[#tan|tan()]]
===== cos() =====
{{anchor:cos}}
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 ===
* [[#sin|sin()]]
* [[#tan|tan()]]
===== tan() =====
{{anchor:tan}}
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 ===
* [[#sin|sin()]]
* [[#cos|cos()]]
====== Karakter-funkciók ======
===== isAlphaNumeric() =====
{{anchor:isalphanumeric}}
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 ===
* [[#isalpha|isAlpha()]]
* [[#isascii|isAscii()]]
* [[#iswhitespace|isWhitespace()]]
* [[#iscontrol|isControl()]]
* [[#isdigit|isDigit()]]
* [[#isgraph|isGraph()]]
* [[#islowercase|isLowerCase()]]
* [[#isprintable|isPrintable()]]
* [[#ispunct|isPunct()]]
* [[#isspace|isSpace()]]
* [[#isuppercase|isUpperCase()]]
* [[#ishexadecimaldigit|isHexadecimalDigit()]]
===== isAlpha() =====
{{anchor:isalpha}}
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 ===
* [[#isalphanumeric|isAlphaNumeric()]]
* [[#isascii|isAscii()]]
* [[#iswhitespace|isWhitespace()]]
* [[#iscontrol|isControl()]]
* [[#isdigit|isDigit()]]
* [[#isgraph|isGraph()]]
* [[#islowercase|isLowerCase()]]
* [[#isprintable|isPrintable()]]
* [[#ispunct|isPunct()]]
* [[#isspace|isSpace()]]
* [[#isuppercase|isUpperCase()]]
* [[#ishexadecimaldigit|isHexadecimalDigit()]]
===== isAscii() =====
{{anchor:isascii}}
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 ===
* [[#isalphanumeric|isAlphaNumeric()]]
* [[#isalpha|isAlpha()]]
* [[#iswhitespace|isWhitespace()]]
* [[#iscontrol|isControl()]]
* [[#isdigit|isDigit()]]
* [[#isgraph|isGraph()]]
* [[#islowercase|isLowerCase()]]
* [[#isprintable|isPrintable()]]
* [[#ispunct|isPunct()]]
* [[#isspace|isSpace()]]
* [[#isuppercase|isUpperCase()]]
* [[#ishexadecimaldigit|isHexadecimalDigit()]]
===== isWhitespace() =====
{{anchor:iswhitespace}}
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 ===
* [[#isalphanumeric|isAlphaNumeric()]]
* [[#isalpha|isAlpha()]]
* [[#isascii|isAscii()]]
* [[#iscontrol|isControl()]]
* [[#isdigit|isDigit()]]
* [[#isgraph|isGraph()]]
* [[#islowercase|isLowerCase()]]
* [[#isprintable|isPrintable()]]
* [[#ispunct|isPunct()]]
* [[#isspace|isSpace()]]
* [[#isuppercase|isUpperCase()]]
* [[#ishexadecimaldigit|isHexadecimalDigit()]]
===== isControl() =====
{{anchor:iscontrol}}
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 ===
* [[#isalphanumeric|isAlphaNumeric()]]
* [[#isalpha|isAlpha()]]
* [[#isascii|isAscii()]]
* [[#iswhitespace|isWhitespace()]]
* [[#isdigit|isDigit()]]
* [[#isgraph|isGraph()]]
* [[#islowercase|isLowerCase()]]
* [[#isprintable|isPrintable()]]
* [[#ispunct|isPunct()]]
* [[#isspace|isSpace()]]
* [[#isuppercase|isUpperCase()]]
* [[#ishexadecimaldigit|isHexadecimalDigit()]]
===== isDigit() =====
{{anchor:isdigit}}
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 ===
* [[#isalphanumeric|isAlphaNumeric()]]
* [[#isalpha|isAlpha()]]
* [[#isascii|isAscii()]]
* [[#iswhitespace|isWhitespace()]]
* [[#iscontrol|isControl()]]
* [[#isgraph|isGraph()]]
* [[#islowercase|isLowerCase()]]
* [[#isprintable|isPrintable()]]
* [[#ispunct|isPunct()]]
* [[#isspace|isSpace()]]
* [[#isuppercase|isUpperCase()]]
* [[#ishexadecimaldigit|isHexadecimalDigit()]]
===== isGraph() =====
{{anchor:isgraph}}
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 ===
* [[#isalphanumeric|isAlphaNumeric()]]
* [[#isalpha|isAlpha()]]
* [[#isascii|isAscii()]]
* [[#iswhitespace|isWhitespace()]]
* [[#iscontrol|isControl()]]
* [[#isdigit|isDigit()]]
* [[#islowercase|isLowerCase()]]
* [[#isprintable|isPrintable()]]
* [[#ispunct|isPunct()]]
* [[#isspace|isSpace()]]
* [[#isuppercase|isUpperCase()]]
* [[#ishexadecimaldigit|isHexadecimalDigit()]]
===== isLowerCase() =====
{{anchor:islowercase}}
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 ===
* [[#isalphanumeric|isAlphaNumeric()]]
* [[#isalpha|isAlpha()]]
* [[#isascii|isAscii()]]
* [[#iswhitespace|isWhitespace()]]
* [[#iscontrol|isControl()]]
* [[#isdigit|isDigit()]]
* [[#isgraph|isGraph()]]
* [[#isprintable|isPrintable()]]
* [[#ispunct|isPunct()]]
* [[#isspace|isSpace()]]
* [[#isuppercase|isUpperCase()]]
* [[#ishexadecimaldigit|isHexadecimalDigit()]]
===== isPrintable() =====
{{anchor:isprintable}}
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 ===
* [[#isalphanumeric|isAlphaNumeric()]]
* [[#isalpha|isAlpha()]]
* [[#isascii|isAscii()]]
* [[#iswhitespace|isWhitespace()]]
* [[#iscontrol|isControl()]]
* [[#isdigit|isDigit()]]
* [[#isgraph|isGraph()]]
* [[#islowercase|isLowerCase()]]
* [[#ispunct|isPunct()]]
* [[#isspace|isSpace()]]
* [[#isuppercase|isUpperCase()]]
* [[#ishexadecimaldigit|isHexadecimalDigit()]]
===== isPunct() =====
{{anchor:ispunct}}
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 ===
* [[#isalphanumeric|isAlphaNumeric()]]
* [[#isalpha|isAlpha()]]
* [[#isascii|isAscii()]]
* [[#iswhitespace|isWhitespace()]]
* [[#iscontrol|isControl()]]
* [[#isdigit|isDigit()]]
* [[#isgraph|isGraph()]]
* [[#islowercase|isLowerCase()]]
* [[#isprintable|isPrintable()]]
* [[#isspace|isSpace()]]
* [[#isuppercase|isUpperCase()]]
* [[#ishexadecimaldigit|isHexadecimalDigit()]]
===== isSpace() =====
{{anchor:isspace}}
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 ===
* [[#isalphanumeric|isAlphaNumeric()]]
* [[#isalpha|isAlpha()]]
* [[#isascii|isAscii()]]
* [[#iswhitespace|isWhitespace()]]
* [[#iscontrol|isControl()]]
* [[#isdigit|isDigit()]]
* [[#isgraph|isGraph()]]
* [[#islowercase|isLowerCase()]]
* [[#isprintable|isPrintable()]]
* [[#ispunct|isPunct()]]
* [[#isuppercase|isUpperCase()]]
* [[#ishexadecimaldigit|isHexadecimalDigit()]]
===== isUpperCase() =====
{{anchor:isuppercase}}
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 ===
* [[#isalphanumeric|isAlphaNumeric()]]
* [[#isalpha|isAlpha()]]
* [[#isascii|isAscii()]]
* [[#iswhitespace|isWhitespace()]]
* [[#iscontrol|isControl()]]
* [[#isdigit|isDigit()]]
* [[#isgraph|isGraph()]]
* [[#islowercase|isLowerCase()]]
* [[#isprintable|isPrintable()]]
* [[#ispunct|isPunct()]]
* [[#isspace|isSpace()]]
* [[#ishexadecimaldigit|isHexadecimalDigit()]]
===== isHexadecimalDigit() =====
{{anchor:ishexadecimaldigit}}
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 ===
* [[#isalphanumeric|isAlphaNumeric()]]
* [[#isalpha|isAlpha()]]
* [[#isascii|isAscii()]]
* [[#iswhitespace|isWhitespace()]]
* [[#iscontrol|isControl()]]
* [[#isdigit|isDigit()]]
* [[#isgraph|isGraph()]]
* [[#islowercase|isLowerCase()]]
* [[#isprintable|isPrintable()]]
* [[#ispunct|isPunct()]]
* [[#isspace|isSpace()]]
* [[#isuppercase|isUpperCase()]]
====== Véletlenszám funkciók ======
===== randomSeed() =====
{{anchor:randomseed}}
A szokásos véletlenszám generátor ([[#random|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|random()]]
===== random() =====
{{anchor:random}}
A funkció véletlenszámot generál. A véletlenszám-képzés még spontánabbá tehető a [[#randomseed|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 ===
* [[#randomseed|randomSeed()]]
====== karakterlánc (char array) funkciók ======
===== strlen() =====
{{anchor:strlen}}
A funkció a [[hu:arduino:variables#char_array|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|strlen()]] - karakterlánc (char array) hossza
* [[#strcpy|strcpy()]] - karakterlánc (char array) másolása
* [[#memcpy|memcpy()]] - karakterlánc (char array) másolása a memóriában
* [[#strcat|strcat()]] - karakterlánc (char array) hozzáfűzés
* [[#strcmp|strcmp()]] - karakterláncok (char array) összehasnlítása
* [[#strchr|strchr()]] - egy karakter első előfordulása a karakterláncban (char array)
* [[#strstr|strstr()]] - egy karakterlánc első előfordulása a karakterláncban (char array)
===== strcpy() =====
{{anchor:strcpy}}
A funkció [[hu:arduino:variables#char_array|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|strlen()]] - karakterlánc (char array) hossza
* [[#strcpy|strcpy()]] - karakterlánc (char array) másolása
* [[#memcpy|memcpy()]] - karakterlánc (char array) másolása a memóriában
* [[#strcat|strcat()]] - karakterlánc (char array) hozzáfűzés
* [[#strcmp|strcmp()]] - karakterláncok (char array) összehasnlítása
* [[#strchr|strchr()]] - egy karakter első előfordulása a karakterláncban (char array)
* [[#strstr|strstr()]] - egy karakterlánc első előfordulása a karakterláncban (char array)
===== memcpy() =====
{{anchor:memcpy}}
[[hu:arduino:variables#char_array|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|strlen()]] - karakterlánc (char array) hossza
* [[#strcpy|strcpy()]] - karakterlánc (char array) másolása
* [[#memcpy|memcpy()]] - karakterlánc (char array) másolása a memóriában
* [[#strcat|strcat()]] - karakterlánc (char array) hozzáfűzés
* [[#strcmp|strcmp()]] - karakterláncok (char array) összehasnlítása
* [[#strchr|strchr()]] - egy karakter első előfordulása a karakterláncban (char array)
* [[#strstr|strstr()]] - egy karakterlánc első előfordulása a karakterláncban (char array)
===== strcat() =====
{{anchor:strcat}}
A funkció [[hu:arduino:variables#char_array|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|strlen()]] - karakterlánc (char array) hossza
* [[#strcpy|strcpy()]] - karakterlánc (char array) másolása
* [[#memcpy|memcpy()]] - karakterlánc (char array) másolása a memóriában
* [[#strcat|strcat()]] - karakterlánc (char array) hozzáfűzés
* [[#strcmp|strcmp()]] - karakterláncok (char array) összehasnlítása
* [[#strchr|strchr()]] - egy karakter első előfordulása a karakterláncban (char array)
* [[#strstr|strstr()]] - egy karakterlánc első előfordulása a karakterláncban (char array)
===== strcmp() =====
{{anchor:strcmp}}
A funkció [[hu:arduino:variables#char_array|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 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|strlen()]] - karakterlánc (char array) hossza
* [[#strcpy|strcpy()]] - karakterlánc (char array) másolása
* [[#memcpy|memcpy()]] - karakterlánc (char array) másolása a memóriában
* [[#strcat|strcat()]] - karakterlánc (char array) hozzáfűzés
* [[#strcmp|strcmp()]] - karakterláncok (char array) összehasnlítása
* [[#strchr|strchr()]] - egy karakter első előfordulása a karakterláncban (char array)
* [[#strstr|strstr()]] - egy karakterlánc első előfordulása a karakterláncban (char array)
===== strchr() =====
{{anchor:strchr}}
A funkció egy karakter első előfordulását vizsgálja a [[hu:arduino:variables#char_array|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|strlen()]] - karakterlánc (char array) hossza
* [[#strcpy|strcpy()]] - karakterlánc (char array) másolása
* [[#memcpy|memcpy()]] - karakterlánc (char array) másolása a memóriában
* [[#strcat|strcat()]] - karakterlánc (char array) hozzáfűzés
* [[#strcmp|strcmp()]] - karakterláncok (char array) összehasnlítása
* [[#strchr|strchr()]] - egy karakter első előfordulása a karakterláncban (char array)
* [[#strstr|strstr()]] - egy karakterlánc első előfordulása a karakterláncban (char array)
===== strstr() =====
{{anchor:strstr}}
A funkció egy karakterlánc első előfordulását vizsgálja a [[hu:arduino:variables#char_array|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|strlen()]] - karakterlánc (char array) hossza
* [[#strcpy|strcpy()]] - karakterlánc (char array) másolása
* [[#memcpy|memcpy()]] - karakterlánc (char array) másolása a memóriában
* [[#strcat|strcat()]] - karakterlánc (char array) hozzáfűzés
* [[#strcmp|strcmp()]] - karakterláncok (char array) összehasnlítása
* [[#strchr|strchr()]] - egy karakter első előfordulása a karakterláncban (char array)
* [[#strstr|strstr()]] - egy karakterlánc első előfordulása a karakterláncban (char array)
====== Bit- és byte-funkciók ======
===== lowByte() =====
{{anchor:lowbyte}}
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 ===
* [[#highbyte|highByte()]]
* [[#bitread|bitRead()]]
* [[#bitwrite|bitWrite()]]
* [[#bitset|bitSet()]]
* [[#bitclear|bitClear()]]
* [[#lowbyte|bit()]]
===== highByte() =====
{{anchor:highbyte}}
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|lowByte()]]-nál.
=== Kapcsolódó témakörök ===
* [[#lowbyte|lowByte()]]
* [[#bitread|bitRead()]]
* [[#bitwrite|bitWrite()]]
* [[#bitset|bitSet()]]
* [[#bitclear|bitClear()]]
* [[#lowbyte|bit()]]
===== bitRead() =====
{{anchor:bitread}}
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 ===
* [[#lowbyte|lowByte()]]
* [[#highbyte|highByte()]]
* [[#bitwrite|bitWrite()]]
* [[#bitset|bitSet()]]
* [[#bitclear|bitClear()]]
* [[#lowbyte|bit()]]
===== bitWrite() =====
{{anchor:bitwrite}}
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 ===
* [[#lowbyte|lowByte()]]
* [[#highbyte|highByte()]]
* [[#bitread|bitRead()]]
* [[#bitset|bitSet()]]
* [[#bitclear|bitClear()]]
* [[#lowbyte|bit()]]
===== bitSet() =====
{{anchor:bitset}}
Egy bitpozíció 1-gyel való felülírása egy változóban. Gyakorlatilag egyenértékű a [[#bitwrite|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 ===
* [[#lowbyte|lowByte()]]
* [[#highbyte|highByte()]]
* [[#bitread|bitRead()]]
* [[#bitwrite|bitWrite()]]
* [[#bitclear|bitClear()]]
* [[#lowbyte|bit()]]
===== bitClear() =====
{{anchor:bitclear}}
Egy bitpozíció 0-val való felülírása egy változóban. Gyakorlatilag egyenértékű a [[#bitwrite|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 ===
* [[#lowbyte|lowByte()]]
* [[#highbyte|highByte()]]
* [[#bitread|bitRead()]]
* [[#bitwrite|bitWrite()]]
* [[#bitset|bitSet()]]
* [[#lowbyte|bit()]]
===== bit() =====
{{anchor:bit}}
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 ===
* [[#lowbyte|lowByte()]]
* [[#highbyte|highByte()]]
* [[#bitread|bitRead()]]
* [[#bitwrite|bitWrite()]]
* [[#bitset|bitSet()]]
* [[#bitclear|bitClear()]]
====== Külső megszakítások ======
===== attachInterrupt() =====
{{anchor:attachinterrupt}}
A megszakításkezelés [[hu:comm:comdict#isr|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 [[hu:arduino:start#interrupt_port|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 ===
[[hu:arduino:flow#yfs201|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: [[hu:arduino:variables#volatile|volatile]]
=== Kapcsolódó témakörök ===
* [[#deattachinterrupt|detachInterrupt()]]
* [[#interrupts|interrupts()]]
* [[#nointerrupts|noInterrupts()]]
===== detachInterrupt() =====
{{anchor:deattachinterrupt}}
Az [[#attachinterrupt|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|attachInterrupt()]]-nál.
=== Kapcsolódó témakörök ===
* [[#attachinterrupt|attachInterrupt()]]
* [[#interrupts|interrupts()]]
* [[#nointerrupts|noInterrupts()]]
====== Megszakítások ======
===== interrupts() =====
A [[#nointerrupts|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.
{{anchor:interrupt}}
=== 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 ===
* [[#attachinterrupt|attachInterrupt()]]
* [[#deattachinterrupt|detachInterrupt()]]
* [[#nointerrupts|noInterrupts()]]
===== noInterrupts() =====
{{anchor:nointerrupt}}
Lásd fent: [[#interrupts|interrupts()]].
=== Kapcsolódó témakörök ===
* [[#attachinterrupt|attachInterrupt()]]
* [[#deattachinterrupt|detachInterrupt()]]
* [[#interrupts|interrupts()]]
====== Kommunikációs funkciók ======
===== Serial =====
Az [[hu:arduino:start#serial|Arduino soros kommunikáció]] ezzel a funkcióval deklarálható.
{{anchor:serial}}
A funkció kifejtése (majd) a "serial" könyvtárnál lesz megtalálható.
=== Kapcsolódó témakörök ===
* [[#stream|Stream]]
===== Stream =====
{{anchor:stream}}
A funkció kifejtése majd a steam könyvtárban lesz megtalálható.
=== Kapcsolódó témakörök ===
* [[#serial|Serial]]