|
|
hu:arduino:var_conv [2019/05/08 14:24] |
hu:arduino:var_conv [2022/04/21 15:02] () |
| ====== Arduino típuskonvertálások (összefoglaló) ====== |
| |
| |
| ^típus^Lehetséges konverziók a típusba^Lehetséges konverziók a típusból| |
| |[[hu:arduino:variables#boolean|boolean]]|-|[[#boolarraytobyte|boolArray → Byte]]| |
| |[[hu:arduino:variables#byte|byte]]|<color orange>alaptípusok → byte</color> : [[#byte_conv|byte()]] \\ [[#boolarraytobyte|boolArray → Byte]] \\ <color orange>int → 2 byte (stuktúra szerint)</color>: [[#inttobyte|IntToByte]] \\ <color orange>long → 4 byte</color>: [[#longtobyte_bytetolong|LongToByte]] \\ <color orange>Word, Double → 2, 4 byte (stuktúra szerint)</color>: [[#d_wordtobyte_byteto_d_word|(D)WordToByte]]|<color orange>2 byte → word</color>: [[#word_conv|word(h, l)]] \\ <color orange>2 byte → int (stuktúra szerint)</color>: [[#bytetoint|ByteToInt]] \\ <color orange>4 byte → long</color>: [[#longtobyte_bytetolong|ByteToLong]] \\ <color orange>2, 4 byte (stuktúra szerint) → Word, Double</color>: [[#d_wordtobyte_byteto_d_word|(D)WordToByte]]| |
| |[[hu:arduino:variables#integer|int]] \\ ([[hu:arduino:variables#intn_t|int16_t]] *)|<color orange>alaptípusok → int</color> : [[#int_conv|int()]] \\ <color orange>char array → int</color>: AVR_C_LIB: [[hu:arduino:avr_reference#atoi|atoi()]] \\ <color orange>2 byte → int (stuktúra szerint)</color>: [[#bytetoint|ByteToInt]]|<color orange>int → char array</color>: AVR_C_LIB: [[hu:arduino:avr_reference#itoa|itoa()]] \\ <color orange>int → 2 byte (stuktúra szerint)</color>: [[#inttobyte|IntToByte]]| |
| |[[hu:arduino:variables#unsigned_int|unsigned int]] \\ ([[hu:arduino:variables#uintn_t|uint16_t]] *)|lásd: INT| | |
| |[[hu:arduino:variables#word|word]]|<color orange>alaptípus → word</color> : [[#word_conv|word()]] \\ <color orange>2 byte → word</color>: [[#word_conv|word(h, l)]] \\ <color orange>2 byte → Word (stuktúra szerint)</color>: [[#d_wordtobyte_byteto_d_word|(D)WordToByte]]|\\ <color orange> Word → 2 byte (stuktúra szerint)</color>: [[#d_wordtobyte_byteto_d_word|(D)WordToByte]] | |
| |[[hu:arduino:variables#long|long]] \\ ([[hu:arduino:variables#intn_t|int32_t]] *)|<color orange>alaptípus → long</color> : [[#long_conv|long()]] \\ <color orange>char array → long</color>: AVR_C_LIB; [[hu:arduino:avr_reference#atol|atol()]] \\ <color orange>4 byte → long</color>: [[#longtobyte_bytetolong|ByteToLong]]|<color orange>long → 4 byte</color>: [[#longtobyte_bytetolong|LongToByte]] | |
| |[[hu:arduino:variables#unsigned_long]] \\ ([[hu:arduino:variables#uintn_t|uint32_t]]*)|Lásd: LONG| | |
| |[[hu:arduino:variables#short|short]] \\ ([[hu:arduino:variables#intn_t|int16_t]] *)|Lásd: INT| | |
| |[[hu:arduino:variables#float|float]]|<color orange>alaptípus → float</color> : [[#float_conv|float()]] \\ <color orange>char array → float</color>: AVR_C_LIB: [[hu:arduino:avr_reference#atof|atof()]]|<color orange>float/double → char array</color>: AVR_C_LIB: [[hu:arduino:avr_reference#dtostrf|dtostrf()]] | |
| |[[hu:arduino:variables#double|double]]|<color orange>char array → float/double</color>: AVR_C_LIB: [[hu:arduino:avr_reference#atof|atof()]] \\ <color orange>4 byte → Double (stuktúra szerint)</color>: [[#d_wordtobyte_byteto_d_word|(D)WordToByte]] \\ <color orange>char array → double</color>: AVR_C_LIB: [[hu:arduino:avr_reference#strtod|strtod()]]|<color orange>float/double → char array</color>: AVR_C_LIB: [[hu:arduino:avr_reference#dtostrf|dtostrf()]] \\ <color orange>Double → 4 byte (stuktúra szerint)</color>: [[#d_wordtobyte_byteto_d_word|(D)WordToByte]]| |
| |[[hu:arduino:variables#char|char]] \\ //a char_array lejjebb//|<color orange>alaptípusok → char</color> : [[#char_conv|char()]]| | |
| |[[hu:arduino:variables#unsigned_char|unsigned char]]|lásd: CHAR| | |
| |[[hu:arduino:variables#char_array|karakterlánc - char_array]]|<color orange>float/double → char array</color>: AVR_C_LIB: [[hu:arduino:avr_reference#dtostrf|dtostrf()]] \\ <color orange>int → char array</color>: AVR_C_LIB: [[hu:arduino:avr_reference#itoa|itoa()]] \\ <color orange>String (object) → char array</color>: [[#stringtochararray|StringToCharArray()]] \\ Az alaptípusok [[#arduino_string_formazas_sprintf_-fel|"sprintf" függvénnyel]] konvertálhatók.|<color orange>char array → int</color>: AVR_C_LIB: [[hu:arduino:avr_reference#atoi|atoi()]] \\ <color orange>char array → float</color>: AVR_C_LIB: [[hu:arduino:avr_reference#atof|atof()]] \\ <color orange>char array → long</color>: AVR_C_LIB: [[hu:arduino:avr_reference#atol|atol()]] \\ <color orange>char array → double</color>: AVR_C_LIB: [[hu:arduino:avr_reference#strtod|strtod()]] \\ <color orange>char array → String</color>: [[#chararraytostring|CharArrayToString]] | |
| |[[hu:arduino:variables#string_object|String (object)]]| <color orange>char_array → String (object)</color>: [[#chararraytostring|CharArrayToString]] \\ //(Legtöbb esetben egyszerűbb először char_array-be konvertálni, majd onnan String-be)//|<color orange>String (object) → char_array</color>: [[#stringtochararray|StringToCharArray()]] \\ <color orange>String (object) → long</color>: [[#stringtolong|StringToLong()]] \\ <color orange>String (object) → float</color>: [[#stringtofloat|StringToFloat()]]| | |
| |[[hu:arduino:variables#array|array]]|A tömb típusú változók konverziójára jól használható a [[hu:arduino:structs#union|union]] definició.| |
| |
| |
| *: a C definiciókkal való megfeleltetések (pl. int = int8_t) csak az alap-board-okon érvényesek, bizonyos típusokon (pl. DUE) ezeknek a bithossza eltér, azaz a megfeleltetés nem igaz. |
| |
| |
| ====== Arduino alaptípus-konverziók ====== |
| |
| ===== char() ===== |
| {{anchor:char_conv}} |
| Egy érték konvertálása a [[#char|char]] típusba. |
| === Szintaktika === |
| <color green>char (x)</color> \\ |
| |
| <color green>x</color>: bármely típus |
| |
| |
| ===== byte() ===== |
| {{anchor:byte_conv}} |
| Egy érték konvertálása a [[#byte|byte]] típusba. |
| === Szintaktika === |
| <color green>byte (x)</color> \\ |
| |
| <color green>x</color>: bármely típus |
| |
| ===== int() ===== |
| {{anchor:int_conv}} |
| Egy érték konvertálása a [[#int|int]] típusba. |
| === Szintaktika === |
| <color green>int (x)</color> \\ |
| |
| <color green>x</color>: bármely típus |
| |
| <code c> |
| // float to int |
| int i; |
| float f; |
| |
| f = 3.6; |
| i = (int) f; // now i is 3 |
| </code> |
| |
| ===== word() ===== |
| {{anchor:word_conv}} |
| Egy érték konvertálása a [[#word|word]] típusba, illetve 2 bemeneti [[#byte|bájt]]ból egy word érték "összeállítása". |
| === Szintaktika === |
| <color green>word (x)</color> \\ |
| <color green>word (h, l)</color> \\ |
| |
| <color green>x</color>: bármely típus |
| <color green>h</color>: a felső (baloldali) bájtja a word-nek |
| <color green>l</color>: az alsó (jobboldali) bájtja a word-nek |
| |
| ===== long() ===== |
| {{anchor:long_conv}} |
| Egy érték konvertálása a [[#long|long]] típusba. |
| === Szintaktika === |
| <color green>long (x)</color> \\ |
| |
| <color green>x</color>: bármely típus |
| |
| ===== float() ===== |
| {{anchor:float_conv}} |
| Egy érték konvertálása a [[#float|float]] típusba. |
| === Szintaktika === |
| <color green>float (x)</color> \\ |
| |
| <color green>x</color>: bármely típus |
| |
| ====== Arduino egyedi típuskonverziók ====== |
| ===== boolArrayToByte ===== |
| <code c> |
| byte BoolArrayToByte(bool boolArray[8]) |
| { |
| byte result = 0; |
| |
| for(int i = 0; i < 8; i++) |
| { |
| if(boolArray[i]) |
| { |
| result = result | (1 << i); |
| } |
| } |
| |
| return result; |
| } |
| </code> |
| |
| ===== StringToCharArray ===== |
| [[hu:arduino:variables#string_object|String (objektum)]] konvertálása [[hu:arduino:variables#char_array|string / char array]]-ba. |
| |
| <code c> |
| String s; |
| char arr[12]; // maximum 12 jegyű szám konvertálása |
| |
| s.toCharArray(arr, sizeof(arr)); |
| |
| </code> |
| |
| ===== CharArrayToString ===== |
| A char array Stringbe konvertálása esetén ügyelni kell arra, hogy az array **null-terminate** (**'\0'**) karakterrel záródjon. Ez a karaktersorozat default megadásnál automatikusan bekerül, például így: |
| <code c> |
| char[] chArray = "some characters"; |
| </code> |
| Array megadásánál viszont erről nekünk kell gondoskodni, például így: |
| <code c> |
| char chArray[] = {'o','b','1','2','1','\0'}; |
| </code> |
| Ha a terminate rendben van, akkor például így lehet a [[hu:arduino:variables#char_array|string / char array]]-t konvertálni [[hu:arduino:variables#string_object|String (objektum)]]-ba. |
| |
| <code c> |
| char[] chArray = "ob121"; |
| char chArray[] = {'o','b','1','2','1','\0'}; |
| |
| // a legegyszerűbb, ha egyenlővé tesszük a char arrayt a stringgel (ebben az irányban működik) |
| |
| String S = chArray; |
| |
| // vagy ez a megoldás is működik: |
| |
| String ebbe_a_Stringbe(chArray); |
| </code> |
| ===== StringToLong ===== |
| [[hu:arduino:variables#string_object|String (objektum)]] konvertálása [[hu:arduino:variables#long|long]]-ba. A konverzió két lépésből áll: |
| * String(object) ⇒ string / char array |
| * string / char array ⇒ Long (az AVR_C_LIB [[hu:arduino:avr_reference#atol|atol]] funkciójával) |
| |
| <code c> |
| long stringToLong(String s) |
| { |
| char arr[12]; // maximum 12 jegyű szám konvertálása |
| s.toCharArray(arr, sizeof(arr)); |
| return atol(arr); |
| } |
| </code> |
| |
| ===== StringToFloat ===== |
| [[hu:arduino:variables#string_object|String (objektum)]] konvertálása [[hu:arduino:variables#float|float]]-ba. A konverzió két lépésből áll: |
| * String(object) ⇒ string / char array |
| * string / char array ⇒ Long (az AVR_C_LIB [[hu:arduino:avr_reference#atof|atof]] funkciójával) |
| |
| <code c> |
| float stringToFloat(String s) |
| { |
| char arr[12]; // maximum 12 jegyű szám konvertálása |
| s.toCharArray(arr, sizeof(arr)); |
| return atof(arr); |
| } |
| </code> |
| |
| ===== IntToByte / ByteToInt ===== |
| {{anchor:inttobyte}} |
| {{anchor:bytetoint}} |
| [[hu:arduino:variables#integer|Integer]] konvertálása [[hu:arduino:variables#byte|bájt]]-ba vagy [[hu:arduino:variables#byte|bájt]] konvertálása [[hu:arduino:variables#integer|Integer]]-be. |
| |
| (A byte-ok tartalma nyilván értelmezhetetlen lesz, hiszen az int típus [[hu:comm:comdict#kettes_komplementer|kettes komplementer]]rel lett képezve. Ellenben viszont a byte-strukturájú [[hu:arduino:comm_example#arduino_i_c_kommunikacio|I²C]] így továbbítani tudja a tartalmát 2 byte-ban, és a másik oldalon ugyanígy össze kell rakni az INT-tet a két byte-ból. |
| |
| Az egyik lehetőség, hogy a bit-shifteléssel hozzuk létre a két bájtot (majd rakjuk ismét össze): |
| |
| <code c> |
| // Example from OB121.com // Vamos Sandor |
| |
| // Convert int to 2-bytes |
| // Convert back |
| |
| int start_val = -30000; |
| byte high_byte, low_byte; |
| |
| void setup() { |
| Serial.begin(9600); |
| } |
| |
| void loop() { |
| |
| Serial.println("for the conversion:"); |
| Serial.println(start); |
| |
| high_byte = (start_val >> 8); |
| low_byte = (start_val); |
| |
| Serial.println("conversion high_byte:"); |
| Serial.println(high_byte); |
| |
| Serial.println("conversion low_byte:"); |
| Serial.println(low_byte); |
| |
| start_val = (high_byte << 8) | low_byte; |
| |
| Serial.println("after the conversion:"); |
| Serial.println(start_val); |
| |
| delay(10000); |
| |
| } |
| </code> |
| |
| Némileg egyszerűbb megoldás, ha tudunk arról, hogy az [[hu:arduino:structs#union|union]] definició - bár az Arduino refenciában nem található - létezik. Ennek a segítségével több változót definiálhatunk egymásra a memóriában: |
| |
| <code c> |
| // OB121.com példaprogram - Vámos Sándor (2019) |
| // Az union definició alkalmazása az Arduino-ban |
| |
| // changing the byte array to the int |
| union { int szam; uint8_t bytes[2]; } combined_in; |
| union { int szam; uint8_t bytes[2]; } combined_out; |
| |
| void setup() { |
| Serial.begin(9600); |
| } |
| |
| void loop() { |
| combined_in.szam = INT16_MAX; // dec. values |
| combined_out.szam = 0; |
| |
| Serial.println(combined_in.szam, DEC); |
| |
| combined_out.bytes[0] = combined_in.bytes[0]; // copy int values over bytes |
| combined_out.bytes[1] = combined_in.bytes[1]; |
| |
| Serial.println(combined_out.szam, DEC); |
| delay(10000); |
| } |
| </code> |
| |
| ===== LongToByte / ByteToLong ===== |
| {{anchor:longtobyte}} |
| {{anchor:bytetolong}} |
| [[hu:arduino:variables#long|Long]] **(int32_t)** konvertálása [[hu:arduino:variables#byte|bájt]]-ba vagy [[hu:arduino:variables#byte|bájt]] konvertálása [[hu:arduino:variables#long|Long]]-ba **(int32_t)**. |
| |
| (A byte-ok tartalma nyilván értelmezhetetlen lesz, hiszen az int típus [[hu:comm:comdict#kettes_komplementer|kettes komplementer]]rel lett képezve. Ellenben viszont a byte-strukturájú [[hu:arduino:comm_example#arduino_i_c_kommunikacio|I²C]] így továbbítani tudja a tartalmát 4 byte-ban, és a másik oldalon ugyanígy össze kell rakni az LONG-ot a négy byte-ból. |
| |
| <code c> |
| // Example from OB121.com // Vamos Sandor |
| |
| // Convert long (int32_t) to 4-bytes |
| // and back again |
| |
| long start_val = 0xDEADBEEF; |
| byte conv[4]; |
| |
| void setup() { |
| Serial.begin(9600); |
| } |
| |
| void loop() { |
| |
| Serial.println("for the conversion:"); |
| Serial.println(start_val, HEX); |
| |
| conv[0] = (start_val >> 24); |
| conv[1] = (start_val >> 16); |
| conv[2] = (start_val >> 8); |
| conv[3] = start_val; |
| Serial.println("Bytes:"); |
| Serial.println(conv[0], HEX); |
| Serial.println(conv[1], HEX); |
| Serial.println(conv[2], HEX); |
| Serial.println(conv[3], HEX); |
| |
| start_val = (conv[0] << 8) | conv[1]; |
| start_val = (start_val << 8) | conv[2]; |
| start_val = (start_val << 8) | conv[3]; |
| |
| Serial.println("after the conversion:"); |
| Serial.println(start_val, HEX); |
| |
| delay(10000); |
| |
| } |
| </code> |
| |
| ===== (D)WordToByte / ByteTo(D)Word ===== |
| {{anchor:wordtobyte}} |
| {{anchor:dwordtobyte}} |
| {{anchor:bytetoword}} |
| {{anchor:bytetodword}} |
| [[hu:arduino:variables#word|Word]] és [[hu:arduino:variables#double|Double]] típusú változók konvertálása [[hu:arduino:variables#byte|byte]]-láncba, majd vissza. A konverzióhoz a legegyszerűbb az Arduino referenciájában nem ismertetett, de azért jól használható [[hu:arduino:structs#union|union]] definiciót használni: |
| |
| <code c> |
| // OB121.com példaprogram - Vámos Sándor (2019) |
| // Az union definició alkalmazása az Arduino-ban |
| |
| // changing the byte array to the word |
| union { word szo; uint8_t bytes[2]; } combined; |
| |
| // changing the byte array to the word |
| union { double dupla; uint8_t bytes[4]; } combinedD; |
| |
| void setup() { |
| Serial.begin(9600); |
| } |
| |
| void loop() { |
| combined.szo = 0xABCD; |
| combinedD.dupla = 0xDEADBEEF; // cannot displayed |
| |
| Serial.println(combined.szo, HEX); |
| |
| combined.bytes[0] = 0x34; |
| combined.bytes[1] = 0x12; |
| |
| combinedD.bytes[0] = 0x11; |
| |
| Serial.println(combined.szo, HEX); |
| |
| delay(10000); |
| } |
| </code> |
| |
| ====== Arduino String formázás "sprintf"-fel ====== |
| Az Arduino nem igazán publikált funkciói közé tartozik a String formázás. Ezzel a különböző, numerikus típusú változokat lehet egységesen és meglehetősen egyszerűen String típusba konvertálni. Megadható például a tizedesjegyek száma, a pozíciókitöltő nullák száma, .. |
| |
| Fontos tudni, hogy a **"sprintf"** függvény egy általános célú C függvény, a konvertálások egy része az Arduino-n nem működik (ezt a lenti kódban jelzem)! A lebegőpontos konvertálást ennek ellenére egy közbevetőleges [[hu:arduino:avr_reference#dtostrf|dtostrf]] függvénnyel meg lehet valósítani (példa a kódban). |
| |
| Egy példakódon keresztül szeretném szemlélteni ennek a formázásnak a menetét: |
| |
| <code c> |
| /* OB121.com, Vamos Sandor, 2019 |
| * String formatálási példák "sprintf" használatával. |
| * |
| * A sprintf függvény a formázási karakterláncot és a változókat a "data" karakterláncba írja. |
| * Olyan formázási-karakterláncsablont biztosít, amely helyfenntartó definíciókat tartalmaz a beilleszteni kívánt változók számára. |
| * Ezeknek a helyfenntartó definíciókat százalékjellel (%) kell jelölni. Például: %s,%d,%f... |
| * A helyfenntartók számának meg kell egyeznie a változók számával. A helyfenntartók definíciói: |
| * |
| * %d = előjeles integer %f = lebegőpontos (Aduinon nem működik) |
| * %s = string %.1f = lebegőpontos, 1 tizedes pontosság (Aduinon nem működik) |
| * %c = character %.3f = lebegőpontos, 3 tizedes pontosság (Aduinon nem működik) |
| * %e = hatványkitevős (Aduinon nem működik) %g = rövid megjelenés az %e vagy %f típusok helyett (Aduinon nem működik) |
| * %u = előjel nélüli integer %o = előjel nélküli oktális |
| * %x = előjel nélüli hex (kisbetűs) %X = előjel nélküli hex (nagybetűs) |
| * %hd = short int %ld = long int |
| * %lld = long long int (Aduinon nem működik) |
| * |
| * A lebegőpontos (%f), hatványkitevős (%e), a rövid megjelenítés (%g) és a long long int Arduino-n nem működik, |
| * ESP32-n viszont igen! |
| * |
| * ============================================================================= */ |
| |
| char data[100]; |
| char* myName = "ob121.com"; |
| char* myBlog = "https://ob121.com"; |
| char lebego[10]; |
| int year = 2019; |
| int num = 47; |
| char myChar = 'a'; |
| float myFloat = 1010; |
| long int lInt = 1234567890; |
| long long int vLong = 1234567890123456789; |
| |
| |
| void setup() { |
| Serial.begin(9600); |
| while (!Serial) { |
| delay(10); |
| } |
| |
| sprintf(data, "Magyar változat %s", myName); |
| Serial.println(data); |
| |
| sprintf(data, "Év: %u, az oldal linkje: %s",year,myBlog); |
| Serial.println(data); |
| |
| Serial.println(); |
| |
| sprintf(data, "karakterek: %c , %c", num, myChar); |
| Serial.println(data); |
| |
| sprintf(data, "Integer (d): %d , szélessége(8d): %8d , 0-kal kiegészítve(07d): %07d", num, num, num); |
| Serial.println(data); |
| |
| sprintf(data, "Floats f: %f, .1f: %.1f, .3f: %.3f", myFloat, myFloat, myFloat); |
| Serial.println(data); |
| |
| dtostrf(myFloat, 5, 2, lebego); |
| sprintf(data,"A lebegőpontos konvertálás hiánya például a ""dtostrf""-val megkerülhető: %s.",lebego); |
| Serial.println(data); |
| |
| |
| sprintf(data, "Tudományos e: %e , g: %g", myFloat , myFloat); |
| Serial.println(data); |
| |
| sprintf(data, "Alapformátumok u: %u , #o: %#o , x: %x , #X: %#X ", num, num, num, num); |
| Serial.println(data); |
| |
| sprintf(data, "ld: [%ld + 1 = %ld]", lInt, lInt+1); |
| Serial.println(data); |
| |
| sprintf(data, "lld: [%lld + 1 = %lld]", vLong, vLong+1); |
| Serial.println(data); |
| |
| } |
| |
| void loop() { |
| //do nothing |
| } |
| </code> |
| |
| |