2: byte2bool

A következő projektünk neve már csupa rejtély. De azért próbáljuk meg megfejteni! A byte és a bool változótípusok, ezekről majd ebben a fejezetben lesz szó. A kettő közötti kettest (2) angolul úgy mondjuk hogy "two". Ennek a kiejtése szinte megegyezik a "to" szócskával, amit angolban úgy szokás használni, hogy "valamihez" vagy "valamivé". Amikor valamit valamivé akarunk alakítani, angolul ezt viccesen a két szó közé biggyesztett "2"-vel tehetjük meg, pl tej2kakaó (milk2chocolate_milk), vagy paprika2lecsó.

Most egy érdekes logika szerint villogó led-sort kell megépítenünk, és miután elkezdett villogni, elmagyarázom, hogy miért csinálja azt, amit:

Arduino kids projekt: Byte2bool 1

Ezúttal is kezdjük először a vassal, azaz építsük meg a kapcsolást. Az átláthatóság kedvéért a projekteket egy pont alá, az "Arduino Projects"-be gyüjtöm össze, erre vagy rákattintassz, itt, baloldalt, és kikeresed a projektet, vagy egyszerűen erre a linkre klikkelsz: Arduino kids projekt: Byte2bool.

Miután végeztél a kapcsolás összeépítésével, gyere ide vissza!

A programozásban (minden programozásban) változókat kell használnunk. Ezek a memóriában olyan területek, melyeknek nevet kell adnunk és ráadásul azt is meg kell határoznunk, hogy mire használjuk ezeket. Ha egyszerűen csak számolni akarunk egyesével, akkor egy ilyen területet kell saját névvel foglalnunk, és meg kell határoznunk a típusát, majd egyszerűen utasítani kell a programot, hogy minden ciklusban számoljon eggyel tovább:

// Az Arduino-n egy byte értéke emelkedik ciklusonként eggyel. 
// Amikor eléri a maximumát, túlcsordul, és kezdi elölről a számolást - 
// ezzel legalább nem kell foglalkozni. 

// ob121.com, Arduino Kids (2: byte2bool), byte léptetés

byte szamol;                     // a változó típusa és neve, a sorokat általában pontosvesszővel kell zárni 
                   

void setup() {                   // első és egyszeri végrehajtás
  Serial.begin(9600);            // a soros kommunikáció sebessége 
                                 // :ezt kell a monitoron is beállítani
  szamol = 0;                    // a byte 0-ról kezd   
}

void loop() {                    // ciklikus végrehajtás
  
  szamol++;                      // a byte tartalmának a növelése 1-egyel
  
  Serial.print("\n");            // "új sor" a soros monitorra
  Serial.print(szamol);          // a byte tartalmának kiírása a soros monitorra
  delay(100);                    // várakozás (0,1 másodperc) - ennek megváltoztatásával
}                                // a program gyorsítható - lassítható.

Ebben a programban a "számol" nevű byte változónak növeljük minden ciklusban az értékét eggyel (a szamol++ paranccsal). Ez a változótípus, a byte legfeljebb 255-ig tud számokat tárolni, ezért 255 után (mivel a változó túlcsordul) a tartalma ismét 0 lesz, előröl kezdi a számolást. Ha bekapcsoljuk a soros monitort, ott látni is fogjuk, hol tartunk éppen.

Változó típusok

A lenti táblázatban a fontosabb változókat összegeztem (van még jópár ezeken kívül):

Arduino főbb változók

A változók legkisebb egysége a bit. Egy bitnek két állapota lehet: igaz vagy hamis, számokkal 1 vagy 0. Az 1 felel meg az igaznak, azaz a "true"-nak C-ben, míg a 0 a hamisnak, azaz a "false"-nak. Egy bit a fenti programban egy LED két állapotát jellemzi. Ha a LED világít, akkor a hozzá tartozó bit értéke 1, azaz "true", ha nem világít, akkor 0, azaz "false".

A bit-nél eggyel nagyobb változó neve a byte. A byte 8 egymás mellé rendezett bitből áll. A változók felépítésénél a kettes számrendszert kell használnunk, mivel a legkisebb változó 2 állapotot tárolhat. Ha például 2 bitet teszünk egymás mellé, akkor azok már négy állapotot tudnak leírni: 00, 01, 10 és 11. Ha minden pozícióhoz egy számot rendelünk, akkor a hátsó lesz az 1, a következő a 2, azaz az előbbi számokat így lehet kiszámolni:

00: 0*2 + 0*1 = 0
01: 0*2 + 1*1 = 1
10: 1*2 + 0*1 = 2
11: 1*2 + 1*1 = 3

Ha ezek után 8 bitet rendezünk egymás mellé, úgy, hogy a jobboldali a legkisebb, míg a baloldali a legnagyobb helyi-értékű, ez lesz az eredmény:

Túlcsordulás

Remélem, a fenti példán is látszik, hogy a 8 biten, azaz bájton tárolható legnagyobb érték a 255, ami így jön ki:

11111111: 1*128 + 1*64 + 1*32 + 1*16 + 1*8 + 1*4 + 1*2 + 1*1 = 255

A C szabályai szerint, ha ebben az esetben, hogy az összes bit "1", és a byte értéke így 255; még egyet hozzá akarunk adni a változóhoz, akkor az egyszerűen ismét "00000000" lesz, azaz 0. Ezt a jelenséget úgy hívjuk, hogy túlcsordulás.

Talán a fenti villogó programunk így már kicsit kiismerhetőbben fogja a LED-eket váltogatni, hiszen a byte 1-1 bitjére kötöttük azokat. A fenti kép szerint változik a bájtunk ("szamol") tartalma, ahogy minden ciklusban hozzáadunk egyet ("szamol++"). Amikor eléri a maximális 255-öt, és ismét hozzáadunk 1-et, túlcsordul, és kezdi elölről a számolást.

Kezdjük az elején a feszültséggel és az árammal, és rögtön egy példával, amivel szerintem jól lehet szemléltetni ennek a két fogalomnak a kapcsolatát. Nézzünk meg egy csövet, amiben víz folyik. Két fontos jellemzőn keresztül tudjuk leírni azt, hogy mi történik ilyenkor. Egyrészt hogy milyen széles a cső, azaz mekkora az átmérője, és hogy milyen gyorsan áramlik benne a víz.

Ha egy kádat szeretnénk megtölteni vízzel, de csak egy szívószálon csordogál a víz, az nyilván nem a legjobb megoldás. Fordítva, ha az üdítőhöz egy pohárnyi méretű csövet adnak szívószál gyanánt, az sem az ideális megoldás. A villanyáramot hasonló módon két paraméterrel jellemezhetjük; a cső átmérőjét nevezzük feszültségnek és az áramló vizet helyettesítsük egyszerűen az árammal.

Az áram jele I, mértékegysége az Amper (A). Ennek az ezred része a milli-amper (mA). A feszültség jele az U, mértékegysége a Volt (V).

A kettőnek a szorzata az elektromos teljesítmény, ennek a jele a P, mértékegysége a Watt (ezredrésze a milli-Watt, mW):

P = U * I

A fenti példában az Arduino board 5V feszültséget ad ki a kimeneteire, ha azok "true" állapotba váltanak. A LED-ek általában 2,8 - 3,3 V feszültséggel üzemelnek, az 5V egyszerűen túl sok nekik leégnek a hatására. Mit lehet ilyenkor tenni? Valahogy csökkenteni kell a feszültséget, és erre a célra az ellenállás az egyik legegyszerűbb módszer.