====== Arduino változók ====== Forrás: https://www.arduino.cc/en/Reference/HomePage A fontosabb változók áttekintése: {{:wiki:kids:dic_vars.png|A fontosabb Arduino változók áttekintése}} ====== Változók típusai és érvényességük ====== ===== Változók kiterjedése ===== {{anchor:var_scope}} Az Arduino-ban a változók hatálya - csakúgy, mint a C-ben - függ attól, hogy hol defeiniáljuk ezeket. A void() hívása előtt definálhatók a globális változók, melyek a program egész területén elérhetők, viszont ezáltal a teljes futásidő alatt foglalják a memóriájukat. Az adott funkciókon belül definiált változók érvényessége csak a funkción belülre terjed, a funkcióból való visszatérés után ezeknek a területe a memóriában felszabadul a következő hívásig. A szabály alól kivételt képeznek a statikus változók, lásd: [[#static|Static]]. Az adott eljáráson, például "for" cikluson belül definiál változók csak az eljáráson belül érvényesek. === Példa === int gPWMval; // globális változó, az egész programban elérhető void setup() { // ... } void loop() { int i; // az "i" változó csak a loop()-on belül használható, float f; // csakúgy, mint az "f" // ... for (int j = 0; j <100; j++){ // a "j" változó csak ezen a cikluson belül használható } } ===== volatile ===== {{anchor:volatile}} A "volatile" egy, a fordítónak szóló jelzés, melyet a változó előtt kell használni, hogy megváltoztassa annak a lefordítási módját. Konkrétan ezzel a jelzővel utasítjuk a fordítót, hogy ne egy tárolóregiszterbe töltse az adott változót (mint a többit), hanem a RAM-ba, egy rögzített helyre. Ez például interrupt hívásoknál lehet fontos (lásd: [[hu:arduino:reference#attachinterrupt|attachinterrupt()]]). Amennyiben a interrupt hívása egybeesik a tárolóregiszter aktualizálásával, a megszakításhoz alkalmazott változó elveszítheti az értékét. ===== static ===== {{anchor:static}} A statikus változókat a funkciókon belül lehet használni. A szabály szerint a funkciókon belüli változók érvényessége csak az adott funkcióra terjed ki, minden újrahívás esetén ezek is újra inicializálásra kerülnek. A statikus változóknak is csak az adott funkcióra terjed ki a hatályuk, de nem kerülnek minden híváskor újra inicializálásra, az értéküket a meghívások között is megtartják. ===== const ===== {{anchor:const}} A "const" kulcsszóval definiálhatjuk a konstansokat, lásd: Konstansok ====== Konstansok ====== A konstansok előre definiált kifejezések, melyek megkönnyítik a programozást és átláthatóbbá teszik a forráskódot. ===== HIGH | LOW ===== {{anchor:high}} {{anchor:low}} Míg a program-logikai szinteket a true (igaz, 1) és false (hamis, 0) konstansokkal, addig a pin-ek állapotát a HIGH (magas, 1) illetve a LOW (alacsony, 0) konstansokkal lehet jellemezni. A HIGH / LOW állapotok (TTL) kiértékeléséről itt olvashat: [[hu:arduino:start#arduino_ttl|Arduino TTL logikai szintek]]. A HIGH állapot egy jel olvasása esetén az 5V-os bemeneteken 3V jelszint felett, míg a 3,3V bemeneteken 2,0V felett jelentkezik. A LOW állapotok 5-os board-oknál 1,5V alatt, 3,3V-os boardoknál kb. 1,0V alatt jelentkeznek. A köztes feszültségszinteket (5V-os boardoknál 1,5V - 3,0V, 3,3V-os board-oknál 1,0V - 2,0V) érdemes kerülni, mert a bemeneti állapot bizonytalanná válik. Amennyiben a bemeneti felhúzóellenállás előzőleg aktiválásra került az adott pin-en, akkor onnan jó eséllyel soha nem fogunk HIGH állapotot olvasni, lásd: [[hu:arduino:reference#digitalread|digitalRead()]]. Kimenetek esetén a HIGH állapot kiadását követően a pin a maximális feszültségszintet veszi fel, azaz 3,3V-os board-oknál a 3,3V-ot, az 5V-osoknál az 5V-ot. Amennyiben előzően a belső felhúzóellenállást aktiváltuk, a kimeneti feszültség is HIGH jel esetén az 5V helyett kevesebb (kb. 3,3V) lesz, lásd: [[hu:arduino:reference#digitalwrite|digitalWrite()]] ===== INPUT | OUTPUT | INPUT_PULLUP ===== {{anchor:input}} {{anchor:input_pullup}} {{anchor:output}} A [[hu:arduino:reference#pinmode|pinMode()]] funkció paraméterei: * INPUT: az adott pin bemenetként kerül alkalmazásra * INPUT_PULLUP: az adott pin bemenet; belső felhúzóellenálláson keresztül * OUTPUT: az adott pin kimenetként kerül alkalmazásra ===== LED_BUILTIN ===== {{anchor:led_builtin}} A pin, melyre az adott board-on LED van csatlakoztatva. Az UNO esetén ez a 13. pin. ===== true | false ===== {{anchor:true}} {{anchor:false}} A **false** a nulla (0) logikai kifejezését szolgálja. \\ A **true** bármely érték megfelelője lehet, mely nem nulla (-10, 2, 3.1415, ..) ===== integer konstansok ===== {{anchor:integer_konstans}} Az integer konstansok egész számok előre (nem változtathatü módon) történő definiálására szolgálnak. A definiális több számrendszerben is elvégezhető: ^számrendszer/típus^példa^formázása^megjegyzés| |10 (decimális)|123|nincs|| |2 (bináris)|B11110011|első karaktere: **"B"**|Csak 8 bites értékek esetén működik (0..255). \\ Csak 0 és 1 karaktereket tartalmazhat.| |8 (oktális)|0173|első karaktere: **"0"**|Csak 0..7 karaktereket tartalmazhat.| |16 (hexadecimális)|0x7B|első karakterei: **"0x"**|Csak 0..9, A-F, a-f karaktereket tartalmazhat.| |unsigned int|30u|a decimális szám után: **"u"**|-| |long|30l|a decimális szám után: **"l"**|-| |unsigned long|30ul|a decimális szám után: **"ul"**|-| A fentieknek megfelelően a konstans-magadásnál figyelni kell arra, hogy a definiált értéket bevezető nullák nélkül adjuk meg, hacsak nem akarjuk a számot oktális értéknek megadni. ===== karakter konstansok ===== {{anchor:character_constants}} ^Ábrázolás^Leírás^Megjelenése| |\0|null terminal|byte 0x00 (in ASCII encoding)| |\'|single quote|byte 0x27 (in ASCII encoding)| |\%%"%%|double quote|byte 0x22 (in ASCII encoding)| |\?|question mark|byte 0x3f (in ASCII encoding)| |%%\\%%|backslash|byte 0x5c (in ASCII encoding)| |\a|audible bell|byte 0x07 (in ASCII encoding)| |\b|backspace|byte 0x08 (in ASCII encoding)| |\f|form feed - new page|byte 0x0c (in ASCII encoding)| |\n|line feed - new line|byte 0x0a (in ASCII encoding)| |\r|carriage return|byte 0x0d (in ASCII encoding)| |\t|horizontal tab|byte 0x09 (in ASCII encoding)| |\v|vertical tab|byte 0x0b (in ASCII encoding)| |\nnn|arbitrary octal value|byte nnn| |\xnn|arbitrary hexadecimal value|byte nn| |\unnnn|Unicode character that is not in the basic character set|code point U+nnnn| |\Unnnnnnnn|Unicode character that is not in the basic character set.|code point U+nnnnnnnn| ^Konstans mérete^Típusa^Prefixe^Példák^UTF megfeleltetés| ^1 byte karakter konstansok|char|x, kódban nincs|'a', '\n', '\13'|UTF-8 (\xF0\x9F\x8D\x8C)| ^2 byte karakter konstansok|char16_t|u|u'貓', u'á'|UTF-16 (\uD83C\uDF4C)| ^4 byte karakter konstansok|char32_t|U|U'貓', U'🍌' ('U0001f34c')|UTF-32 (\U0001f34c)| ^"wide" karakter konstansok|wchar_t|L|L'β', L'貓'|| Példák: // OB121.com példaprogram - Vámos Sándor (2019) // karakter konstansok alkalmazása az Arduino-ban // integer character constants, int c1='a'; int c2='🍌'; // multicharacter constant int c3='ab'; // 16-bit wide character constants char16_t uc1 = u'a'; char16_t uc2 = u'á'; char16_t uc3 = u'¢'; char16_t uc4 = u'猫'; // 32-bit wide character constants char32_t Uc1 = U'a'; char32_t uc2 = U'á'; char32_t Uc3 = U'¢'; char32_t Uc4 = U'猫'; char32_t Uc5 = U'🍌'; // wide character constants wchar_t wc1 = L'a'; wchar_t uc2 = L'á'; wchar_t wc3 = L'¢'; wchar_t wc4 = L'猫'; wchar_t wc5 = L'🍌'; ==== U és L formázó-karakterek ==== {{anchor:u_l}} ^formázó-karakter^példa^leírás| |'u' vagy 'U'|11U|Az adott konstanst előjel nélküli (unsigned) típusnak deklarálja (force-olja)| |'l' vagy 'L'|22L|Az adott konstanst "long" típusnak deklarálja (force-olja)| |'ul' vagy 'UL'|33UL|Az adott konstanst előjel nélküli (unsigned) "long" típusnak deklarálja (force-olja)| ===== lebegőpontos konstansok ===== {{anchor:high}} {{anchor:low}} ^lebegőpontos konstans^matematikai kifejtése^valós érték kifejtése| |10.0|10|10| |2.34E5|2.34 * 10 %%^%% 5|234000| |67e-12|67.0 * 10 %%^%% -12|.000000000067| ===== C típuskonstansok ===== A Arduino - mivel C bázisú - természetesen elérhetővé teszi a C változótípusait ([[#intnt|intn_t]], [[#uintnt|uintn_t]],..) csakúgy, mint az ezekhez rendelt konstansokat is. Ezek közül néhány fontosabb: * **INTn_MIN**: Az INT-ek minimum értéke (pl. INT16_MIN) * **INTn_MAX**: Az INT-ek maximum értéke (pl. INT16_MAX) * **UINTn_MAX**: Az előjel nélküli INT-ek maximum értéke (pl. UINT16_MAX) // OB121.com példaprogram - Vámos Sándor (2019) // C típuskonstansok alkalmazása az Arduino-ban Serial.print("INT8_MIN"); Serial.println(INT8_MIN); Serial.print("INT16_MIN"); Serial.println(INT16_MIN); Serial.print("INT32_MIN"); Serial.println(INT32_MIN); Serial.print("INT8_MAX"); Serial.println(INT8_MAX); Serial.print("INT16_MAX"); Serial.println(INT16_MAX); Serial.print("INT32_MAX"); Serial.println(INT32_MAX); ====== Adattípusok ====== ===== void ===== {{anchor:void}} A void kulcsszó olyan funkciók deklarációjához használható, melyek meghívásuk esetén nem adnak visszatérési értéket. // a "setup" és "loop" funkciók az Arduino alap-programszerkezetéhez tartoznak // visszatérési értékük nincs void setup () { // ... } void loop () { // ... } ===== boolean ===== {{anchor:boolean}} A boolean típus a true vagy false értéket veheti fel. Minden boolean változó egy bájt memóriát foglal. ===== char ===== {{anchor:char}} A típus egy bájton egy karakter tárolására alkalmas, pl: "A". A változó értéktartománya -128 .. 127-ig terjed. A C __alap-megfeleltetése szerint__ a típus az **int8_t**-nek vagy **c-char**-nak felel meg, lásd: [[hu:arduino:variables#intn_t|strint.h]] type. A karakterlánc ismertetése itt található: [[hu:arduino:variables#char_array|char_array]]. Speciális karakter a **'\0'** (null terminal), amivel a karakter-láncokat kell lezárni. char myChar = 'A'; char myChar = 65; // a két definíció egyenértékű A típus lehetséges konvertálási lehetőségei itt találhatók: [[hu:arduino:var_conv|Arduino típuskonvertálások]] ===== unsigned char ===== {{anchor:unsigned_char}} A típus egy bájton egy karakter tárolására alkalmas, pl: "A". A típus megegyezik a "char"-ral, de a változó értéktartománya itt 0 .. 255-ig terjed. A C __alap-megfeleltetése szerint__ a típus az **uint8_t**-nek felel meg, lásd: [[hu:arduino:variables#intn_t|strint.h]] type. unsigned char myChar = 240; A típus lehetséges konvertálási lehetőségei itt találhatók: [[hu:arduino:var_conv|Arduino típuskonvertálások]] ===== charn_t ===== A C-ben alapvetően négy "char" típus található, ezek mindegyike használható az Arduino-nál (lásd: [[hu:arduino:variables#karakter_konstansok|karakter konstansok]]): * char (c_char): 8 bit * char16_t : 16 bit * char32_t : 32 bit * wchar_t : 64 bit ===== byte ===== {{anchor:byte}} A byte típus egy nyolc bit terjedelmű előjel nélküli típus. Értéktartománya 0 .. 255-ig terjed. A típus lehetséges konvertálási lehetőségei itt találhatók: [[hu:arduino:var_conv|Arduino típuskonvertálások]] ===== int ===== {{anchor:integer}} A típus előjeles, két bájt terjedelmű változókat tárolhat. Értéktartománya: -32.768 .. 32.767 (//- 2 %%^%% 15 .. 2 %%^%% 15 - 1//). A számértékek tárolását az un. [[hu:comm:comdict#kettes_komplementer|kettes komplementer]] képzéssel valósítja meg. Az INT típus 4 bájt hosszú változata a [[#long|LONG]]. A típus általában megegyezik a [[#short|SHORT]]-tal. A C __alap-megfeleltetése szerint__ a típus az **int16_t**-nek felel meg, lásd: [[hu:arduino:variables#intn_t|strint.h]] type. Több board-on és plattformon az "int" típus nem 2, hanem 4 bájtos, azaz a [[#dint|DINT]] típusnak felel meg! Ilyen board-ok: Arduino Due, SAMD alapú board-ok (például MKR1000 és Zero). Néhány példa az INT típus számérték-tárolására: ^ Szám\\ (decimális formában) ^ INT\\ (bináris formában) | | 100 | 2#0000_0000_0110_0100 | | 10 | 2#0000_0000_0000_1010 | | 2 | 2#0000_0000_0000_0010 | | 1 | 2#0000_0000_0000_0001 | | 0 | 2#0000_0000_0000_0000 | | -1 | 2#1111_1111_1111_1111 | | -2 | 2#1111_1111_1111_1110 | | -10 | 2#1111_1111_1111_0110 | | -100 | 2#1111_1111_1001_1100 | A típus lehetséges konvertálási lehetőségei itt találhatók: [[hu:arduino:var_conv|Arduino típuskonvertálások]] ===== short ===== {{anchor:short}} Képzése megegyezik az [[#int|INT]]-ével: a típus előjeles, két bájt terjedelmű változókat tárolhat. Értéktartománya: -32.768 .. 32.767 (//- 2 %%^%% 15 .. 2 %%^%% 15 - 1//). Előnye azt [[#int|INT]]-tel szemben, hogy a terjedelme minden plattformon azonos. A C __alap-megfeleltetése szerint__ a típus az **int16_t**-nek felel meg, lásd: [[hu:arduino:variables#intn_t|strint.h]] type. A típus lehetséges konvertálási lehetőségei itt találhatók: [[hu:arduino:var_conv|Arduino típuskonvertálások]] ===== intN_t ===== {{anchor:intnt}} {{anchor:int_16t}} Az Arduino, mivel a fordítója C bázisú, az //"alap"// C változótípusokat is ismeri és kezeli. Ilyen típus **intN_t** is. Ennek a használatával (ha szükséges), elkerülhető, hogy a különböző board-ok az INT-et más-más bithosszal értelmezzék, ez a típus ugyanis rögzíti az alkalmazott bithosszt: * **int8_t** : 8 bit * **int16_t** : 16 bit, az Uno-n ez felel meg az [[#int|INT]] típusnak * **int32_t** : 32 bit, az Uno-n ez felel meg az [[#dint|DINT]] típusnak, az Arduino Due, SAMD boardokon ez felel meg az [[#int|INT]] típusnak * **int64_t** : 64 bit ^Arduino típus^C típus^stdint.h típus^Bits^Előjel^Tartomány| |[[hu:arduino:variables#unsigned_char|unsigned char]]|char|uint8_t|8|Unsigned|0 .. 255| |[[hu:arduino:variables#char|char]]|signed char|int8_t|8|Signed|-128 .. 127| |[[hu:arduino:variables#unsigned_int|unsigned int]]|unsigned short|uint16_t|16|Unsigned|0 .. 65,535| |[[hu:arduino:variables#int|int]]|short|int16_t|16|Signed|-32,768 .. 32,767| |[[hu:arduino:variables#unsigned_long|unsigned long]]|unsigned int|uint32_t|32|Unsigned|0 .. 4,294,967,295| |[[hu:arduino:variables#long|long]]|int|int32_t|32|Signed|-2,147,483,648 .. 2,147,483,647| |-|unsigned long long|uint64_t|64|Unsigned|0 .. 18,446,744,073,709,551,615| |-|long long|int64_t|64|Signed|-9,223,372,036,854,775,808 .. 9,223,372,036,854,775,807| A típusokkal együtt a konstansok is elérhetők a C-ből, lásd: [[#c_tipuskonstansok|C típuskonstansok]] ==== uintN_t ==== {{anchor:uintnt}} {{anchor:uint_16t}} Az Arduino, mivel a fordítója C bázisú, az //"alap"// C változótípusokat is ismeri és kezeli. Ilyen típus **uintN_t** (előjel nélküli integer) is. Ennek a használatával (ha szükséges), elkerülhető, hogy a különböző board-ok az UINT-et más-más bithosszal értelmezzék, ez a típus ugyanis rögzíti az alkalmazott bithosszt: * **uint8_t** : 8 bit * **uint16_t** : 16 bit, az Uno-n ez felel meg az [[#unsigned_int|unsigned int]] típusnak * **uint32_t** : 32 bit, az Uno-n ez felel meg az [[#unsigned_long|unsigned long]] típusnak, az Arduino Due, SAMD boardokon ez felel meg az [[#unsigned_int|unsigned int]] típusnak * **uint64_t** : 64 bit A típusokkal együtt a konstansok is elérhetők a C-ből, lásd: [[#c_tipuskonstansok|C típuskonstansok]] ===== unsigned int ===== {{anchor:unsigned_int}} A típus előjel nélküli, két bájt terjedelmű változókat tárolhat. Értéktartománya: 0 .. 65.535 (//0 .. 2 %%^%% 16 - 1//). A C __alap-megfeleltetése szerint__ a típus az **uint16_t**-nek felel meg, lásd: [[hu:arduino:variables#intn_t|strint.h]] type. A típus lehetséges konvertálási lehetőségei itt találhatók: [[hu:arduino:var_conv|Arduino típuskonvertálások]] ===== long ===== {{anchor:long}} A LONG típus képzését tekintve megegyezik az [[#int|INT]]-tel, azzal a különbséggel, hogy 4 byte hosszú, így értéktartománya: -2.147.483.648 .. 2.147.483.647 (//- 2 %%^%% 31 .. 2 %%^%% 31 - 1//). A számértékek tárolását az un. [[hu:comm:comdict#kettes_komplementer|kettes komplementer]] képzéssel valósítja meg. A C __alap-megfeleltetése szerint__ a típus az **int32_t**-nek felel meg, lásd: [[hu:arduino:variables#intn_t|strint.h]] type. Konstansként megadása esetén az [[#u_l|"L" formázókarakter]]rel lehet "force"-olni a típus használatát. A típus lehetséges konvertálási lehetőségei itt találhatók: [[hu:arduino:var_conv|Arduino típuskonvertálások]] ===== unsigned long ===== {{anchor:unsigned_long}} Hasonlóan az [[#unsigned_int|UNSIGNED_INT]] típushoz, a típus előjel nélküli, négy bájt terjedelmű változókat tárolhat. Értéktartománya: 0 .. 4.294.967.295 (//0 .. 2 %%^%% 32 - 1//). A C __alap-megfeleltetése szerint__ a típus az **uint32_t**-nek felel meg, lásd: [[hu:arduino:variables#intn_t|strint.h]] type. A típus lehetséges konvertálási lehetőségei itt találhatók: [[hu:arduino:var_conv|Arduino típuskonvertálások]] ===== word ===== {{anchor:word}} A WORD típus egy 2 bájt hosszú tárolótípus. Képzési logikája nincs, a tartalma szabadon meghatározható, kezelhető. A típus kétszeres hosszú változata a [[#double|DOUBLE]]. Több board-on és plattformon a "word" típus nem 2, hanem 4 bájtos, azaz a [[#double|DOUBLE]] típusnak felel meg! Ilyen board-ok: Arduino Due, SAMD alapú board-ok (például MKR1000 és Zero). A típus lehetséges konvertálási lehetőségei itt találhatók: [[hu:arduino:var_conv|Arduino típuskonvertálások]] ===== double ===== {{anchor:double}} A DOUBLE típus egy 4 bájt hosszú tárolótípus, terjedelme gyakorlatilag a [[#word|WORD]] duplája. Képzési logikája nincs, a tartalma szabadon meghatározható, kezelhető. Több board-on és plattformon a "double" típus sem 4, hanem 8 bájtos! Ilyen board-ok: Arduino Due, SAMD alapú board-ok (például MKR1000 és Zero). A típus lehetséges konvertálási lehetőségei itt találhatók: [[hu:arduino:var_conv|Arduino típuskonvertálások]] ===== float ===== {{anchor:float}} A típus törtszámok [[hu:comm:comdict#lebegopontos|lebegőpontos számábrázolás]]-sal tárolására alkalmas 4 bájton. Értéktartománya: -3.4028235E+38 .. 3.4028235E+38. A lebegőpontos műveletek sokkal több időt vesznek igénybe, mint a fixpontosok, időkritikus program esetén érdemes ezeket kerülni, vagy sűrűbben konvertálni. A típus változóit minden esetben tizedesponttal kell megadni (10 ☛ 10.0), egyébként int típusúként kerülnek feldolgozásra. int x; int y; float z; x = 1; y = x / 2; // az y eredménye 0 lesz, mert egész számként a ½ nem ábrázolható z = (float)x / 2.0; // a z eredmény most 0,5 lesz A típus lehetséges konvertálási lehetőségei itt találhatók: [[hu:arduino:var_conv|Arduino típuskonvertálások]] ===== Karakterlánc (char array) ===== {{anchor:string}} {{anchor:char_array}} A sting típust kétféle módon lehet kezelni. Egyrészt karakterek sorozataként, másrészt egyfefüggő önálló objektumként. Az első meoldást kis s-sel kell írni (string), míg a másodikat, melyet [[#string_object|itt talál]], nagy S-sel (String). Speciális karakter a **'\0'** (null terminal), amivel a karakter-láncokat kell lezárni. Automatikus értékadás mellett ezt a fordító valósítja meg: char greeting[] = "Hello"; A fenti esetben a karaktersorozat hossza 6 byte lesz, mert a fordító a kifejezés végére beilleszt egy null-terminált: 'H', 'e', 'l', 'l', 'o', '\0'. Kézi értékmegadásnál erről a programozónak kell gondoskodnia: char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'}; Ez itt a kis s-sel írandó típus, azaz a string itt karakterek ([[#char|CHAR]]) sorozata: char Str1 [15]; char Str2 [8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'}; // arduino char Str3 [8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\ 0'}; // arduino + null-karakter char Str4 [] = "arduino"; // automatikus méretezés char Str5 [8] = "arduino"; char Str6 [15] = "arduino"; A karakterláncokat mindig null-karakterrel zárni, ez lehetővé teszi a string-kezelő funkciók számára (pl. Serial.print ()) hogy megállapítsák a string végét. Ezért a string-eket egy karakterrel hosszabbra kell méretezni, mint azoknak a várható tartalma, így a fenti példában a Str4 automatikusan 8 karakter hosszú lesz. A típusban a formázókaraktereket is lehet tárolni, lásd a [[#karakter_konstansok|karakter konstansok]]nál. A típus lehetséges konvertálási lehetőségei itt találhatók: [[hu:arduino:var_conv|Arduino típuskonvertálások]] === Kapcsolódó funkciók === * [[hu:arduino:reference#strlen|strlen()]] - karakterlánc (char array) hossza * [[hu:arduino:reference#strcpy|strcpy()]] - karakterlánc (char array) másolása * [[hu:arduino:reference#memcpy|memcpy()]] - karakterlánc (char array) másolása a memóriában * [[hu:arduino:reference#strcat|strcat()]] - karakterlánc (char array) hozzáfűzés * [[hu:arduino:reference#strcmp|strcmp()]] - karakterláncok (char array) összehasnlítása * [[hu:arduino:reference#strchr|strchr()]] - egy karakter első előfordulása a karakterláncban (char array) * [[hu:arduino:reference#strstr|strstr()]] - egy karakterlánc első előfordulása a karakterláncban (char array) ===== String - object ===== {{anchor:string_object}} A String objektum, eltérően a string karakterlénctól, inkább összefüggő, komplexebb szövegek kezelésére készült. Ennek egyelőre nincs kész a fordítása, az eredetije itt található: https://www.arduino.cc/en/Reference/StringObject A típus lehetséges konvertálási lehetőségei itt találhatók: [[hu:arduino:var_conv|Arduino típuskonvertálások]] ===== array ===== A tömb valamilyen változótípushoz tartozó indexelhető és fix-hosszúságú értékek összessége. A tömb létrehozására néhány példa: int myInts [6]; // "üres" tömb, kezdeti értékadás nélkül int myPins [] = {2, 4, 8, 3, 6}; // a tömb méretezése automatikusan, a megadott elemek számától függően int mySensVals [6] = {2, 4, -8, 3, 2}; // kezdeti értékekkel részben feltöltött tömb char message [6] = "hello"; // karakterlánc, ahol legalább egy karaktert "üresen" kell hagyni, lásd: string A C-fordító nem ellenőrzi, hogy a tömb indexelésével a területről "kiindexel-e". Azaz az alábbi példa szerint int myArray [10] = {9,3,2,4,3,2,7,8,9,11}; A myArray[9] értéke 11, mivel az indexelést mindig 0-val kell kezdeni. A myArray[10]-ben, amit probléma nélkül olvashatunk, sőt, írhatunk is (!), a tömb területén kívül eső memóriaterület lesz. ===== pointer ===== A pointer a változók memóriabeli címét tárolja. Szintaktikája: **type *var-name;** Néhány példa a definiálására: int *ip; /* pointer to an integer */ double *dp; /* pointer to a double */ float *fp; /* pointer to a float */ char *ch /* pointer to a character */ Példa a pointer alkalmazására: int var = 20; /* actual variable declaration */ int *ip; /* pointer variable declaration */ void setup() { } void loop() { ip = &var; /* store address of var in pointer variable*/ // &var: Address of var variable // ip: Address stored in ip variable // *ip: Value of *ip variable } ====== Alkalmazások ====== ===== sizeof ===== {{anchor:sizeof}} A sizeof funkció a paraméterében megadott változó vagy tömb bájt-hosszával tér vissza. === Szintaktika === sizeof (változó) \\ változó: bármely típus, vagy bármilyen elem-típusú tömb === Példa === char myStr[] = "ez egy teszt"; int i; void setup(){ Serial.begin(9600); } void loop() { for (i = 0; i < sizeof(myStr) - 1; i++){ Serial.print(i, DEC); Serial.print(" = "); Serial.write(myStr[i]); Serial.println(); } delay(5000); // csak szép lassan } for (i = 0; i < (sizeof(myInts)/sizeof(int)); i++) { // műveletek a myInts[i]-vel }