4.rész Arduino

Soros port.

A számítógépünkön nem csak párhuzamos port, hanem soros port is van. Ebből pedig kétféle. A régi, és az új, az USB. A régi soros port már elavult, ezért már nem foglalkozik vele ez az írás.
A párhuzamos vezérlésnél egyszerre több vezérlési adatot tudtunk küldeni. Egy porton akár egyszerre nyolc (sőt, 12-öt) LED-et is tudtunk ki-be kapcsolgatni közvetlenül.
A soros porton keresztül  LED-eket nem vezéreljük közvetlenül,  arra használjuk, hogy  egy másik számítógépnek küldjük át rajta az utasításokat. Ez kétféleképpen történhet.

Az egyik módszer, hogy a másik számítógép egy nagyobb memóriájának küldjük át egybe az egész programot, ami aztán önállóan fut azon a másik számítógépen. Annak a másiknak nem kell egy ugyanolyan nagyméretű asztali számítógépnek lennie, hanem lehet egy chip méretű kicsi célszámítógép is. Ezeket mikróvezérlőknek (mikrokontrollernek) hívjuk.

A másik módszer a soros vezérlés (ami lényegében a távirányítást jelenti), ahol a jeleket kisebb csomagokban, egymás után küldjük a mikróvezérlő kisebb memória  pufferébe, ami begyűjti az 5-9 LED-hez tartozó utasításokat (biteket), majd ezeknek megfelelően ki-be kapcsolja őket. A következő utasításcsomagot pedig a másodperc tört része alatt is megkaphatja, mivel egy másodperc alatt sok ezer jel küldhető, vagyis a jelküldés nagyon gyors, akár egy autó távirányítása is jól működik így.

Első körben arról lesz szó, hogy a mikróvezérlőt  (Arduino-t) programozzuk fel, ami aztán önállóan a számítógéptől, max. az USB tápját használva, vagy külön adapterrel, esetleg elemmel végzi a dolgát.

Ezután a második módszert vesszük alapul. Itt elsőnek az Arduino szoftverből tartjuk a kapcsolatot a mikrokontrollerünkkel, majd egy rövid példát mutatok, hogyan lehet JavaScript-tel vezérelni, utána pedig azt, hogyan írhatunk saját vezérlő, kommunikáló programot Visual Basicben (Visual Stúdió-val) az Arduino -hoz.


USB(Universal Serial Bus)

Az USB jó tulajdonsága, hogy osztható, ezt úgynevezett USB hub-ok hajtják végre.
A két szélső érintkezője a tápellátást biztosítja, a rácsatlakoztatott hardvernek, amennyiben annak szüksége van rá, a belső kettő  pedig az adat érintkező. Ezeken a bitek nagy sebességgel, egymást követik az információ áramlásban, ezért hívják sorosnak ezt a portot. A bitek úgynevezett differenciális módon vannak küldve. Ez azt jelenti hogy, mindkettő érpáron feszültség van. Amikor a bit 0 adatot jelent, akkor az egyik vezetékben 2,8 V fölé megy a feszültség, és a másikban 0,3 V alá. Amikor 1 adatot küldünk, akkor az érpár feszültségszintjei felcserélődnek.
Gondolom, hogy a földelésen keresztül záródnak az áramkörök tehát egy USB-ben valójában három áramkör van. Egy táp a rácsatlakoztatható eszköznek, és kettő adat, amelyekben a feszültségszintek egymással szinkronban, de ellentétesen alakulnak. Legalábbis valami ilyesmit értelmezek. Valójában egy bit-es közvetlen vezérlést meg lehetne ezen keresztül is valósítani, esetleg egy tranzisztor segítségével, tehát egy valamit ki-be lehetne kapcsolgatni, de nem érdemes. Alapjában a soros port adatátvitelre való, és nem közvetlen vezérlésre.
http://esca.atomki.hu/PIC18/usb.html
Ma már az adatátvitelt általában USB-n keresztül valósítják meg, a távvezérlés kivételével, amikor rádióhullámot, fényt, internet, stb. használhatnak.

Arduino alapok.

Az Arduino egy mikrokontroller (mikróvezérlő), és egy hozzá tartozó azonos elnevezésű szoftver. Gondolj erre a hardverre nyugodtan úgy, mint egy kicsi számítógépre, csak ez olyan, hogy leginkább azt tartalmazza alapból, amire eszközök vezérléséhez szükség van, vagyis egy célszámítógép. Az Arduino előtt is voltak mikróvezérlők, de azoknak a programozása nem volt felhasználóbarát, ismerni kellett a hardvert, és hasonlóan kellett használni, mint amikor a számítógépet gépi kódolják. Az  Arduino megjelenése óta pedig vannak még jobb kis számítógépek (pl: Raspberry Pi), azok viszont drágábbak, mint az Arduino. Így jelenleg még mindig ez a legnépszerűbb. A több Arduino változatából az UNO, és NANO,  talán a legnépszerűbbek.
Az Arduino programozásához már nem kell ismerni a processzor felépítését, hasonlóan programozhatjuk, mint a számítógépünk párhuzamos portját, ezért, és az áruk miatt népszerűek.

Az Arduino mikróvezérlő  annyival rosszabb megoldás a párhuzamos port vezérléstől, hogy külön eszközt kell vásárolnunk személyében, de annyival jobb, hogy külön tápellátással, függetleníthetjük a nagy számítógépünktől.

Akár építhetsz is egyet:
https://www.youtube.com/watch?v=sNIMCdVOHOM
de ha jó helyről veszed meg az alaplapot, akkor nem lesz olcsóbb.

Emulátor:
Abban különbözik a szimulátortól, hogy nem csak részben, hanem teljen úgy viselkedik, mint az Arduino. Ezt használva virtuális kipróbálhatod, és megtanulhatod az Arduino kezelését anélkül, hogy ténylegesen birtokába lennél egy ilyen eszköznek.
Bővebben hamarosan.

Használata:
Vegyél egy Arduinot klónt(sokkal olcsóbb), szerintem elsőre Arduino Nano-t, vagy egy avval kompatibilis másolatot
https://www.hestore.hu/prod_10035527.html
 érdemes venni. 
Olcsó és kicsi, de szinte mindent kipróbálhatsz rajta.
Ezen az oldalon pl. itthonról is elég olcsón beszerezheted:
http://shop.tavir.hu/
Ráadásul itt van egy ingyenes tanfolyam, amihez olcsón beszerezhetsz  készletcsomagot, a webáruházban:
http://www.tavir.hu/60nap
vagy Ebay.com -ról...

Arduino szoftver letöltése:
Ha van már Arduino eszközöd, akkor letöltöd erről
https://www.arduino.cc/en/Main/Software
az oldalról az aktuális Arduino nevű programot. Ebbe programozunk, majd azt ez fordítja le az Arduino eszközünk számára a kódunkat, és evvel töltjük fel rá az utasításainkat is.Tartalmaz a program súgót, és mintakódokat , stb. is.
Ha windows-od van, akkor a tömörített állományt ajánlom, amihez nem kell admin jog (non admin install). Bárhová letöltöd ahol megtalálod, majd kibontod, majd az arduino.exe fájlt elindítod! Ha valami hiba van, ismételd meg a telepítést. Ha az arduino.exe fájlra jobb egérgombbal rákattintasz majd a küldés, az asztal (parancsikon kiválasztása), akkor az asztalodra teszi parancsikont, onnan mindig el tudod indítani a szoftvert, nem kell a mappába kikeresni az exe. fájlt.

Arduino eszközünk telepítése:
Mivel nekem NANO eszközöm van, és mert abból egy csomó láb kiágazik, először beledugtam a soklyukas próbapanelbe, hogy ne érjen hozzá semmihez, majd a számítógépem  egyik USB-jéhez csatlakoztattam. A NANO amúgy is úgy lett tervezve, hogy próbapanelbe kell dugni. Jegyezd meg, hogy melyik USB csatlakozóba teszed bele először, mert azt fogod majd beállítani, és a későbbiekben is azt kell majd használni.
Ha UNO-d van, akkor  is érdemes szerintem figyelni rá. hogy ne nagyon érjél hozzá a kivezetésekhez, alkatrészekhez, ugyanis annyit tudni érdemes a chipekről, hogy a statikus feltöltődés tönkreteheti őket. Bár nekem úgy tűnik evvel senki nem törődik, de szerintem érdemes a számítógéped házán lévő csavarhoz, vagy a fűtőtesthez érned először, és ott levezetni az esetlegesen a pulóveredtől  származó feltöltődésedet, mielőtt az Ardinoval elkezdesz játszani.

Dugaszolós próbapanel:
Ezt arra találták ki, hogy ne keljen forrasztanod, és egyszerűen, gyorsan tudjál áramköröket, alkotni, illetve áramköri elemeket összekötni.
Én egy Arduino Nano-t szereztem be, mivel ez volt a legolcsóbb, és mert tetszett, hogy csak bele kell dugni a próbapanelbe, és így nagyon könnyen, és egyszerűen lehet vele tanulni.
Amikor aztán ténylegesen bele akartam nyomni, nemigen sikerült, gondolom a nem túl jó  minőségű olcsó panel miatt, de persze lehet béna vagyok. Valamennyire bele ment, de a villogó kipróbálásánál kiderült, hogy jó néhány lábnál érintkezési (kontakt) hiba van.  Végül arra jutottam, hogy a legegyszerűbb, és leghatékonyabb megoldás az, ha a próbapanel hátulját lehúzom, kiszedem az érintkezőket azon a helyen, ahová a soklábas Arduino Nano kerül, majd a próbapanelbe belenyomom, majd az érintkezőket nyomogatom vissza egyesével a próbapanelbe.

 Így a chip lábai teljes mélységébe belekerültek a dugaszolós próbapanelbe,

és megszűnt a kontakthiba! Ha óvatosan tépted le a próbapanel hátát, akkor vissza is tudod ragasztani, ha ez nem sikerült, akkor szigetelőszalag csíkokkal fedd le a fémcsíkokat.

Általában ilyen próbapanelt adnak az Arduino csomagokhoz:

A zöld vonalakat én rajzoltam rá, ezekkel mutatom, hogy a lyukak hogy vannak benne összekötve. Persze ha leszeded az alját látni lehet az érintkezők fémcsíkjait, és hogy a lyukak hogy vannak összeköttetésben:

Ha Arduino Nano eszközöd van, akkor úgy nyomd bele, hogy egyik lábát sem zárod rövidre, azaz, minden lába külön fémhez van kötve. Vagyis a panel hosszanti szélére, úgy, hogy az Arduino Nano USB csatlakozása kifelé néz, és a közepére, hogy a lábak ne legyenek egymással kapcsolatban. Szerintem az a jobb, ha a D6,D7,D8 stb. lábak oldalánál marad több lyuk(3).

Csatlakoztatás a számítógépre: A számítógép, ahogy csatlakoztatod, rögtön telepíti a hardvert, de windows 7 és 8 alatt a netről magától lehúzza a szükséges drivert. XP alatt lehetséges, meg kell kerestetni vele, esetleg meg kell mutatni neki.
Ez a következőképpen történik XP operációs rendszerben:

Megjelenik az új hardver varázsló, amikor csatlakoztatod. A LED-ek az eszközön világítanak, egy zöld folyamatosan, egy piros pedig másodpercenként villog.
Én a hardvervarázslóval nem jártam valamiért sikerrel, így azt lekapcsoltam. Helyette a Start menü, majd Jobb gombbal Saját gépre, majd Eszközkezelőre érdemes szerintem kattintani. Ott a portoknál megjelenik egy sárga kérdőjel. Az azt jelenti, hogy az a mi Arduino eszközünk, de nincs hozzá driver. Ekkor jobb egérrel rákattintunk, és az illesztőprogram frissítése gombbal, 1-2 perc alatt megtalálja a drivert, telepíti, majd a sárga kérdőjel helyére beírja, hogy USB Serial Port (COM3).

(Nekem win7 és 20 éves pc alól egy usb driver hibát írt ki. Ezt telepítettem:
http://www.ftdichip.com/Drivers/VCP.htm
 a táblázatban a setup változatot, Elindít, kibont, telepít és kész. nem cifráztam, megoldotta a problémát)
Lehet ez is segít:
http://www.hobbyist.co.nz/?q=uno_driver_installation

Most próbáljuk ki, hogy működik! A C++ programozási nyelv egy célspecifikus változatát fogjuk használni:

Az Arduino szoftver magyarul nyitódik meg, és sketch_mar27a néven ez a kódrészlet jelenik meg:

void setup() {
  // put your setup code here, to run once:

}
void loop() {
  // put your main code here, to run repeatedly:

}



Most a fenti kódot ne is elemezzük, helyette először csináljuk meg a beállításokat:

Az Eszközök (tools, ha nálad angol lenne) menüben válasszuk ki, az Alaplap almenüben azt az eszközt, amivel rendelkezünk. Én NANO-val...
Majd a Port almenüben azt a soros portot válasszuk ki, amelyet telepítettünk, nálam a COM3 volt.

Ezután most cseréljük ki a villogtató próbakódot:
A piros LED-ünk a készüléken másodpercenkénti periódussal villog, tehát már alapból rajta van ez a program. Kattints a fájlmenüre, példák almenüre, majd 01. Basic almenüben válaszd ki a Blink példakódot.
A kódban az 1000 milliszekundumot írd át 100-ra. Ettől gyorsabban fog a piros LED-ünk villogni, bizonyítva, hogy lecseréltük a programot. Most pedig nyomj rá a feltöltés gombra, a pipa mellett, a jobbra néző nyilat tartalmazó gomb. Most kicseréltük az új kódra a programot, és a piros LED sokkal gyorsabban villog.
Amikor éppen a programot küldöd az Arduinora, akkor nem szabad közben levenned, megszakítva a folyamatot.
Ha viszont már fut a program, akkor már leszedheted az USB-ről, majd amikor vissza csatlakoztatod, akkor tápfeszültséget kapva, és megjegyezve a programot amit rátöltöttünk, azt fogja futtatni újra.

Feltöltés-építés:
Nekem az logikus, bár sehol nem olvastam, ha először az üres Arduinora hardverünkre feltöltjük a programot, majd levesszük a számítógépről (az elektromos tápellátásról), utána építjük ki az áramkört, és visszarakjuk a tápra (USB-re). Ekkor néhány másodperc után már adnia kell azt, amit korábban feltöltöttünk rá.

Pin-ek:
Most ami fontos nekünk, a kivezetések (NANO esetében lábak), amiket pin-eknek hívnak.
Ezek közül is, a digitális pin-ek. NANO esetében D-vel van számozva:
A NANO esetében a D0 az RX1 és a TX1 a D1.
Ez pedig az UNO:
Amint látod, az UNO és a NANO nagyjából ugyanaz...

Kimenet-bemenet:
Ezek a kivezetések működhetnek kimenetként (output), vagy bemenetként (input). Így is hívják őket I/O pin-ek... 
Kimenet, amikor a LED-et vezéreljük, és adunk neki feszültséget, vagy sem. 
Bemenet, amikor a érzékelőként használjuk, és érzékeli, hogy kap feszültséget, vagy nem kap.

Példaprogramon keresztül, ahol kettő LED-et fogunk villogtatni.
void setup() {                
  pinMode(13, OUTPUT);    
  pinMode(12, OUTPUT);      
}

void loop() {
  digitalWrite(13, HIGH);
  delay(1000);
  digitalWrite(13, LOW);
  delay(1000);

digitalWrite(12, HIGH);
  delay(1000);
  digitalWrite(12, LOW);
  delay(1000);
}

Mit csináltunk? A void setup résszel kezdtünk, és beállítottuk, hogy a 13-as, és a 14-es lábakat (kivezetést) kimenet módban (OUTPUT) akarjuk használni. Tehát egy áramkörhöz, ami például egy LED-et is tartalmaz tápfeszültséget biztosítunk, és azt ki-be kapcsoljuk. 
Ezután, a void loop részben. a 13-as, és a 12 es kivezetéshez (lábakhoz) írjuk a parancsokat.
digitalWrite(13, HIGH); A write itt megint azt jelenti, hogy itt most tápfeszültséget fogunk ki-be kapcsolgatni valami számára, azaz bit-eket írunk. A High (magas) Azt jelenti, hogy logikailag magas állapotban van a kivezetés, ami bit értéken 1-nek felel meg, vagyis a tápfeszültséget kapcsoljuk, a rajta lévő LED világítani fog.
A  delay(1000); A delay várakozást jelent, azt is megmondjuk, hogy 1000 mikroszekundum, azaz 1 másodpercig várjon a program, és csak utána lépjen a következő parancsra. A delay értéke minimum 1, azaz a másodperc egy ezred értéke lehet, a maximális pedig 65535, azaz kicsivel több, mint 65 másodperc lehet. 
A digitalWrite(13, LOW); -nál az új elem az, hogy itt magas helyett LOW, vagyis alacsony logikai szint van, vagyis bit értéken 0, tehát kikapcsoljuk a tápfeszültséget, a LED nem világít.
Az után a program egy újbóli egy másodperces várakozás után a következő kivezetés be-ke kapcsolására tér rá, majd amikor a végére és a kódnak a loop (hurok) parancs miatt újra és újra kezdi elölről a kód végrehajtását.

Most kössük rá a  két LED-ünket:
Először a 13 -as láb áramkörét alakítsuk ki! Kössük rá a 13-as kivezetésre az egyik LED-et. Mint írtam a LED az egyik irányba vezeti csak az áramot. A LED hosszabb lába megy a 13-as kivezetésére, majd az áramkörünk kössünk be egy ellenállást. Az ellenállás és a LED helye felcserélhető, nem számít a sorrendje. 
Az ellenállás azért kell, mert ha túl nagy áram éri a kivezetésünket, akkor az károsodhat. A tápfeszültségünk alapból 5V, de ebből le kell  vennünk. Tehát a lábat nem szabad egyből a földhöz kötni, vagyis nem szabad ellenállás nélküli áramkört csinálni, más néven nem szabad rövidre zárni. 
Az ellenállás értéke 220ohm és 1kohm között legyen. A tápfeszültség 5V, a LED-en kb. 1,2 V feszültség esik, így az ellenállásra 3,8V kerül. A 3,8 V-tal mindenféle típusú LED világít, de a kivezetésünket se éri nagy áram. Az ellenállásról pedig kössük rá az áramkörünket a földre, aminek GND (ground=föld) a jelölése az Arduinón. Minden LED-hez ugyanolyan értékű ellenállás használjunk. 

Most elkészült az első áramkörünk, és a programmal villogtatni tudjak a LED-einket. És még a többi D jelzésű lábakat is felhasználhatod, tehát jó sok LED-et tudsz vezérelni. 
Kapcsolódó videók ehhez a leckéhez:

További info:
Minden pin-hez a házban  kötve van egy 20-80 kohm értékű ellenállás. Ezt felhúzó ellenállásnak nevezik. Ezeket az ellenállásokat amikor a láb bemenetre van állítva akkor be vagy ki lehet kapcsolni úgy, hogy HIGH vagy LOW értéket írunk rá. 
Például: 

 pinMode(12, INPUT); 
// a 12-es láb bemenetre van kapcsolva
digitalWrite(12, HIGH);
// és a HIGH -jal bekapcsoljuk a felhúzó ellenállást

A felhúzó ellenállásra azért van szükség, mert ha túl nagy áram van a lábon, akkor az tönkre teheti azt. 
Amikor kimenetként használjuk, akkor is 220ohm-1kohm közötti ellenállást kössünk be, az áramkörbe. Az első áramkörünkbe is ezért kötöttünk a LED-ek mellé ellenállásokat. 
-----------------------------------------------------------------
2. project
Egy hét szegmenses kijelzőt számoltassuk visszafelé 9-től nulláig, ismételgetve.
Info: Kétféle hétszegmenses kijelző van, amelyiknek közös az anódja, és amelyiknek közös a katódja. 
A közös katódú jobb, mert ahhoz csak egy ellenállást kell használni.
Én ilyet kaptam a csomagba: DNZ 5611A5, ez közös katódú.

Ha nem tudod neked milyen van, egyszerűen megnézheted:
Például két 1,5 V-os ceruzaelemet sorbakapcsolva, azaz 3V-tal a hármas, vagy a nyolcas (ezek közös lábak), és az 5-ös lábára ráérintesz (az a kijelzőn a kis pont LED-je lesz). Ha akkor villan fel, amikor az elem pozitív vezetékét tetted a kijelző 5-ös lábára, és a negatívat a 3-asra, akkor közös katódú, az kell nekünk. 

Ha fordítva, akkor a benne lévő LED-ek fordítva vannak bekötve. Ha az anód a közös, akkor minden egyes lábhoz, mielőtt az arduino adott D kivezetésével összekötöd, közbe kell iktatnod egy külön ellenállást, vagyis akkor nyolc ellenállásra lesz szükséged, viszont nem kell közbeiktatnod a föld elé.
 Fent említettem, hogy milyen értékű ellenállás használunk az Arduinon egy LED-hez, azaz 220ohm és 1kohm közöttit. 

 De most nézzük azt a szerencsésebb esetet, hogy közös katóddal rendelkezel, és csak egy ellenállás kell, a földelés elé iktatva!
A rajzon be is kötöttem az Arduino a D2-es kivezetését,  a kijelző 7. lábára, ami az "A" jelzésű ledet fogja be-ki kapcsolgatni.
Az Arduinon valamelyik föld (GND-jelzésű) lábát a kijelző 3-as, vagy 8-as lábra (tehát valamelyik üresen marad) kösd, de itt iktass közbe egy 220ohm és 1kohm közötti értékű  ellenállást!



Az Arduino többi lábát így kösd be: 
Az Arduino 3. lábát kösd, a kijelző 6-os lábára,
Az Arduino 4. lábát kösd, a kijelző 4-es lábára,
Az Arduino 5. lábát kösd, a kijelző 2-es lábára,
Az Arduino 6. lábát kösd, a kijelző 1-es lábára,
Az Arduino 7. lábát kösd, a kijelző 9-es lábára,
Az Arduino 8. lábát kösd, a kijelző 10-es lábára,
Az Arduino 9. lábát kösd, a kijelző 5-ös lábára,

Ez után nyisd meg az Aurdino programodat, töröld ki azt a kódot, ami benne van, másold be az alábbit, majd kösd össze az Aurdino-dat a számítógépeddel, ezután pár másodpercet várj, és nyomd meg a feltöltés gombot. Amikor  a program feltölti az Aurdinodra a kódot, akkor azon a kijelző visszafelé fog számolni, és ezt ismételgeti. Itt a Kód:

void setup() {               
  pinMode(2, OUTPUT);  
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  digitalWrite(9, 1);  
}

void loop() {
 digitalWrite(2, 1);
 digitalWrite(3, 1);
 digitalWrite(4, 1);
 digitalWrite(5, 0);
 digitalWrite(6, 0);
 digitalWrite(7, 1);
 digitalWrite(8, 1);
 delay(1000);

 digitalWrite(2, 1);
 digitalWrite(3, 1);
 digitalWrite(4, 1);
 digitalWrite(5, 1);
 digitalWrite(6, 1);
 digitalWrite(7, 1);
 digitalWrite(8, 1);
 delay(1000);

 digitalWrite(2, 1);
 digitalWrite(3, 1);
 digitalWrite(4, 1);
 digitalWrite(5, 0);
 digitalWrite(6, 0);
 digitalWrite(7, 0);
 digitalWrite(8, 0);
 delay(1000);

 digitalWrite(2, 1);
 digitalWrite(3, 0);
 digitalWrite(4, 1);
 digitalWrite(5, 1);
 digitalWrite(6, 1);
 digitalWrite(7, 1);
 digitalWrite(8, 1);
 delay(1000);

 digitalWrite(2, 1);
 digitalWrite(3, 0);
 digitalWrite(4, 1);
 digitalWrite(5, 1);
 digitalWrite(6, 0);
 digitalWrite(7, 1);
 digitalWrite(8, 1);
 delay(1000);

 digitalWrite(2, 0);
 digitalWrite(3, 1);
 digitalWrite(4, 1);
 digitalWrite(5, 0);
 digitalWrite(6, 0);
 digitalWrite(7, 1);
 digitalWrite(8, 1);
 delay(1000);

 digitalWrite(2, 1);
 digitalWrite(3, 1);
 digitalWrite(4, 1);
 digitalWrite(5, 1);
 digitalWrite(6, 0);
 digitalWrite(7, 0);
 digitalWrite(8, 1);
 delay(1000);

 digitalWrite(2, 1);
 digitalWrite(3, 1);
 digitalWrite(4, 0);
 digitalWrite(5, 1);
 digitalWrite(6, 1);
 digitalWrite(7, 0);
 digitalWrite(8, 1);
 delay(1000);

 digitalWrite(2, 0);
 digitalWrite(3, 1);
 digitalWrite(4, 1);
 digitalWrite(5, 0);
 digitalWrite(6, 0);
 digitalWrite(7, 0);
 digitalWrite(8, 0);
 delay(1000);

 digitalWrite(2, 1);
 digitalWrite(3, 1);
 digitalWrite(4, 1);
 digitalWrite(5, 1);
 digitalWrite(6, 1);
 digitalWrite(7, 1);
 digitalWrite(8, 0);
 delay(4000);
}

A kód magyarázata:
A setup részben megadjuk melyik lábakat fogjuk használni, és hogy kimenetként. 
A kijelző 5-ös lábát (ami a pont), amit az Arduino 9-es lábára kötöttünk nem vezéreljük, az nem világít! Ha átírjuk 1-re a kódban, akkor viszont folyamatosan világítani fog!

A loop részben láthatod, hogy 10 egység van, a 0-tól a kilencig lévő számparancsok. Minden egységben a kijelző hét LED-ét kapcsolgatjuk ki be. A LED-ek az Aurdino 2-től a 8-as lábain vannak vezérelve. A nulla az adott LED lekapcsolását, az 1 a felkapcsolását jelenti. Az adott számhoz tartozó LED-eket az egységbe nem egyszerre kapcsoljuk, mint a párhuzamos vezérlésnél, hanem egymásután, de ha jól értelmezem, az Arduinoba a puffermemória összegyűjti a 7 bites utasításcsomagot, és azután már egyszerre hajtja végre. A Delay az egységek, vagyis a számok kiírása közötti várakozási idő, ami 1000 milliszekundum, azaz 1 másodperc. 

3.project Bemenet 
A nagy átverés?
Csináljunk egy olyan áramkört, ahol érzékeljük, hogy egy kapcsoló be van-e kapcsolva, vagy sem, és egy másik áramkört vezéreljünk vele.
Először az 5 képen látható "A" jelzésű áramkört csináljuk meg!

Az R6-os ellenállás kb. 4,7kohm körül legyen, a LED-hez tartozó ellenállás pedig a hozzá szokásos, 220ohm és 1kohm közötti értékű. Kapcsolónak most ne használjunk semmit, csak a két vezetéket (a végükön a tűket) érintsük majd össze, illetve. válasszuk majd szét!
Az aurdio szoftveren keresztül ezt a kódot töltsük rá:

void setup() {
pinMode(6, INPUT);
digitalWrite(6, HIGH);
pinMode(13, OUTPUT);

void loop(){
if (digitalRead(6) == LOW) {
digitalWrite(13, LOW);
} else {
digitalWrite(13, HIGH);
}
}

Próbáld ki, ahogy a vezetékeket összeérinted, vagy szétválasztod, a LED aszerint reagál.
Ezt az alap áramkört mindenhol alap úgy magyarázzák, hogy a D6-os láb, mivel hogy bemenetnek van beállítva (mellesleg a belső felhúzó ellenállása is be van kapcsolva) nem áramforrás, hanem az +5V az áramforrás, és amikor a kapcsolóval a föld felé zárjuk az áramkört, akkor az elektronok inkább a föld felé mennek, mert a bemeneti lábon belül a házban be van kapcsolva a felhúzó ellenállás, és az elektromosság arra megy, amerre kisebb az ellenállás, vagyis a föld felé, a bemeneti lábon így alig van feszültség, amikor zárjuk a vezetékeket. 
Ez a magyarázat így ebben a formában bizonyosan nem igaz, ezt bizonyítja a "B" jelzésű áramkör!
Csináld meg azt is, a programkódot nem kell kicserélned. Most teljesen elválasztottuk a két áramkört, A LED, és a kapcsoló áramkörét, és a bemeneten nincs +5V, a beállítása ugyanaz mint előzőleg, mégis ugyanúgy működik az effekt!
Arra gyanakszom, hogy a  bemenet valójában szintén kimenet..
Eleve hülyeség az, amikor azt írják, hogy az elektronok a pozitív pólustól áramlanak! Sajnos, amikor felfedezték az elektronikát, akkor ezt hitték, és csak később jöttek rá, hogy fordítva van. Ezért kétfajta áramirány van.
Technikai áramirány: a pozitív pólustól a negatív pólus irányába (a villamos szakmák hagyományosan ezt használják, rajzokban, magyarázatokban)
A fizikai, valós áramirány: a negatív pólustól a pozitív pólus irányába (az elektronok valós haladási iránya).
Talán ez okozza a keveredést? Majd utánajárunk! 

Egy kis elmélet:
Setup rész. 
Ebben a részben a beállításokat adjuk meg:
 A chip bekapcsolásakor minden  kivezetése bemenet, de ettől függetlenül meg kell adni melyiket minek szeretnénk használni!
Pl:

void setup() {

 pinMode(12, OUTPUT);
        // 'pin' kimenette valik

}

A kimenetek logikai magas (High) vagy alacsony (Low) állapotban lehetnek.
Ha a kivezetést kimenetként (output) állítjuk be, akkor az alacsony ellenállású kivezetésként viselkedik, és 40 mA árammal képes meghajtani az ide csatlakoztatott áramkört. Ez elegendő egy LED és az áramkorlátozó soros ellenállása meghajtására, de kevés a legtöbb relé, motor tápellátására! Ha rövid zárral vagy túl nagy árammal túlterheled a kimenetet, akkor  az  tönkreteheti ezen részét, vagy az egész chipet is! A legtöbb esetben ezért javasol a soros 220 ohm...1 kohm ellenállás beépítése.

void setup() {

pinMode(10, INPUT);
        // 'pin' bemenette valik
digitalWrite(10, HIGH);
        // felhuzoellenallas bekapcsol

}

Minden bemeneten a chippen belül egy kb. 20..80 kohm-os felhúzó-ellenállás van beépítve (a kivezetések és a tápfeszültség között), melyek ki-/bekapcsolhatóak.
Amikor a lábakat bemenetre vannak állítjuk, akkor a HIGH kiírással kapcsolható be a felhúzó-ellenállás:

Loop:
Ebben a részben egymás után az utasításokat adjuk meg, amit a program sorrendben végrehajt, és ezt folyamatosan ismétli (loop = ciklus, hurok)
PL:

void loop(){

    digitalWrite(12, HIGH);
        // a 12 magas szintű, vagyis bekapcsoljuk az ide kötött áramkört
    delay(l000);
        // majd egy másodpercig várakozik a program
    digitalWrite(pin, LOW);
        // a LOW-val kikapcsoljuk az áramkört
    delay(l000);
        // megint egy másodperc várakozás

}

delay(value):
 A  várakozás értéke minimum 1, a maximum  65.535 (kb. 65 sec) lehet.

Változók:
int inputVariable = 10;
  // így definiáljuk: int majd változónév és megadtuk az értékét,
A void setup() sor előtt kell, létrehozni, ha a változót az egész programba, globálisan akarod használni. Ha csak egy részprogramban, akkor elég a blokknak az elején definiálni!

Változók típusai:

Byte vagy Char:
Byte/Char típusban 8-bites egész számértéket tárolhatunk, azaz 0-255 közötti értéket vehet fel.
byte someVariable = 180;
  // byte definiálva, 180-as kezdeti ertekkel

Integer:
Egész vagy más néven integer típusú változóban egész számot tárolhatunk 16 biten (2 byte-nyi helyen), melynek értéke -32.768 és +32.767 közé esik.
int someVariable = 1500;
  // intrger, 1500-as kezdoertekkel

Long:
Bővített méretű adattípus az ún. long (long integer : kb. hosszú egész). Az adattípus egész számok tárolására alkalmas 4 byte (32 bit) lefoglalásával. A tárolható számérték  -2.147.483.648 és 2.147.483.647 közé esik.
long someVariable = 90000;
  // long tipus, 90000 kezdettel

Float:
A lebegőpontos (float) adattípus tizedes-törtek tárolására is alkalmas. Sokkal nagyobb számtartomány lefedésére megfelelő, mint az integer (egész) típus. A float típus értéke  -3.4028235E+38-tól -3.4028235E+38-ig terjed, 4 byte helyet foglal. A leírásában a tizedes törtet mindig ki kell írni! Ha egy változó értékének például 2.0-t adunk az float lesz. Ha 2-t, akkor valamely egész típusú (nem lebegőpontos).
float someVariable = 3.14;
  // a valtozo erteke 3.14
Fontos! A lebegőpontos számok nem mindig pontosak. A tizedes-törtek tört része (is) 2-es számrendszerben kerül ábrázolásra! (például a 1/3 sem ábrázolható a 10-es számrendszerben.) A lebegőpontos számokkal való matematikai műveletek is lassabbak, mintha az egész (int) típussal végeznénk. Erre - főleg sok számolást tartalmazó program esetén - figyelni kell!

Tömb:
A tömb nem más, mint értékek/számok gyűjteménye, melyeket az ún. index számán (kb. sorban elfoglalt helye) érhetünk el. A tömb bármely elemét meg lehet így címezni. A tömb indexelése a 0. azonosítóval kezdődik. A tömböt - a többi változóhoz hasonlóan - használat előtt deklarálni kell és lehetőség szerint a kezdőértékkel feltölteni.
int myArray[] = {value0, value1, value2...}
Látható, hogy a tömb deklarálásakor meg kell adni a típusát, méretét és opcionálisan az elemeit.
int myArray[5];
  // tombot definialunk 0..4 indexekkel
myArray[3] = 10;
  // a negyedik elem erteke 10
Az első lépésben definiálunk egy 5 elemű tömböt, majd ennek 4. eleme a 10-es értéket kapja (Jegyezd meg: a tömb elemszáma: 0...4 indexelhető (5 db elem)!)
Kiolvasni a tömb adott elemét és ezt egy változó értékének átadni az indexszámmal azonosítva lehetséges:
x = myArray[3];
  // x erteke 10

Igaz/Hamis (True/False):
Ezek a logikai konstansok logikai szinteket (is) jelentenek. Hamis (False) meghatározása egyezik a 0-val, míg az Igaz (True) gyakran 1-ként definiálódik. Azonban a logikai igaz bármely értéket felvehet a 0-t kivéve! Így a logikai konstans (hívják Boolean-nak is) értéke, ha -1, 2 és akár a 200 mind True-nak definiálódik…

if (b == TRUE); {
        doSomething;
    }

Magas/Alacsony (High/Low)

Ezek a konstansok a chip kivezetések (angolul: pin) állapotát  jellemzik. Magas (High) a lábon közel a tápfeszültség mérhető, míg alacsony (Low) esetén GND. Ha a kivezetés kimeneti állapotát írjuk, akkor is a High/Low értéket használjuk, de amikor visszaolvassuk, hogy milyen állapota van, akkor is High illetve Low értéket kapunk vissza. A High logikai 1-ként definiálódik, a Low pedig logikai 0-ként. A kód már ismerős lehet:

digitalWrite(13, HIGH);

 Túlcsordulás

Változók esetén ún. túlcsordulással is számolnunk kell. Példaként a byte típust használjuk. Ekkor, ha az értékét folyamatosan növeljük, a legnagyobb érték után a legalacsonyabbat kapjuk! Illetve csökkentéskor a legkisebb után a legnagyobbat. Például, ha x = 255 és ehhez hozzáadunk egyet (programban: x=x+1 vagy x++), akkor az eredmény nem 256, hanem 0!
Oka:
 1111.1111    255
+ 0000.0001   + 1
 1.0000.0000      0! (8 biten, mivel a 9. bit elveszett)
(a központozás az olvashatóságot szolgálja)
Ugyanilyen túlcsordulás minden változótípusra igaz, csak ott a határok kitolódtak.

Feltétel:

A feltétel is egyszerű, logikai művelet:
    - A kisebb, mint B: A<B
    - A nagyobb, mint B: A>B,
    - A egyenlő B-vel: A==B,

    - A nemegyenlő B: A !=B.

If (feltétel) {
Igaz utasitasok;
} else {
Hamis utasitasok;
}

Az else rész elhagyható!

Ciklusok:
For:
for (long i=0; i=temp1long; i++) {..}, ahol:

i: ún. ciklusváltozó, ez az ami a számolást végzi,
long i: a ciklus létrehozásakor megmondjuk jelen esetben, hogy a ciklusváltozó long típusú (előjel nélküli hosszú egész). Ha nem definiáljuk itt, akkor a ciklus előtt valahol definiálni kellene korábban (különben úgyis hibaüzenetet kapunk). Fontos! Törekedjünk arra, hogy ha egy változót másutt is használtunk, akkor belsőbb részen ne definiáljuk újra! Igen misztikusak azok a hibák, ha a teljes programra vonatkozóan (pl. void setup() előtt) a ciklusmagot byte-ként már definiáltuk, a ciklusban ugyanígy i-t definiálunk, csak long-ként. Most a fordító mit vegyen alapul a ciklus közepén?
A ciklusváltozó bármilyen értékű lehet (csak a számolás férjen bele az általa lefedett tartományba). Azonban nem szám (pl. szöveglánc (ún. string), logikai változó (ún. boolean)) nem lehet és szintén nem lehet konstansként sem definiálni!
i= : itt adható meg, hogy a számolásnak mi legyen az indulóértéke,
i == temp1long: ez a feltétel mondja meg, hogy meddig számoljak. De ez lehet persze a következő is: i >= temp1long. Csak az i értéke egyesével nő és így félrevezető a végpont feltétele,
i++ : a ciklusban a lépés egyesével nőjön. Az aritmetika leckében volt ez a rövidítés. Ez nem jelent mást, mint: i= i+1.
A for() ciklusok a C nyelvben és leszármazottaiban nagyon rugalmasan kezelhetőek. Nézd meg a következő programot:
for(int x = 2; x < 100; x = x * 1.5){
  println(x);
}

Számlálóval (do-while):
/*  Beep parameterekkel
    Do-While megkozelites
    60 nap alatt arduino tanfolyam
    (c) TavIR http://www.tavir.hu  */

      //varakozas a jelvaltasnal
    unsigned int var=2000;
      //ennyi ideig szoljon
    unsigned long tartam=200000;
      //segedvaltozo
    unsigned long temp1long;
      //melyik labon a csipogo
    #define Speaker 10

void setup() {
      //hangszoro kimeneti labon
    pinMode(Speaker, OUTPUT);
  }

void loop() {
        //ennyi darab impulzust kell kiadni
    temp1long=tartam/(var*2);
        //do: ismeteld
    do {
        //hangszoro alacsonyra
      digitalWrite(Speaker,LOW);
        //varakozas valtas kozt
      delayMicroseconds(var);
        //hangszoro magasra
      digitalWrite(Speaker,HIGH);
        //varakozas valtas kozt
      delayMicroseconds(var);
      temp1long = temp1long-1;
        //while: amig a feltetel igaz
    } while (temp1long != 0);
        //10 sec szunet
    delay(10000);
        //utana kezdjuk ujra
}

Számlálóval (while):
/*  Beep parameterekkel
    While megkozelites
    60 nap alatt arduino tanfolyam
    (c) TavIR http://www.tavir.hu  */

      //varakozas a jelvaltasnal
    unsigned int var=2000;
      //ennyi ideig szoljon
    unsigned long tartam=200000;
      //segedvaltozo
    unsigned long temp1long;
    unsigned long temp1int;
      //melyik labon a csipogo
    #define Speaker 10


void setup() {
      //hangszoro kimeneti labon
    pinMode(Speaker, OUTPUT);
  }

void loop() {
        //ennyi darab impulzust kell kiadni
    temp1long=tartam/(var*2);
       //ismeteld, amig a feltetel igaz
    while (temp1long != 0) {
        //hangszoro alacsonyra
      digitalWrite(Speaker,LOW);
        //varakozas valtas kozt
      delayMicroseconds(var);
        //hangszoro magasra
      digitalWrite(Speaker,HIGH);
        //varakozas valtas kozt
      delayMicroseconds(var);
      temp1long = temp1long-1;
    }
      //10 sec szunet
    delay(10000);
      //utana kezdjuk ujra
}

Nagyon fontos! A do {..} while(feltétel); az úgynevezett hátultesztelő ciklus, a while (feltétel) {..} megoldást pedig elöltesztelő ciklusnak hívjuk. A nagyon nagy és lényegi különbség, hogy a feltétel hol kerül ellenőrzésre! Az első mintában a ciklusmag (a középső rész) egyszer mindenképp lefut, míg a második esetben a ciklusmag lefutása előtt történik meg a kilépési feltétel ellenőrzése (és persze a ciklusmag után (átlépésével/kihagyásával) folytatódik a program futása!

Boolen:

Nagyjából ez a programnyelv! Itt az egész:
Ez a rész hamarosan jobban meg lesz szerkesztve!
--------------------------------------------------

4.Project Számoló
Az előző áramkörök bármelyikével ("A" vagy "B")  használjunk az elméleti részből egy kicsit több programozást is! Tölts fel az alábbi kódot! Amikor több, mint 3-szor választod szét a vezetékeket, akkor a program azt számolja, és negyedikre világítani fog a LED. Próbáld ki! A vezetékeket úgy próbáld összeérinteni, hogy tényleg határozottan összenyomod, és szétválasztod, és nem csinálsz súrlódást. Ha nem így teszel, akkor mivel az Arduino nagyon gyors működésű, a súrlódást, illetve a kézremegésedet is kapcsolgatásnak fogja számolni, miközben nem érted, hogy te csak kétszer érintetted össze a vezetéket, és miért kapcsolt már be a LED. Ezt a jelenséget hívjuk Perlegésnek. A kapcsolóknál is megfigyelhetjük ezt, mert nem csak a kezed remeg, hanem még azok is. Erről majd a következőkben lesz szó. Most nézzük a kódot, töltsd fel, és próbáld ki:

int allapot = 0; 
int mennyiseg = 0;
int ertek = 0;
int indulasm = 0;

void setup() {
pinMode(13, OUTPUT);  
pinMode(6, INPUT); 
digitalWrite(6, HIGH);
}

void loop(){
allapot = digitalRead(6); 
if (allapot == HIGH) { 
ertek = 1;
}

else {
ertek = 0;
}


if(ertek != indulasm){
if(ertek == 1){
mennyiseg = mennyiseg + 1;
}
}

if(mennyiseg > 3){
digitalWrite(13, HIGH);
} else {
digitalWrite(13, LOW);
}

indulasm = ertek;
delay(250);
}

Egy kis magyarázat a kódhoz: 
Először is, ez a kód már hajlik a gyakorlatilag is értelmes alkalmazhatóság felé. Én biztonsági őr vagyok, és a munkám jelentős részét teszi ki, hogy rendezvényeken a katasztrófavédelmi létszámot betartsuk. Vagyis van egy szám, amelynél többen nem mehetnek be a rendezvény területére. Így a kódban a mennyiség egy rendezvény területén lévők létszáma, amely ha eléri a négy főt, kigyullad a LED, figyelmeztetve engem, a biztonsági őrt, hogy több embert nem engedhetek be. 
A kapcsoló áramkörét, így fogjuk fel úgy, mintha fénykapu lenne, Ha valaki megszakítja az áramkört (fényt) azt számolja. A kódban az if feltételben az if feltétel azért van, mert ha csak egyszerű feltétel lenne, akkor a bekapcsolásokat számolná a szerkezetünk, nem a megszakításokat...

Infraredes számláló:
 Tovább fejlesztve, kicsit, adjuk hozzá a hétszegmenses kijelzőt. 
Csináld meg a fentebb leírt 7 szegmenses kijelzőt, annyi különbséggel, hogy az arduino 9. lábat nem kötöd be, hanem ezen a képen szereplő plusz két áramkört is kialakítod:
A vevő körében az ellenállás a szokásos kb. 4,7kohm, az adóéban a szokásos 220ohm-1kohm közötti.
Itt a kód hozzá, ez már számlál 10-ig felfelé!

int allapot = 0; 
int mennyiseg = 0;
int ertek = 0;
int indulasm = 0;

void setup() {
pinMode(2, OUTPUT);  
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
digitalWrite(9, 1);  
pinMode(10, INPUT); 
digitalWrite(10, HIGH);
pinMode(9, OUTPUT);
digitalWrite(9, 1);  
}


void loop(){
allapot = digitalRead(10); 
if (allapot == HIGH) { 
ertek = 1;
}

else {
ertek = 0;
}


if(ertek != indulasm){
if(ertek == 1){
mennyiseg = mennyiseg + 1;
}
}

if(mennyiseg > 9){
 digitalWrite(2, 1);
 digitalWrite(3, 1);
 digitalWrite(4, 1);
 digitalWrite(5, 1);
 digitalWrite(6, 1);
 digitalWrite(7, 1);
 digitalWrite(8, 0);
}

if (mennyiseg == 9) {
 digitalWrite(2, 1);
 digitalWrite(3, 1);
 digitalWrite(4, 1);
 digitalWrite(5, 0);
 digitalWrite(6, 0);
 digitalWrite(7, 1);
 digitalWrite(8, 1);
}

if (mennyiseg == 8) {
 digitalWrite(2, 1);
 digitalWrite(3, 1);
 digitalWrite(4, 1);
 digitalWrite(5, 1);
 digitalWrite(6, 1);
 digitalWrite(7, 1);
 digitalWrite(8, 1);
}

if (mennyiseg == 7) {
 digitalWrite(2, 1);
 digitalWrite(3, 1);
 digitalWrite(4, 1);
 digitalWrite(5, 0);
 digitalWrite(6, 0);
 digitalWrite(7, 0);
 digitalWrite(8, 0);
}


if (mennyiseg == 6) {
 digitalWrite(2, 1);
 digitalWrite(3, 0);
 digitalWrite(4, 1);
 digitalWrite(5, 1);
 digitalWrite(6, 1);
 digitalWrite(7, 1);
 digitalWrite(8, 1);
}

if (mennyiseg == 5) {
 digitalWrite(2, 1);
 digitalWrite(3, 0);
 digitalWrite(4, 1);
 digitalWrite(5, 1);
 digitalWrite(6, 0);
 digitalWrite(7, 1);
 digitalWrite(8, 1);
}

if (mennyiseg == 4) {
 digitalWrite(2, 0);
 digitalWrite(3, 1);
 digitalWrite(4, 1);
 digitalWrite(5, 0);
 digitalWrite(6, 0);
 digitalWrite(7, 1);
 digitalWrite(8, 1);
}

if (mennyiseg == 3) {
 digitalWrite(2, 1);
 digitalWrite(3, 1);
 digitalWrite(4, 1);
 digitalWrite(5, 1);
 digitalWrite(6, 0);
 digitalWrite(7, 0);
 digitalWrite(8, 1);
}

if (mennyiseg == 2) {
 digitalWrite(2, 1);
 digitalWrite(3, 1);
 digitalWrite(4, 0);
 digitalWrite(5, 1);
 digitalWrite(6, 1);
 digitalWrite(7, 0);
 digitalWrite(8, 1);
}

if (mennyiseg == 1) {
 digitalWrite(2, 0);
 digitalWrite(3, 1);
 digitalWrite(4, 1);
 digitalWrite(5, 0);
 digitalWrite(6, 0);
 digitalWrite(7, 0);
 digitalWrite(8, 0);
}

if (mennyiseg == 0) {
 digitalWrite(2, 1);
 digitalWrite(3, 1);
 digitalWrite(4, 1);
 digitalWrite(5, 1);
 digitalWrite(6, 1);
 digitalWrite(7, 1);
 digitalWrite(8, 0);
}

indulasm = ertek;
delay(250);
}

Amikor más kódját elemzi az ember az sokkal nehezebb, mint a sajátot. Azt is érdemes megjegyezni, hogy mindig érdemes konkrét célok felállításával tanulni, mert úgy jobban hasít az ember! Most és a látogatószámláló irányába veszem az irányt, hiszen azt  a munkámba is jól fogom tudni használni...

-----------------------------------------------------------------
További Arduino leckék találhatók ezeken a weboldalakon:
Magyarul:
Angolul:
----------------------------------------------------------------
Példaprojekt:
Ezen az oldalamon, amely egyébként a menüből is elérhető, találsz egy példaprojektet az arduino használatára:



Arduino programozása JavaScripttel:
Ha már a fentiekből eljutottál egy LED villogtatásáig, akkor azt most már megteheted JavaScript segítségével is! Tartsad be a sorrendet, először az arduino saját programjával villogtass, és csak után gyere ide!
A JavaScripttel másképpen működik az arduino hardver, mert csak egy fordítót (firmata?) töltünk rá, nem a vezérlő programot. A vezérlő program a számítógépen fut, ezért amikor az arduino hardvert levesszük, nem tudjuk pusztán tápfeszültséggel ellátva az arduino hardver a számítógéptől függetlenül működtetni! Tehát itt soros kommunikációról van szó, nem a mikróvezérlő felprogramozásáról.
A Node.js a Chrome V8-as Javascript motorja alapján íródott rendszer amivel gyors, és bővíthető hálózati alkalmazásokat írhatunk. Kicsi, de hatékony esemény-alapú (event-driven) blokkolás-mentes (non-blocking) IO modellt használ. Adat-alapú, és valós idejű alkalmazások futhatnak a segítségével.


Első lépés: a NODE.JS telepítése az npm menedgerrel:
(Ha windows XP-d van, innen
https://nodejs.org/docs/v0.10.28/
 le tudod tölteni azt a verziót, mivel az újak már nem támogatják a windows xp-t, ezért kell ezt a régi változatot használni hozzá, mert ez még igen.)

 Ha neked  pl Windows7 32bit van, akkor nem tudom, mert én ezen mindig valamilyen hibát kapok.
:( Azért nem semmi, hogy ilyen szarul csinálták meg a node-npm dolgot...Így nem is fog terjedni, pedig ez többre lenne érdemes...)

Ha xp-d van, akkor a továbbiakban így tovább lehet haladni:

Építsd ki az arduinon a LED-ellenállás áramkört.
Az arduino eszközödön kösd be a 13-as lábra egy LED-et, hozzá sorban egy 220ohm-os ellenállást, majd a GND-re, azaz a földre.Majd csatlakoztasd a számítógépedhez az arduino eszközödet!

Nyisd meg az Arduino programodat! Nyisd meg benne a file, példák, firmata, firmata standard fület. Töltsd fel azt a kódot az arduino eszközödre! Ezután be is csukhatod az arduino programodat, nincs már szükséged rá!

Hozz létre egy mappát a javascript programodnak. 
Én a C meghajtóra csináltam egy progim nevű mappát, ha lehet, kövess, de olyan nevet adsz neki, amilyet akarsz. Abba fogod menteni majd az alább megírt js fájlodat!

Írd meg a javascript programodat!
Nyisd meg a jegyzettömböt (start menü, kellékek)! Másold bele ezt a kódot:

var five = require("johnny-five");
var board = five.Board ( {port: "COM3"} );

board.on("ready", function() {
  var led = new five.Led(13);
  led.blink(500);
});


Ha neked nem a COM3-on van az arduino-d, akkor azt írd a kódba, ahol van!

Mentsd el a programodat js fájlként, olyan néven amilyenen szeretnéd, legyen például led.js, és  előzőleg mondtam, hogy hova mentsd (vagyis a progim mappába)!

Ezután a Parancssor nevű program ablakába fogunk dolgozni. 
Megnyitod a Parancssor nevű programodat a gépeden. Ilyen minden számítógépen van! Command prompt a neve angolul.

A windows gépeken az alábbi helyen található.
A start menü, minden program, kellékek, Parancssor.
Más gépen néz utána hogy tudod megnyitni ( a googe a barátod)!

Ilyesmit kell látnod:
http://1.bp.blogspot.com/-LSa1CURhb7I/TWmdLsjjCGI/AAAAAAAAADc/G4czpUCTHnM/s1600/cmd.jpg
Nem baj, ha neked nem pont az van beleírva, mint amit a képen látsz. Alap esetben amit látsz beleírva, az egy mappa elérési mutatja, de mindenkinek más van alapba beállítva.

Írd be a parancssorba annak a mappának az elérési útját, ahová mentetted a led.js fájlt!
Ha engem követsz, akkor így, és ezt:

cd C:\progim

majd nyomd meg az enter gombot! (Ez a jel. \ az Alt Gr + Q  együtt a két gomb megnyomva írja ki!)
Ekkor, ha nem kapsz hibaüzenetet, akkor annyit ír ki, hogy C:\progim>

Most beleléptél abba a mappába, amelyikben a led.js fájlod van.
Ezután az npm (package manadgereddel kell telepíteni a Johnnyi-five-t, a progim mappádba!
npm install johnny-five

Amennyiben Windows7-tel vagy akkor így telepítsd, különben kiír egy ilyet:
no such file package json
Akkor ezt írd be telepítési parancsnak:


https://youtu.be/GpRRtF3OKWs?list=PLnPkMlQGVnlLf8Luf6UJq29w4TB8Jfyxm

Akár fél percig is úgy tűnhet, hogy nem csinál semmit, de amíg nem írja ki újra a megnyitott mappa elérési útvonalát, azaz hogy C:\progim , addig dolgozik. Amikor viszont megindul kiír egy csomó dolgot.

Most már telepítetted a Johnny-five-t is, majdnem készen vagyunk!

Ezután csatlakoztasd az arduino hardveredet a számítógéphez, azaz USB-vel dugd össze.

Ezután futtasd a fájlodat, és villogtasd a Led-et!
Most ezt a parancsot írd be a Parancssor nevű program ablakába, majd enter gomb:

node led.js

Ekkor a Lednek az Arduino-on villognia kell!

Gratula, JavaScripttel vezéreled az Arduino-t!

Ez után csukd be a Parancssor nevű program ablakát, és a LED is kikapcsol...

Következő:
Írd át a led.js kódot erre:

var five = require("johnny-five");
var board = five.Board ( {port: "COM3"} );

board.on("ready", function() {
  var led = new five.Led(13);
  this.repl.inject({
    led: led
  });

  led.blink();
});

Hívd meg parancssor nevű program ablakából, azaz gépeld be, hogy:

node led.js

Most elkezd villogni...
Most írd de ezt a parancsot:

led.stop()

Majd próbáld ki ezt:

led.off()

és végül ezt:

led.on()

Ahogy látod így tudod ki be kapcsolgatni, és villogtatni!
Amikor lekapcsolod a parancssort, a led égve marad. Ha pedig a led villogásának értéket adsz (pl. 1000)
akkor a  led stop parancsra nem égve marad, hanem lekapcsol.

Sajnos win7 alól nem sikerült a NOD-ot és a részeit megfelelően telepítenem, így egy időre elfelejtem a JavaScriptes vezérlést. Ha valamit szarul csinálnak meg, vagy nincs hozzá megfelelő segítség, nem fogjuk használni, ez van...

Soros kommunikáció (USB-n keresztül) az Arduino-val egy saját magad által megírt (vagy átalakított ;) ) szoftveren keresztül:
A soros kommunikáció valamivel problémásabb, mint a párhuzamos.
 (Apropó, mi van, ha lpt-usb átalakítóval dolgozunk? Elméletileg akkor USB-n keresztül, az átalakító (egy kábel aminek az egyik fele USB, a másik 25 lyukú, és + áramkörök + szoftver ami bele van építve) egy  virtuális párhuzamos portot hoz létre, így elvileg működik. Ki kéne próbálni, kb. 1500 Ft...) .

A mélységeit itt, és most viszont el akarjuk kerülni, a cél, egy módszer elsajátítása, amivel használni tudjuk! Itt találtam azért nektek, egy laikusoknak nem teljesen érthető 9 rövid oldalas cikket, azért talán érdemes átfutni:
https://www.hobbielektronika.hu/cikkek/egyszeru_soros_kommunikacio_avr-rel_uart.html?pg=1

Első feladatban, kapcsolgassunk két LEd-et be-ki egy Visual Basic programmal!
A formra húzz rá négy gombot! Az egyk gombra írd rá, hogy LED1 BE, a másikra: LED2 BE, a harmadikra: LED1 KI, a negyedikre: LED2 KI.
Húzz rá még egy SerialPort-ot is. Az a tulajdonságaiban úgy állítsd be, hogy a port neve az legyen, amit az Arduino szoftverben megadtál, amin keresztül azon kommunikálsz az arduino eszközzel. Nekem COM4.

A visual basicben a gombokat, meg a formot így programozd be! a form1 ben is írd át a COM4-et arra, amely USB csatlakozást te használod!:

Imports System.IO
Imports System.IO.Ports
Imports System.Threading
Public Class Form1
    Shared _continue As Boolean
    Shared _serialPort As SerialPort

    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        SerialPort1.Close()
        SerialPort1.PortName = "com4" 'change com port to match your Arduino port
        SerialPort1.BaudRate = 9600
        SerialPort1.DataBits = 8
        SerialPort1.Parity = Parity.None
        SerialPort1.StopBits = StopBits.One
        SerialPort1.Handshake = Handshake.None
        SerialPort1.Encoding = System.Text.Encoding.Default 'very important!
    End Sub

    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        SerialPort1.Open()
        SerialPort1.Write("1")
        SerialPort1.Close()
    End Sub

    Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click
        SerialPort1.Open()
        SerialPort1.Write("0")
        SerialPort1.Close()
    End Sub

    Private Sub Button3_Click(sender As Object, e As EventArgs) Handles Button3.Click
        SerialPort1.Open()
        SerialPort1.Write("4")
        SerialPort1.Close()
    End Sub

    Private Sub Button4_Click(sender As Object, e As EventArgs) Handles Button4.Click
        SerialPort1.Open()
        SerialPort1.Write("3")
        SerialPort1.Close()
    End Sub
End Class

Ez pedig az arduino kódja:

int val = 0;

void setup()
{
pinMode(7, OUTPUT);
  digitalWrite(7, LOW);
  pinMode(8, OUTPUT);
  digitalWrite(8, LOW);

  Serial.begin(9600);
}

void loop()
{

int val = Serial.read() - '0';
if (val == 1) {
digitalWrite(7, HIGH);
}
if (val == 0) {
digitalWrite(7, LOW);
}

if (val == 4) {
digitalWrite(8, HIGH);
}
if (val == 3){
digitalWrite(8, LOW);
}

}

 Máris kapcsolgathatod kedvedre a LED-eket a VB-ből!
Annyi magyarázat a kódhoz, hogy ez a rész fogadja a bejövő adatokat:
A számok valójában nem integerek, hanem stringek, mert a vb csak szövegként tudja küldeni az adatokat. A string-ből ez a rész fordítja számmá, azaz integer-re a szöveget, miközben kiolvassa:
int val = Serial.read() - '0';


Az arduino ellenben többféleképpen tudja az adatot elküldeni, de a visual basic (vb) mindig szöveget csinál belőle a szövegből, de a bájtból is, mert ascii protokollnak veszi:

Serial.write például bájtot ad:

Serial.write(val) 
A val értéké max. 127 lehet, mert ekkor ez az ascii protokol szerinti bájtot küldi ki, amely 8 bit-ből áll, és ebben a protokollba csak 127 karakterhez tartozó bájtot tudunk küldeni.
Itt van a ascii táblázata:
http://www.catonmat.net/images/ascii-cheat-sheet.png
láthatjuk, hogyha ezt a kódot írjuk be:
Serial.write(49)
akkor valójában az egyes szimbólumot, pontosabban az annak megfelelő bájtot küldjük ki!
Lehet látni, hogy evvel a módszerrel csak egyjegyű számot küldhetünk.

A többi:

https://www.arduino.cc/en/Serial/Write

Serial.print() stringet ad (mi ezt fogjuk használni!):
https://www.arduino.cc/en/serial/print
például:
Serial.println("Hello2");
ugyanakkor egy egész, számot, integer-t is küldhetünk vele, pl:
Serial.println("1972");
de ekkor ez a szám string-gé, azaz szöveggé válik, így nem lehet vele műveleteket elvégezni, pl. összeadni, szorozni, stb.

Küldjünk egy szöveget az arduino-val a számtógépnek! Egyelőre csak az arduino szoftver soros monitorjának!

Első körben az arduino beállítása nem nehéz, a setup kódba be kell illeszteni a kommunikáció sebességét megadó kódot.:
void setup() {
  Serial.begin(9600);
}

Evvel a sebességgel bizonyosan jól fog működni mindegyik arduino-val...
A ciklus (loop) részbe pedig be kell írni, amikor, és ahogy adatot akarsz küldeni (printelni):

void loop() {
Serial.println("Hello1");
delay(500);
Serial.println("Hello2");
delay(500);
}

Ez a kód küld egy másodpercenként két szöveget (strintget), az egyik Hello1, a másik Hello2.
Az arduino szoftverbe van egy beépített soros monitor, az ablak jobb felső sarkába van a gomb, vagy a menübe is megtalálod, ha rákattintasz, akkor látod, hogy fél másodpercenként küldi a szövegeket.
Itt a soros monitorba láthatod, hogy te is tudsz küldeni az arduino-nak adatokat.


Most küldjünk egy változó számot szövegként (másodpercenként számol egyet felfele nullától)!

Itt az arduino kódja:

int szam =0;

void setup() {
Serial.begin(9600);
}


void loop() {
szam = szam + 1;
Serial.print(szam);
delay(1000);
}


Ahogy látod, a kommunikáció string-ként, azaz szövegként zajlik. Ez okoz egy kis nehézséget, mert szöveget pont nemigen kell kommunikálnunk, helyette a szám lenne a lényeg. Mivel szöveget nem tudunk osztani szorozni, mindig a fogadónak vissza kell alakítania számmá, ha nemcsak megjeleníteni akarja, hanem az adattal pl. műveleteket is akar végezni.

Most a változó számot, amely valójában szövegként, azaz string-ként lett elküldve,  egy Visual Basic soros monitoron jelenítsük meg! 
itt le is tudsz tölteni egy ilyet:
http://www.martyncurrey.com/?wpdmdl=2173
Csomagold ki, majd a belső mappát másold bele a visual studió projekt mappájába. Ott belépve a mappába a projekt fájlra ( .sln) kattintva beküldheted a visual stúdió programba, és ott megnézheted, és szerkesztheted a kódját!
Itt is megnézheted:
http://www.martyncurrey.com/arduino-and-visual-basic-part-1-receiving-data-from-the-arduino/

Példa projekt 

arra, ha két különböző adatot akarsz elküldeni a Visual Basic programodnak. Pl: Egy kollégiumban van egy rendezvény, de külön, és egyszerre kell számolni az arduino-val a külsősök, és a kollégisták létszámát, illetve az össz. létszámot is. Így néz ki:



Arduino kód (most csak modellezzük két számlálóval a számolást, az egyik számláló egyel, a másik kettővel növeli az értékét, és ezt a két adatot küldi el a számítógépnek, a visual basic programunkba. Ugyanakkor az értékeket becsomagolja egy jelbe, és így küldi stringbe, amit a vb majd értelmez.
< A0014> Azt jelenti, hogy a külsősök létszáma 14. A <B0123> pedig azt, hogy a kolisok létszáma 123. 
Arduino kód:

const boolean DEBUG = true;
unsigned int szam = 0;
unsigned int szamb = 0;
char karakterhossz[10];

void setup()
{
  Serial.begin(9600);
  Serial.println("Adruino is ready");
  Serial.println(" ");
}


void loop()
{
 
       szam = szam + 1;
       formatNumber( szam, 4);
       Serial.print("<A");
       Serial.print(karakterhossz);
       Serial.print(">");
       if (DEBUG) { Serial.println("");  }

       szamb = szamb + 2;
       formatNumber( szamb, 4);
       Serial.print("<B");
       Serial.print(karakterhossz);
       Serial.print(">");
       if (DEBUG) { Serial.println("");  }

    delay (1000);
}

void formatNumber( unsigned int number, byte digits)
{
    char szamString[10] = "\0";
    strcpy(karakterhossz, szamString);
    itoa (number, szamString, 10);
    byte numZeros = digits - strlen(szamString) ;
    if (numZeros > 0)
    {
       for (int i=1; i <= numZeros; i++)    { strcat(karakterhossz,"0");  }
    }

    strcat(karakterhossz,szamString);

}

Visual Basic kód:
Az alábbi  VB (visual basic) kóddal tudsz szöveget (string) kiolvasni az arduino-ból.

Fontos, hogy bizonyos feltételek között kikapcsolta az arduino nano klónomat a program, és így nem feltétlenül működött. Evvel a beállítással viszont megszűnt ez a probléma:
A SerialPort-ot, amikor ráhúzod a form1-re, vagyis amikor hozzáadod, a tulajdonságai beállításánál, a Rts Enable, és DtrEnable-t átállítottam True-ra. Ez minden ilyen arduino (nano-t) olvasó vb programnál szükséges lehet. Ha hiba van, állítsd át te is!
Ott egyébként át kell írnod a port nevét arra, amit te használsz(amit az arduino szofverben megadtál, azaz amelyik USB-be van dugva, annak a nevét.) port neve nálam: COM4

A VB kódot még egy helyen kell átírni, mégpedig, itt:
SerialPort1.PortName = "com4"
cseréld ki  a kettős vessző közötti com4-et itt is a saját USB címedre (nálam com4)
a többi helyen a SerialPort1. -et nem kell átírogatni.
Tehát a VB kód! A fenti képen láthatod mit kell ráhúzni, és amit nem látsz, még egy timmer, és egy SerialPort van ráhúzva. Még annyit a VB kódhoz, hogy ez a kód nem fogad negatív számokat! 
https://docs.microsoft.com/en-us/dotnet/visual-basic/language-reference/functions/type-conversion-functions
Ha negatív számokat akarsz küldeni, akkor se küldjél az arduinóval közvetlenül, hanem pl. adj hozzá az arduinó kódban 1000-ret, és itt a VB-ben vond ki, vagy használj más kódot!
https://www.dotnetperls.com/parse-vbnet
https://stackoverflow.com/questions/7708838/how-do-i-convert-from-a-string-to-an-integer-in-visual-basic
 Szóval így programozd most be az alkotóelemeket:

Imports System
Imports System.IO.Ports


Public Class Form1
    Dim kulsos As Integer
    Dim kolis As Integer
    Dim osszes As Integer
    Dim comPORT As String
    Dim receivedData As String = ""


    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

        Timer1.Enabled = False

        comPORT = ""
        For Each sp As String In My.Computer.Ports.SerialPortNames
            ComboBox1.Items.Add(sp)
        Next
    End Sub


    Private Sub comPort_ComboBox_SelectedIndexChanged(sender As Object, e As EventArgs) Handles ComboBox1.SelectedIndexChanged
        If (ComboBox1.SelectedItem <> "") Then
            comPORT = ComboBox1.SelectedItem
        End If
    End Sub


    Private Sub connect_BTN_Click(sender As Object, e As EventArgs) Handles Button1.Click
        If (Button1.Text = "Start") Then
            If (comPORT <> "") Then
                SerialPort1.Close()
                SerialPort1.PortName = comPORT
                SerialPort1.BaudRate = 9600
                SerialPort1.DataBits = 8
                SerialPort1.Parity = Parity.None
                SerialPort1.StopBits = StopBits.One
                SerialPort1.Handshake = Handshake.None
                SerialPort1.Encoding = System.Text.Encoding.Default 'very important!
                SerialPort1.ReadTimeout = 10000

                SerialPort1.Open()
                Button1.Text = "Stop"
                ComboBox1.Enabled = False
                Timer1.Enabled = True
            Else
                MsgBox("Select a COM port first")
            End If
        Else
            Timer1.Enabled = False
            SerialPort1.Close()
            Button1.Text = "Start"
            ComboBox1.Enabled = True
            ComboBox1.Text = String.Empty

        End If

    End Sub


    Private Sub Timer1_Tick(sender As Object, e As EventArgs) Handles Timer1.Tick


        Timer1.Enabled = False
        receivedData = ReceiveSerialData()
        If ((receivedData.Contains("<") And receivedData.Contains(">"))) Then
            parseData()
        End If
        Timer1.Enabled = True
    End Sub


    Function ReceiveSerialData() As String

        Dim Incoming As String
        Try
            Incoming = SerialPort1.ReadExisting()
            If Incoming Is Nothing Then
                Return "nothing" & vbCrLf
            Else
                Return Incoming
            End If
        Catch ex As TimeoutException
            Return "Error: Serial Port read timed out."
        End Try

    End Function


    Function parseData()

        Dim pos1 As Integer
        Dim pos2 As Integer
        Dim length As Integer
        Dim newCommand As String
        Dim done As Boolean = False

        While (Not done)

            pos1 = receivedData.IndexOf("<") + 1
            pos2 = receivedData.IndexOf(">") + 1

            If (pos2 < pos1) Then
                receivedData = Microsoft.VisualBasic.Mid(receivedData, pos2 + 1)
                pos1 = receivedData.IndexOf("<") + 1
                pos2 = receivedData.IndexOf(">") + 1
            End If

            If (pos1 = 0 Or pos2 = 0) Then

                done = True

            Else
           
                length = pos2 - pos1 + 1
                If (length > 0) Then
                    newCommand = Mid(receivedData, pos1 + 1, length - 2)
                    receivedData = Mid(receivedData, pos2 + 1)


                    If (newCommand.Substring(0, 1) = "A") Then
                        kulsos = newCommand.Substring(1, 4)
                        osszes = kulsos
                        Label2.Text = kulsos

                    End If

                    If (newCommand.Substring(0, 1) = "B") Then
                        kolis = newCommand.Substring(1, 4)
                        osszes = osszes + newCommand.Substring(1, 4)
                        Label1.Text = kolis
                        Label5.Text = osszes
                    End If

                End If

            End If

        End While

    End Function
End Class


Ha nem működik, akkor ne felejtsd el átállatni a
Rts Enable, és DtrEnable beállításokat a SerialPort1 elem tulajdonságaiban True-ra, ahogy fentebb már említettem...

Van három hasonló projekt:
Az oldalon a projekt is letölthető. Az oldalon egy ellenállás értékét olvassa ki a program, de ha a fenti arduino kódot használod hozzá, akkor felfelé számol nullától. A szám értékének meg bármit megadhatsz, szóval szerintem univerzálisabb...

http://www.martyncurrey.com/arduino-and-visual-basic-part-1-receiving-data-from-the-arduino/

http://www.martyncurrey.com/arduino-and-visual-basic-part-2-receiving-data-from-the-arduino-part-2/

http://www.martyncurrey.com/arduino-and-visual-basic-part-3-controlling-an-arduino/

Vezeték nélküli kommunikáció:
Lehetőségek:
-infrared
-Transmitten:
http://www.instructables.com/id/Wireless-communication-Arduino-RF/
-bluetooth
-wifi

----------------------------------------------------------------------------
Számrendszerek közötti átváltások:
http://www.inf.u-szeged.hu/~ihorvath/teaching/prog2/zh/1_zh.pdf

Laikusoknak nem túl érthető könyv magyarul:
http://www.tankonyvtar.hu/hu/tartalom/tamop412A/2011-0010_harsanyi_fizikai_szamitastechnika/index.html

Egyelőre ennyi, talán még folytatom! A többi oldal a kapcsolódó projektek bemutatása.
Remélem azért volt hasznosítható dolog! Ha igen, írj néhány ösztönző, vagy akár ostorozó sort, itt a lap alján nekem!
Vége!