Váci Robotika Labor |
You are here » Váci Robotika Labor » Tanári tanfolyam (csak olvasható) » Tananyagok
Ide fogom gyűjteni azokat a dolgokat amik hasznosak lehetnek.
Az előadáson bemutatott prezentáció innen tölthető le: Robotika_prezentáció
Ajánlott videók:
Arduino - alapok
És az egyik első a témában amiből anno én elindultam (vigyázat, ez hosszúúú! - csak "elvetemülteknek"): Heckerspace workshop
Sziasztok!
András említette, hogy sok fritzing ábrát fogunk látni. Gondoltam, elkészítem és közreadom Nektek a jelzőlámpás kapcsolást. Letöltöttel a fritzing-et az oldalról (http://fritzing.org/download/), de sajnos mind a 64 bites, mind a 32 bites lefagy. Megjelenik az ablak, de "nem válaszol". Több gépen is próbáltam, sehol nem működik. Van valakinek tapasztalata vagy ötlete? András, Te használod? Működik?
Szia!
Nekem már le volt töltve az itthoni gépemre (kb egy hónapja szedtem le) az működik...
Lehet, hogy az aktuális verzióval van valami, nem tudom.
Nekem ez van meg:
Gyorsan össze drótoztam benne a 3 ledes kapcsolást:
A ledek hosszabbik lába van egy oszlopban az ellenállással.
A rövidebbik lábuk mindegyike az alsó kék (negatív, azaz föld) sorra kapcsolódik (az meg az Arduino GND-jére)
Az ellenállások pedig sorban az Arduino 13, 12, 11 lábára
Az arudino 5V-jéről való piros vezeték (az alsó) elhagyható - csak ezzel jelzem, hogy így szoktunk a "dugdosós" panelra áramot kötni. Ha az Arduino-ra menő vezetékek közül bármelyiket a piros sorba kötjük, az a led állandóan világítani fog (hisz így az Arduino tulajdonképpen csak mint áramforrás van jelen)
Ha a Fritzing mégsem működne akkor egy online alternatíva a www.tinkercad.com
Most játszogatom vele, elvileg tudja amit nekünk kell... Érdemes kipróbálni
És akkor az előbbi 3 fényű közlekedési lámpa kiegészítve a gyalogosoknak szánt kétszínű lámpával.
Az elv ugyan az, minden led pozitív (hosszabbik) lába egy ellenálláson keresztül kapcsolódik az Arduino egy lábára...
Ez a rajz már az online trincercad-al készült
Szorgalmi feladat piros pontért: hogy néz ki az Arduino kód?
Sikerült megoldanom a fritzing-et. Hosszú, majd elmesélem a tantermi szeánszon
Sziasztok!
Erről a linkről letölthetitek a C programozási nyelv könyvet.
Ez a programozási nyelv e könyv szerzői által lett kifejlesztve, illetve az Arduino IDE
is jórész ezzel használható.
http://vili.pmmf.hu/portal/documents/18 … nighan.pdf
András lécci írd meg, kedden mit vigyünk a készletből.
Sziasztok!
A Blink-et átírtam Morse S O S-re ...---...
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
for (int i = 0 ; i<3 ; i++) {
digitalWrite(LED_BUILTIN, HIGH);
delay(100);
digitalWrite(LED_BUILTIN, LOW);
delay(100);
}
delay(1000);
for (int i = 0 ; i<3 ; i++) {
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
delay(1000);
for (int i = 0 ; i<3 ; i++) {
digitalWrite(LED_BUILTIN, HIGH);
delay(100);
digitalWrite(LED_BUILTIN, LOW);
delay(100);
}
delay(2000);
}
Sziasztok!
A közlekedési lámpa kódja:
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
pinMode(11, OUTPUT);
pinMode(10, OUTPUT);
pinMode( 9, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);
digitalWrite( 9, HIGH);
delay(500);
digitalWrite(12, HIGH);
delay(200);
digitalWrite(13, LOW);
digitalWrite(12, LOW);
digitalWrite(11, HIGH);
digitalWrite( 9, LOW);
digitalWrite(10, HIGH);
delay(500);
digitalWrite(11, LOW);
digitalWrite(12, HIGH);
digitalWrite(10, LOW);
delay(500);
digitalWrite(12, LOW);
}
Zoli
Ötletes és jópofa az SOS!!! Főleg, hogy már a For-t is használtad változóval. Köszönjük, hogy közreadtad!
Csak "kötöszködés": az i változót használod mind a 3 alkalommal és mind a háromszor deklarálod is az int i-vel. Nem hiba (!!!) de elég lenne a legelején egyszer megadni, hogy int i, aztán a for-ban úgyis i=0-val beállítod a kezdőértéket.
Csak így tovább! 
Repes a szívem a kísérletezést látva!!
És jár a piros pont a közlekedési lámpa kódjáért! Kedden ki is próbáljuk!
Amit keddre hozzunk magunkkal a csomagból: (levélben is elküldöm, hogy tuti mindenkihez elérjen)
Arduino Uno + a kék USB kábel (+ ha tud valaki hozzon USB hosszabbítót, hogy kényelmesen elérjen a gépig)
dugdosós próbapanel
színes vezeték csokor
jumper készlet (átlátszó dobozban szines rövid merev "drótok" - a próbapanel alatt volt)
LED - 2 piros, 1 sárga 2 zöld
a 4db 220Ohm ellenállás amit kiosztottam (adok még hozzá)
2db nyomógomb (zöld kupakkal)
potméter (az az arany/ezüst színű tekergethető bigyó)
Multiméter (aki már tudja használni annak nem kell, csak aki még nem látott ilyet)
Amit keddre tervezek:
Multiméter használata (ellenállás, fesz mérés)
jelzőlámpa program és kapcsolás
digitális és analóg bemenetek kezelése (gomb és potméter)
soros monitor és soros plotter használata
ha jut rá idő: (ha nem akkor legközelebb)
kimenet erősítése és leválasztása (tranzisztor, FET, ULN2003, opto csatolók stb...)
Sziasztok!
Az Arduino szofvver referenciája:
https://www.arduino.cc/reference/en/lan … cture/for/
A i változóra visszatérve. Köszönöm a meglátást, precíz.
Régi megszokás, hogy lokál változókkal nem töltöm a memóriát,
csak a függvény futási idejében.
Igen ám, de itt a program mindössze egy függvény, így ez a helytakarékosság
nem áll fenn.
Sziasztok!
András hozzak holnap pákát?
Közlekedési lámpa 2.0 (ugyanis az előző hibás)
Ez áttekinthetőbb:
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
pinMode(11, OUTPUT);
pinMode(10, OUTPUT);
pinMode( 9, OUTPUT);
}
void loop() {
int i;
//1 fázis autónak piros, gyalogosnak zöld
digitalWrite(13, HIGH);
digitalWrite( 9, HIGH);
delay(1000);
//Váltás: autónak piros-sárga, gyalogosnak villogó zöld
digitalWrite(12, HIGH);
for (i=0; i<3; i++){
digitalWrite( 9, HIGH);
delay(200);
digitalWrite( 9, LOW);
delay(200);
}
//2. fázis Autónak zöld, gyalogosnak piros
digitalWrite(13, LOW);
digitalWrite(12, LOW);
digitalWrite(11, HIGH);
digitalWrite( 9, LOW);
digitalWrite(10, HIGH);
delay(1000);
//Váltás autónak sárga, gyalogosnak piros
digitalWrite(11, LOW);
digitalWrite(12, HIGH);
delay(1000);
digitalWrite(12, LOW);
digitalWrite(10, LOW);
}
Ha tudsz és szeretnéd, hogy kipróbáljuk hozd! (és ha még időben olvasod ezt)
Kiküldtem az e-mailt is a keddi szeánszunk-ra vonatkozólag - de bízom benne, hogy ha nem is regisztráltak fel a fórumra, azért olvasták a többiek is...
A most délutáni kísérletünk egyik kapcsolása a fentebb látható 5 ledes kapcsolás (jelzőlámpa), és a hozzá tartozó kiinduló kód amit bővíteni fogunk:
int gyalogzold = 13;
int gyalogpiros = 12;
int autozold = 11;
int autosarga = 10;
int autopiros = 9;
int i;
void setup() {
pinMode(gyalogzold, OUTPUT);
pinMode(gyalogpiros, OUTPUT);
pinMode(autozold, OUTPUT);
pinMode(autosarga, OUTPUT);
pinMode( autopiros, OUTPUT);
digitalWrite(gyalogzold,LOW);
digitalWrite(gyalogpiros,LOW);
digitalWrite(autozold,LOW);
digitalWrite(autosarga,LOW);
digitalWrite(autopiros,LOW);
}
void loop() {
}
Sziasztok!
Lampa 3.0
Kód javítva András iránymutatása alapján
int autopiros = 13;
int autosarga = 12;
int autozold = 11;
int gyalogpiros = 10;
int gyalogzold = 9;
int i;
void setup() {
pinMode(gyalogzold, OUTPUT);
pinMode(gyalogpiros, OUTPUT);
pinMode(autozold, OUTPUT);
pinMode(autosarga, OUTPUT);
pinMode( autopiros, OUTPUT);
digitalWrite(gyalogzold,HIGH);
digitalWrite(gyalogpiros,LOW);
digitalWrite(autozold,LOW);
digitalWrite(autosarga,LOW);
digitalWrite(autopiros,HIGH);
}
void loop() {
//1 fázis autónak piros, gyalogosnak zöld
digitalWrite(autopiros, HIGH);
digitalWrite( gyalogzold, HIGH);
delay(1000);
//Váltás: autónak piros-sárga, gyalogosnak villogó zöld
digitalWrite(12, HIGH);
for (i=0; i<3; i++){
digitalWrite( gyalogzold, HIGH);
delay(200);
digitalWrite( gyalogzold, LOW);
delay(200);
}
//2. fázis Autónak zöld, gyalogosnak piros
digitalWrite(autopiros, LOW);
digitalWrite(autosarga, LOW);
digitalWrite(autozold, HIGH);
digitalWrite(gyalogzold, LOW);
digitalWrite(gyalogpiros, HIGH);
delay(1000);
//Váltás autónak sárga, gyalogosnak piros
digitalWrite(autozold, LOW);
digitalWrite(autosarga, HIGH);
delay(1000);
digitalWrite(autosarga, LOW);
digitalWrite(gyalogpiros, LOW);
}
int gyalogzold = 13;
int gyalogpiros = 12;
int autozold = 11;
int autosarga = 10;
int autopiros = 9;
int i;
void setup() {
pinMode(gyalogzold, OUTPUT);
pinMode(gyalogpiros, OUTPUT);
pinMode(autozold, OUTPUT);
pinMode(autosarga, OUTPUT);
pinMode( autopiros, OUTPUT);
digitalWrite(gyalogzold,LOW);
digitalWrite(gyalogpiros,LOW);
digitalWrite(autozold,LOW);
digitalWrite(autosarga,LOW);
digitalWrite(autopiros,LOW);
}
void loop() {
//auónak piros gyalog zöld
digitalWrite(autopiros,HIGH);
digitalWrite(gyalogzold,HIGH);
delay(2000);
//váltás: autó piros-sárga, gyalog-zöld villog
digitalWrite(autosarga,HIGH);
for (i=0; i<3; i++) {
digitalWrite(gyalogzold,LOW);
delay(200);
digitalWrite(gyalogzold,HIGH);
delay(200);
}
//gyalog piros, autó zold
digitalWrite(gyalogpiros,HIGH);
digitalWrite(gyalogzold,LOW);
digitalWrite(autopiros,LOW);
digitalWrite(autosarga,LOW);
digitalWrite(autozold,HIGH);
delay(2000);
//autóknak sárga
digitalWrite(autozold,LOW);
digitalWrite(autosarga,HIGH);
delay(200);
//autóknak piros, gyalog zöld
digitalWrite(autopiros,HIGH);
digitalWrite(gyalogzold,HIGH);
digitalWrite(gyalogpiros,LOW);
digitalWrite(autosarga,LOW);
}
II. alkalom
Digitális bemenet, le/fel húzó ellenállás
A keddi okításon foglalkoztunk a digitális és analóg bemenetekkel és azok stabil vagy "lebegő" változatával.
Ha egy mikrovezérlő egyik lábát bemenetre állítom, például a pinMode(A0,INPUT) paranccsal, akkor onnantól gondoskodnom kell arról, hogy ez a bemenet csak föld (GND) vagy táp (5V) feszültség értéken legyen. Ha nem kötök rá semmit, vagy előállhat olyan helyzet, amikor semelyik fix potenciálra nem csatlakozik, akkor az a bemenet lebeg, és az onnan jövő információ értékelhetetlen, hisz minden zavart összeszed a környezetből.
A kódunk így néz ki:
Tehát bemenetnek az A0-ás lábat használom (ami képes analóg és digitális jelek fogadására is), kimenetnek pedig a jól megszokott 13-as lábunkat, amire egy 220 Ohm ellenálláson keresztül egy ledet kötök.
Ha az A0-ás lábra nem kötök semmit, vagy csak egy sima vezetéket ami sehova nem csatlakozik (tulajdonképpen antenna lesz), akkor mivel az minden zavart összeszed, hol magas, hol alacsony értékre kerül a bemenet, tehát a ledet is vagy bekapcsolja vagy sem - de ez kontrollálhatatlan, hisz teljesen a környezeti zavaroktól függ!
Kísérlet gyanánt, az A0-ás lábat ha fixen 5V-re kötöm (rádugom a próbapanel piros sorába), az már magas szinten stabilizálja a bemenetet, tehát a led folyamatosan világítani fog - és már nem lesz érzékeny a zavarokra, ahogyan fordítva is: ha fixen a GND-re kötöm a vezetéket a led elalszik, és úgy is marad, hisz a bemenet stabil GND állapotba kerül.
Ha tudjuk végezzük el újra ezt a kísérletet, hogy biztosan értsük, hogy mi történik, és lássuk, hogy miért kell elkerülni a lebegő állapotot
(viszont gyerekekkel látványos "elektroszmog jelzőt" lehet így készíteni, mert a fénycsövek, hívásban lévő telefonok és egyéb nagyfrekvenciás zavaró jelek remekül "megbolondítják" a ledet)
Ezután bővítsük ki a kapcsolást egy nyomógombbal és egy 10Kohm-os ellenállással a rajz szerint:
(ne felejtsük el, hogy a készletben kapott nyomógomb keresztben kapcsol, tehát az egymással átlósan szemben lévő lábait használjuk - mint a rajzon!)
A rajz szerint most az A0 bemenet egy 10K ellenálláson keresztül folyamatosan "földre van húzva", tehát ha a nyomógomb nincs benyomva, akkor stabil alacsony állapotban van, ha pedig a nyomógombot benyomjuk, akkor az 5V tápfeszültség kerül rá. Jelen esetben ez egy pozitív kapcsolt, földre húzott stabil bemenet!
(mivel az ellenállás elég nagy, ezért a nyomógomb benyomásakor nem keletkezik rövidzár, hisz az ellenálláson folyó áram nagyon kevés, így ezzel nem kell foglalkoznunk)
Ennek a fordítottja lenne, ha a 10K ellenállás nem a GND-re, hanem az 5V-ra lenne kötve, és a nyomógombom pedig nem az 5V-ot, hanem a GND-t kapcsolná. Akkor egy föld kapcsolt, tápra húzott bemenetet kapok, ami alap állapotban HIGH, tehát magas szinten van, a nyomógomb benyomásával pedig LOW, alacsony szintre kerül (amíg nyomom)
Mindkét eset helyes, mert mindkettő folyamatos stabil állapotot eredményez. A különbség csak annyi, hogy amikor a programban a bemenetet vizsgálom, akkor azt kell figyelnem, hogy HIGH vagy LOW állapotban van-e a nyomógomb benyomva.
Tehát, földre húzott, táp kapcsolt esetben (első variáció):
if (digitalRead(A0,HIGH)) { digitalWrite(13,HIGH) } // - ha benyomom a gombot a led világít
else { digtalWrite(13,LOW); } // - különben nem világít
Ugyan ez tápra húzott, földkapcsolt estben:
if (digitalRead(A0,LOW)) { digitalWrite(13,HIGH) } // - ha benyomom a gombot a led világít
else { digtalWrite(13,LOW); } // - különben nem világít
A feszültségosztó
Ha egy tápegységre (jelen esetben az arduino 5V és GND lába) két ellenállást kötök sorosan (tehát GND - első ellenállás, második ellenállás 5V) akkor a két ellenállás és a GND közötti feszültséget a két ellenállás egymáshoz viszonyított értéke határozza meg. - Ez a feszültségosztó.
Rajzon egy így néz ki:
Tehát a rajz alapján az U1 lesz a tápunk, azaz a bal alsó pont az arduino GND-jére csatlakozik, a bal felső pedig az 5V-re. Ha az R1 és R2 ellenállás értéke egyforma - pl mindkettő 10KOhm lenne, akkor a kimenet a bemeneti feszültség pont felére csökkenne, tehát U2 = 2,5V
Ha a felső R1-es ellenállás értékét csökkentem, akkor a kimenet az 5V felé húzódik, tehát az U2 feszültség nőni fog.
Fordítva ugyanígy, ha az alsó ellenállás értékét csökkentem, akkor a rendszer már a föld felé húzódik inkább, így az U2 kimeneti feszültség csökken.
Az órán is mondtam, hogy ezzel a megoldással előállított feszültség viszont nem alkalmas arra, hogy azzal nagy fogyasztókat lássunk el árammal, mert ez csak nagy ellenállásokkal működik, amiken csak kevés áram halad, tehát a kimenetét (az U2) nem használjuk sem villanymotor se semmi más meghajtására, kizárólag mérésre!
És itt jön képbe...
A potenciométer
(a zsargonban csak potméter, vagy poti)
A potiknak 3 lábuk van, a két szélső közül az egyiket (mindegy melyiket) a tápra (5V) kötjük, a másikat pedig földre (GND) A középső láb lesz az amin keresztül annyi feszültség jön ki, ahol éppen áll a potméter. Ha abba az irányba tekerjük a potit, amelyik lábára a földet kötöttük akkor csökken a feszültség (egész 0-ig) ha a másik irányba akkor 5V-ig nő a feszültség.
A programunk maradjon ugyan az mint az előző hozzászólásban volt, tehát a 13-as láb lesz a kimenet, amire egy 220Ohm-os ellenállás és egy led van kötve, és az A0 lesz most is bemenetünk ahova a poti középső lábát kötjük.
Mivel a programban digitalRead(A0) szerepel, a láb digitálisan fogja beolvasni a bemenő feszültséget, ami vagy LOW, vagy HIGH szintet fog eredményezni attól függően, hogy hova tekertük a potinkat, és így a led is vagy kigyullad vagy nem.
(ínyenceknek: ez így komparátornak tekinthető, azaz egy bemenő analóg jelből így lesz digitális jel, illetve állapot)
Plussz infó: Wikipedia - poetenciométer
Mi a csomagunkban 2db 10KOhm-os, lineáris potencométert kaptunk. A két szélső lábra ha rámérünk a multiméterünkkel akkor 10KOhm körüli értéket kell, hogy kapjunk. Ha kivesszük a potmétert a kapcsolásból és az egyik szélső lábra és a középsőre mérünk rá (pl, a kapott krokodilcsipesszel rögzítve a kábeleket) akkor a poti tekergetésével együtt láthatjuk annak ellenállás változását is.
Ha a fenti kapcsolást meghagyjuk, és az Arduino is áram alatt van, és úgy kötjük a multiméterünket a GND-re és a poti középső lábára (és feszültségmérésre kapcsoluk) akkor azt az osztott feszültséget látjuk, ami az A0 bemenetre kerül, így a ledet is figyelve kimérhető, hogy az Arduino mekkora feszültségnél értékeli HIGH (magas) állapotnak a bemenő jelet, és mikor alacsonynak.
Na most a fenti kapcsolás ugyan remekül működik, de nem sok értelme van, hisz csak annyit csinálok, hogy a potmétert kapcsolónak használom, azaz bizonyos szint alatt ki, felette pedig bekapcsolom vele a ledet.
Arra használható ez a megoldás, ha pl egy tartályból amiből lassan folyik el a víz, azt figyeljük egy potméterre kötött úszóval, hogy kezd kifogyni (az úszó a víz tetején egyre lejebb kerül, magával húzva a potit), így bekapcsolhatunk pl egy kis szivattyút ami újratölti a tartályt...
Hogy az A0 bemenetünket valóban analóg bemenetnek tudjuk használni kis módosításra van szükség a beolvasásnál, tehát a digitalRead(A0) helyett az analogRead(A0) parancsot fogjuk használni.
És, hogy valahol tárolódjon is a kiolvasott érték felveszünk a setup elött, egy új változót:
int ertek;
Még egy dolog mielőtt továbblépnénk...
Soros monitor
Ugye eddig csak feltöltöttük a programjainkat a gépről de a mikrovezérlő nem üzent vissza semmit a számítógépnek, pedig igen hasznos lenne ha megtenné..
A Setup részben deklaráljuk a soros monitort így:
Serial.begin(9600);
Itt a 9600 az Baud-ban van megadva, azaz bit/másodpercben. Általában kétféle értéket szoktunk használni a 9600-at és a 115200-at. (hogy miért pont ezt... ööö... csak?)
Tehát ha deklaráltuk a soros portot akkor a programban (tehát a loop-on belül) bárhol használhatjuk is az alábbi paranccsal:
Serial.println("hello!");
A két " közötti rész amibe bármit írhatunk, ha a program odaér akkor kiírja soros monitorra. Ahhoz, hogy lássuk is amit ír nekünk a mikrovezérlő nyissuk meg az eszközök menüpont, soros monitor-t. Az így megjelenő ablak jobb alsó sarkában ellenőrizzük, hogy a 9600-as szám van-e, ha nem gördítsük le és állítsuk be ezt.
Innentől ezt debug monitorként is használjuk, azaz a program kódba nem csak kommenteket helyezhetek el ( //valami ) hanem, hogy ellenőrizni tudjuk a működést a soros monitorra is kiírathatunk üzeneteket, hogy lássuk épp ott tart a program, vagy akár változók aktuális értékeit is...
(és mivel az arduino nem foglalkozik azzal, hogy van-e valaki aki megkapja ezt az üzenetet, akkor sem okoz hibát ha nincs számítógépre kapcsolva az elkészült áramkör. Sokszor használják összetettebb rendszerekben is, hogy ott van a soros csatlakozó a vezérlő panelen, és beállításhoz vagy hibakereséshez használják, majd lehúzzák róla a számítógépet és "dumál a semmibe")
Visszatérve az analóg bemenet méréshez a programunk most így nézzen ki:
Ha ezt feltöltjük, és elindítjuk a soros monitort, akkor láthatjuk, hogy folyamatosan írja az értékeket 0 és 1023 között attól függően, hogy a potit merre tekerem el.
Ugyan ezt megnézhetjük soros plotteren is (a soros monitort előbb zárjuk be) és nyissuk meg az eszközök menüpont soros plotter-ét.
Ilyenkor egy görbén ábrázolva látjuk a potméterünkkel beállított értéket (a 0 az 0V, az 1023 pedig 5V-nek felel meg a poti középső lábán, a feszültségosztó szabályai szerint)
Összefoglalás
Idáig tehát amiről szó volt:
-Arduino IDE letöltése és telepítése
-Arduino általános felépítése (feszültségei, digitális ki/bemenetei, analóg lábak stb..)
-Forrasztásmentes próbapanel (dugdosós próbapanel) használata (vezetékek, összeköttetések stb)
-Digitális kimenetek (ellenálláson keresztül bekötött led be és kikapcsolása)
-Digitális bemenetek (gomb fel vagy lehúzó ellenállás használatával)
-Analóg bemenetek (potméter használata valamely analóg bemeneten A0-A5)
-Soros monitor (szöveg vagy változó értékének kiíratása a számítógép soros monitorára)
-Soros plotter használata (potméter aktuális értékének grafikonos megjelenítése)
Alkatrészek amiket ismerünk:
- Arduino UNO (Rev3 klón, Atmel328 AVR mikrovezérlő)
- LED (szabvány 5mm-es, különböző színűek)
- Ellenállás (220Ohm, és 10KOhm)
- Potenciométer (10K lineáris)
- Nyomógomb (vigyázat! Lábai keresztben!)
Ha lehet, ezeket a kísérleteket végezzük el otthon is gyakorlásként, hogy haladni tudjunk.
Ha valaki elakadt vagy kérdése van írjon!
Arduino érdekességek (led vezérlés kicsit másképp)
A jelzőlámpa programban minden kimenethez egy-egy led tartozott de ezzel egyrészt hamar elfogyhatnak a kimeneteink, másrészt egy jelzőlámpánál "illik" biztosítani, hogy semmilyen hibánál ne fordulhasson elő, hogy egyszerre világítson a piros és a zöld. Egy egyszerű módszer amivel növelhetjük a kimeneteink számát, és egy plusz elektronikai biztonságot is viszünk a rendszerünkbe:
A Charlieplexing
Azt már tudjuk, hogy az Arduino kienete vagy magas (HIGH = 5V tápfeszültség) vagy alacsony (LOW = GND, azaz föld) szinten van. Azt is tudjuk, hogy egy led csak akkor világít ha a rövidebb lába a föld felé, a hosszabbik pedig az 5V felé néz (és valahol van egy 220Ohm-os ellenálás is ami korllátozza az átfolyó áramot)
Ezeket felhasználva két ledet beköthetünk úgy is, hogy egymáshoz képest fordítva kötjük össze a rövid és hosszú lábakat párhuzamosan, és egy közös soros ellenálláson keresztül kötjük két különböző Arduino kimenetre. (tehát nem rövid a közös földre, és a hosszú egy-egy kimenetre, ahogy eddig, most kimarad a föld, hisz valamelyik kimenet lesz az)
Valahogy így:
(a két ellenállás helyett elég egy db 220Ohm-os is)
Ezzel még csak annyi történt, hogy a két led egyszerre nem tud világítani, csak az egyik, méghozzá akkor ha az egyik láb HIGH, a másik LOW szinten van - vagy fordítva. Ha mindkettő kimenet HIGH vagy LOW szinten van akkor nem történik semmi hisz így nincs feszültség a két kimeneti pont között. (emlékszünk: feszültség csak két pont között lehet, amik eltérő potenciálon vannak)
Tehát ez elektronikailag biztosítja, hogy egyszerre csak valamelyik led világíthasson - bármit rontunk el esetleg a programban.
De ez fokozható!
3 Arudino kimenet használatával már 6db ledet lehet kapcsolni, a következő rajz szerint:
A rajzon fel vannak tüntetve az egyes ledekhez tartozó kimeneti variációk is.
Természetesen nem kötelező ez a megoldás, csak jó ha tudjuk, hogy az érzékeny elektronikai vezérléseket ilyen módon biztosíthatjuk, ahogyan azt az életben is szokták. (és pont mivel elektronikailag is védve vannak pl a jelzőlámpák, azokat nem lehet távolról "meghackelni" úgy, mint a filmekben néha látható)
És persze a közlekedési és vasúti jelők ("biztosítóberendezések") többszörösen is túlbiztosítottak, több feltétel egyidejű fennállása esetén mutathatnak csak zöldet, és ha bármelyik feltétel nem teljesül a kimenet azonnal "visszaesik", és inkább "zavarba megy" és semmit sem mutat minthogy hibás jelzéskép jelenjen meg rajta
Hogy állunk a "házi feladat" változtatható sebességű Night Rider futófénnyel?
Segítség a kapcsoláshoz:
Hogy néz ki a kód?
Sziasztok!
András, kedden mit hozzunk?
Futófény:
byte labak[]{6, 7, 8, 9, 10, 11, 12, 13};
byte i;
int ido;
void setup() {
pinMode(labak[7], OUTPUT);
pinMode(labak[6], OUTPUT);
pinMode(labak[5], OUTPUT);
pinMode(labak[4], OUTPUT);
pinMode(labak[3], OUTPUT);
pinMode(labak[2], OUTPUT);
pinMode(labak[1], OUTPUT);
pinMode(labak[0], OUTPUT);
pinMode(A0, INPUT);
for (i=0; i<8; i++)
{
digitalWrite(labak[i],LOW);
}
}
void loop() {
ido = 100;
for (i=0; i<8; i++)
{
digitalWrite(labak[i],HIGH);
delay(ido);
digitalWrite(labak[i],LOW);
}
for (i=8; i>0; i--)
{
digitalWrite(labak[i],HIGH);
delay(ido);
digitalWrite(labak[i],LOW);
}
}
byte típusú tömb használata, ez igen!
Beírok még egy piros pontot!
De a poti aktuális állását hol olvasod be a sebesség változtatásához? Nem ido=analogRead(A0); kellene inkább az ido=100 helyett?
Nemrég láttam egy igazán tömör/lusta megoldást:
int i;
void setup() {
for (i=6; i<14; i++) {
pinMode(i,OUTPUT);
digitalWrite(i,LOW);
}
}
void loop() {
for (i=6; i<14; i++) {
digitalWrite(i,HIGH);
delay(analogRead(A0));
digitalWrite(i,LOW);
delay(analogRead(A0));
}
for (i=13; i>5; i--) {
digitalWrite(i,HIGH);
delay(analogRead(A0));
digitalWrite(i,LOW);
delay(analogRead(A0));
}
}
Kedves Mindenki!
Kedden a PWM jelekkel, és a kimenetek erősítésével szeretnék foglalkozni, ezért a következő eszközöket hozzuk magunkkal:
- Arduino UNO + USB kábel (ha tudunk USB hosszabbítót is hozzunk)
- Dugdosós próbapanel + Jumperkészlet + kábelek
- krokodil csipeszek (legalább 4db)
- elemtartó és a 4db ceruzaelem
- Relémodul (két kék kocka van rajta)
- 2db BD139 tranzisztor és 2db IRFZ44 FET (az összesen 4db 3 lábú csúfság a dobozból)
- Az autós készletből egy db motor és egy db kerék
- A robotkar készletből 1 db szervó motor
- Piezo modul (kis fekete henger egy kis modulon)
- ellenállások és ledek amiket kaptunk
Amire számítani lehet:
- Futófény kapcsolás és program kipróbálása (aki esetleg nem csinálta volna meg otthon)
- Optocsatoló és Relé (galvanikus leválasztás, azaz valami "nagy" kapcsolása)
- PWM jelek lelkivilága (kis elmélet)
- Zene generálása (ne számítsunk nagy zenei élményre)
- tranzisztorok, FET-ek, ULN2003 Darlington IC
- Változtatható fényerejű LED, változtatható sebességű villanymotor
- szervómotor vezérlés
Ezeket tervezem...
III. alkalom
Már tudjuk, hogy az Arduino kimenetei maximum 40mA árammal terhelhetőek, ami maximum egy LED meghajtására képes (220Ohm ellenálláson keresztül).
Hogy ennél nagyobb fogyasztókat is tudjunk kapcsolni a kimeneti jelet fel kell erősíteni...
A tranzisztor
A csomagban mi egy BD139 típusú tranzisztort kaptunk, melynek 3 lába van:
- Bázis - erre kötjük az Arduino kimenetét egy ellenálláson át
- Collector - ez lesz a "kapcsolt" kimenetünk, amire a fogyasztót kötjük
- Emitter - Ide jön az Arduino és a külső áramforrás közösített földje
Két féle tranzisztort különböztetünk meg: az NPN és a PNP típust. A betűk sorrendjéből tudjuk, hogy a tranzisztor bázisára földet vagy pozitívat kapcsolva záródik a tranzisztor másik két lába (a középső betű a bázis, P-pozitív N-negatív).
Az NPN tranzisztor esetében (amilyen a BD139 is) a középső betű P, tehát pozitív - azaz a tranzisztor akkor kapcsol, ha a bázisára pozitív feszültséget kapcsolunk, és mivel a másik két betű N ezért a földet (negatívat) kapcsoljuk. A tranzisztort a bázisán átfolyó áram kapcsolja, tehát valamennyi áramnak haladni kell rajta keresztül. Amikor a tranzisztor bekapcsol, akkor a földre kötött Emitterét rákapcsolja a Collectorára, tehát tulajdonképpen a földet (negatívat) kapcsolja a fogyasztóra, amire ezért a pozitívat állandóan ráadjuk.
Így néz ki a tranzisztorunk egy rajzon:
Ebből azt is megtudjuk, hogy a bal oldali lábat kell a külső tápegység és az arduino GND-ére kötni, a középső lábon "jön ki a kapcsolt föld" - tehát az megy a fogyasztó negatívjára (pl led rövidebbik lába) és a jobb oldali láb a bázis, tehát azt kell az arduino kimenetére kötnünk, legalább egy 220Ohm ellenállással.
Elméletileg egy BD139-es 1,5A kapcsolására képes, tehát egy tranzisztor beiktatásával a kiinduló 40mA helyett már másfél Amper áramot tudunk kapcsolni. (azért egy egyszerű tranzisztorral inkább csak fél Ampert kapcsoljunk, különben nagyon melegedni fog)
A fenti elvet követve így néz ki egy egyenáramú villanymotor Arduino-s vezérlése:
A teljességhez tartozik, hogy a villanymotorral párhuzamosan egy fordított polaritású védődiódát is "illik" használni, ami a motor által okozott fordított irányú "tüskéktől" védi a tranzisztort.
MOSFET
Bár az előző példában is villanymotor szerepelt mint "nagy" fogyasztó, de villanymotorokat, és más nagyobb áramfelvételű eszközöket inkább FET-el szokás kapcsolni.
A FET a mi szempontunkból a tranzisztor nagy testvére. Hivatalosan a három lábának más a neve:
- Gate (ami megfelel a tranzisztor bázisának)
- Drain (ami a tranzisztor collector-ra lenne, tehát a kapcsolt föld, azaz "kimenet")
- Source (ami a közös negatív, azaz a tranzisztor emittere lenne)
Nagy különbség viszont, hogy amíg a tranzisztor a bázisán átfolyó áram nyitja ki, addig a FET feszültségvezérelt, azaz nem folyik rajta keresztül áram, csak meg kell jelennie a feszültségnek a Gate lábán és máris nyit.
Ez a gyakorlatban annyit jelent, hogy nem az Arduino kimenete és a FET Gate-je, közé kell tenni sorosan az ellenállást (hisz úgysem folyik rajta igazán áram) hanem arról kell gondoskodni, hogy ha megszűnik a nyitáshoz szükséges feszültség akkor az húzódjon le a földre. (ismerős? Lehúzó ellenállás!)
Tehát a Gate lábát közvetlenül az Arduino-ra kötjük, DE egy 10KOhm-os ellenállással lehúzzuk a GND-re!
FET-ből is kétféle van, az N csatornás és a P csatornás.
A csomagban kapott alkatrész egy IRFZ44N MOSFET, melyből az utolsó betű azt jelenti, hogy N csatornás, tehát "negatívat kapcsol" (és ezért pozitív feszültséggel vezérelendő)
Az adatlapja szerint, ez a típus már 49Amper-t is képes kapcsolni (!!!) DE ez csak komoly hűtőbordával és aktív, ventillátoros hűtéssel, optimális körülmények között lehetséges, mi inkább maradjunk 1-2 Amper környékén (az sem kevés! Sőt...)
Darlington IC
Mivel az Arduino-nak több kimenete van, és gyakran fordul elő, hogy ezek mindegyikét erősíteni kell egy "kicsit" (pl kimenetenként nem egy hanem több ledet szeretnénk kapcsolni), ezért előszeretettel használják az ULN2003-as Darlington IC-t. Ez tulajdonképpen (pongyolán fogalmazva) 7db NPN tranzisztor összekötve, tehát az Arduino kimeneteit közvetlenül rátesszük az IC bemenetére az egyik oldalán, és a túloldalt kijön a már erősített (és ellenkező polaritású) maximálisan 500mA-es áram. (tehát lábanként maximum 500mA, de senki sem tiltja, hogy párhuzamosan több lábat használjunk egyszerre...)
Ahogyan a tranzisztoroknál, úgy a Darlington-nál is "fordul" a kapcsolás, tehát "pozitív-val kapcsolok, negatívat kapok". Mivel ez egy integrált áramkör ezért táp is kell neki, méghozzá úgy, hogy a GND az közös legyen az Arduino GND-jével, a Common névre keresztelt bemenet pedig vagy külső táp pozitív ága vagy az Arduino VIN-je legyen.
Darlington egyetlen be és kimenetének használta DC motor meghajtására:
PWM
Pulse Width Modulation - Impulzus-szélesség moduláció
Egy fogyasztó teljesítményének szabályozására kitalált módszer. Működési elve: Az analóg kimenő feszültségjelek helyettesíthetők digitális impulzus sorozattal.
Ha egy digitális jelet nézünk, annak magas értéke Arduino esetében 5V, alacsony értéke 0V. Ha adott frekvenciával "megszaggatjuk" ezt a jelet, és a kitöltési tényezőjét változtatjuk, (milyen széles legyen a magas állapot) akkor annak átlaga megfeleltethető egy analóg jel mértékének.
Mivel a mikrovezérlők nem képesek "valódi" analóg jel előállítására, így ezt a módszert használjuk helyette a teljesítmény szabályozására, pl LED fényerejének változtatására, egyenáramú villanymotor sebesség szabályozására stb..
Az Arduino UNO 6db PWM képes kimenettel rendelkezik (a száma melletti ~ jel jelzi, hogy az adott láb PWM képes), az erre kiadott analogWrite paranccsal tudunk egy kimeneten PWM jelet előállítani. (küldött jel értéke 0 és 255 között lehet)
You are here » Váci Robotika Labor » Tanári tanfolyam (csak olvasható) » Tananyagok