Így érdemes:

Ha teljesen laikus vagy, akkor az első résztől olvasd el a honlapot, mert egymásra vannak építve az oldalak! Jobbra a menü...

4.rész Arduino

A lapon számos programkód, leírás a 60 nap alatt Arduiono tanfolyamból származik!
forrás: www.tavir.hu honlap 

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.

1.LECKE / BEMUTATÁS

Itt egy igen részletes könyv, ha valakinek erre lenne szüksége:
http://mumia.art.pte.hu/mami/tartalom/elokeszito-2017/tovabbi_konyvek/Harsanyi_Reka_Juhasz_Marton_Andras--Fizikai_szamitastechnika__elektronikai_alapok_es_Arduino_programozas_.pdf

Bevezető
Az Arduino-val alacsony szintű programozói, és elektronikai tudással is készíthetünk, egyszerű LED-es, villogós áramkörköröket, vagy akár robotokat. Tömören az arduino a vezérlésről szól! Ha teljesen laikusak vagyunk, akkor is hamar, és könnyen megtanulhatjuk a használatát.
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, amit vezérlésre használnak! Az  Arduino mellett vannak más kis cél-számítógépek is (pl: Raspberry Pi), azok viszont drágábbak, illetve vannak más programozható elektronikák is, de jóval bonyolultabbak. A több Arduino változatából talán az UNO, és NANO,  a legnépszerűbbek.

Arduino főbb típusok:
- Arduino/S
- Diecimila/Duemilanove
- Mega2560
- UNO
- Due
- UNO R3
- Leonardo
- Mini
- NANO
- stb.


Az arduino-t egy (USB) kábellel csatlakoztatjuk a számítógéphez, ami az eszközhöz jár. Ezen keresztül töltjük fel a programot az arduino-ra, vagy vezéreljük azt a számítógépről. Az USB kábelen keresztül 5V tápfeszültséget is kap.

Az arduino egyik kivezetésén is megjelenik az 5V feszültség, és ha valamit el akarunk látni külön táppal, például két-három LED-et, amit nem is akarunk vezérelni, csak világítani akarunk vele, akkor azt innen is megtehetjük. Ezt azonban nem lehet nagyon megterhelni, a nano esetében nem is annyira biztonságos, az arduino vezérlésre való, nem tápnak így szerintem baromság ezt a kivezetést használni...

A különböző típusok nagyjából ugyanúgy működnek, általában olyanokban van különbség, hogy mekkora a memóriájuk, hány kivezetés (pin) van rajta. Így például általában egy UNO-val leírt leckét, áramkört meg lehet csinálni a NANO-val is.

Amikor feltöltjük rá a programot, akkor akár függetleníteni is lehet a számítógéptől, csak máshonnan kell adni neki a tápfeszültséget. Ahogy tápfeszültséget kap, elkezdi a feltöltött programot ismételgetni.

Ha függetleníteni akarjuk a számítógéptől, akkor van egy olyan lába, amelyre ráköthetünk pl. egy 9V-os elemet, vagy egy kilenc voltos adaptert. Az arduino 5 Volttal működik, de ha erre a lábra kötöd a 9 Voltot, akkor azt leredukálja magának 5-re, és még ki is simítja magának, ha kis mértékben ingadozna, illetve nem lenne stabilizált a feszültség, stb.. A 9 Voltra azt mondják, hogy ideális. A pontos adatok ezzel kapcsolatban később...

Van egy olyan lába is, amelyre stabilizált, pontosan 5V -ot is ráköthetünk, hogy ellásuk energiával, de ezt a lábat csak akkor használhatjuk, ha tényleg pontosan 5V, és stabilizált a feszültség (pl. egy jobb mobil töltő), mert elkerüli az arduino feszültségszabályozóját, és ha erre kötöd a 9 Voltot, akkor a NANO elromlik. Ezt a lábat is szerintem nem érdemes használni. Szóval van rajta egy pár felesleges láb...

Esetleg lehet még olyan különbség a típusok között, hogy valamelyik régi típusnak nem 5V-tal, hanem 3Volt-tal megy, és ha külön tápról akarjuk működtetni (bár ennek jobban utána kell nézni).

 A nano és pl. az uno között az egyik fontosabb különbség, hogy a nanoról, hogy kicsi legyen, lehagytak egy túlfeszültségtől védő áramkört. Így a NANO-t könnyebben el lehet füstölni, ha az 5Voltos tápkivezetését, amit mint írtam szintén nem érdemes használni, rövidre zárjuk.

Amíg LED-ekkel játszol vele, addig valószínűleg nem fogod elfüstölni, de nagyobb motoroknál amikor elnézi az ember, akkor felszállhat egy kis puki. Ez lehet a tanuló pénz, bár azért írom, hogy ne legyen...

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, valamint sokkal nagyobb a kapacitása.

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.


Beszerzése:
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,
http://www.tavir.hu/60nap
vagy  beszerezhetsz  kezdők részére készletcsomagot , amely már vagy tartalmaz egy arduino alappanelt vagy lehet hozzá választani, vagy nem, de mint írtam, én a nanot ajánlom, és egy készletet hozzá, amely tartalmaz LED-eket, ellenállásokat, motorokat, távirányítót, kijelzőket, stb., így nem kell ezeket majd külön megvenned:
http://shop.tavir.hu/product_info.php/tanfolyami-kezdocsomag-arduino-tavir-oktatokeszlet-rfid-mintakodokkal-p-260
vagy olcsóbban itt:
https://www.hestore.hu/prod_10036694.html#
vagy Ebay.com -ról:
fele árban, vagy még olcsóbban...

2. LECKE/ TELEPÍTÉS ÉS BEÁLLÍTÁS

Érdemes szerintem figyelni rá, bár sehol nem említik, hogy ne nagyon érjél hozzá a kivezetésekhez úgy, hogy statikusan fel vagy töltődve (mondjuk a pulovered által). 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.

Le kell töltened, és telepítened kell a gépedre az arduino szoftvert!
Szerencsére elég egyszerű a szoftver, és a beállítása is, lásd alább.

Innen kell letölteni:
https://www.arduino.cc/en/Main/Software

Ha telepítetted, akkor kettő dolgot kell beállítan!

1. A programban 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. Vagyis a NANO-t
Ezen az oldalon van fénykép a beállításról:
http://www.elektromanoid.hu/progi1.html

2. Majd a Port almenüben azt a soros portot válasszuk ki, amelyet hasznáni fogunk, vagyis amibe a csatlakozó USB kábelt be fogjuk dugni. Valószínűleg még nem tudod melyik az, ennek a kiderítése a aláb. Most jegyezd meg, hogy mely portokat (csatlakozókat, amelyekbe már most is be van dugva valami, pl. talán USB-és egér) mutatja (pl. COM1, COM2, COM3).

Az arduino nano-t MOST dugd a géphez. Ekkor a számítógép telepíti az új eszközt. Ha kell hozzá driver, akkor automatikusan telepíteni fogja a netről.

Ha most becsukod az arduino szoftvert, majd újra megnyítod, akkor fogod látni, hogy egy új USB portot is felajánl (PL. COM4) . Azt állítsad be!

Most már csak használnod kell!

------------------------
Ha valami probléma adódna:

(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

3. LECKE / 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. Frissítés: Ugyanez a típus pl. a hestore.hu-nál jó minőségben beszerezhető, és annál nincs ilyen gond! 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).

4. LECKE/ PINEK



Digitális, és föld pinek:
Az első gyakorlati leckéknél a digitális pineket (lábak, kivezetéseket), és a föld kivezetését ) fogjuk használni. A digitális azt jelenti, hogy van (áram az áramkörben), vagy nincs, avagy elvont fogalomként igen, vagy nem, avagy számítógépnyelven jelölve digit 1 vagy 0 avagy a kódban így is jelölhetjük High (magas) vagy LOW (alacsony). A digitális pinek az arduinon D-vel vannak jelölve, a föld pedig GDN-nel.


Kimenet:

A digitális pineket kétféleképpen használhatjuk. Lehet kimenet (output) és beállíthatjuk a kódban bemenetként is (input). Az első gyakorlati leckéknél kimenetként fogjuk használni őket, és egy vagy több LED-et fogunk villogtatni rajtuk. Ekkor egy telepként is elképzelhetjük az arduinonkat, aminek az adott digitális pinje (D) az 5 Voltos telep pozitív pólusa, a föld (GDN)  pedig a negatív pólusa, amelyre a külső áramkörünket vagyis a LED-et csatlakoztatjuk. Ez az elképzelt "telep" pedig nem állandó feszültséget ad, hanem olyan ritmusban kapcsolja azt a LED-re be vagy ki, ahogy beprogramoztuk.



Bemenet(digitális érzékelő):

A digitális pineket a kódban beállíthatjuk bemenetként is, de erről majd később részletesebben lesz szó. Ekkor nem LED-et (a hozzá való ellenállással), hanem egy olyan áramkört építünk rá, amely egy kapcsolót tartalmaz. Ekkor az arduino azt fogja érzékelni, hogy a kapcsoló, vagyis az áramkörünk zárt, vagy nyitott, és például egy másik kimenetként beállított digitális pinen lévő áramkört tudunk ennek a függvényében be, vagy kikapcsolni, vagy például az asztali számítógépünknek továbbítjuk az adatot, hogy a kapcsoló zárva, vagy nyitva van.


Az arduino NANO 14 digitális pint tartalmaz, 0-tól 13-ig. Minden digitális pin D jelzésű az arduinon, lásd a fényképet, kivéve a D0 ami RX1 jelzésű, és a D1 ami TX1 jelzésű. Ezeket a pigitális pineket kezdőként még ne használjuk, majd később lesz szó róluk. Tehát kezdésnek 12 digitális pin ál rendelkezésünkre a NANO-n, D2-től D13-ig, amelyekből tetszőlegesen választhatjuk ki azt, amire az első áramkörünket  fogjuk rákötni.



Analóg pinek:

Vannak olyan pinek is az arduinon, amelyekkel nem csak azt lehet érzékelni, hogy a kapcsoló nyitott vagy zárt, azaz nem digitális igen-nem értékük van, hanem például egy ellenállás értékét. Az ilyeneket analóg pineknek hívjuk, amelyek A-val vannak jelölve. Ezekkel például olyan áramkört építhetünk, amely nem azt jelzi, hogy van víz a pohárban, vagy nincs, hanem azt, hogy mennyi van benne. Ezekkel később fogunk foglalkozni.



Föld pinek:

Az arduino NANO-n kettő föld pin található, amelyeknek GND jeléssel vannak jelölve, és azt használod, amelyiket akarod.


A többi pinnel egyenlőre nem foglakozunk, most csak a digitális, és a föld pineket fogjuk használni.


Az arduino beépített LED-jei:

Az arduino NANO-ra három kicsi LED van ráépítve. Az egyik azt jelzi, hogy tápfeszültséget kap az eszköz. A másik akkor villog, amikor kommunikál, vagyis például amikor vezéreljük, vagy amikor kódot küldünk rá. A harmadik a 13. Digitális pinre (kivezetésre, lábra) van rákötve. Tehát például egy olyan áramkört akarunk csinálni, ahol egy LED-et villogtatunk másodpercenként, akkor ha a 13-as pinre esik a szabad választásunk, és azt használjuk, akkor nem csak az áramkörünk LED-je fog villogni, hanem ez a kicsi beépített LED is.Sőt, ha levesszük a saját LED-es áramkörünket, az arduino ezen LED-je még ugyanúgy fog villogni, tehát ez a LED párhuzamosan van a 13-as pinre kötve.


Amikor először használjuk, ill. csatlakoztatjuk az új arduino eszközünket, akkor olyan egy olyan kód van feltöltve gyárilag az arduinora, amely a 13-as pint villogtatja. Tehát megfigyelhetjük, hogy ez a LED villogni fog.


Sőt, később is, amikor csatlakoztatjuk az arduinót a számítógépünkhöz, akkor első körben megvizsgálja, hogy mik vannak rácsatlakoztatva, ekkor az egyik beépített LED szintén villog, és csak néhány másodperc múlva kezdi lejátszani, és vég nélkül ismételni azt a programot, ami fel van rá töltve.

Ez pedig az UNO pinjei:


5. LECKE/ A KÓD FELTÖLTÉSE

Feltöltés-építés:
Ha eddig nem volt csatlakoztatva az arduni a számítógépünkhöz, akkor most tegyük meg! Az előző részben már beállítottuk az eszközt (NANO) és a portot, vagyis hogy melyik USB csatlakozót használjuk (pl. COM3) az arduino szoftverben.

Nekem az logikus, bár sehol nem olvastam, hogy először az üres Arduinora (tehát először még ne építsük fel rá az áramkört,)  feltöltsük fel a programot!  Utána vegyük le a számítógépről (az elektromos tápellátásról), és csak utána építsük ki rá az áramkört!

Tehát csatlakoztassuk az arduino-t és nyissuk meg az arduino szoftvert is!
Az Arduino szoftver elméletileg magyarul nyitódik meg, és 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:

}


Ezt egyszerűen töröljük ki, és másoljuk a helyére ezt:

void setup() {                
  pinMode(11, OUTPUT);         
}

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


Mi ez a kód?
A programkód két részből áll!
Az egyik rész a void setup
a másik a void loop rész.

A void setup a beállítás. 
Ehhez ne nyúlj:
void setup() {
Itt beállítjuk melyik pint akarjuk használni (a 11-est):
 pinMode(11, OUTPUT); 
Az OUTPUT azt jelenti, hogy kimenetnek állítottuk be! 
A kód végét a kapcsos zárójel zárja: }

Ezután jön a void loop rész:
A számítógép hasonlóan olvassa a kódot, mint az ember. Fentről lefelé, balról jobbra.
A loop kód azt jelenti, hogy amikor a végére ér, újra az elejére ugrik, és újra, és újra elolvassa, és végrehajtja. Tehát amíg a setup (beállítás) részt egyszer olvassa el, addig a loop részt végtelenül ismételgeti.
A void loop rész az utasítást tartalmazza
digitalWrite(11, 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(11, 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.
Azután a program egy újbóli egy másodperces várakozás után a következő kivezetés be-ki kapcsolására tér rá, majd, amikor a kódnak a végére ér, a kódot itt is a kapcsos zárójel zárja, majd a loop (hurok) parancs miatt a loop-ban lévő rész újra és újra elolvasásra, és végrehajtásra kerül.

Most töltsük fel a kódot az arduinora!
A program felső részében rögtön a jobbra mutató nyílra kell kattintani. Kép itt:
A kép innen származik:
Ezután a képernyő alsó részében az írja ki a program, hogy fordítás majd feltöltés. Amikor feltölt, akkor az arduino kis beépített LED-je pislog. Ezután kiírja, hogy a feltöltés kész, az arduino-t vegyük le a számítógépről, és építsük rá az áramkört! Az arduino szoftvert akár be is zárhatjuk.


6. LECKE/ AZ ÁRAMKÖR KIÉPÍTÉSE


Kössük rá a 11-es 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ünkbe 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, azaz ezt csökkentjük az ellenállással. 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 a kivezetést.
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. Folytassuk az áramkör kiépítését! Az ellenállásról kössük rá az áramkörünket a földre, aminek GND (ground=föld) a jelölése az Arduinón. Ha több pint használunk, és mindegyikhez egy-egy LED-et, akkor mindegyikhez ugyanolyan értékű ellenállás használjunk. 

Most elkészült az első áramkörünk, csatlakoztassuk az arduino-t a számítógéphez. Ahogy megkapja a tápfeszültséget, egy kicsit gondolkodik, megnézi mi van rákötve, majd elkezdi futtatni a programot. A LED-ünk villogni fog.  És még a többi D jelzésű lábakat is felhasználhatod, tehát jó sok LED-et tudsz vezérelni. 

Most változtassunk a kódon, és hagyjuk el az egyik kapcsos zárójelet! A szoftver ki fogja írni, hogy hiba van, és nem fogja feltölteni a kódot az arduinora.
Most változtassunk a késleltetésen, és a kódban az ezer helyett írjunk 3000-ret. Az LED lassabban fog villogni!
Most építsünk ki három áramkört három pin felhasználásával, és villogtassunk három LEDet, csináljunk knight rider effektet.
Kapcsolódó videók ehhez a leckéhez:

-----------------------------------------------------------------
Így bővíthetjük kettő LED esetén:

void setup() {                
  pinMode(11, OUTPUT);       
  pinMode(10, OUTPUT);  
}

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

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

7. LECKE / ELEKTROTECHNIKA

Ez talán a legnehezebb lecke! 

Ebben a linkeket is el kell olvasni!
Általános adatok:
-Egy átlagos LED általában 10mA-t, vagyis 0,01A-t igényel.
-Arduino lábait max. 40mA-rel lehet terhelni,
-Az Arduino-t összességében maximum 200mA -t vehet fel.
-USB port maga általánosságban max. 500 mA-re van tervezve, ennél jobban nem szabad megterhelni!
Teljesítmény = feszültség x áram
P = V x I
P max az USB esetén = 5V x 0,5A = 2,5Watt
-Például még a mikró szervomotorok is 200-400mA-t vesznek fel, mert kicsi az ellenállásuk,
ezért pl egy Arduino kivezetésével nem szabad meghajtani őket, a digitális kivezetéssel csak vezéreljük a motort, a tápot külön forrásból szolgáltatjuk neki, de erről később.

U = feszültség, amelynek a mértékegysége: V (Volt) = I*R
R = ellenállás, amelynek a mértékegysége:  Ω (Ohm) = U/I
I = áramerősség, amelynek a mértékegysége: A (Amper) = U/R
P= Teljesítmény,  amelynek a mértékegysége: W (Watt) = U * I
De szerencsére vannak kalkulátorok is, amely elvégzi helyettünk a számításokat, pl.:


Elektrotechnika:
Most jutottunk el oda, hogy át kell rágnunk magunkat az elektrotechnikai részén, de nem kell megijedni. Laikus vagyok én se értek sokat hozzá, illetve csak az Ohm törvényéről lesz szó.
Elsőre a feszültségről beszéljünk. A feszültséget az elektronikában egy tartályban lévő gáz nyomásához tudnám hasonlítani. A tartályra egy csapot is szereljünk fel. Ha a csapot teljesen kinyitjuk, akkor a túlnyomás (feszültség) segítségével kiáramlik belőle a gáz. A feszültség az a hajtóerő, ami első körben meghatározza azt, hogy mennyi energia áramolhat ki a vezetékből! Az arduino 5V-tal működik, és a kivezetéseken nem lehet nagyobb terhelés 0,04 Ampernél. Mi az ellenállás? A tartályon, amibe belepumpáltunk  plusz levegőt és így túlnyomás (az elektronikában feszültség) van,  mint említettem van egy csap, amin keresztül ki lehet engedni azt. Ha hirtelen kettétörne a  tartály, akkor szinte ellenállás nélkül távozna a túlnyomás a tartályból, a csapon keresztül, különösen, ha csak kicsit nyitjuk ki, akár csak kiszivárogtathatjuk. A csap tehát egy ellenállás, ami lefolytja a levegő (energia, töltés) áramlását, ami a nyomás hatására megy ki. Az áramerősség  a levegő kiáramlásának az erőssége. Ezeknek a jelei, és összefüggései:


LED, mint hardver:
Fontos linkek, ezeket el kell olvasni:


8. LECKE / 2. projekt
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 220ohm és 1kohm közötti ellenállást kell használni, igaz annak nagyobb Watt értékűnek (nagyobb) mértékűnek kell lennie, hogy ne melegedjen.


É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 220ohm és 1kohm közötti ellenállásra lesz szükséged.



 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. 

9. LECKE / 3.projekt 
Bemenet: Ekkor a lábbal nem vezérlünk, ki-be kapcsolunk egy eszközt (pl. LED-et), hanem érzékelőként használjuk. Azt vizsgáljuk a programmal, hogy az adott lábon lévő áramkör zárt, vagy meg van szakítva.

Bemenet, azaz az arduino egy "D" (digitális) jelzésű  lábának (kivezetés) használata érzékelőként:
Minden pin-hez az arduino házában  hozzá van kötve 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 lehet, és be is kell kapcsolni úgy, hogy HIGH  értéket írunk rá. Tehát amikor az INPUT -hoz adjuk a HIGH, akkor a HIGH nem az áram bekapcsolását jelenti, hanem a felhúzó ellenállás bekapcsolását!

(amikor a kódban a sor ezzel kezdődik // , akkor a szoftver azt a sort nem veszi figyelembe, és ezzel a kódba megjegyzéseket tudsz úgy illeszteni, hogy nem zavarsz bele.) 
Például: 

 pinMode(12, INPUT); 
// most a 12-es láb bemenetre van kapcsolva

digitalWrite(12, HIGH);
// és a HIGH -jal bekapcsoljuk a felhúzó ellenállását is, felkészítve a kivezetést, hogy érzékelőként használjuk

Ha (érzékelőként) használjuk a kivezetést, akkor alap, hogy bekapcsoljuk az arduinon belül lévő felhúzó ellenállást, de ezen kívül még az arduinora kötöt áramkörben is elég nagy ellenállást kell alkalmaznunk. Az alább a példa:

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 a 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!
Tehát a  bemenet a valóságban szintén kimenet, de nem így kell rá gondolnunk....
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 valójában 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). 

10. LECKE /A programozás 1.

A teremtés filozófiája

Adatok:
Az adatnak többféle típusa lehet:

1. lehet szám, például: 12
2 lehet szöveg, például: "bla bla bla"
3 lehet logikai érték: hamis, vagy igaz.


Változók:
Mi a változó? A programozás folyamán adatokkal dolgozunk, de az adatok önmagukban nem mondanak semmit. Például, ha azt mondom 12, akkor az egy adat, de önmagában nem mond semmit. A változó az a valami, ami lehet akármi is, és ami az adathoz még kapcsolódik.  Például 12 alma. Ez már többet mond, ez már így együtt az adattal használható információ.

Az adatnak van változója, de fordítva szemlélve is igaz, hogy a változónak van adata.

A változó persze lehet akármi is, így írhatjuk azt is, hogy 12 szilva, vagy ha elvontak vagyunk, akkor ezt is használhatjuk: 12 akármi, vagy 12 valami.

De az adat értéke is változhat, így írhatjuk akár azt is, hogy 13 akármi, vagy 13 valami.

A lényeg, hogy önmagában egy változó, vagy adat nem mond semmit, de a változó és az adat együtt, már használható információ.

Önmagában semmi nem létezhet, csak valami máshoz képest. Valami csak úgy jöhet létre, vagy valamit csak úgy teremthetünk, hogy azt megkülönböztetjük a többitől.  Férfi csak akkor létezhet, ha van nő, magyar csak akkor, ha van szlovák, stb. Miközben megkülönböztetjük őket,  együtt használható információt alkotnak. A jin-jang...

(Miközben a zsidók a többiek kiirtásán fáradoznak, saját maguk megsemmisülését is elérik...)

Amikor egy változónak értéket adva használható információt teremtünk, akkor az így is megjelenhet a kódban:

alma = 12;

Minden parancsot a kódban új sorba írunk a programozás során, és (szinte) minden sort pontosvesszővel zárunk. Különleges karaktert a változóban nem használunk, így vesszős betűt se, és két külön szót se. Ha piros almát akarunk teremteni, akkor azt egybe írjuk, és az új szót írjuk nagybetűvel, így nekünk könnyebben olvasható marad:

pirosAlma = 12;

A változó tartalmazhat számot is (de ha jól sejtem ebben a nyelvben sem kezdődhet számmal), pl.:

pirosAlma2 = 12;

vagy

pirosAlma3 = 6;

A változónak nem csak szám lehet az adata (értéke), hanem lehet szöveg, vagy logikai érték (igaz, vagy hamis) is.

Tehát ilyen is szerepelhet egy kódban, hogy:

pirosSzegfu = " Narancs"

A szöveget string-neg nevezzük a programozásban, és a kódban két idézőjel közé tesszük: "szöveg "
Az idézőjel közé tett szöveg állhat több szóból, és tartalmazhat ékezetet is.

myString = "Ez az én szövegem!"

Amikor először használunk egy változót, akkor értéket is kell adnunk neki, hogy a használható információt megteremtsük! Írunk egy változót, majd az egyenlőség jelel értéket (adatot) adunk neki, ez a deklarálás (kihirdetjük, hogy megszületett valami).

Egy nagyobb program több programblokkból is állhat.

Ha a void setup() sor elé írjuk a deklarálást, akkor az egész programba, globálisan érvényes lesz a kihirdetésünk. Tehát az egész kódban létezni fog a teremtményünk. Ha azt akarjuk, hogy csak a program egy részében létezzen, akkor elég az adott programblokk elején definiálni! Általában  a void setup() rész elé írjuk, a deklarálást, és az így globálisan érvényes, azaz a programot a változó(k) definiálásával kezdjük.
pl:

int pirosAlma3 = 6;

void setup() {
//és utána jön ez a setup rész ahol a beállítás van
}

void loop() {
//és utána ez a loop rész, ahol a feladat van meghatározva
}


Mi az az int a pirosAlma3 előtt?
 A legtöbbször számok az adatok. és sajnos a legtöbb programnyelvben a takarékosság miatt többféle számcsoportokat hoznak létre. Így az arduino nyelvében is. A leggyakrabban az integer számok csoportját használjuk. Ezek azok az egész számok, amelyek  -32.768 és +32.767 között vannak. Ha olyan dolgot programozunk, ahol nem használunk olyan számot, amely ezen a csoporton kívül esik, pl. 80925, hanem a legkisebb, és legnagyobb szám, ami felmerülhet az integer csoporton belül lesz, és csak egész számokkal fogunk dolgozni, akkor az integer csoportot használjuk. Ez annyit tesz, hogy amikor definiáljuk a változót, akkor megjelöljük, a gép számára, hogy mivel  az integer számokat 16 biten tudjuk  kifejezni számítógépnyelven 2 byte-nyi területet tartson fel a memóriában a számaink részére. Ha nem teljesen világos, nem baj, csak annyit kell tudni, hogy ha elég az integer csoport, és általában elég, akkor a változó deklarálásánál elé kell írni azt, hogy az integer csoportot (vagy halmazt, ha így érthetőbb) fogjuk használni. Nézzük meg egy példakódban hogy fog ez kinézni:

int szam = 0;

Az int az integer csoportot jelöli, a szam a  változó, a 0 a hozzáfűződő adat.
Mivel a szam (szám) változót globálisan az egész kódban a gép számára érthetővé akarjuk tenni, ezzel kezdjük a kódot, utána jön a setup, és a loop rész.

A kód további loop részében már nem kell odaírni a szam változó elé az int-et, mert a gép már tudni fogja, hogy egy integer csoportban lévő számot jelöl a szam változó.

A kezdők nem bonyolítják, mindig mindenhol csak az integert használnak :), mert ez általában elég, és jó mindenre, ezért elég ha most csak eddig értetted nagyjából, mert mi is egyenlőre ezt fogjuk csak használni, de itt van a többi számcsoport is, de csak futtasd át a szemed rajta, és folyasd programozás 2 résztől:

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. pl:
long szamCsoport = 803000;
  
Float:
Magyarul lebegőpontos. Tizedestörtest számok -3.4028235E+38-tól -3.4028235E+38-ig terjed, és 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.
float szamCsoport = 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!

Unsigned int

Előjel nélküli egész számok tárolására alkalmas. Mivel ugyanúgy 2 byte-on működik mint az integer,  de nincsenek negatív számok, így nagyobb pozitív értéket tud tárolni: 0 és 65 535 között az ATMega alapú arduinoknál. Due típuson 4 byte-tel működik, így 0 és 4 294 967 295 között használható.

Unsigned long

Ugyanúgy 32 biten tárol számértéket mint a long, de nincs előjele, így 0-tól 4 294 967 295 (2^32 - 1) -ig terjedhet az értéke.

például:
unsigned long var = 4 294 367 214;

Short
(ez ugyanaz, mint az integer, így szerintem tök felesleges)
16 bites adat típus, ATMega és ARM alapú Arduinokhoz.  -32 768 és 32 767 között.
Pl:
short var = 30 163;

word
Ugyan az mint az unsigned int, felesleges...
Double
Ugyanaz mint a float, felesleges...
11. LECKE / Programozás 2 és a 4. projekt

Most soros monitoron keresztül fogunk egy LED-et fel-le kapcsolgatni, közben pedig megtanuljuk a releváns programrészeket.
Az előző programozási részbe szó volt arról, hogy egy nagyobb program több programblokkból is állhat. Ha a változót a setup rész előtt deklaráljuk, akkor az egész program globálisan érteni ismerni fogja a változót. Erre egy példa ez a kód. A változónk a val és értéke a 0 számadat, ami az integer csoportba van, és amikor a loop függvényben változtatni fogjuk az értékét erre: Serial.read() - '0'; , akkor elárulom, hogy ebben a csoportban is marad, ezért int előjelet is kap:

int val = 0;

void setup() {
  pinMode(7, OUTPUT);
  digitalWrite(7, LOW);
  Serial.begin(9600);
}

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

Itt a másik változata. Mivel ez kis program, nincs több programblokkja se, ahol a val változónkat használni kellene, ezért a loop blokkban van deklarálva a változónk, nem a setup rész előtt. Értéknek pedig ezt a kódot adtuk meg neki: Serial.read() - '0';


void setup() 

{

  pinMode(7, OUTPUT);

  digitalWrite(7, LOW);
  Serial.begin(9600);
}

void loop() 
{
int val = Serial.read() - '0';
if (val == 1) {
digitalWrite(7, HIGH);
}
if (val == 2) {
digitalWrite(7, LOW);
}
}
Boncolgassuk tovább a kódot! Az új elem a setup részben a Serial.begin(9600);
Ez a soros kommunikáció protokolljának a része. Amikor a számítógépeddel akarod vezérelni az arduinodat, illetve az arra felépített áramkörödet, és nem csak a kódot akarod rá feltölteni, akkor azt a kódrészletet mindig el kell helyezned a setupban Valami olyasmit jelent, hogy másodpercenként 9600  bit-es sebességgel fogsz kommunikálni. Más arduinok tudnak gyorsabban is, de NANO ezt szereti, és ez az alap. 
A loop függvényben a Serial.read() az új rész. Ez a soros port olvasását jelenti. Vagyis a val változónk értéke mindig az, amit küldünk a soros porton, és amit kiolvas. 
A Serial.read() után még ez a folytatás: - '0'; Ez valami olyasmit jelenthet, hogy a soros adatküldés során a számítógéptől nem integer számadatot kap, hanem char karaktert, és ez a kódrészlet fordítja azt át integer számra. 
Mielőtt tovább boncolgatnánk a kódot, próbáljuk ki a gyakorlatban! 
Töltsük fel az arduinora, vegyük le a számítógépről, majd építsük ki rá az áramkört. Egy LED, majd a szokásos, legalább 220 ohm-os ellenállás a D7 pin-re, és a GDN-re kötve. Ehhez már rajz sem kell, a kódból látszik! 
Most csatlakoztassuk újra a számítógéphez az arduino-t! Az arduino programban, a jobb felső sarokban, van egy négyzet alakú kis gomb. Mintha egy kis nagyítót ábrázolna, de lehet hogy nem az... Itt a kép mutatja:
A kép forrása ez az oldal: http://www.elektromanoid.hu/progi4.html
Tehát katt a gombra, és bejön a soros monitor nevű szoftver az arduino szoftveren belül. Ebbe írjuk be, hogy 1, majd enter. A LED világít! Írjuk be hogy 2, a LED kialszik! Az 1 és 2 helyett használhatsz 4, és 8-at is, vagy amit akarsz, és átírhatod a kódot, de csak egy számjegyű számra, mert csak egy karaktert tudsz használni, de erről majd később
Ha kiélted magad, akkor vedd le a gépről a cuccot, és folytassuk a kód boncolgatásával! 

Az If azaz a feltétel függvény:
Most nézzük a kódból ezt a részt:

if (val == 1) {
digitalWrite(7, HIGH);
}

Ez egy függvény. Onnan tudod, hogy függvényről van szó, hogy sima zárójeles része, amiben a függvény beállítása van, és kapcsos zárójeles, amiben az utasításai.

A setup, és a loop rész is függvény.

Az if függvényünkben:
-Az if angolul azt jelenti, hogy ha. 
- (val==1) ez a sima zárójeles rész a függvény beállítása. 
- {digitalWrite(7, HIGH);} ez a kapcsos zárójelben lévő rész a függvény utasítása.
Lefordítva a függvényt magyarra ezt jelenti:
Ha a val változó értéke egyenlő eggyel, akkor a 7-es pin-re kacsolja be a feszültséget.

Még egy érdekesség van a kódban, mégpedig az, hogy az egyenlőséget két egyenlő jellel fejezi ki, mert ebben a nyelvben az összehasonlításban így csináljuk. Használhatunk még nagyobb > , és kisebb < jeleket is, és még továbbiakat (nem egyenlő, stb.), de erről később.

Tehát a kódunk arról szól, hogy ha a soros portról leolvasásra kerül egy adat, és ez az adat 1, akkor kapcsolja be a LED-ünket, ha 2, akkor kapcsolja ki.

Char adattípus:
Most van itt az ideje, hogy megismerkedjünk a char adattípussal!
A char a karaktereknek az adattípusa.
A szöveg, a string valójában karakterek láncolata. Amikor a szöveget deklaráljuk, akkor char előjelet használunk:
char myString = "Ez az én szövegem!";
 A karaktereknek van egy táblázata, amit úgy hívnak, hogy ASCII. Itt nézheted meg képen:
Ebben 127 karakter van, amely nagyjából lefedi a klaviatúrát. 
Amikor kommunikálunk, akkor a klaviatúra egy karakterét  küldjük a soros portra. Például a kis a vagy a nagy A karaktert, de amikor az 1-est nyomjuk le, akkor nem mint egyese számot küldünk, hanem az egye karaktert, chart, ami decimálisan a 49-es. 
A 49-es karaktert, ami nem szám, át kell konvertálni egyes számmá, hiszen a kódban a val változót int-tel jelöltük, azaz azt mondtuk, hogy integer számértéket adunk neki.
A soros kommunikációban karaktert küldünk, és nem számot, és mivel számból egy karakteres csak 0 és 9 között létezik, ezért nem adhatunk meg a kódunkban pl. 22-es számot arra, hogy lekapcsoljuk a LED-et!

De mi van, ha átalakítjuk a kódunkat, és nem integerrel, azaz számmal akarjuk vezérelni, azaz be-ki kapcsolni a LED-ünket, hanem charral? Tölts fel az alábbi kódot, és a soros monitorba az egyes, majd a kettest vidd be!

void setup() {
  pinMode(7, OUTPUT);
  digitalWrite(7, LOW);
  Serial.begin(9600);
}

void loop() {
char val = Serial.read();
if (val == 49) {
digitalWrite(7, HIGH);
}
if (val == 50) {
digitalWrite(7, LOW);
}
}

Működni fog, mert az egyes egyenértékű a 49-essel, a kettes az 50-essel.  

Folytatás hamarosan, és érthetővé szerkesztés hamarosan!

12. LECKE /Számoló Project 
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éldaprojektek a menüben...


Nagyjából ez a programnyelv! Itt az egész:

Soros kommunikáció (USB-n keresztül) az Arduino-val egy saját magad által megírt (vagy átalakított ;) ) Visual Basic 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 LED-eket Visual Basic programból!

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

Vagy itt egy másik változat, itt nem kell beállítanod a COM -odat a kódban, hanem a program megnyitásakor tudod beállítani, hogy az adott portot, amelyre rácsatlakozva tudod kapcsolgatni az arduinóval a rá kötött LED-eket.
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 állítsd át True-ra.
Kód:
Imports System.IO
Imports System.IO.Ports

Public Class Form1
    Dim comPORT As String
    Dim receivedData As String = ""

    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        comPORT = ""
        For Each sp As String In My.Computer.Ports.SerialPortNames
            ComboBox1.Items.Add(sp)
        Next
    End Sub

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

    End Sub

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

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

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

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

    Private Sub Button5_Click(sender As Object, e As EventArgs) Handles Button5.Click
        If (Button5.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()
                Button5.Text = "Stop"
                ComboBox1.Enabled = False
                Button1.Enabled = True
                Button2.Enabled = True
                Button3.Enabled = True
                Button4.Enabled = True
            Else
                MsgBox("Select a COM port first")
            End If
        Else
            SerialPort1.Close()
            Button5.Text = "Start"
            Button1.Enabled = False
            Button2.Enabled = False
            Button3.Enabled = False
            Button4.Enabled = False
            ComboBox1.Enabled = True
            ComboBox1.Text = String.Empty

        End If
    End Sub
End Class

Innen le is töltheted ezt a kis programot:
https://drive.google.com/open?id=0B6pno-EE64URUXNsb1lYZEhMblk

Ez pedig az arduino kódja hozzá:

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 nem tud integert küldeni, és fogadni. 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';

Ami rossz hír, hogy alapból csak egy számjegyet tud így fogadni az arduino, vagyis 0 és 9 közötti számokat. Tehát így nem volt gond, a 0, 1, 2, és 3 fogadása a fenti kódban, amelyekhez feladatokat tudtunk kötni, de ha egy 112-est akarsz elküldeni, akkor nem fogja helyesen kiolvasni, feldolgozni!
Persze van erre is megoldás, ez a jó hír ;) !  A fenti VB (Visual Basic) kódot írd át úgy, hogy ne a "3", meg a "4" legyen az elküldött szám, hanem pl. az "50", meg "100", és használd az alábbi arduino kódot! Evvel, viszont lassabb feldolgozással, de több számjegyű számokat is fogsz tudni fogadni, bár csak kb. másodpercenként hajlamos egy számadatot fogadni.
Az arduino kódja, most csak egy LED-et használva:

void setup() {
  pinMode(7, OUTPUT);
  digitalWrite(7, LOW);
  Serial.begin(9600);
}


void loop() {
if (Serial.available()){
int val = Serial.parseInt();

if (val == 100) {
digitalWrite(7, HIGH);
}
if (val == 50) {
digitalWrite(7, LOW);
}
}
}

Az alábbi  módszerrel viszont gyorsan tudsz fogadni betű, és számkaraktereket, amikhez egyenként tudsz kötni utasítás, így nagyon kibővítettük (128 -ra) a lehetőségeket:

    char val = Serial.read();
    Serial.println(szam);

Ha pedig kibővítjük  a kódban szereplő sorral (piros), akkor a betűkből megkapjuk a ASCII táblázatban a hozzájuk rendelt számértéküket, így 0-tól 127-ig  tudunk gyorsan számot fogadni!

if (Serial.available()>0){
    char val = Serial.read();
    int szam = int(val);
    Serial.println(szam);
}

Evvel a VB kóddal pedig a számot tudod char-ra alakítani:
        Dim szam As Integer
        szam = 115
        Label1.Text = Chr(szam)
Tehát így VB-ből 0-tól 127-ig egyszerűen, és gyorsan tudsz akár számadatot is küldeni úgy, hogy a VB-ben a számot átalakítod char-rá (karakterré), elküldöd a soros porton keresztül az arduinónak, ott meg visszaalakítod számmá! (ezt a módszert fogom használni a robotkar projektemben).

Vb-ben chart fogadunk, amit átalakítunk integerré:
        receivedData = ReceiveSerialData()
        Dim szam As Integer = Convert.ToInt32(receivedData)
        Label1.Text = szam
Vb-ben a 104-es számot, azaz integert átalakítjuk char-ra, és elküldjük az arduinonak:
SerialPort1.Write(Chr(104))

Arduinóban fogadjuk a chart, átalakítjuk integerré, majd az integgert vissza char-rrá, és visszaküldjük a vb-nek:
if (Serial.available()>0){
    char val = Serial.read();
    int szam = int(val);
    char mychar = char(szam);
    Serial.println(mychar);
}


Az arduino ellenben többféleképpen tudja az adatot elküldeni, de a visual basic (vb)  vagy bájtot, vagy stringet, vagy char-t tud fogadni, számot nem.

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.
Persze van rá mód, hogy több számjegyű számot is tudjunk fogadni, pl. az alábbi kóddal, de avval meg az baj, hogy számként kell küldeni, az arduinos soros monitorja tudja, de a visual basic erre nem képes. A kód visszaküldi azt a 0 és 255 közötti számot, amit küldünk neki az arduino soros monitorjából:

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


void loop() {
  if (Serial.available())
  {
    int speed = Serial.parseInt();
    if (speed >= 0 && speed <= 255)
    {
      Serial.println(speed);
   
}



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.
Ne felejtsük el, hogy ahhoz, hogy fogadjuk az adatokat folyamatosan olvasgatni kell a portot. Az arduino-nál ez automatikus, hiszen mindig egy loop-ot hajt végre, vagyis a loop kódrészletet, amibe a soros port olvasásának a kódja van, folyamatosan ismételgeti. A visual basicben is, ismételgetni kell az olvasás kódját ahhoz, hogy adatokat tudjunk fogadni, tehát pl. egy timer kódjába kell tenni az olvasás kódját! A timer ismételgetési ideje pedig közel annyi legyen, amennyi az arduino kód ismételgetési ideje, tehát nagyjából szinkronban kell ezeknek is lennie.

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!

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
-hálózat
pl. internet
----------------------------------------------------------------------------
Arduino vezérlése 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...
----------------------------------------------------------------------------
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