Í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


Soros port.
A régi 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épnek 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 viszont 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. Ilyen az arduino is.

A másik módszer a soros távvezé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, a soros távvezérlést sajátítjuk el. Itt elsőnek az Arduino szoftverből tartjuk a kapcsolatot a mikrokontrollerünkkel, majd egy rövid példát mutatok, hogyan írhatunk saját távvezérlő, kommunikáló programot Visual Basicben (Visual Stúdió-val) az Arduino -hoz.
Aztán érdekességből  megmutatom, hogyan lehet JavaScript-tel, vagyis a böngésződdel távvezérelni.


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 (pl. az arduinonak), 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 kisebb adatcsomagok vagyis byte-ok, vagy nagyobb adatcsomagok, akár teljes programok egy másik számítógéphez történő átvitelre való, és nem egy bittel (áram be vagy ki) való közvetlenül egy eszköz, pl. LED 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 (gondolj a telefonodra pl.), a távvezérléshez persze használhatnak rádióhullámot, fényt, internet, stb. is.

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 is. Tömören az arduino leginkább a vezérlésről szól, be-ki kapcsolgathatunk vele valamiket (pl. lámpákat), vagy csak a rákötött érzékelőkkel adatokat küldhetünk az asztali számítógépnek.  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 tartozik. Ezen keresztül töltjük fel a programot az arduino-ra, vagy távvezéreljük azt a számítógépről, bár azt lehet akár rádióhullámokon keresztül is. 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 velük, akkor azt innen is megtehetjük. Ezt azonban nem lehet nagyon megterhelni, a nano esetében nem is annyira biztonságos, az arduino  nem tápnak való, így szerintem általában 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, de fordítva mindenképpen.

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 digitális bemenet / érzékelő
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 számítógép alapjai nagyon régiek, ha bővebben érdekel olvasd el a wikin, de én leginkább egy zenedoboztól indulnék ki, egy ilyenből:
https://www.youtube.com/watch?v=zUM6DeZvZH4
Itt már lyukszalag tartalmazza az információt, hogy a hangfésű melyik foga mikor pendüljön meg:
https://www.youtube.com/watch?v=LLgd72t4brA
Ha a zenedoboz fésűiből elektromos érintkezőket csinálnánk, akkor nem hang, zene, hanem például LED-ek (olyan kis villanykörtéhez hasonló világító izék) kapcsolnának be-és ki. (A monitor vagy 3 millió ilyen kis "lámpából" áll, és ezek fel, és lekapcsolásának a kombinációjából bármilyen képet kirajzolhatunk.)

A lyukszalagon lévő lyukat 1-nek jelölik a számítástechnikában, amikor nincs lyuk, akkor azt 0-nak.
A számítógépben manapság olyan "lyukszalagot" használnak amelyen egy sorban nyolc oszlop lyukhely van, vagyis nyolc fésűs. Tehát nyolc LED-ed (vagy villanykörtét, stb.) lehet vele egyszerre vezérelni.  A lyuk helyét bitnek hívjunk.  A bit szó egy angol rövidítés, a binary digit szavakból áll össze, jelentése: bináris (kétértékű) számjegy. A nyolc bitet összesen, vagyis egy sort bájtnak (Byte ) hívunk. Tehát ha a nyolc oszlopos lyukszalagunkon az első sorban nincs lyuk, akkor az így írjuk le:
00000000 ha pedig minden helyen lyuk van, akkor így: 11111111. Ha pedig ezt írom: 00100001 akkor az azt jelenti, hogy abban a sorban csak kettő lyuk van, amikor ehhez a sorhoz ér a fésű, akkor a harmadik, és a nyolcadik LED világít. Az egész lyukszalagot le lehet írni így egy jó hosszú, a 0 és 1 kombinációjából álló sorral. Ezt hívják gépi kódnak.
A 0 és az egyes számjegyek sorozatával a kettes számrendszerbe számokat is kódolunk.
A nyolc bittel, vagyis 1 byte-tal 0-tól 256-ig írhatjuk le a számokat, a következő módon. A 0, nullát, az 1 pedig egyet jelent, ha jobboldalon az első helyen van,  de ha egyel balra, akkor mindig kétszer annyit, mintha jobbra lenne eggyel, és  és ezek az értékek a számsorban összeadódnak. Tehát:
00000000 = 0
00000001 = 1
00000010 = 2
00000100 = 4
00000011 = 3
11111111= 256
Amikor csinálsz egy ilyen lukszalagot, akkor programozol. Még annyit, hogy amikor beszélnénk erről a lyukszalagról egymás között, és annak az egyik lyukhelyéről, akkor azt ehhez hasonlóan tennénk.
-A kilencedik sorban a második bitnél (vagy oszlopban lévő lyukhelynél) el van tépődve a papír.

Tehát megadnánk a lyukhelynek a koordinátáját, vagyis címet adnánk neki.

A koordináta, de bármilyen  információ is az életünkben, mindig legalább két részből áll, egy adatból, és egy valamiből még, ami hozzá társul.

 Az adatok önmagukban nem mondanak semmit. Például, ha azt mondom 12, akkor az egy adat, de önmagában nem mond semmit. Mindig kell még hozzá valami,  Például 12. sor, 12. oszlop, 12 LED, 12 alma, stb.. Ez már többet mond, ez már így együtt az adattal információ.

Nyilván a számítógép összetettebb, mint a mi elképzelt "zenedobozunk".  Ahhoz, hogy a számítógéphez gépi kódot írjunk, szintén ismernünk kell a gép felépítését, de azt nem lehetne néhány óra alatt megtanulni... Ezért elkezdték a programozást egyszerűsíteni.
Kitaláltak programnyelveket, amelyen keresztül elkezdhetünk programozni úgy, hogy nem ismerjük részleteiben a számítógép felépítését.

Először a bájtot rövidítették le, és kialakították a hexadecimális kódolást, majd az első nyelv az Assemble következett, amely a legközelebb áll a gépi kódhoz. Ez volt az első generációs nyelv. Most a negyedik generációs nyelveknél tartunk, amelyeknél arra törekednek, hogy minél több ember, minél egyszerűbben tudjon kódolni, programozni.

A programnyelvek találmánya az, hogy nem az ember tanulja meg a gép fizikai felépítését, hanem a gép igazodik az emberhez. Mi megírjuk a programot valamilyen programnyelven, amely a gép fizikai felépítésétől egyre inkább elvonatkoztatott világ, amit majd a számítógép fordít le magának gépi kódba.

Például gondolj az adatokra úgy, mint az otthonodban a holmijaidra (ruhák, könyvek, stb.).
A holmijaid pedig dobozokban, szekrényekben, polcokon vannak,  ezek a memóriacímek, koordináták, és a fúrógépedet a nagyDobozból veszed majd elő, hogy majd használjad!

Az adat a programban többféle lehet:

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

A memóriahely koordinátáját, vagy címkéjét, amivel az adatot megtaláljuk, vagy elvontan elképzelhetjük egy doboz nevének, vagy címkéjének is, amibe az adatokat (holmijainkat) rakjuk. A programozásban a gépicímkétől elvonatkoztatunk, és egy tetszőleges dologgal helyettesítjük, akár egy elképzelt dobozzal, amelybe egyenlőségjellel teszünk adatot, vagyis értéket adunk neki. Például:

nagyDoboz = 12;

Tehát a memóriahely koordinátáját, címét, egy dologgal helyettesíthetjükEzt a dolgot, ami az adathoz kapcsolódik, és amivel együtt az adat információ lesz, hívjuk változónak.

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

Változó  egy konkrét értéken kívül  bármilyen karaktervariáció lehet. 
Lehet értelmes, mint a doboz, de lehet értelmetlen pl. asdf is.
A gyakorlatban a maximalizált hossza, és a rá vonatkozó egyéb szabályokban programnyelvenként vannak kisebb eltérések.

Így a változó lehet akármi is, vagyis írhatjuk azt is, hogy 12 led, vagy ha elvontak vagyunk, akkor ezt is használhatjuk: 12 akármi, vagy 12 valami.

Az adat, vagyis a változó értéke is változhat, de a programban magát a változót is átváltoztathatjuk 13 akármiről,  13 valamire. Talán ezért változó a neve?

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óhoz értéket társítva információt teremtünk, az így is megjelenhet a kódban:

led = 1;

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 a piros LED-et akarjuk változónak, akkor azt egybe írjuk, és a második szót írjuk nagybetűvel, így nekünk embereknek könnyebben olvasható marad a kód:

pirosLed = 0;

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

pirosLed2 = 1;

vagy

pirosLed3 = 12;

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 használunk egy változót, akkor előbb-utóbb értéket is kell adnunk neki, hogy az információt megteremtsük! Írunk egy változót, deklaráljuk (kihirdetjük) majd az egyenlőség jelel értéket (adatot) adunk neki.

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

Ha a void setup() sor elé írjuk a deklarálást, vagyis deklarálással kezdjük a programot, akkor az egész programba, globálisan érvényes lesz a kihirdetésünk. Tehát az egész kódban létezni, működni 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 pirosLED3 = 0;

vagy LED helyett egy fogalom is lehet változó, például maga az adattípus fogalma a szám, a mennyiség, érték, stb. és ehhez adunk adatként egy konkrétumot, hogy információ legyen. Gyakori, hogy egyszerűen csak egy számra, vagy egy mennyiségre, értékre (angolul value, rövidítve val) van szükségünk, és ekkor ez így jelenítjük meg a kódban:

int szam = 12

vagy így. ez nem kötelező, csak általános szokás. A val helyett használhatunk bármit...

int val = 12;

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 szam 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 soros monitor

Most soros monitoron keresztül, a klaviatúra karaktereivel (char adattípus) fogunk egy LED-et fel-le kapcsolgatni, vagyis közvetlenül vezérelni, közben pedig megtanuljuk a releváns programrészeket.

Töltsük fel az arduinora az alábbi kódot, majd vegyük le a számítógépről, és építsük ki rá az egy LED-es áramkört. Egy LED, majd a szokásos, legalább 220 ohm-os ellenállás a D9 pin-re, és a GDN-re kötve. Ehhez már rajz sem kell szerintem!
A kód:

char val; 
void setup() {
Serial.begin(9600);
pinMode(9, OUTPUT);
}
void loop() {

val = Serial.read();
if (val == 'B') {
digitalWrite(9, HIGH);
}
if (val == 'K') {
digitalWrite(9, LOW);
}
}

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:
http://www.elektromanoid.hu/img/soros1.jpg
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, a nagy B (a be-re utalok vele) karaktert, majd enter. A LED világít! Írjuk be hogy K, a LED kialszik! A B és K helyett használhatod a klaviatúra bármelyik karakterét is, ha  átírhatod a kódot is az adott karakterre, de csak egy karaktert tudsz használni, de erről majd később
Ha kiélted magad, akkor folytassuk a kód boncolgatásával!

Az előző programozási részben szó volt a változóról, na itt már használjuk. A változónkat a setup rész előtt már deklaráltuk (char val;), de értéket csak a loop részben fog kapni. Itt új elem az is, hogy nem integer (int) a változónk, hanem char!

Char
Most van itt az ideje, hogy megismerkedjünk a char adattípussal!
A char (character) a karaktereknek az adattípusa.
A szöveg, másképpen a string valójában karakterek láncolata. Amikor a szöveget deklaráljuk, akkor is char előjelet használunk:
char myString = "Ez az én szövegem!";
 A karaktereknek van egy olyan táblázata, amit úgy hívnak, hogy ASCII. Itt nézheted meg képen:
http://www.catonmat.net/images/ascii-cheat-sheet.png
Ebben 127 karakter van, amely nagyjából lefedi a klaviatúrát.
Amikor soros porton vezérlünk, akkor a klaviatúra egy karakterét  küldjük a soros portra. A számítógépnek az egyik elődje a géptávíró, innen öröklődött ez...
Azonban azt is látjuk a táblázatban, hogy a karaktereknek megvan az egyenértékűk más adattípusba is. Amikor a B karaktert küldjük, akkor az egyenértékű a 66-os decimális számtípussal. A K pedig a 75-össel.

Most a val változónkat deklaráljuk integernek (int val;) !

int val;
void setup() {
Serial.begin(9600);
pinMode(9, OUTPUT);
}
void loop() {

val = Serial.read();
if (val == 'B') {
digitalWrite(9, HIGH);
}
if (val == 'K') {
digitalWrite(9, LOW);
}
}

Ugyanúgy a B és a K karakterekkel vezéreljünk, és a kód így is működik! Mégpedig azért, mert a char az szám is! A B a 66 decimális számnak felel meg, a K a 75-nek, ezért a program elfogadja 66-os és 75-ös integer számnak! Most a kódban használjuk ténylegesen az integer megfelelőjét, de a klaviatúrán továbbra is a B és a K betűket nyomkodjuk!:

int val;
void setup() {
Serial.begin(9600);
pinMode(9, OUTPUT);
}
void loop() {

val = Serial.read();
if (val == 66) {
digitalWrite(9, HIGH);
}
if (val == 75) {
digitalWrite(9, LOW);
}
}

Láthatjuk, hogy működik! A char tehát szám is, mert mint hogy írtam a karaktereknek egyidejűleg van számértékük is, sőt, a táblázatban láthatod,
http://www.catonmat.net/images/ascii-cheat-sheet.png
hogy bináris,  hexadecimális megfelelőjük is van.
Tehát, amikor soros kommunikációban küldünk egy karaktert, az egyben egy szám is! A nagy B egyben a 66-os szám, a nagy K egyben a 75 ös szám is.

A setup részben az új elem 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 arduinók 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. Amikor olvasásra kerül ez a sor, akkor ez leolvassa mi van küldve nekünk a soros porton.
val = Serial.read();
Ezzel az egyenlőségjellel, most adunk értéket a val változónknak. Az értéke mindig az lesz, amit a Serial.read(); kód kiolvas a soros portból.


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

if (val == 'B') {
digitalWrite(9, 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 rész az utasításait tartalmazza.

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

Az if függvényünkben:
-Az if angolul azt jelenti, hogy ha.
Az if után a zárójel a függvény beállítását, ebben az esetben a feltételét jelenti. A val a változónk, és az if függvény beállításában kettős egyenlőségjelet kel használni, de a jelentése ugyanúgy egyenlő.
Tehát az
 if  (val=='B') idáig azt jelenti, hogy
Azt jelenti, hogy: ha a val változónk értéke 'B',
A kapcsos zárójelbe az van, hogy mit csináljon, ha teljesül a feltétel.
 {digitalWrite(7, HIGH);
}
vagyis 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.

A másik if függvény:

if (val == 'K') {
digitalWrite(9, LOW);
}

meg azt jelenti, hogy:
Ha a val értéke K, akkor a 9-es pin-en kapcsolja ki a feszültséget.
A K és a B egy hiányjel ( ' ) között van. Talán ez jelöli azt, hogy egy karakterről van szó, és nem karakter láncolatról, azaz szövegről pl. "ez egy szöveg". Ha szövegről van szó, akkor ugyanis a szövegrészt macskaköröm közé kell tenni. Szöveggel ugyanis nem lehet vezérelni, vagyis lehet, de máshogyan, az kicsit bonyolultabb, és lassabb, 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 karakter, és ez az adat B, akkor kapcsolja be a LED-ünket, ha K, akkor kapcsolja ki.


Egyéb:
A soros kommunikációban tehát karaktereket küldünk, és fogadunk. A 127 karaktert bele lehet kódolni a 7 bitbe: 1111111 = 127 Ha jól értettem, amikor utánanéztem, a kommunikáció során egy byte, azaz 8 bit kerül sorban, egymás után elküldésre, és azt az arduino egy kis memóriaterületen összegyűjti, majd egyszerre byte-ként dolgozza fel. A nyolcadik bitnek az értéke azonban mindig 0, mert ez zárja le, illetve jelzi a karakter kód végét. A nyolcadik bitet a táblázat nem mutatja, de mivel csak 7 bit van a karakterek számára, ezért csak 127-féle karaktert lehet ASCII soros protokollal küldeni.

Még az if (feltételes ) függvényről:
Az if függvényben nem csak egyenlőség utasítást használhatunk, hanem például azt is beállíthatjuk, hogy nagyobb, kisebb, nem egyenlő stb.
 Mint ahogy láttuk ebben a részben, az egyenlőség jele a kettős egyenlő jel, de itt van a többi:

Összehasonlító jelek:

!= (nem egyenlő)
< (kevesebb mint)
<= (kevesebb mint, vagy egyenlő)
== (egyenlő)
> (nagyobb mint)
>= (nagyobb mint, vagy egyenlő)

fontosabb logikai jelek:
&& (és)
|| (vagy)

https://www.arduino.cc/reference/en/

például if (feltételes) függvényben:

if(val3 == 0 || val3 == 127){
val1 = val1 + 1;   
}

Magyarra lefordítva:
Ha val3 változónk értéke nulla, vagy 127, akkor val1 változónk értékéhez hozzáadunk egyet.

12. LECKE/ PROGRAMOZÁS 3 - SOROS MONITOR 2
Továbbra is a soros monitort fogjuk tesztelgetni, és továbbra is egy LED-et kapcsolgatunk be-ki rajta keresztül.  Ezzel a kóddal 0 és 9 közötti számjegyekkel lehet vezérelni!


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

void loop() 
{

int val = Serial.read() - '0';

if (val == 1) {
digitalWrite(9, HIGH);
}
if (val == 0) {
digitalWrite(9, LOW);
}

}

A soros monitorba írd be az 1-et, majd enter, azután a 0-át majd enter. A LED felkapcsol, és kikapcsol. 
Az újdonságok a kódban. Az egyik az, hogy nem a setup előtt deklaráltuk a val változónkat, hanem a loop részben:
int val = Serial.read() - '0';
A másik a Serial.read() után található - '0' . Ez a kód úgy viselkedik, mintha cáfolná azt, amit az előző részben írtam, mert úgy tűnik, hogy a klaviatúra egyes gombja most nem karaktert küld, hanem az egyes számot, de ez nem igaz, csak ez a kód fordítja át az 1-es karaktert 1-es számmá, hiszen a soros monitor ugyanúgy karaktert küld, mint eddig.
Ez egyébként a tapasztalatom szerint nagyon gyors, az egyetlen hátránya, hogy csak 0 tól 9-ig működik.

A következő kóddal azonban bármelyik integer számot használhatjuk a vezérlésre!

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

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

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

A soros monitorba gépeljük be a 100-at, majd enter, utána az 50-et, majd enter. Mint írtam ezeket a számokat kicserélhetjük bármelyik integerre. 
Ebben a kódban két újdonság van. Az egyik, hogy a loopban van egy ilyen függvény, és ebben van belefoglalva a többi kód:
if (Serial.available()){
// itt van a többi kód
}
Tehát egy feltételes if függvényben van a másik kettő feltételes if függvény. A kód értelme egyébként az, hogy ha a soros port elérhető, olvasható, illetve van valami küldve benne, akkor olvassa csak el a benne lévő kódokat a gép, különben átugorja. 
A másik újdonság, hogy Serial.read();  helyett Serial.parseInt(); a változónk értéke.
A parse int szintén egy fordító, ami az egybefűzött számkaraktereket fordítja le számmá.
Amolyan tolmács...
Az egyetlen, de nagy hibája a kódnak, hogy nagyon lassú. A fordítás időbe telik, és sok olyan terület van, amikor  a vezérlésnél nem lehetünk ennyire lassúak. Pl. egy autó nekimegy valaminek, mire a vezérlő parancs végrehajtásra kerül...

Most fordítsuk meg a dolgot, és az arduino-val küldjünk adatot a sorosmonitornak!
Most nem kell majd áramkört építeni az arduinora, csak kommunikálunk vele...
Töltsd fel ezt a kódot az arduinora, majd nyísd meg a sorosmonitort!

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

Azt fogod látni, hogy fél másodpercenként az arduino egyszer ezt a szöveget,
Hello1
majd ezt küldi: 
Hello2

A kódban ez a rész küldi a szöveget:
Serial.println("Hello1");
Jelentése kb. az, hogy a soros portra printerjed ki, hogy Hello1. a print kódrészlethez kötődő ln pedig azt jelenti, hogy utána új sorba mehet majd a nyomtatás.

Most változtassunk a kódon annyit, hogy a print csak önmagában van, ln nélkül:

void setup() {

  Serial.begin(9600);

}

void loop() {

Serial.print("Hello1");

delay(500);

Serial.print("Hello2");

delay(500);

}

Azt láthatjuk, hogy most a szövegeket egymás után, sortörés nélkül printeli. Tehát az ln a sortörést jelenti, ahogy említettem...

A szövegben persze lehet szám, de ne felejtsük el, hogy ez csak karakterlánc, a printelt szám is, amit ha a számítógépen akarunk használni, egy programmal vissza kell alakítani számmá, és csak utána tudunk vele számtani műveleteket csinálni (összevonást, szorzást, stb.)!

Most játszunk egy kicsit!
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);
}

És végül csináljunk egy olyan kódot, ahol elküldünk a soros monitorból az arduino-nak egy számot, és ő azt hozzáadja az előzőhöz, és az eredményt visszaküldi a soros monitornak!

Össze tudod rakni?

Én így csináltam:

int val = 0;
int val1 = 0;

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


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

    val = val + val1;

    Serial.println(val);

    val1 = val;
    
}
delay(20);
}



13. LECKE /Számoló (fény) kapu 

Töltsük fel az alábbi kódot:
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);
}

Építsük ki az áramkört:

Az R6 4,7Kohm-os ellenállás, az R8 a szokásos, legalább 220ohm-os a LED mellé. Az S1 kapcsoló helyett használhatsz infrared vevő LED-et. Annak a hosszabb lábát kell a földre kötni (tehát fordítva használjuk, mint a sima LED-et). 

Elsőre a kapcsolós áramkört ajánlom. Ha nincs kacsoló, akkor megteszi az is, ha két vezetéket összeillesztünk, majd szétválasztjuk. 
A projekt azt fogja produkálni, hogy ha többször, mint háromszor megszakítjuk a kapcsolót,  akkor felkapcsol a LED.
Kapcsoló helyett használhatunk infrared vevőt is. Az adó, ha nincs inrared adó LED-ünk, lehet egy gyertya, vagy az ablakon beszűrődő fény is. Ha inraredes kísérlet mellett döntünk, akkor érdemes este csinálni, kompakt vagy LED-es fényforrás mellett, hogy ne zavarjon bele a játékba, vagy egyszerűen csak tisztába kell lenni azzal, hogy a természetes fény is tele van infrared fénnyel, és ezt figyelembevéve kell eljárni. 


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:


Egy kis magyarázat a kódhoz: 
A setup rész előtt deklaráltunk  egy csomó mindent, amire majd szükségünk lesz, és még kezdeti értéket is adtunk neki:
int allapot = 0; 
int mennyiseg = 0;
int ertek = 0;
int indulasm = 0;

Ezután setup részben megcsináltuk a beállításokat. A 13-as pin a kimenet, a világító LED ezen lesz rajta:
pinMode(13, OUTPUT);  

A 6 pint bemenetként (érzékelőként) állítottuk be:
pinMode(6, INPUT); 
A 5-os érzékelő (bemeneti) pinünkre kiirtunk egy magas beállítást, ezzel bekapcsoltuk rá az arduino-ban lévő belső, védő, úgynevezett felhúzó ellenállást:
digitalWrite(6, HIGH);
Ha bemenetként állítunk be egy pint, akkor mindig be kell hozzá állítani ezt a felhúzó ellenállást, tehát ez a két sor mindig együtt van:
pinMode(6, INPUT); 
digitalWrite(6, HIGH);

Most jön a loop rész, a végrehajtandó feladat:
Az állapot változónknak adjuk meg a bemenetelünk értékét. A digitális bemenet vagy magas, vagy alacsony, ill. 1 vagy nulla, mindegy melyikre utalunk majd.:
allapot = digitalRead(6); 

Azt ezt mondjuk. Ha az állapot értéke magas, akkor az érték változónk értéke 1, máskülönben 0. Természetesen a változóknak más elnevezéseket is lehet adni, de ékezetes betűt nem tartalmazhatnak:
if (allapot == HIGH) { 
ertek = 1;
}

else {
ertek = 0;
}

Most jön egy bonyolultabb rész, ráadásul itt feltételes függvény is van a feltételes függvényben:
if(ertek != indulasm){
if(ertek == 1){
mennyiseg = mennyiseg + 1;
}
}
Magyarul ezt jelenti: Ha az érték változóm nem azonos az indulás voltozóval, és ha az érték változóm egy, akkor a mennyiség változómhoz adjon hozzá egyet. A mennyiség változó számolja, hogy mennyiszer szakítjuk meg az áramkort. Az indulás változó a bonyolultabb. Mint írtam, a loop rész folyamatosan ismételgeti önmagát, de a változók értéke ha a ciklusban változik, a következő ciklusban is annyi lesz, amennyire az előzőben megváltozott. Tehát amikor lefut a kód, és megváltozik például az érték változó értéke, akkor a következő ciklusban is annyi lesz, amennyire az előzőben változott. A gép egy másodperc alatt nagyon sokszor lefuttatja a ciklust, azaz a kódot...
Ha csak azt számolná a kód, hogy akkor növelje az érték változónkat, ha a ciklusban meg van szakítva az áramkör, akkor nem azt számolná, hogy hányszor szakítottuk meg, mert hanem azt, hogy hányszor volt megszakítva, amikor végigfuttatta a ciklust. Ha egy másodpercig tartanánk megszakítva az áramkört, akkor mivel az alatt rengetegszer lefuttatta a ciklust, ezért rengeteg lenne a mennyiség változónknak az értéke, miközben csak egyszer szakítottuk meg, egy másodpercre. Ezért ebbe a kódba azt mondjuk el, hogy ne pusztán akkor számoljon, ha meg van szakítva az áramkör:
if(ertek == 1){
mennyiseg = mennyiseg + 1;
Hanem akkor, merüljön ez föl egyáltalán, ha az előző ciklushoz képest megváltozott az rézékelő állapota:

if(ertek != indulasm){

}

Minden ciklusban az érték értéke az lesz, hogy éppen magas, vagy alacsony állapotban van az érzékelő. Indulásként az indulás változó, még a setup részben 0 értéket kapott, így ha az érték magas lesz, azaz 1 (érzékelőnél akkor magas, ha meg van szakítva, azaz nincs áram a vezetékben, tehát fordítva van a kimenethez képest), akkor különbözni fog az érték, és az indulás, és  a mennyiség egyel nőhet. A kód végén az indulás azonban felveszi az érték értékét:
indulasm = ertek;
és a következő ciklusban csak akkor nőhet a mennyiség egyel, ha az érzékelő másik állapotba kerül, és nem marad abban, amiben az előző ciklusban volt.

A kódban ezután már könnyebb rész jön:
if(mennyiseg > 3){
digitalWrite(13, HIGH);
} else {
digitalWrite(13, LOW);
}
Magyarul, ha a mennyiség nagyobb mint három, akkor a 13-as pinen lévő LED-et kapcsolt fel, máskülönben ne legyen felkapcsolva.

Erről pedig volt már szó, itt veszi fel az indulás az érték értékét:
indulasm = ertek;

Ezután lassítjuk a ciklust, mert nincs rá szükség, hogy marha gyorsan ismételgesse a kódot a gép:
delay(250);

Majd a loop függvény is lezárul:
]

Ez a honlapon az egyik legbonyolultabb kód...

14. LECKE/ PERGÉS (PRELL)
A nyomógombokat, kapcsolókat általában nem csinálják meg tökéletesre, és amikor összezárjuk az érintkezőit, akkor azok a rugalmasságuk miatt berezonálnak, ami az áramkör sokszori nyitásával, zárásával járhat, amit az arduino annak is érzékel. Például ha csinálunk egy projektet, amely számolja, hogy hányszor nyomjuk meg a nyomógombot, a rossz minőségű gomb miatt azt fogjuk tapasztalni, hogy egyszer nyomtuk meg, de vagy ötöt számolt. Erre két megoldás van. Az egyik, hogy jó minőségű gombot használunk, vagy ha csak egy-két gombról van szó, akkor kondenzátorral, és ellenállással elnyeletjük. 
Bővebben erről itt, de ez nem a legegyszerűbb megoldás:

 A másik, hogy a programban figyelembe vesszük a pergést.
A legegyszerűbb megoldás szerintem a következő. Tölts fel az arduinora ezt a kódot:

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

void setup() { 
pinMode(6, INPUT); 
digitalWrite(6, HIGH);
Serial.begin(9600);
}

void loop(){
allapot = digitalRead(6); 


if(allapot != indulasm){
if(allapot == 0){
mennyiseg = mennyiseg + 1;
Serial.println(mennyiseg);
}
}


indulasm = allapot;
delay(10);
}

Építsd ki a következő áramkört: 
A 6-os pinre kössél egy 4,7 Kohm-os ellenállást, majd arra sorban egy nyomogombot (az se baj, ha csak két vezeték összeérintésével helyettesíted, ha nincsen, majd a nyomógomb után sorban a föld (GND) következik.
Most csatlakoztasd a számítógépedre az arduinodat, és nyisd meg a soros monitort. Minden lenyomásra számolni fog nullától eggyel felfelé. Ha szar a gombod, és pereg, vagy nagyon remeg a kezed, akkor egy gomblenyomásra többet is számolhat...

Ennek a legegyszerűbb kivédése, ha amikor az érzékelő érzékel (vagyis valamilyen kapcsolás történt), akkor megvárjuk egy delay késleltetéssel, hogy a pergés lecsengjen, majd rávizsgálva megnézzük, hogy milyen állapotban van a kapcsoló, és ha zárt, na csak akkor számolunk egyet:

int allapot = 0; 
int mennyiseg = 0;
int indulasm = 0;
int szamolo = 0;

void setup() { 
pinMode(6, INPUT); 
digitalWrite(6, HIGH);
Serial.begin(9600);
}

void loop(){
allapot = digitalRead(6); 


if(allapot != indulasm){
delay(1000);
allapot = digitalRead(6);
if(allapot == 0){
mennyiseg = mennyiseg + 1;
Serial.println(mennyiseg);
}
}

delay(20);
}

Ahogy olvasom, általában nincs szükség a legrosszabb minőségű nyomógombok esetén se ennél nagyobb delay(50) várakozási időre max. delay(60), és nincs szükség az egy másodpercre delay(1000), amit  a példában alkalmaztunk...
Persze lehet kísérletezni a te nyomógombod milyen gyorsaságnál kezd tévedni...


15. LECKE MOTOROK 1 /ÁLTALÁNOS ISMERTETŐ

Az eddigi részekben leginkább LED-eket kapcsolgattunk, és rajtuk keresztül megtanultuk a vezérlést, és azt, hogy mivel kommunikáljuk.

A robotokat, gépeket azonban motorok mozgatják, így most már a motorokkal fogunk foglalkozni!


Általános tudnivalók (ismétlés):
-Arduino lábait max. 40mA-rel lehet terhelni, 

-Az Arduino-t összességében maximum 200mA -t vehet fel, illetve a 3,3V (a NANO-nha jól tudom nincs bekötve, és az 5V-os?) kivezetése 50mA önmagában, de ezeknek nézz utána!

-USB port á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 a mikró szervomotorok is 200-400mA-t vesznek fel,
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. Ez alól van kivétel, alább bővebben)


Szétválasztás (vagy leválasztás, ahogy tetszik):
A motorok általában nagyobb áramerősséget vesznek fel, mint amit az arduino megenged, sőt, sokszor amit az USB tápja megenged, ezért a motorokat néhány mikró szervomotor kivételével, nem az arduino, vagy az USB tápjáról, hanem külön tápról üzemeltjük. Egyszerű esetben elemről, vagy adapterről. Az, hogy nagyobb ármérősséget vesz fel, azt jelenti, hogy kicsi az ellenállása, és az áram a feszültség hatására, a kis ellenállás miatt nagyon megindul, ami miatt a vezeték, vagy az arduino végzetesen felmelegszik. Minél kisebb az ellenállása valaminek, annál nagyobb áramerősséget vesz, fel, annál inkább melegíti az eszközünket, és annál kevésbé szabad rákötni az arduinora. A legkisebb ellenállása a rövid zárnak van, akkor felszáll a füst is... 
Szétválasztani azért kell, hogy még véletlenül se terheljük túl az arduinot vagy, a párhuzamos, vagy a soros portot,  vagyis még véletlenül se kerüljön rá nagy áramerősség, vagy/és feszültség.
Szétválasztás relével:
Talán ennek a példájával lehet a legegyszerűbben bemutatni mi a szétválasztás.
Képzeljük el, hogy arduinoval akarjuk a villanyt a szobában előre programozva pont este 22:00-kor felkapcsolni, és reggel 5:00-kor le.
Az arduino, mint a többi vezérlő áramkör kis feszültséggel működik, 5V-al, ezt pedig hiába kapcsolom rá az adott időpontban a 230 V hálózati feszültséggel működő 60W-os villanykörtére, az nem fog világítani. Ezért például egy relét használunk.
A relé áll egy tekercsből, a közepében egy vasmaggal, és egy érintkezőpárból. Ha a tekercs a kis  5V-os áramot megkapja, akkor a kialakuló mágneses tér összehúzza az érintkezőpárokat. Az érintkező egy másik áramkört kapcsol össze, mégpedig a 60W-os villanykörtét, a hálózati 230V-os feszültséggel.  Tehát a kicsi feszültségű arduino áramkörrel, ami nem rázz, kapcsolgatom a nagyfeszültségű áramkört, de a nagyfeszültség még véletlenül sem kerülhet az arduinora.
Motoroknál meg a motor ellenállása olyan kicsi, akár csak 10 ohm, hogy rövid zárnak tekinthető. Ha az arduino  5V -os áramkörét ha rövidre zárjuk, akkor azzal túl nagy lesz az áramerősség, az eszköz elfüstöl, kinyiffan. Ezért a motorokat is külön tápról, elemről, adapterről látjuk el energiával, amik jobban bírják a majdnem hogy "rövidrezárást".


A szétválasztás történhet:

- vagy általában az adott motorhoz adott meghajtókat, drivereket, vagy vezérlőmodulokat használunk (amelyekben tranzisztor vagy optocsatoló van). Lejjebb ezeket fogjuk kipróbálni, és használni, de az érdekesség kedvéért néhány szót ejtünk arról, hogy történhet:
- optocsatolóval,
- laikusok számára bonyolultabb tranzisztorral,
- vagy a már említett relével.

Leválasztás optocsatolóval:
Hogy még véletlenül se kerüljön nagyobb áram a vezérlésre, a legjobb megoldás szerintem az optocsatoló. Ebben van egy fényt adó LED, és egy fényt vevő egység. Ugyanúgy vezéreljük, mintha sima LED-et tennénk. Amikor a LED világít, persze ebből nem látunk semmit, mert fekete tokban van, lásd a képen, akkor a vevő vezeti az áramot. Ha nem világit, akkor nem. Ha kicsit világít, akkor a vevő is csak kisebb mértékben engedi át magán az áramot. A LED oldalán, az arduino áramkörében, így csak a megszokott LED vezérléshez használt kis áram folyik (azért a 220ohm-os ellenállásról ne feledkezzünk meg, de a vevő áramkörében sokkal nagyobb feszültség, áramerősség lehet, amely már meg tud hajtani motorokat is (35V, 50mA, 150mW ).
Kezdőknek szerintem nagyon jó, a PC817, (LTV817, K817) optocsatoló, mivel csak négy lába van,
így egyszerű a használata.

Az 1-es, 2-es az arduinó áramköre, a 4-es, 3-as a motoré. A fekete tokon egy kis körrel jelölték az 1-es lábat, ha kinagyítod a képet ezen is láthatod!

Egy hasonló példaprojekt:
http://www.instructables.com/id/Isolating-circuits-from-your-arduino-with-optocoup/

A szétválasztás történhet tranzisztorral, vagy azt tartalmazó gyárilag megtervezett, és összerakott motor driver-rel:
-Ha nem akarunk egyesével vacakolni tranziszorokkal, egyszerűen csak használjuk az ULN2308A jelű 8 csatornás tranzisztormezőt. 2-2 csatorna közösíthető, így 1 A is kapcsolható a chippel, csatornánként!
Vagy a készletekben általában benne van ULN2003 modul, a készletekben szintén megtalálható 28BYJ-48 léptetőmotorhoz!



Önindukció, egyebek:
A motorokban tekercsek vannak, amelyek elektromágnesek. A mágneses erő mozgatja a motorokat. Amikor egy motor tekercsében hirtelen megszűnik a feszültség, vagyis kikapcsoljuk, a mágneses tere, miközben összeomlik, feszültséget gerjeszt a tekercsben, de ennek az áramiránya ellentétes. Viszont akár 150V-tal is visszarúghat egy kisebb motor tekercse is. Ez a nagy feszültség veszélyeztetheti a félvezetőkből készült elektronikát, így sok esetben kell valamit csinálni vele. A motorokhoz használt driverekbe, vezérlőmodulokba bele van építve ennek a kezelése (pl. szétválasztás).
Bővebben hamarosan. 

Motorok:
3 félét vizsgálunk:
-DC motor,
- stepper motor,
- servo motor,


DC motor:
Egyszerűen működik. Áramot kap, és forog. Fordított bekötéssel fordított irányban. H-híddal lehet vezérelni a fogásirányt. Kicsi áramra gyengén és lassan, nagyobbra erősebben, és gyorsabban. Például használhatjuk egy modell autó motorjaként.
PWM

16.LECKE/ MOTOROK /SERVO


Igen használt a távirányításnál (RC-rádió kontroll) világban!
Tipikusan csak 180 fokban működik, tehát például egy modell autó kormányművét mozgathatjuk vele jobbra, vagy balra.
Ugyanakkor léteznek 360 fokban forgó szervomotorok is!
Nagy előnye, hogy egy vezérlővezetéke van, és mindig tudjuk hol áll a motor. Ott, ahová küldtük...

Működése:
Ezt is vezérelni kell, de nem digitek sorozatával, hanem egy elektromos négyzetjel hosszával, ami meghatározza, hogy milyen pozícióba álljon. Tehát egy rövid elektorom impulzussal vezéreljük. Az elektromos impulzus hosszából tudja a motor, hogy 0 és 180 fok között hová álljon be.
A szervo vezérlőjelének tipikus időtartama 20 ms,  az impulzus szélessége nagyjából 0,7 és 2,3 ms között változik.



A servo motorban valójában egy DC motor van. A DC motor tengelyére a potméter (állítható ellenállás) is csatlakozik. A vezérlőjelet a motorba épített elektronika átértelmezi egy ellenállás értékre. Az elektronika elkezdi fogatni a motort, és vele együtt az állítható ellenállást is. Folyamatosan összehasonlítja az állítható ellenállás értékét, és a kapott ellenállás értékét, és addig fogatja a motort, amíg ezek az értékek azonosak nem lesznek. Ha erőszakkal ki akarnánk mozdítani a beállt fokból a motort, akkor nem engedi, és ellenforog, hogy tartsa a kapott értéket (szöget). 



A mikró szervomotorok is, 200-400mA vesznek fel, ami nagyobb, mint ami megengedhető az arduino kivezetésének a terhelhetősége (40mA), illetve meghaladhatja az arduino eszköz, és megközelíti az USB port korlátát is. Így óvatosan kell eljárni.

Micro servo:  9g SG90:


Ezt a típust leválasztás nélkül használják az arduinohoz.
Én mindenesetre először optocsatolós leválasztással próbáltam ki...
Aztán később bátrabb voltam, és tényleg nem füstölt el az arduino, amikor a piros vezetékét az 5V-ra kötöttem be. A motor kb. 200mA áramot vehet fel, de nem egy adott digitális pinről látjuk el tápfeszültséggel (onnan csak vezéreljük), hanem az arduino 5V-os tápkivezetéséről, amely kb. ennyit tud max. elviselni. Kettő servot egyszerre viszont ne köss rá, mert az már nem biztonságos. 

3 vezetéke van, ha tápot használsz, 5V-ot, akkor a 
-fekete vagy barna a föld, vagyis a táp negatív sarkára
-Piros vezeték a táp  5V+ pólusára  kell kötni
-A sárga, narancssárga vezetéket az arduino adott vezérlő kivezetésére kell kötni.

Tehát tulajdonképpen két áramkör van, az egyik a vezérlő pin, a servo sárga vezetéke, ami a motorban a földre, a feketére, vagy barnára végződik,  A másik a motor tápellátása, ami az arduino 5V-otjáról indul, és ez a pozitív pólus, a servo piros vezetékén megy be a motor házában lévő DC motorba, és szintén a föld vezetékére végződik, amit az arduino GND, azaz föld lábára kötünk be.

Klassz dolog benne az, hogy egyetlen egyetlen digitális pin kell csak a vezérlésére!

Ami viszont igen kellemetlen, hogy amikor be vagy kikapcsolod a servo motorodat, akkor gyakran tapasztalhat ugrálást, illetve beáll egy random pozícióba. A hirtelen feszültség löketet vezérlésnek veszi, és felvesz valamilyen  pozíciót. Ez főleg akkor zavaró, ha robotkarról van szó, és a robotkar a "jeltől" furcsa kifacsart állapotba áll be. 
Ezen lehet állítólag segíteni, ha a táp pozitív és negatív pólusa közé egy 100uF értékű, vagy nagyobb kondenzátort kötsz be, mégpedig minél közelebb a motorokhoz. Sőt, az az ideális, ha minden motorhoz, a tövéhez raksz egyet. Ha ez tényleg igaz, akkor nem értem miért nem építik eleve bele...
Sőt, ha hosszabb vezetéket használsz hozzá, akkor akár egy szobavillany fel, és lekapcsolásra beáll a motor egy pozitívba. Gondolom nem árt, ha árnyékolt vezetéket használsz hozzá. Bizony lehetnek még egyéb hasonló meglepetések is. Ráadásul ennek a konkrét kis microservonak a tengelyén vagy egy kis holtjáték is...

Amikor az arduino nano 5V-oltját használod, akkor nagyon legyél figyelmes, hogy nehogy rövidre zárd! Ha két, vagy több motort akarsz üzemeltetni egyszerre, akkor használj külső tápot, de szerintem eleve használj külső tápot! Ez lehet egy mobil töltője, amelyek 5V -osak általában, de vigyáz a polaritására. A mobil töltőjénél a piros vezeték nem biztos, hogy a pozitív pólus, mert nincs erre szabvány! Ki kell mérni melyik vezetéke melyik pólus!  Használhatsz 3 db. 1,5V-os elemet sorba kötve, azaz 4,5 V-ot, és annál még könnyebb is megállapítani,  hogy melyik a pozitív és negatív sarka, mivel rá van írva. A voltmérővel is így lehet pl. megállapítani, hogy melyik a pozitív. Megnézed, egy elemen, hogy a voltmérő melyik vezetékét rakva az elemre mutat plusz voltot, és ugyanezt a vezeték elrendezést használva a telefontöltőn rájöhetsz, melyik annak a pozitív vezetéke.
Így kell bekötni az arduinora a servot, ha külső tápot használsz ( kondenzátort ha használsz, főleg, ha hosszabb vezetékre cserélted az eredetit, a motorhoz közel a barna és a piros vezeték közé kell tenni, ez nincs  a képen. Mivel valószínű elektrolit kondenzátort fogsz használni, annál nézni kell a polaritást. Általában a negatív lábát jelölik meg, vagyis azt kell a barna vezetékre kötni) :


Jellemző projektvezérlése a knob és a sweep (söprés).

A sweep-nél oda-vissza mozgást produkálunk:
0 fok-90 fok- és 180 fokba áll be ilyenkor a motor. Igazából megadhatunk 0 és 180 fok között bármilyen szöget...

void setup()
{
myservo.attach(6);
}

void loop()
{
myservo.write(0);  
delay(1000);
myservo.write(90);  
delay(1000);
myservo.write(180);  
delay(1000);
}
A kód önmagáért beszél A myservo.attach(6); megadjuk, hogy a 6-os digitális pin lesz a vezérlő, a
myservo.write(90); pedig hegadjuk, hogy mekkora szögbe álljon be a motor.
Példa:

A knob-nál egy potenciométerrel változtatjuk a motor helyzetét, és nem csak  fokokban  tudjuk beállítani, hanem a 0 és 180 fokot tulajdonképpen átalakítjuk 0 és 1024 jellé, így még finomabban tudjuk állítani, amihez potmétert használunk. A két kód között a potenciométer és a map kód a különbség...
Példa:

Még finomabb vezérlés:
A szervo vezérlését be tudjuk állítani úgy is, hogy nem fokokban (0-180),hanem a 0 és 180 fok közötti vezérlőjel időtartamával vezérlünk. Alapértéknek 544 és 2400 µs van beállítva, és ezt kihasználva a kódban lassú mozgást, vagy/és igen precíz vezérlést is megvalósíthatunk. Pl lassú sweep:

#include <Servo.h>
Servo myservo;
int val1 = 650;
int val2;
int val3 = 0;
void setup()
{
myservo.attach(6,640,2400);
}
void loop()
{
val2 = val1;

if(val3 == 0){
val1 = val1 + 1;    
}

if(val3 == 1){
val1 = val1 - 1;    
}

if (val1 == 2390) {
  val3 = 1;
}

if (val1 == 650) {
  val3 = 0;
}      
        
myservo.write(val2);  
        
delay(10);

}

Ezzel pedig a sorosmonitorral vezérelhetjük igen pontosan. Először vigyük be a kívánt pozíciót 640 és 2400 közötti értéket, és a motor beáll a pozícióba. A 2-essel a kiküldött cél előtt meg tudjuk állítani, és akkor is elküldi a pozícióját a sorosmonitornak, hol állt meg. A változók nevei:
-bejövő (adat)
-pozíció
Ezekkel könnyebb megérteni, és a kód: 

#include <Servo.h>
Servo myservo;
int bejovo;
int pozi = 650;
void setup()
{
myservo.attach(9,640,2400);
Serial.begin(9600);
}

void loop()
{
if (Serial.available()){
bejovo = Serial.parseInt();
}

if(bejovo > 642 && bejovo < 2398){
if( pozi < bejovo){
pozi = pozi + 1;   
}  
if( pozi > bejovo){
pozi = pozi - 1;   
}
}
  
if (bejovo == 2){
  bejovo = pozi;
  Serial.println(pozi);
}

if (bejovo != pozi){
myservo.write(pozi);
}

delay(10);
}

Egyéb:

Servo vezérlése javascirpttel, böngészőből:


17. LECKE/ STEPPER (LÉPTETŐ) MOTOR

nyomtató, floppy, winchester, scanner, CD-rom-ba, robotokba használják.
Ott, ahol amúgy is digitális jeleket használnak, hiszen digitálisan lehet elég precízen vezérelni, és a kívánt pozitívba állítani.
Ha egy motorra szűkíteném a választást, akkor a léptetőmotor az, amire nekünk szükségünk van a robotjainkhoz, gépeinkhez! 

Alapvetően kétféle léptetőmotor van, a bipoláris, és az unipoláris, 

Unipoláris motor:
A készletekben általában ez az unipoláris motor van benne:
28BYJ-48 a hozzá való ULN2003 as vezérlőmodullal (driverrel).
Az első tapasztalatom vele:4 tekercs van benne, a piros vezeték a közös föld. A piros vezetéken és akármelyik tekercsen 29-30 ohm-ot mértem. Tehát egy tekercsen kb. 218 mA indul meg, és 1Watt teljesítményt ad le. Persze a driverbe nem tudom pontosan mi van, de nyugodtan vegyük ezt. Természetesen a digitális pinek itt is csak vezérelnek, a driverre külön 5V tápot adunk, hiszen ekkora áramot egy digitális táp nem nagyon viselne el. 1 motort az Arduino 5V tápkivezetése elvisz, de már akkor is a maximumon van, de én jobban szeretem mindig a külső tápot. Használhatunk 3db 1,5 Voltos elemet sorba kötve, vagy akár egy 5V-os telefontöltőt, amely kettő,  talán három motort elvisz egyszerre 

-Nem túl gyors, de robotok mozgatására teljesen jó
-Akár csak 4,5 Voltos teleppel is megy, de az alatt elkezd tévedni, 3 Volttal nem működött.
Van 12 Voltos változat is, de az 5 Voltos az általános.
-Belső áttételei miatt, ha nincs áram alatt, akkor sem lehet kézzel se elforgatni, sőt, elég erőt fejt ki működés közben is, és nagyon pontos lenne, ha nem lenne a tengelyének egy pici kotyogása. Így mini robotkarhoz szerintem kiváló, ráadásul talán a legolcsóbb stepper motor, de rajzgéphez, 3D nyomtatóhoz, gravírozó gépekhez, vagy mini CNC-hez a kotyogás miatt problémás. Talán ellensúllyal kell a tengelyt az egyik irányban terhelni, és úgy jó lehet.

Az unipoláris motorokban több, mint kettő tekercs van. Ebben konkrétan négy, 5 vezetékkel. A motor úgy működik, hogy a tekercsekre egymás után kacsoljuk a feszültséget, amellyel elforgatásra késztetjük. Az négy tekercsnek az ötödik, a piros vezeték egy közös pontja:
A leválasztást ULN2003 modullal csináljuk (amit a készletekben amúgy is e motor mellé adnak), és így kötjük be, azaz 
az áramkör kiépítése:
A rajzok erről az oldalról valók:
Bár szerintem jobb, ha tápellátásnak 3 db 1,5 V-os ceruzaelemet sorba kötve használhatunk, vagyis 4,5V-ot, vagy egy 5 Voltos mobil töltőt. 

Arduino kód:

int grade = 0;
int marker = 0;
int mill = 1;
// soros
void setup() {
 pinMode(8, OUTPUT);
 pinMode(9, OUTPUT);
 pinMode(10, OUTPUT);
 pinMode(11, OUTPUT);
 Serial.begin(9600);
}

void loop() {

int marker = Serial.read() - '0';


if (marker == 1) {
mill = 1;
}

if (marker == 2) {
mill = 2;
}

if (marker == 3) {
mill = 3;
}


if (mill == 1){
  grade = 0;
}

if (mill == 2){
  grade++;
}

if (mill == 3){
  grade--;
}

 if (grade == 0){
     digitalWrite(8, LOW);
     digitalWrite(9, LOW);
     digitalWrite(10, LOW);
     digitalWrite(11, LOW);
 }

if (grade == 1){
     digitalWrite(8, LOW);
     digitalWrite(9, LOW);
     digitalWrite(10, LOW);
     digitalWrite(11, HIGH);
}
 if (grade == 2){
     digitalWrite(8, LOW);
     digitalWrite(9, LOW);
     digitalWrite(10, HIGH);
     digitalWrite(11, HIGH);
 }
 if (grade == 3){
     digitalWrite(8, LOW);
     digitalWrite(9, LOW);
     digitalWrite(10, HIGH);
     digitalWrite(11, LOW);
 }
 if (grade == 4){
     digitalWrite(8, LOW);
     digitalWrite(9, HIGH);
     digitalWrite(10, HIGH);
     digitalWrite(11, LOW);
 }
 if (grade == 5){
     digitalWrite(8, LOW);
     digitalWrite(9, HIGH);
     digitalWrite(10, LOW);
     digitalWrite(11, LOW);
 }
 if (grade == 6){
     digitalWrite(8, HIGH);
     digitalWrite(9, HIGH);
     digitalWrite(10, LOW);
     digitalWrite(11, LOW);
 }
 if (grade == 7){
     digitalWrite(8, HIGH);
     digitalWrite(9, LOW);
     digitalWrite(10, LOW);
     digitalWrite(11, LOW);
 }
 if (grade == 8){
     digitalWrite(8, HIGH);
     digitalWrite(9, LOW);
     digitalWrite(10, LOW);
     digitalWrite(11, HIGH);
 }


 if(grade>8){
   grade=1;
 }

 if(grade<1){
   grade=8;
 }

 delay(1);
}

A mások által írt kódok nekem is nehezen értelmezhetőek. Úgy tudsz ezen némileg segíteni, ha megpróbálod kitalálni, hogy a változók mire kellenek, és saját elnevezésre átírod őket. Ekkor olvashatóbb lesz. 

Ez a kód azt csinálja, hogy ha megnyitod a soros monitort, és 1-est küldesz neki, akkor az egyik irányba forog, ha 2-est, akkor a másikba, ha 3-ast, akkor megállítod.

Szerintem ezt a projektet ki lehet próbálni merevlemez motorral is, annyi különbséggel, hogy annak csak három tekercse van, nem négy, és értelemszerűen ennek megfelelően kell változtatni...

Második unipoláris projekt:

Most töltsed fel az alábbi kódot:Amennyiben nem működik a motor, akkor a pinkiosztást kell megvariálni!A program úgy működik, hogy a sorosmonitoron küldesz neki egy számot, és annyit lép az egyik irányba. Ha negatív előjellel küldöd akkor a másik irányba fog elfordulni. 

#include <Stepper.h>// stepper könyvtár megnyitása

int in1Pin = 8;
int in2Pin = 9;//változók hozzárendelése a lábakhoz
int in3Pin = 10;
int in4Pin = 11;

Stepper motor(512, in1Pin, in2Pin, in3Pin, in4Pin); //kimenetek hozzárendelése a stepper motorhoz
//512 a stepper motor 360fokos elmozdulásának felosztása
void setup()
{
pinMode(in1Pin, OUTPUT);
pinMode(in2Pin, OUTPUT);//beállítás kimenetként
pinMode(in3Pin, OUTPUT);
pinMode(in4Pin, OUTPUT);


while (!Serial);

Serial.begin(9600);//soros monitor bitsebességének beállítása
motor.setSpeed(20);//a motor sebessége
}

void loop()
{
if (Serial.available())
{
int steps = Serial.parseInt();//bekéri az értéket a serial monitorból
motor.step(steps);//kiíratás a stepper motorra
}

}



Bipoláris motor:

Motornak használhatjuk szintén a 28BYJ-48 unipoláris motorunkat, de meghekkeljük, és úgy alakíthatjuk át bipolárissá, hogy a tekercsek közös vezetékét, azaz a pirosat nem használjuk fel (nem kell kivágni, de a két tekercs összekötését is el kell vágni. Bővebben itt:
Az így átalakított motorunk már bipolláris, azaz csak kettő tekercse van. Úgy működik, hogy a kettő tekercsen az áramirányt váltogatjuk egy H-híddal.

Különböző kisebb bipoláris léptetőmotorokhoz CNC vagy 3D nyomtató projektekhez még olcsó vezérlő megoldás a L293D ( H-híd) léptetőmotor driver is:
Ennél a projektnél ezt fogjuk használni drivernek.

Mivel a tekercsek hossza megkétszereződött, mert a négy tekercsből kettőt csináltunk, ennél a projektnél NE az arduino 5 Voltját használjuk, hanem kb 7 V-ra van szükségünk. Én kipróbáltam 12V-tal, tényleg nagyon erősnek tűnt, de erőteljesen elkezdett melegedni a motor, és a meghajtó is! Mivel megdupláztuk a tekercs hosszát, mert a négy tekercsből csináltunk 2-őt, azért annak az ellenállás egyenként nem 22,9ohm, hanem 74 köről alakul. Így az áramfelvétel csak fele lesz, és a motor teljesítménye is, ezért 5V-al így nem működik megfelelően a motor. Ezért kell a nagyobb feszültség. 

Az L293 bekötése:
Az 1-es, 8-as, 9-es és 16-os kivezetését a külső táp + pólusára kössük!
a 2-es kivezetését az arduino 12 lábára
a 3-as kivezetését az motor citrom színű vezetékére
a 4-es és 5-ös, 12-es, és 13-as kivezetését a külső tápunk - pólusára, és az arduino földjére (GND) kössük!
az 6-ös kivezetését a motor kék színű vezetékére
a 7-es kivezetését az arduino 11-es lábára
a 10-es kivezetését az arduino 10-es lábára
a 11-es kivezetését a motor rózsaszínű színű vezetékére
14-es kivezetését a motor narancs színű vezetékére
15-ös kivezetését az arduino 9-es lábára


Arduino kód:
(ha a kód nem működik, akkor a pin kiosztásokat variáld meg)

#include <Stepper.h>// stepper könyvtár megnyitása

int in1Pin = 12;
int in2Pin = 11;//változók hozzárendelése a lábakhoz
int in3Pin = 10;
int in4Pin = 9;

Stepper motor(512, in1Pin, in2Pin, in3Pin, in4Pin); //kimenetek hozzárendelése a stepper motorhoz
//512 a stepper motor 360fokos elmozdulásának felosztása
void setup()
{
pinMode(in1Pin, OUTPUT);
pinMode(in2Pin, OUTPUT);//beállítás kimenetként
pinMode(in3Pin, OUTPUT);
pinMode(in4Pin, OUTPUT);


while (!Serial);

Serial.begin(9600);//soros monitor bitsebességének beállítása
motor.setSpeed(20);//a motor sebessége
}

void loop()
{
if (Serial.available())
{
int steps = Serial.parseInt();//bekéri az értéket a serial monitorból
motor.step(steps);//kiíratás a stepper motorra
}

}

A soros monitorba be kell gépelni hány lépést tegyen meg a motor. Ha negatív számot írunk be, akkor ellenkező irányba fog fordulni.

Mi van, ha nincs 7 voltos tápunk, hanem csak 12V-os van?

Az 5 Voltos 28BYJ-48 motor 5Volttól nem működik jól bipolláris módban, a 12V-tól meg nagyon felmelegszik. 9V-nál már csak kismérétkű a melegedés, de mi van, ha csak 12V-os tápunk van?

Vagy egy ellenállást tesszük elé, amin csökkenhet a feszültséget 7-9Voltra, vagy feszültségstabilizátor használunk, pl: IC7809 de ha jól látom, az pl. 9 voltra stabilizál.

A 28BYJ-48 5V-os unipoláris használtanál a négy tekercs egyenként kb. 30 ohm-os ellenállást jelent. Ekkor tekercsenként 166mA folyik.
https://www.rapidtables.com/calc/electric/watt-volt-amp-calculator.html
Egyszerre a 4 tekercsből általában 2 van használatban. Vagyis a két tekercs ellenállása párhuzamosan érvényesül, és a teljes motor ellenállása csak 15ohm.
https://www.allaboutcircuits.com/tools/parallel-resistance-calculator/
A motor áramfelvétele tehát:
5V/15ohm = 0,333A Tehát 330mA a motor teljesítménye pedig 1,666 Watt

Bipolláris módban a négy tekercsből kettő lesz, tekercsenként 60 ohm-os ellenállással, de mivel egyszerre mindkettő tekercs működik, ezért a teljes motornak ilyenkor 30 ohm lesz az ellenállása, és csak 0,166A tud átfolyni rajta.
Ezért a motor teljesítménye azonos 5V-tal leesik, és nem működik jól:
P= V*I
5V * 0,166= 0,83 Watt Ezért gyenge, ezért nem működik jól, mert nagyobb feszültség kell. A 12V-tal viszont túl nagy lesz a teljesítménye, 4,8W ezért melegszik.


Tehát először azt kell kiszámolnunk, hogy mekkora feszültségre van szükségünk ahhoz, hogy a motor teljesítménye 1,666Watt körül alakuljon.
P = (V*V)/R Ebből adódik, hogy:
(v*v)=1,666 * 30 = 49,98 aminek a gyöke = 7 Volt

Vagyis ha 7 voltot használunk bipoláris módban, akkor fog ez a motor annyi teljesítményt leadni, mint 5 volttal unipoláris módban,és ekkor 0,233A fog folyni.

Ha 12Voltos a tápunk, akkor egy ellenállással 5V-tal kell csökkentenünk a feszültséget, hogy 7 Voltot, és 233mA-kapjunk.

Most azt kell kiszámolnunk, hogy mekkora előtét ellenállást kell használnunk, hogy a 12 Voltot 7 Voltra, azaz 5 Volttal ejtsük!

Ehhez is ohm törvényét kell használnunk, mégpedig úgy, hogy a kívánt ejteni szándékozott feszültséget, és azt az áramerősséget használjuk a képletben, amelyikre majd 7 voltnál alakul.

R=U/I


5v/0233= 21 Ohm
Tehát ha a motorunkkal sorba bekötünk a 12V-os áramkörünkbe egy 21 Ohm-os ellenállást, akkor azon 5V-ot fog esni a feszültség, és akkor a motorunk teljesítménye 1,666W körül lesz!

Az ellenállás teljesítményértéke is fontos lehet:
P=U2/R
P = (5*5)/21 = 1,190 Wattosat, vagyis 2 Wattosat használjunk! Ha csak negyed Wattossal próbáljuk, akkor csak 1-2 percig fog működni a rendszer, mert az ellenállás nagyon felmelegszik, tovább nő az értéke, és a feszültség, azzal együtt pedig a motor teljesítménye is leesik.

https://megaled.hu/hu/cikkek/13-led-ekrol-kezdoknek

Kerekítve 18-20-22 Ohmos ellenállást mondjuk 2W-osat lehet kapni, vagy ha nincs éppen a fiokban, ki lehet alakítani:
https://www.allaboutcircuits.com/tools/parallel-resistance-calculator/

 Dupla hekkelés:
12V-tal meghajtunk kettő 28BYJ-48 5V-os motort, amelyeknek a tekercseit sorosan kapcsoltjuk. Ezzel nem csak nagyobb teljesítményt kapunk, hanem a motorok tengelyét egymásnak feszítve eltüntethetjük a motorok holtjátékát is!
Ez a rajzon egymás felé fordítva a motorokat, a tengelyüket összekötve mutatja a motorok bekötését.
Ehhez 12 V tápfeszültséget kell használni. Ekkor a motorok 31 fokra, az L293D max. 61 fok Celsiusra melegedettet csupán, a tesztem során, ami elég jó!



Bővebben:

18. LECKE / ANALÓG PIN

Ebben a leckében egy analóg pin projektet kell csinálni!
A nehézség az, hogy most egy külső oldalról kell megvalósítani. Vagy egy magyar nyelvű oldalról, vagy egy idegennyelvűről.
A cél az, hogy egy potméter (változtatható) értékű ellenállás értékét felosztjuk 0-1024-ig, és amikor eltekerjük, akkor az értékét kiírjuk a soros monitorra.
Tip: ebben a könyvben:
http://mumia.art.pte.hu/mami/tartalom/elokeszito-2017/tovabbi_konyvek/Harsanyi_Reka_Juhasz_Marton_Andras--Fizikai_szamitastechnika__elektronikai_alapok_es_Arduino_programozas_.pdf
a 157. oldaltól a 159. oldalig van leírva a projekt!

A következő részben leckében az arduino programozásáról, kódokról, lesz szó.

Az arduino alapjait gyorstalpaló módon elsajátítottad. A további fejlődésedet a fentebb linkelt könyv elolvasásával, és egyéb arduino leckék kipróbálásával csiszolhatod.

Egyéb arduino leckéket tartalmazó oldalak:
http://harsanyireka.blog.hu/

http://www.tankonyvtar.hu/hu/tartalom/tamop412A/2011-0010_harsanyi_fizikai_szamitastechnika/index.html

60 napos ingyenes arduino tanfolyam e-mailben:
http://www.tavir.hu/60nap

http://www.elektromanoid.hu/arduino.html

http://jataka.hu/rics/artu/index.html#arduino

http://gamessoon.ru/hu/arduino-basis-arduino-lessons-for-beginners-we-blink-led/

Ha valakit kihagytam, akkor küldjétek el a linkjét a lap alján...

19.LECKE/ ARDUINO KÓDOK:


Ezen az oldalon van az arduino nyelve:
https://www.arduino.cc/reference/en/#functions

Talán az alapokhoz még a for és az array tartozhat. Ezeket itt találod meg:
https://www.arduino.cc/reference/en/language/structure/control-structure/for/
https://www.arduino.cc/reference/en/language/variables/data-types/array/

20.LECKE/ AZ ARDUINO ÉS A VB

Ha már számítógéppel összekötöttük az arduinonkat, akkor azzal is tudjuk vezérelni azt, mint ahogyan a sorosmonitoron keresztül tettük. Ha viszont  saját sorosmonitort csinálunk, akkor a kód egy részét, vagy  a közvetlen végrehajtást kivéve, majdnem az egészet  is kiszervezhetjük a számítógépre, és így annak  a  sokkal nagyobb erőforrásait, memóriáját, és egyéb képességeit kihasználva, szinte korlátlanok lehetnek a lehetőségeink.

1. A legtöbb programnyelven sajnos nem olyan egyszerű programozni, mint a  JavaScripttel, és általában sajnos le kell töltenünk, és telepítenünk kell a programíráshoz egy programot is. Ezeket IDE-nek, integrált fejlesztői környezetnekek hívjuk.


Töltsd le a Visual Studio Express-t, de a 2012-est ajánlom, mert a legfrissebbnek a telepítése már nagyon el van bonyolítva, és problémáid lehetnek vele!
Ennek a telepítéséhez itt találsz például segítséget a youtube-on:

2. Ha telepítetted, akkor nézd meg ezt a két 15 perces videót, mely elmondja az alapokat, és utána ha a következőket is elolvasod, akkor fogod tudni irányítani az arduinodat Visual Basicből, illetve egyszerűbb másmilyen programokat is fogsz tudni csinálni!



Itt egy bónusz, hogy csinálhatsz saját böngészőt! Elképesztően egyszerű, de már elavult, nem biztos hogy teljesen jó lesz:



21 LECKE/ VB SOROS KOMMUNIKÁCIÓ!

Most elkészítjük a saját soros monitorunkat VB-vel. Ez egy egyszerű program lesz, ahol van 4 gomb. Minden gomb lenyomásánál elküldünk egy-egy kódjelet, amivel a két LED-ünket fel, vagy lekapcsolhatjuk.  Alakítsuk ki a VB kódot!
Nyissuk meg a Visual Studio 2012-őt, és válasszuk ki a Basic nyelvet, valamint a Windows for applicationt-t. Adjunk valami nevet is a projektnek, pl. LED contorol is lehet.
Ezután betölti a form1-et a program.
A tools-ból húzz rá a form1-re négy gombot! Az egyik gombra írd rá, hogy LED1 BE, a másikra: LED2 BE, a harmadikra: LED1 KI, a negyedikre: LED2 KI.
Amikor rákattintasz az adott elemre egy bal egérkattal, vagyis amikor egy elemet (pl. gombot) kijelölöd, akkor a properties  (tulajdonságai) ablakban megtalálod a Button (gomb) text részt, ott tudod átírni a gombok alap feliratát, pl. a Button1-et LED1-BE-re, stb. Húzz rá még egy SerialPort-ot is, ez is a toolsban van, mint a gomb (button), vagy a label, azaz a címke, amin a feliratokat tudjuk megjeleníteni a form-on. Ha kettőt rákattintasz a form1-re, vagy valamelyik elemére, pl. gombra, akkor megjelenik a program által generált kódja. Ha a gombra kattintasz, akkor kurzor a gomb kódjába lesz benne, ahová kell írni, hogy a gomb mit csináljon, ha lenyomod.
 A kódban az alábbi  részt generálja a program, amikor a form1-re mindent ráhúztál, amit említettem.


Public Class Form1


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

    End Sub

    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click

    End Sub

    Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click

    End Sub

    Private Sub Button3_Click(sender As Object, e As EventArgs) Handles Button3.Click

    End Sub

    Private Sub Button4_Click(sender As Object, e As EventArgs) Handles Button4.Click

    End Sub
End Class


Ha valamelyik kódrészlet nem jelenik meg, pl ez.

 Private Sub Button4_Click(sender As Object, e As EventArgs) Handles Button4.Click

    End Sub

Akkor kattints a Form1 VB (designe) fűlre, majd a negyedikre ráhúzott gombra (Button4) kettőször. Akkor a kódrészlete belekerül a négyes gomb a program által generált kódja is, amibe illeszd be ezt:

        SerialPort1.Open()
        SerialPort1.Write("3")
        SerialPort1.Close()

Vagyis így fog kinézni a kódrészlet:

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

Mindegyik kódrészletet tölt fel, illetve egészíts ki, hogy a teljes kód így nézzen ki:

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

Ilyen egyszerű a VB! A vizuális elemeket a program kódolja, és mi azokba írjuk a saját kódjainkat...
Ha megnézed a teljes kódot, akkor az alábbi lesz a kinézete, max, az elemek kódrészletei nem ilyen sorrendben jelennek meg nálad. Írd át a com4 részt  arra, amely USB csatlakozást te használod, pl com3-ra, pirossal megjelöltem a helyet! Tehát arra az USB portra, amelyet az arduino programban is bejelöltél, hogy melyik USB "lyukat" használod.

A kód magyarázata:
Megnyitjuk a soros kommunikációs csatornát:
SerialPort1.Open()
Elküldjük az arduinónak a 3-as klaviatúra gomb karakterét:
SerialPort1.Write("3")
Bezárjuk a soros kommunikációs csatornát:
SerialPort1.Close()

ez pedig az arduino kódja hozzá, ezzel már találkoztunk:

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);
}

}

A VB kódból láthatjuk, hogy a 4.-re a form1-re ráhúzott gombbal  ( Private Sub Button4_Click...)
Egy 3-as karaktert küldünk az arduinonak, ami, ezt meg az arduino kódjában láthatjuk, a 8-as pinen lévő LED-et lekapcsolja.
Ez a rész a soros kommunikációs protokolja a VB-nek, ezt csak be kell mindig másolni a VB form1 kódjába, mint amikor az arduino setupjába a Serial.begin(9600); részt másoltuk. Többet nem kell róla tudnunk, a különbség csak annyi, hogy ez hosszabb, mint az arduino kódjának a protokollja:

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

És ehhez a soros kommunikációs protokollhoz tartozik ez a rész is:

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

Most csak ennyit erről a VB kódról...
---------------------------------------------------------------------

Az alábbi írás innentől éppen szerkesztés alatt áll!

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


 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...

--------------------------------------------------------------------

ARDUINO -VB LECKE / SZÁMADATOK  IDE-ODA

Küldjünk egy egyes számot a Visual Basic-ből  az arduinonak, avval adjunk hozzá még egyet, küldjük vissza a VB-nek, ott adjunk hozzá megint egyet, majd jelenítsük meg egy címkén (label). Aztán a VB gomb segítségével most a növel számot küldjük el az arduinonak, és így tovább!

Az arduino kódja:

const boolean DEBUG = true;
unsigned int kimeno;
char karakterhossz[10];
int bejovo;

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


void loop()
{
if (Serial.available()){
bejovo = Serial.parseInt();
}

if (bejovo > 0){
  kimeno = bejovo + 1;
  formatNumber( kimeno, 4);
  Serial.print("<A");
  Serial.print(karakterhossz);
  Serial.print(">");
  if (DEBUG) { Serial.println("");  }
}
delay(10);
}

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

    strcat(karakterhossz,kimenoString);


}

A VB kódja:
( egy sorosport, egy label, két gomb, egy combobox, és egy timer, van ráhúzva a formra. Semmi más különleges beállítás nincs, csak amit a kódban látsz.) 


Imports System
Imports System.IO.Ports
Public Class Form1

    Dim comPORT As String
    Dim receivedData As String = ""
    Dim bejovo As String
    Dim kimeno As Integer

    Private Sub Form1_Load(sender As Object, e As 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 Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Timer1.Start()
        If Label1.Text > 1 Then
            kimeno = Label1.Text + 1
            SerialPort1.Write(kimeno)

        Else
            SerialPort1.Write("1")
        End If
    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

            Else
                MsgBox("Select a COM port first")
            End If
        Else
            SerialPort1.Close()
            Button5.Text = "Start"
            Button1.Enabled = False
            Timer1.Enabled = False
            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
                        Label1.Text = newCommand.Substring(1, 4)
                     
                    End If

                End If

            End If



        End While

    End Function


End Class

----------------------------------------------------------------
EGYÉB:

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