Robotika tanfolyam

User info

Welcome, Guest! Please login or register.


You are here » Robotika tanfolyam » Tanfolyam » Tananyagok


Tananyagok

Posts 1 to 30 of 56

1

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

Magyar Arduino labor (1.rész)

És az egyik első a témában amiből anno én elindultam (vigyázat, ez hosszúúú! - csak "elvetemülteknek"): Heckerspace workshop

0

2

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?

0

3

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:
https://kepkuldes.com/images/d571012499587fe756ac30bc8487956d.jpg

Gyorsan össze drótoztam benne a 3 ledes kapcsolást:
https://kepkuldes.com/images/e997fe914cf5cf8855144665d1d8d51f.jpg

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)

0

4

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

0

5

É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
https://kepkuldes.com/images/17d0424730ac435dc4ccf2257ece89f8.jpg

Szorgalmi feladat piros pontért: hogy néz ki az Arduino kód?

0

6

Sikerült megoldanom a fritzing-et. Hosszú, majd elmesélem a tantermi szeánszon

0

7

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.

0

8

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

0

9

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

0

10

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!

0

11

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

0

12

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.

0

13

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

0

14

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

0

15

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() { 

}

0

16

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

0

17

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

0

18

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:
https://kepkuldes.com/images/27150a71b68159589548c2c5b0285f2c.jpg

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!)
https://kepkuldes.com/images/bbf2906d9d41d8b00451daee1de58b17.jpg

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

0

19

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:
http://www.bsselektronika.hu/rajzok/feszoszto.gif

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.
https://kepkuldes.com/images/399ff2d763fa9abedf3a8402a7dc17b8.jpg

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.

0

20

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:

https://kepkuldes.com/images/bb907d96aa53755190b6a4880f1fc177.jpg

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)
https://kepkuldes.com/images/d21c7fef3fe9fb3faf6318c9d729345d.jpg

0

21

Ö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!

0

22

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:
http://lh4.ggpht.com/_8ktnCuSk9ms/SX4wtvMb81I/AAAAAAAAAv8/mMfotRARWgU/s400/Schematic%201.jpg
(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:
https://cdn.instructables.com/FUW/LNM1/HH2VL6Y8/FUWLNM1HH2VL6Y8.LARGE.jpg

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

0

23

Hogy állunk a "házi feladat" változtatható sebességű Night Rider futófénnyel?
http://voomay.com/wp-content/uploads/2017/08/knight-rider-sa.gif

Segítség a kapcsoláshoz:
https://kepkuldes.com/images/7cf6ed47ea946bbf1608fe23a5cb71f8.jpg

Hogy néz ki a kód?

0

24

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

}

0

25

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

0

26

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

0

27

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:
http://projectshopbd.com/wp-content/uploads/2015/08/BD-139.gif

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:
https://i.ytimg.com/vi/xyxYbesE0qE/maxresdefault.jpg
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.

0

28

MOSFET

https://www.theengineeringprojects.com/wp-content/uploads/2017/09/Introduction-to-IRFZ44N_3.png

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!
https://cdn.instructables.com/FS7/Z3A4/JDYUZ4NR/FS7Z3A4JDYUZ4NR.LARGE.jpg

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

0

29

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

https://www.theengineeringprojects.com/wp-content/uploads/2017/06/ULN2003-pinout-768x349.jpg

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:
https://i.pinimg.com/474x/2b/fb/65/2bfb65dae8f51cdc9e39e1d5971b38e4--arduino-motors.jpg

0

30

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.
http://megtestesules.info/hobbielektronika/mbed/images/pwm/pwm_example.png

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)

0


You are here » Robotika tanfolyam » Tanfolyam » Tananyagok