Oldalforrás megtekintése Korábbi változatok Hivatkozások Tartalomjegyzék Arduino típuskonvertálások (összefoglaló) Arduino alaptípus-konverziók char() Szintaktika byte() Szintaktika int() Szintaktika word() Szintaktika long() Szintaktika float() Szintaktika Arduino egyedi típuskonverziók StringToCharArray StringToLong StringToFloat IntToByte / ByteToInt LongToByte / ByteToLong (D)WordToByte / ByteTo(D)Word Arduino típuskonvertálások (összefoglaló) típusLehetséges konverziók a típusbaLehetséges konverziók a típusból boolean-- charalaptípusok → char : char() unsigned charlásd: CHAR bytealaptípusok → byte : byte() int → 2 byte (stuktúra szerint): IntToByte long → 4 byte: LongToByte Word, Double → 2, 4 byte (stuktúra szerint): (D)WordToByte2 byte → word: word(h, l) 2 byte → int (stuktúra szerint): ByteToInt 4 byte → long: ByteToLong 2, 4 byte (stuktúra szerint) → Word, Double: (D)WordToByte int (int16_t *)alaptípusok → int : int() char array → int: AVR_C_LIB: atoi() 2 byte → int (stuktúra szerint): ByteToIntint → char array: AVR_C_LIB: itoa() int → 2 byte (stuktúra szerint): IntToByte unsigned int (uint16_t *)lásd: INT wordalaptípus → word : word() 2 byte → word: word(h, l) 2 byte → Word (stuktúra szerint): (D)WordToByte Word → 2 byte (stuktúra szerint): (D)WordToByte long (int32_t *)alaptípus → long : long() char array → long: AVR_C_LIB; atol() 4 byte → long: ByteToLonglong → 4 byte: LongToByte unsigned_long (uint32_t*)Lásd: LONG short (int16_t *)Lásd: INT floatalaptípus → float : float() char array → float: AVR_C_LIB: atof()float/double → char array: AVR_C_LIB: dtostrf() doublechar array → float/double: AVR_C_LIB: atof() 4 byte → Double (stuktúra szerint): (D)WordToByte char array → double: AVR_C_LIB: strtod()float/double → char array: AVR_C_LIB: dtostrf() Double → 4 byte (stuktúra szerint): (D)WordToByte karakterlánc / char arrayfloat/double → char array: AVR_C_LIB: dtostrf() int → char array: AVR_C_LIB: itoa()char array → int: AVR_C_LIB: atoi() char array → float: AVR_C_LIB: atof() char array → long: AVR_C_LIB: atol() char array → double: AVR_C_LIB: strtod() String (object)String (object) → char array: egyedi konvertálás: StringToCharArray() String (object) → long: egyedi konvertálás: StringToLong() String (object) → float: egyedi konvertálás: StringToFloat() arrayA tömb típusú változók konverziójára jól használható a 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() Egy érték konvertálása a char típusba. Szintaktika char (x) x: bármely típus byte() Egy érték konvertálása a byte típusba. Szintaktika byte (x) x: bármely típus int() Egy érték konvertálása a int típusba. Szintaktika int (x) x: bármely típus word() Egy érték konvertálása a word típusba, illetve 2 bemeneti bájtból egy word érték "összeállítása". Szintaktika word (x) word (h, l) x: bármely típus h: a felső (baloldali) bájtja a word-nek l: az alsó (jobboldali) bájtja a word-nek long() Egy érték konvertálása a long típusba. Szintaktika long (x) x: bármely típus float() Egy érték konvertálása a float típusba. Szintaktika float (x) x: bármely típus Arduino egyedi típuskonverziók StringToCharArray String (objektum) konvertálása string / char array-ba. String s; char arr[12]; // maximum 12 jegyű szám konvertálása s.toCharArray(arr, sizeof(arr)); StringToLong String (objektum) konvertálása long-ba. A konverzió két lépésből áll: String(object) ⇒ string / char array string / char array ⇒ Long (az AVR_C_LIB atol funkciójával) long stringToLong(String s) { char arr[12]; // maximum 12 jegyű szám konvertálása s.toCharArray(arr, sizeof(arr)); return atol(arr); } StringToFloat String (objektum) konvertálása float-ba. A konverzió két lépésből áll: String(object) ⇒ string / char array string / char array ⇒ Long (az AVR_C_LIB atof funkciójával) float stringToFloat(String s) { char arr[12]; // maximum 12 jegyű szám konvertálása s.toCharArray(arr, sizeof(arr)); return atof(arr); } IntToByte / ByteToInt Integer konvertálása bájt-ba vagy bájt konvertálása Integer-be. (A byte-ok tartalma nyilván értelmezhetetlen lesz, hiszen az int típus kettes komplementerrel lett képezve. Ellenben viszont a byte-strukturájú 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): // 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); } Némileg egyszerűbb megoldás, ha tudunk arról, hogy az 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: // 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); } LongToByte / ByteToLong Long (int32_t) konvertálása bájt-ba vagy bájt konvertálása Long-ba (int32_t). (A byte-ok tartalma nyilván értelmezhetetlen lesz, hiszen az int típus kettes komplementerrel lett képezve. Ellenben viszont a byte-strukturájú 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. // 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); } (D)WordToByte / ByteTo(D)Word Word és Double típusú változók konvertálása 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ó union definiciót használni: // 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); }