+420 602 267 146
[email protected]

Proměnné a datové typy v Arduino

Při psaní kódu pro Arduino je nezbytné porozumět základním stavebním kamenům programování, kterými jsou proměnné a datové typy. Proměnná v programování funguje na stejném principu jako matematická proměnná - je to symbolické označení pro určitou hodnotu, která může být v průběhu programu měněna. V kontextu Arduina si můžeme proměnnou představit jako malý "šuplík" v paměti, na kterém je cedulka s jménem (název proměnné) a uvnitř je uložena nějaká informace (hodnota proměnné).

Aby Arduino mohlo s daty efektivně pracovat, je nutné definovat, jaký druh a jakou velikost informace bude proměnná uchovávat. K tomu slouží datové typy. Výběr správných a nejvíce úsporných datových typů přichází s praxí. Každá proměnná má dvě základní vlastnosti: její název a hodnotu, kterou může nabýt.

Název proměnné je klíčový pro její identifikaci v kódu. Při vymýšlení názvů proměnných je třeba dodržovat několik pravidel:

  • Název by měl být popisný a intuitivní, aby bylo zřejmé, co proměnná obsahuje.
  • Nesmějí se používat speciální znaky jako mezery, diakritika (ěščřžýáíéúů), tečky, čárky, lomítka, aritmetické operace (+, -, *, /), závorky ((), {}, []) a další speciální znaky.
  • Číslice lze v názvu použít, ale název nesmí číslicí začínat (např. "test1" je platné, ale "1test" nikoliv).
  • Je vhodné nepoužívat klíčová slova programovacího jazyka Wiring, aby nedošlo ke zmatkům.

Pro lepší čitelnost a srozumitelnost kódu se doporučuje používat tzv. velbloudí notaci (camelCase), kde se první písmeno prvního slova píše malým a každé další slovo začíná velkým písmenem (např. `motorBrana`), nebo hadí notaci (snake_case), kde se slova oddělují podtržítkem (např. `motor_brana`).

Ilustrace principu proměnné jako šuplíku s cedulkou a obsahem

Deklarace proměnných

Než začneme proměnné používat, musíme je deklarovat. Deklarace říká programu, že daná proměnná bude existovat, jaký bude mít název a jaký datový typ. Deklarace je zakončena středníkem.

V rámci deklarace můžeme proměnné rovnou přiřadit počáteční hodnotu pomocí operátoru "=". Pokud hodnota není přiřazena explicitně, proměnná může obsahovat náhodnou hodnotu z paměti (v případě číselných typů jako `int` nebo `float` se často jedná o 0, ale nelze na to spoléhat).

Příklad deklarace proměnné:

int pocetKroku = 10; // Deklarace celočíselné proměnné 'pocetKroků' s počáteční hodnotou 10char prvniPismeno = 'A'; // Deklarace znakové proměnné 'prvníPismeno' s hodnotou 'A'

Komentáře v kódu

Pro lepší pochopení kódu je možné vkládat komentáře. Komentáře program ignoruje, ale pomáhají programátorům (včetně vás samotných v budoucnu) porozumět logice kódu. V jazyce Wiring (používaném pro Arduino) existují dva způsoby komentování:

  • Jednořádkové komentáře: Začínají dvěma lomítky `//` a pokračují až do konce řádku.
  • Víceřádkové komentáře: Začínají lomítkem a hvězdičkou `/*` a končí hvězdičkou a lomítkem `*/`. Celý text mezi těmito znaky je ignorován.

Příklad:

// Toto je jednořádkový komentář/* Toto je víceřádkový komentář */

Datové typy v Arduino

Volba správného datového typu je klíčová pro efektivní využití paměti a správnou funkci programu. Každý datový typ definuje, jaký druh dat proměnná uchovává a kolik paměti k tomu potřebuje.

Číselné datové typy

Celá čísla (Integer types)

  • `byte`: Typ `byte` je datový typ `unsigned`, který uchovává celá čísla v rozsahu 0 až 255. Jedná se o 8 bitů (1 bajt).
  • `short`: Typ `short` je celočíselný datový typ, který ukládá 16bitová data (2 bajty). Jeho rozsah se pohybuje od -32768 do 32767.
  • `int`: Standardní celočíselný typ. Na většině desek Arduino (např. UNO s mikrokontrolery AVR) ukládá 16bitovou hodnotu v rozsahu -32768 až 32767. Na výkonnějších deskách jako Arduino Due může ukládat 32bitovou hodnotu v rozsahu -2147483648 až 2147483647.
  • `long`: Typ `long` je proměnná s rozšířenou velikostí, která uchovává 32 bitů (4 bajty). Jeho rozsah je od -2147483648 do 2147483647. Pro vynucení typu `long` u konstant lze za číslo přidat písmeno 'L'.
  • `unsigned int`: Uchovává pouze kladné hodnoty, rozsah je od 0 do 65535 (16 bitů).
  • `unsigned long`: Podobně jako `long`, ale uchovává pouze kladné hodnoty. Rozsah je od 0 do 4294967295 (32 bitů).
  • `word`: Typ `word` označuje nezáporná čísla v rozsahu 0 až 65535 (16 bitů).

Čísla s plovoucí desetinnou čárkou (Floating-point types)

  • `float`: Typ `float` je určen pro čísla s desetinnou čárkou (např. 3.14). V jazyce Wiring se používá desetinná tečka. Jeho velikost je 32 bitů (4 bajty). Typ `float` může uchovávat čísla v rozsahu přibližně od -3.4E+38 do +3.4E+38.
  • `double`: Typ `double` se také používá pro čísla s desetinnou čárkou, ale s vyšší přesností a rozsahem než `float`. Na deskách ATmega a UNO zabírá 4 bajty (stejně jako `float`), ale na Arduino Due zabírá 8 bajtů, čímž poskytuje dvojnásobnou přesnost.

Znakové datové typy

  • `char`: Typ `char` slouží k uchování jednoho znaku (písmeno, číslo, symbol). Znak je v paměti reprezentován svým číselným kódem podle ASCII tabulky. Literály `char` se zapisují v jednoduchých uvozovkách (např. `'A'`). Typ `char` je technicky vzato celočíselný typ s minimální velikostí 8 bitů.
  • `unsigned char`: Podobně jako `char`, ale bez znaménka, což umožňuje uchovat hodnoty v rozsahu 0 až 255. Typ `byte` je v podstatě synonymem pro `unsigned char`.

Logické datové typy

  • `boolean`: Proměnné tohoto typu mohou nabývat pouze dvou hodnot: `true` (pravda) nebo `false` (nepravda).

Speciální datový typ

  • `void`: Typ `void` se používá k deklaraci funkcí, které nevracejí žádnou hodnotu. Také se používá k označení prázdné množiny hodnot.

Pole (Arrays)

Pole je speciální typ proměnné, který umožňuje shromáždit více hodnot stejného datového typu do jedné proměnné. Můžeme si jej představit jako krabičku s očíslovanými přihrádkami. Každá přihrádka (prvek pole) je přístupná pomocí svého indexu, který začíná od nuly.

Příklad deklarace pole:

int cisla[5]; // Deklarace pole 'cisla' s 5 prvky typu intcisla[0] = 10; // Přiřazení hodnoty do prvního prvku (index 0)
Ilustrace pole jako řady očíslovaných krabiček

EEPROM paměť

Arduino disponuje integrovanou EEPROM pamětí, která umožňuje ukládat data, která zůstanou zachována i po odpojení napájení. Pro rozšíření této kapacity lze použít externí moduly EEPROM, jako je například AT24C256.

Modul EEPROM AT24C256 má kapacitu 256 kbit (32 kbyte), což odpovídá 32 768 bajtům. Pro komunikaci s Arduinem využívá protokol I2C a vyžaduje připojení pouhých čtyř vodičů (VCC, SCL, SDA, GND). Data lze do EEPROM zapisovat a následně je číst.

Příklad zápisu a čtení do EEPROM:

#include <Wire.h>void setup() { Serial.begin(9600); Wire.begin(); // Zápis znaku '!' na maximální adresu EEPROM.write(32767, '!'); // Čtení a výpis znaku z EEPROM char data = EEPROM.read(32767); Serial.print("Precteny znak: "); Serial.println(data);}void loop() { // ...}

EEPROM paměť je vhodná pro ukládání konfigurací, nastavení nebo zálohu dat, která je potřeba uchovat i po výpadku napájení.

Arduino návody | I2C EEPROM paměť AT24C256

Základní pravidla syntaxe Arduino

Při psaní kódu v Arduino IDE je důležité dodržovat základní pravidla syntaxe:

  • Každý příkaz, deklarace proměnné nebo volání funkce musí být zakončeno středníkem (;).
  • Složené závorky ({}) se používají k ohraničení bloků kódu (např. tělo funkce, příkazy `if`, `for`). Středník se za složenou závorkou nepíše, pokud nejedná o specifické případy jako víceřádková deklarace 2D pole.
  • Příkazy jako `if`, `else`, `for`, `while` se obvykle nepíší na samostatný řádek se středníkem, pokud následuje blok kódu v závorkách.

Příklad správného použití středníku:

int promenna; // Deklarace proměnné zakončená středníkempromenna = 5; // Přiřazení hodnoty zakončené středníkemdigitalWrite(13, HIGH); // Volání funkce zakončené středníkemif (promenna == 5) { // Blok kódu uvnitř if Serial.println("Promenna je 5"); // Příkaz uvnitř bloku} // Konec bloku kódu, středník zde není
Schema Arduino desky s vyznačenými piny a jejich funkcemi

Praktické příklady použití proměnných

Pro lepší pochopení principu proměnných si ukážeme několik jednoduchých příkladů.

Příklad 1: Blikání LED diody s proměnnou pro interval

V tomto příkladu použijeme proměnnou pro určení délky pauzy mezi rozsvícením a zhasnutím LED diody. To nám umožní snadno měnit rychlost blikání pouhou změnou hodnoty proměnné.

int ledPin = 13; // Pin, ke kterému je připojena LEDint interval = 500; // Délka pauzy v milisekundáchvoid setup() { pinMode(ledPin, OUTPUT); // Nastavení pinu jako výstup}void loop() { digitalWrite(ledPin, HIGH); // Rozsvícení LED delay(interval); // Pauza digitalWrite(ledPin, LOW); // Zhasnutí LED delay(interval); // Pauza}

Zkuste si změnit hodnotu proměnné `interval` na 100 nebo 1000 a pozorujte rozdíl v rychlosti blikání.

Příklad 2: Počítání stisknutí tlačítka

V tomto příkladu použijeme proměnnou k počítání, kolikrát bylo stisknuto tlačítko. Každé stisknutí zvýší hodnotu proměnné.

int buttonPin = 2; // Pin, ke kterému je připojeno tlačítkoint ledPin = 13; // Pin, ke kterému je připojena LEDint pocetStisku = 0; // Proměnná pro uchování počtu stiskůvoid setup() { pinMode(buttonPin, INPUT); // Nastavení pinu tlačítka jako vstup pinMode(ledPin, OUTPUT); // Nastavení pinu LED jako výstup Serial.begin(9600); // Inicializace sériové komunikace}void loop() { int buttonState = digitalRead(buttonPin); // Přečtení stavu tlačítka if (buttonState == HIGH) { // Pokud je tlačítko stisknuto pocetStisku++; // Zvýšení počtu stisků Serial.print("Pocet stisku: "); Serial.println(pocetStisku); digitalWrite(ledPin, HIGH); // Rozsvícení LED delay(200); // Krátká pauza, aby se jedno stisknutí nepočítalo vícekrát } else { digitalWrite(ledPin, LOW); // Zhasnutí LED, pokud tlačítko není stisknuto }}

Tento příklad ukazuje, jak lze proměnné využít k uchování stavu nebo počtu událostí v programu.

tags: #arduino #uint #promenna #byte

Oblíbené příspěvky: