Robotika tanfolyam

User info

Welcome, Guest! Please login or register.


You are here » Robotika tanfolyam » Tanfolyam » Tananyagok


Tananyagok

Posts 31 to 56 of 56

31

Servo motor

Speciális, saját áramkörrel rendelkező motor, mely 0 és 180 közötti fordulatra képes (elvileg... inkább mondjuk azt, hogy a vezérlése addig fogadja a jeleket). A vezérlése direkt módon történik, azaz nem "nézi", hogy hol áll éppen, a megadott pozícióra ugrik - mindegy hol állt előtte.

Az Arduino PWM képes kimenetére kell kötni a sárga (jel) vezetéket (pl 9-es láb), míg, a pirosat a VIN-re (vagy ha lehet külső áramforrás + ágára) a feketét (barnát) pedig a GND-re (és ha külső áramforrást használunk akkor annak a fekete vezetékét is közösíteni kell az Arduino GND-vel)
https://i.stack.imgur.com/OfiCf.png

Kipróbálásához használjuk az Arduino IDE-ben, a példákon belül megtalálható "Sweep" programot!
Ha mindent jól csináltunk a motor oda-vissza fog forogni (és ha  nincs meg a 180 fok akkor se lepődjünk meg, az a példány épp nem tud annyit...)

A szervó motor használatánál mivel nem tudjuk hogy eredetileg hol állt, mielőtt beszereljük valahova (pl a robotkarba) mindig küldjük el 90 fokra, hogy a mozgási tartománya közepén álljon. Ezzel sok későbbi bosszúságot spórolunk meg magunknak...

0

32

Az előző oldal alján tárgyalt, Darlington IC-t tartalmazó villanymotor fordulatszám vezérelt kapcsolás kódja:

int seb;

void setup() {
  pinMode(11,OUTPUT);
  digitalWrite(11,LOW);
  pinMode(A0,INPUT);
}

void loop() {
seb=analogRead(A0);
analogWrite(11,map(seb,0,1023,0,255));
}

Itt érdekes a map parancs, mely a mostani példában a 0 és 1023 közti bemenő analóg értéket "arányítja át" (mapolja) a 0 és 255 közötti PWM értékre.

0

33

Szolgálati közlemény:

Valaki ott felejtett a teremnél egy ezüst színű fém kulacsot. A következő alkalommal átvehető nálam.

0

34

Az október 2-i alkalomra a következő dolgokat hozzuk:

- Arduino UNO + USB kábel (ha van hosszabb kábelünk, vagy USB hosszabbítónk akkor azt is)
- Próbapanel + Jumper készlet, kábelek
- Elemtartó és ceruza elemek
- Kisautó készlet és ha tudunk egy kis csillag csavarhúzót is (aki eddig nem rakta össze most megteheti)
- Arduino Nano (zárt zacskóban van, sárga színű és mellette tüskék)
- Wemos D1 mini (szintén zárt zacskóban van, kékes színű, mellette tüskék)
- Ultrahangos távolságérzékelő szenzor (kék panelon két henger "szem", rajta rács)
- DHT22 - rácsos műanyag egy modulon, mellette kábelek
- piezo modul (fekete henger egy kis modulon)
- H-híd modul (piros panelon nagy fekete hűtőborda és kék csatlakozók az oldalán)
- ellenállások, pár db led, egy nyomógomb, egy potméter

Amit tervezek:
Szeretném felforrasztani a kisautó motorjaira a vezetékeket, az elemtartóra csatlakozó tüskét rakni, és összeforrasztani a két eddig nem használt vezérlő modult. Persze ezt mindenkinek aki kéri.

Közben Ti sem fogtok unatkozni:

- Ultrahangos távolságérzékelő építés
- Hőmérséklet és páratartalom mérés
- H-híd működése (kisautó motorjainak vezérlése előre-hátra +sebesség állítás)
- A múltkor elmaradt "zene"

A kapcsolásokat és kódokat feltöltöm ide a fórumra, és lesz webkamera is - bár ez inkább "műhelygyakorlat" jellegű alkalom lesz.

Ha valaki hoz magával forrasztót és besegít azt megköszönöm :)

0

35

IV. alkalom

Az ultrahangos távolságérzékelőhöz:

Keressük meg és töltsük le valamelyik HC-SR04 library-t.

A bekötésről és használatról videó: video

Ultrahangos távolságérzékelő
------------------------------------------------------------------------------

DHT22 hőmérséklet és páratartalom méréshez:

DHT22
------------------------------------------------------------------------------

L298N "H-híd" motorvezérlő:

Video

H-híd leírás és példa
------------------------------------------------------------------------------

"zene" a piezo modullal:

Piezo

0

36

A H-híd
(H-Bridge)

Az egyenáramú villanymotorok forgási irányát a rájuk kapcsolt feszültség polaritása határozza meg - tehát, hogy a motor melyik csatlakozója pozitív és melyik negatív. Az Arduino lábai elvileg képesek ezt megoldani DE a motorok áramfelvétele bőven sokkal több mint amit az Arduino lábai elbírnak. Korábbi példánkban már volt szó tranzisztoros/FET-es, vagy darlington IC-s erősítésről, de ezek mindegyikében közös, hogy ha a bemenetüket pl pozitív jellel (HIGH állapot) vezérlem, akkor a kimenetükön földet kapcsolnak. Ez a megoldás jó a sebesség szabályozására PWM jellel (ahogyan tettük is a múltkori alkalommal) de a polaritás fordítására nem.

A kimeneti polaritás tetszőleges beállítására találták ki a H-híd kapcsolást, ami alap állapotban így néz ki:
https://upload.wikimedia.org/wikipedia/commons/thumb/d/d4/H_bridge.svg/310px-H_bridge.svg.png

Látszik, hogy a 4 db bemeneti kapcsolóból ha az egymással átellenes kapcsolókat zárom akkor az M-el jelölt motorra + -   vagy  - + irányú feszültség kerül.
https://3.bp.blogspot.com/-90Du_s-a31c/WiwG6CTSdeI/AAAAAAAARZI/2fd54BZifOgIKY0LvIIZ_Fw3eJ0LWJjJwCLcBGAs/s320/4.png

Ha ezt a kapcsolást elméletben továbbfejlesztjük és a 4 kapcsolót 2 PNP és 2 NPN tranzisztorra cseréljük, megkapjuk a következő (már valóban használható) áramkört:
http://www.circuitstoday.com/wp-content/uploads/2011/01/h-bridge-motor-driver.png
A kapcsolás nagy hátránya, hogy ha az egy oldalon lévő, egymás alatti tranzisztorok közül mindkettő bekapcsolt állapotba kerül akkor rövidzárlat keletkezik!

A probléma kivédésére többféle módszer is ismert (további tranzisztorok beiktatásával kizárható a hibás kapcsolás) DE szerencsénkre a probléma olyan gyakori, hogy arra ma már kész megoldás is van: ez a H-híd IC vagy H-híd motorvezérlő modul.

Az IC változat kisebb áramokra készült de működését tekintve megegyezik a modullal (ami jóval nagyobb terhelést is elbír)

Egy IC vagy modul 2db villanymotor vezérlésére képes egymástól függetlenül, tehát két db H-hidat tartalmaz. Egy H-híd vezérléséhez szükséges a két irányt meghatározó láb alacsony vagy magas szintje, és opcionálisan egy PWM jel amivel a sebességet tudjuk beállítani.

Tovébbi infó és bekötés itt: motorvezérlés

0

37

"Tank" példa:

int balelore = 13;
int balhatra = 12;
int jobbelore = 11;
int jobbhatra = 10;

void setup() {
  pinMode(balelore,OUTPUT); digitalWrite(balelore,LOW);
  pinMode(balhatra,OUTPUT); digitalWrite(balhatra,LOW);
  pinMode(jobbelore,OUTPUT); digitalWrite(jobbelore,LOW);
  pinMode(jobbhatra,OUTPUT); digitalWrite(jobbhatra,LOW);

}

void stop() {
  digitalWrite(balelore,LOW);
  digitalWrite(balhatra,LOW);
  digitalWrite(jobbelore,LOW);
  digitalWrite(jobbhatra,LOW);
}

void elore() {
  stop();
  digitalWrite(balelore,HIGH);
  digitalWrite(jobbelore,HIGH);
}

void hatra() {
  stop();
  digitalWrite(balhatra,HIGH);
  digitalWrite(jobbhatra,HIGH);
}

void balra() {
stop();
digitalWrite(jobbelore,HIGH);
digitalWrite(balhatra,HIGH); 
}

void jobbra() {
stop();
digitalWrite(balelore,HIGH);
digitalWrite(jobbhatra,HIGH); 
}

void loop() {
  elore();
  delay(2000);
  jobbra();
  delay(1000);
  elore();
  delay(2000);
  balra();
  delay(2000);
}

0

38

Kicsit visszatérve a relékre és a tranzisztoros erősítésre itt egy jó leírás:
Link

És érdekessék: Relé ami nem is az...
A szilárdtest relé

Ha valaki hálózati feszültséget akarna kapcsolni (230V) - és megígéri, hogy nagyon, nagyon óvatos lesz a szerelésnél és a szigetelésnél!!! - akkor itt egy leírás a szilárdtest relékről:
Szilárdtest relé

És hozzá egy 40A-es (!!!) szilárdtest relé beszerzési forrása:
Szilárdtest relé 40A

Nem győzöm hangsúlyozni, hogy hálózati feszültség szerelésénél mennyire fontos az érintésvédelem, és a megfelelő szigetelés!!! Ha ilyenre adjuk a fejünket, és nem vagyunk biztosak magunkban akkor inkább kérjünk meg a egy villanyszerelőt, hogy készítsen nekünk egy bedobozolt relét amin van szabványos villásdugó, konnektor és csak az a két vezeték jön ki belőle amivel vezéreljük! (GND és  mondjuk +12V jel, amit a relémodulunkról hajtunk meg)

Tehát a tuti biztos sor így néz ki: Ardunio egy digitális kimenete megy a relé modulunkra, az kapcsol egy fali dugasztápról jövő 12V-ot, az megy a külön bedobozolt szilárdtest relére ami kapcsolja a 230-at...
Feleslegesnek tűnik a közbeiktatott relé modul és 12V dugasztáp, mert a szilárdtest relét is lehet közvetlenül kapcsolni Arduino-ról - sokan így is használják, DE nekem pl ér annyit az életem (~2000Ft a dugasztáp és a relé modul) és az is, hogy nem gyújtok fel semmit, hogy közbeiktassam. 3 iskolában működik ilyen megoldással a csengő vezérlése több éve.

Mindenki saját felelősségére kísérletezzen ilyesmivel

Ne feledjük az örök bölcsességet: Az a vezeték amelyik ráz, pont úgy néz ki mint amelyik nem, de más a fogása :)

0

39

Szia András!

Mit hozzunk 2018.10.09-én?

0

40

Remélem még nem későn szólok:

Kisautó, Arduino UNO, kábelek (szokásos)
Ha tudjuk akkor a kis OLED kijelzőt (be van fóliázva, 4 tüske áll ki belőle)

Alapvetően ezt az órát a különböző kommunikációs eljárásokra szánom: soros átviteli módszerek, USB-soros vezérlés, serial monitor bemenetként használata, I2C kommunikáció.

Link

0

41

Az elektronikai eszközök alapvetően vagy soros vagy párhuzamos kommunikációt használnak. Párhuzamos kommunikáció esetén több vezeték megy egymás mellett (pl 8db jel +1 föld) amelyik mindegyike megfelel egy bit-nek. Ha át kívánunk küldeni rajta egy byte-ot (ami egyetlen betűnek felel meg) akkor annak bináris alakját egy időben tudjuk rajta megjeleníteni. Ilyenkor is meg kell határozni a sebességet (milyen gyorsan követhetik egymást az átküldeni kívánt byte-ot) de alapvetően egyszerű módszernek számít. A nagy hátránya, hogy annyi jelátviteli vezetékre van szükségünk ahány bit "szélességű" adatot akarunk egyszerre átküldeni - ami nyilván ugyanannyi I/O lábat foglal le a bemenetből.
A mára már nagyrészt "kihalt" LPT "nyomtató port" formájában találkozhatunk még vele a PC-knél.

Soros kommunikáció

A soros kommunikáció nagyon leegyszerűsítve úgy működik mint a morse kód: egymás utáni jelsorozatok alkotják az átvinni kívánt bit-eket, amikből a byte-ok összeállnak.

A kommunikáció az alábbi 5 rétegre bontható le:

- Fizikai réteg: ezen a csatlakozók kialakítását, tényleges fizikai paramétereit értjük (méret, forma, stb.).
- Elektromos réteg: azt definiálja, hogy milyen feszültségszinteket használunk a kommuikációhoz.
- Logikai réteg: azt definiálja, hogy melyik feszültségszint jelenti a logikai 1-et és melyik a logikai 0-át.
- Adat réteg: definiálja a kommunikáció sebességét, azt, hogy a biteket 8, 9 vagy 10 bitből álló csoportokban küldjük-e. A csoportok előtt és után használunk-e speciális jelzőbiteket az  adatcsoportok elkülönítésére.
- Alkalmazási réteg: azt adja meg, hogy milyen sorrendben kell az egyes adatcsomagokat küldeni, hogyan szerveződnek az adatcsomagok üzenetekké.

Amivel a leghamarabb találkozunk (és mi magunk is használjuk) az a: TTL-UART
Ilyen pont-pont közötti kapcsolatot mi magunk is előállíthatunk két mikrovezérlő, vagy egy mikrovezérlő és a PC között. 3 vezetékre van szükségünk. az RX - az adás vételi oldala, a TX a kiküldött adat, és egy közös föld. Az RX és a TX egymással szembefordítva működik, tehát az egyik mikrovezérlő RX-re a másik TX-ére csatlakozik és fordítva. (a két mikrovezérlő GND-je össze van kötve)

Az Arduino UNO board-unkba is van integrálva egy TTL-UART USB konverter IC (CH340 vagy CP2102 a két legismertebb típus) amit amikor csatlakoztatunk a PC-hez, a Windows egy virtuális soros portként érzékel és telepít. Innentől szoftveresen egy COM azonosítóként látszik az átalakító áramkör RX és TX vége, és erre csatlakozik az Atmel328P mikrovezérlő - ami tulajdonképpen maga az Arduino.

Vigyázat! A "natív", tehát valóban a számítógép hátulján található soros port (ami mindig a COM1 nevet kapja - ha van) nem TTL (0V és 5V) jelszintű hanem RS232, ami +12V és -12V tartományban működik - tehát NEM köthető közvetlenül mikrovezérlőre!!! (de létezik hozzá MAX232 nevű IC, amivel már igen)

Mire jó nekünk mindez?! :)

Egyrészt később építhetünk magunknak saját Arduino-t, hisz maga a board csak egy mikrokontrollerből és egy USB átalakítóból áll (meg feszültségstabilizátorból, kristályból stb...), másrészt ha tudjuk, hogy a PC felé a kapcsolat kétirányú akkor nem csak adatot fogadhatunk az áramkörünkről de küldhetünk is neki vezérlő utasításokat.

Az Arduino IDE-be épített soros monitor helyettesíthető bármilyen más soros kommunikációt ismerő "terminál" program (pl "Putty" "Termite" stb) vagy gyakorlottabbak akár írhatnak is saját vezérlő programot bármilyen programnyelven.

Az Arduno felől a beérkező adatokat a Serial.read() paranccsal nyerhetjük ki (vigyázat, ilyenkor a pufferből törlődik is a kiolvasott adat!!!)
Azt, hogy van-e egyáltalán a pufferben bejövő adat a Serial.available() függvény mondja meg: ha ennek értéke igaz, vagy 0-nál nagyobb szám akkor van kiolvasható adat, ha 0 vagy false akkor nincs.

Nagyon jól használható példa van az IDE-ben, a communication részben található SerialEvent programban, ahol külön eljárásban vizsgálja a soros monitort, és ha van adat azt hozzáírja az inputString változóhoz, majd ha sor vége érték érkezik (/n) akkor kiíratja a kapott értéket, majd törli a változót.

String inputString = "";         // a String to hold incoming data
boolean stringComplete = false;  // whether the string is complete

void setup() {
  // initialize serial:
  Serial.begin(9600);
  // reserve 200 bytes for the inputString:
  inputString.reserve(200);
}

void loop() {
  // print the string when a newline arrives:
  if (stringComplete) {
    Serial.println(inputString);
    // clear the string:
    inputString = "";
    stringComplete = false;
  }
}

void serialEvent() {
  while (Serial.available()) {
    // get the new byte:
    char inChar = (char)Serial.read();
    // add it to the inputString:
    inputString += inChar;
    // if the incoming character is a newline, set a flag so the main loop can
    // do something about it:
    if (inChar == '\n') {
      stringComplete = true;
    }
  }
}

0

42

Az I2C kommunikáció

Az előbbi példákban pont-pont közötti összeköttetésről volt szó, azaz csak két egységet tudunk ezzel a módszerrel összekapcsolni. Ha azt szeretnénk, hogy egyetlen adatbuszra több eszköz is csatlakozzon, és mindegyikük ugyan azt a buszt használja akkor vagy az RS485-ös szabványú hálózatot, vagy az I2C kommunikációt kell használnunk...

bővebben

Az I2C kommunikáció előnye, hogy két vezetéken (SDA és SCL) valósítja meg a kapcsolatot, és elméletileg több mint 128 eszköz csatlakozhat ugyanerre a két vezetékre. Hátránya, hogy a távolság csak 10cm (vagy néhányszor 10cm) körül stabil, tehát a gyakorlatban egyetlen "dobozban" egymás mellett lévő eszközöket szokás ilyen módszerrel összekötni.

Mivel az Arduino cím szerint szólitja meg az eszközöket ezért a csatlakoztatott eszköz címét előbb ki kell "szkennelnünk":

#include <Wire.h>

void setup()
{
  Wire.begin();

  Serial.begin(9600);
  while (!Serial);             // Leonardo: wait for serial monitor
  Serial.println("\nI2C Scanner");
}

void loop()
{
  byte error, address;
  int nDevices;

  Serial.println("Scanning...");

  nDevices = 0;
  for(address = 1; address < 127; address++ )
  {
    // The i2c_scanner uses the return value of
    // the Write.endTransmisstion to see if
    // a device did acknowledge to the address.
    Wire.beginTransmission(address);
    error = Wire.endTransmission();

    if (error == 0)
    {
      Serial.print("I2C device found at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.print(address,HEX);
      Serial.println("  !");

      nDevices++;
    }
    else if (error==4)
    {
      Serial.print("Unknown error at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.println(address,HEX);
    }   
  }
  if (nDevices == 0)
    Serial.println("No I2C devices found\n");
  else
    Serial.println("done\n");

  delay(5000);           // wait 5 seconds for next scan
}

0

43

A kis 4 kerekű autónkhoz korábban használt TANK program kiegészített változata, ahol nem előre meghatározott irányba mozog az autó, hanem a soros bemenet felől várja az utasításokat (E - előre, H - hátra, S - stop, J - jobbra, B - balra)

Az utasítást vagy számítógépről küldhetjük a kisautónak, vagy ha az arduino RX és TX lábához egy bluetooth adaptert csatlakoztatunk, akkor mobiltelefonnal is vezérelhetjük.

int balelore = 13;
int balhatra = 12;
int jobbelore = 11;
int jobbhatra = 10;

void setup() {
  pinMode(balelore,OUTPUT); digitalWrite(balelore,LOW);
  pinMode(balhatra,OUTPUT); digitalWrite(balhatra,LOW);
  pinMode(jobbelore,OUTPUT); digitalWrite(jobbelore,LOW);
  pinMode(jobbhatra,OUTPUT); digitalWrite(jobbhatra,LOW);
  Serial.begin(9600);
 

}

void stop() {
  digitalWrite(balelore,LOW);
  digitalWrite(balhatra,LOW);
  digitalWrite(jobbelore,LOW);
  digitalWrite(jobbhatra,LOW);
}

void elore() {
  stop();
  digitalWrite(balelore,HIGH);
  digitalWrite(jobbelore,HIGH);
}

void hatra() {
  stop();
  digitalWrite(balhatra,HIGH);
  digitalWrite(jobbhatra,HIGH);
}

void balra() {
stop();
digitalWrite(jobbelore,HIGH);
digitalWrite(balhatra,HIGH); 
}

void jobbra() {
stop();
digitalWrite(balelore,HIGH);
digitalWrite(jobbhatra,HIGH); 
}

void loop() {
   while (Serial.available()) {
    char inChar = (char)Serial.read();
    if (inChar=="E") { elore(); }
    if (inChar=="B") { balra(); }
    if (inChar=="J") { jobbra(); }
    if (inChar=="H") { hatra(); }
    if (inChar=="S") { stop(); }
   }
}

0

44

A csomagban kapott HC-06 Bluetooth modul csatlakoztatása az Arduino-hoz (ekkor az Arduino úgy érzékeli, hogy az adatok soros porton keresztül érkeznek)
http://androidsmile.com/wp-content/uploads/2017/01/hc06.png

A bekötés nagyon egyszerű: Az RX és TX vonalakat egymással szembe fordítva bekötjük az Arduino 0-ás és 1-es lábára (tehát a HC-06 RX-re megy az Arduino 1-es lábára ami megfelel a soros TX-nek) és fordítva.
Ezen kívül csak 5V tápot és földet igényel a modul.

Bekapcsolás után egy android telefonnal máris párosítani tudjuk a HC-06 nevű bluetooth eszközt, ezután egy terminál programmal küldhetjük az adatokat.

A BlueAct programot innen lehet letölteni: Link

0

45

OLED kijelző vezérlése

A csomagban kaptunk egy kis, OLED kijelzőt amire I2C kommunikációval kapcsolódhatunk. Első lépés minden I2C-t használó eszköznél, hogy "kiszkenneljük" a címét. Ehhez állítsuk össze az alap áramkört:
https://cdn.instructables.com/FTK/8UGP/J62FVIVJ/FTK8UGPJ62FVIVJ.LARGE.jpg

(figyeljünk a sorrendre: VCC, GND, SCL, SDA)
A csomagban kapott Arduino UNO board-on találunk külön SDA és SCL port-okat is, használhatjuk azokat is, de a rajzon lévő A5 és A4-es lábak is ugyan úgy működnek.

Ha ez megvan, másoljuk be és töltsük fel a korábban az I2C kommunikációnál bemutatott programot, majd indítsuk el. Ha mindent jól csináltunk a soros monitort megnyitva az Arduino megadja a rákötött képernyő I2C címét hexadecimális formában. Ezt jegyezzük fel! (nekem pl azt írta: 0x3C címen van a kijelző)

Ezután telepítenünk kell a képernyő kezeléséhez szükséges két könyvtárat...

Könyvtár telepítése az IDE-be

A "vázlat" menüponton belül nyissuk meg a "könyvtárak kezelése" részt. Ekkor egy ablakba jutunk ahol az elérhető és letölthető külső könyvtárak listáját látjuk. A keresőbe írjuk be: oled és a találatok között válasszuk ki az Adafruit_SSD1306 nevű könyvtárat, majd kattintsunk a telepítésre. Ezután ugyan úgy keressük meg az Adafruit_GFX könyvtárat és telepítsük azt is.

Ha mindkét könyvtár telepítve, akkor a példák között meg kell, hogy jelenjen az Adafruit_SSD1306-os menüpont, azon belül válasszuk az Adafruit_ssd1306_128x32_i2c példát. (a dolog furcsa, mert a mi kijelzőnk 128x64-es de nekem ez a példa hibát jelzett, míg a 128x32 működik) Töltsük fel, és máris látjuk működni a képernyőnkre készített demo programot, mely bemutatja a karakteres és grafikus képességeit a kijelzőnek.

Angol nyelvű leírás: Link

Egy másik leírás és példák: Link

0

46

OLED kijelző használatához a következő minimális kódra van szükségünk:
Fontos: minden kiadott képernyő utasítás csak akkor hajtódik végre ha a display.display(); parancsot is kiadtuk!!!

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);

void setup() {
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.display();
}

void loop() {
  display.clearDisplay();
  display.display();
  delay(1000);
 
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.println("Szia robotika!");
  display.display();
  delay(2000);   
}

0

47

Program a soros bemenet felől érkező szöveg kiíratása:
(és ugye a korábbiakból már tudjuk, hogy a soros bemenet lehet akár Bluetooth eszköz, számítógép virtuális soros monitora, vagy másik mikrovezérlő is!)

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);

String szoveg;
char betu;

void setup() {
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.display();
  Serial.begin(9600);
  display.clearDisplay();
  display.display();
}

void loop() {
if (Serial.available()>0) {
  betu=Serial.read();
  szoveg=szoveg+betu;
  if (betu=='*') { szoveg=""; }
  display.clearDisplay();
  display.display();
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.println(szoveg);
  display.display(); 
}
   
}

0

48

PIR - Passzív Infravörös Szenzor
avagy: mozgásérzékelő

https://i2.wp.com/randomnerdtutorials.com/wp-content/uploads/2014/08/Arduino-with-PIR-motion-sensor-schematics.jpg

A modul működése nagyon egyszerű: 5V és GND adja a tápot, az OUT pedig mozgás esetén LOW szintre vált (alapból HIGH)

A két trimmer (potméter) az érzékenységet és a jelzési időt állítja.

Építsük meg a rajzon lévő áramkört (a Led elé tegyünk 220Ohm ellenállást!)

A rajz szerint a 2-es digitális láb lesz a bemenetünk, tehát ennek aktuális állapotát kell vizsgálnunk. Ha ez HIGH értéken van, nincs mozgás, ha LOW akkor a szenzor mozgást érzékel.

0

49

Áramforrások - Akkumulátorok

Minden áramforrásnak van két alapvető paramétere ami számunkra fontos: a névleges feszültsége és a belőle kinyerhető maximális áram. (ezen kívül akkunál/elemnél a kapacitás is fontos)

Azért névleges feszültségről beszélünk, hisz amíg nincs terhelés egy elemen vagy akkumulátoron addig magasabb, ha fogyasztót kötünk rá akkor alacsonyabb tényleges feszültséget ad le.

A mikrovezérlők nagyon érzékenyek arra, hogy a táplálásuk mindig állandó, fix feszültségű legyen a terheléstől függetlenül is, ezért a fejlesztői lapok (pl Arduino UNO board) általában rendelkeznek egy stabilizátor IC-vel, mely egy olyan alkatrész, melynek bemenetére egy nagyobb feszültséget kötünk, és a kimenetén az alkatrész típusától függően mindig fix feszültséget kapunk.

Stabilizátor IC-t tartalmaz a csomagban kapott, próbapanelre dugható tápegység is, mely 5V és 3,3V feszültség leadására képes, maximum 1A terhelés esetén. Ahhoz, hogy egy stabilizátor IC megfelelően működhessen a bemenetére a kimenetnél minimum 1 (de inkább 1,5) V feszültségnél magasabb feszültségnek kell megjelenni. (a pontos típus az alkatrész felépítésétől, a be és kimeneti feszültség különbségétől és az áthaladó áramtól is függ, pl 3,7V névleges bemenet esetén, 3,3V kimenettel és AMS1117-es SMD IC-vel számolva 0,6V "többlet" feszültség is elég a bemenő oldalon)

Nagyobb terhelést jelentő fogyasztók bekapcsolásakor (pl villanymotorok indulása, szervómotorok állítása stb) könnyen előállhat az a helyzet, hogy a tápegység (pl elemek) nem tudnak elegendő áramot szolgáltatni, amitől a feszültség hirtelen leesik. Ezt a problémát un. puffer kondenzátorok beiktatásával lehet megelőzni, vagy nagyobb teljesítményt leadni képes áramforrást kell használnunk.

A régebbi akkuk általában NiCd vagy NiMh típusúak, melyeket manapság leváltottak a Lithium akkuk. Lithium akkut találunk a mobiltelefonokban, laptopokban is. A korábbi típusokhoz képesti előnyei:

- Mivel a lítium a legkönnyebb fém, így az ebből készült akkumulátorok sokkal könnyebbek a nikkelalapúaknál és tartósabbak is.
- Nincs memóriaeffektus: egyáltalán nem képződnek kristályok az akkumulátorban, így nem kell gondot fordítani a rendszeres tréningeztetésre. Sőt a Li-ion-akkumulátorok nem is szeretik igazán, ha teljesen kisütik őket.
- A nikkel-metál-hidrid (Ni-MH) technológiához hasonlóan ezek az akkuk is nagyon kevés mérgező anyagot tartalmaznak.
- Lassan veszíti el a töltését.
- Mivel még a kimerült cella is képes legalább 3 V-ot szolgáltatni az 1-1,25 V-os NiCd-, illetve NiMH-akkumulátorokkal szemben (teljesen feltöltött állapotban mintegy 4 V a cellafeszültség), egyetlen cellával táplálható a legtöbb modern mobiltelefon.
- Az egyetlen cellából épített akkumulátor esetén nem kell számolni a rosszul párosított vagy gyári hibás cellákból eredő, valamint az egyenetlen elöregedés okozta problémákkal.

Hátrányai:
- Túltöltés vagy a névlegesnél magasabb feszültséggel való töltés esetén hő fejlődik, ami az akku felrobbanásához is vezethet. (!!!)
- Az akkumulátornak védőáramkörökre van szüksége.
- Öregedési és elhasználódási probléma, hasonlóan a nikkelalapú akkumulátorokhoz (a 40% töltöttségi szint körüli, hideg (kb. 0 C-os), száraz helyen való tárolás lassítja az öregedési folyamatot.)
(további adatok: Wikipedia

A legfontosabb számunkra a biztonság kérdése. A Lithium akkuk bizony sokkal instabilabbak mint a hagyományos társaik, ezért mindig megfelelő óvatossággal használjuk!
Tisztában kell lennünk azzal, hogy a Lithium technológiából fakadóan, az ilyen akkuk nagyon nagy áramok leadására képesek (20-30 Amper felett!!!) ezért egy rövidzárlat esetén nagyon hamar tudnak tüzet okozni!

A fizikai sérülésekre viszonylag érzékenyek, tehát ne szedjük szét, és főleg ne tegyük ki erős fizikai hatásnak! (semmi esetre se üssünk rá kalapáccsal, és ne fúrjuk át! - nem vicc!)

Alapvetően kétféle Lithium akkuval találkozhatunk: Li-Ion (ebből kaptunk mi  is két db-ot a csomagban) és a Li-Po (lithium-polimer)
A Li-Ion akkuk hengeresek, átmérőjük és hosszuk a nevükben lévő számból jön ki: pl mi 2db 18650-es típusú Li-Ion akkut kaptunk a csomagban, így 18mm átmérőjű és 650mm hosszú egy db cella mérete. Kapacitásuk kb 2000mAh, tehát elvben 1 órán keresztül képesek 2A áramot leadni. (érezzük, hogy ez jó sok!) Egy új mérőszám a "C" érték, ami azt jelzi, hogy mennyi a maximálisan leadható legnagyobb áram ami a cella károsodása nélkül még kinyerhető belőle. (ez kb 20-30C)

Töltésük:
Míg egy hagyományos savas (autó akku) vagy zselés akkut egyszerűen a névleges feszültségnél "valamivel" nagyobb feszültséggel szokás tölteni, addig a Lithium akku töltése KIZÁRÓLAG HOZZÁVALÓ TÖLTŐVEL lehetséges!!! SOHA ne kapcsoljunk áramforrást a Lithium akkura!!!

Használat közben figyelni kell arra is, hogy nehogy túlmerítsük az akkut. Egy Lithium cella névleges feszültsége 3,7V Teljesen feltöltött állapotban 4,2V, és ha használat közben eléri a 3,2V feszültséget akkor az akku üresnek tekintendő! 3,2V alatt ugyanis a celle károsodik és többet nem tölthető fel.

Mindezen hátrányokkal együtt elmondható, hogy a lithium akkuk sokkal jobban használhatóak a gyakorlatban mint elődeik, így megéri a "kockázatot" (ami megfelelő kezelés mellett elhanyagolható)

0

50

Feszültség átalakítás

Alcím: Mert sosem jó az ami éppen van :)

Fizikából tanultuk, hogy váltóáram esetén egy közös vasmagra helyezett két tekerccsel fel vagy le transzformálható a feszültség DE ez egyenáram esetén NEM működik!

Az előzőkben is volt szó a stabilizátor IC-ről, ami kis áramfelvétel eseten nagyon jól használható, elterjedt megoldás. A stabilizátor IC működési elve az, hogy a bemenő és a kimenő feszültség különbségét, a rajta átfolyó árammal szorozva "elfűti", tehát W=U*I képlet alapján ha 12V a bemenet, 5V a kimenet, és a rajta áthaladó áram 1A, akkor (12-5)*1=7W, tehát 7wattot el kell fűtenie az IC-nek. Egy darabig hűtőborda felszerelésével és ventilátor beiktatásával el lehet kerülni a túlmelegedést, de tartós nagy áramoknál (ami pl a kisautónk motorjai, vagy a robotkar szervói) ez a megoldás nem használható. Itt jön képbe a step-down modul, ami szintén a feszültség csökkentésére szolgál de lényegesen jobb hatásfokkal mint a stab IC-k. (nem, vagy csak nagyon kicsit melegszik, így sokkal kisebb a veszteség. A működési elve ugyanis nem a "felesleg elfűtése", hanem egy indukciós tekercs folyamatos töltéséből és merítéséből mely nagy frekvenciával váltakozik. Bővebben: DC-DC feszültségátalakító )

Természetesen a feszültség növelésére is szükség lehet, ekkor step-up modult kell használnunk ami a bemenő kisebb feszültségből állít elő nagyobb kimenő feszültséget. Természetesen a fizika törvényei alapján a különbséget valahonnan venni kell, tehát ez a bemenő oldalon jelentkező nagyobb áramfelvételben fog megmutatkozni. Egyszerűen szólva: lehet egy ceruzaelemből 12V-os meghajtást előállítani, csak akkor nagyon hamar le is fog merülni...

0

51

Kísérlet:

Az akkutartónk kimeneteit kössük a step-down modul bemenetére, a step-down modul kimenetére pedig (krokodil csipesz segítségével) a multimétert, egyenfeszültség mérési módban (20V tartománnyal) Ha a modulon lévő pici trimmert (potmétert) eltekerjük, a kimeneti feszültségnek változnia kell. Állítsunk be 6V-os kimeneti feszültséget, majd a kimenetet kössük be a kisautónkon lévő H-híd feszültség bemenetére. Ha mindent jól csináltunk a 9V-os elemre már nem is lesz szükség, és a kisautó a behelyezett két 18650-es akkuval fog működni.

0

52

Arduino - memória

A számítógépek (és ebbe most a mikrokontrollerek is beletartoznak) a kezdetek óta tartalmaznak valamilyen típusú memóriákat. Az iskolai tananyag általában kétfélét említ, a RAM (Random Access Memory) és ROM (Read Only Memory) Az adattárolás fajtájaként azonban meg kell különböztetnünk (az elektronikus típusok közül) a RAM-ot, a FLASH memóriát, az EPROM-ot (azon belül az UV fénnyel törölhető EPROM-ot és az elektronikusan újraírható EEPROM-ot) Az, hogy melyiket mire használjuk (programtárolás, chache, processzor akkumulátor stb) mindig az adott feladat és az adott tárolási mód előnyös tulajdonságai alapján határozzuk meg. (pl kapacitás, fogyasztás, folyamatos írási/olvasási sebesség, elérési idő, megbízhatóság stb)

Az ATmega328 típusú mikrokontroller (ami az Arduino UNO lapon is található) 3 féle memóriával rendelkezik: (és mindegyik a RAM egyes változatának tekinthető)

Flash  - program memóra - 32k bytes (ebből .5k foglalt a bootloader számára)
SRAM  - a program futásakor a változók értékeit tárolja (kikapcsolásig vagy felülírásig), gyakorlatilag RAM-ként fogható fel - 2k bytes
EEPROM - hosszútávó írható/olvasható memória, mely a kikapcsolás után is megőrzi az adatokat (a programtól elkülönítve), ebbe tölthetjük a változóink értékét későbbi felhasználásra - 1k byte

Vegyük észre, hogy ez a felépítés eltér a Neumann elvekben meghatározott közös program és adattárolás elvétől!

Az EEPROM eléréséhez a szükséges az IDE-be épített EEPROM könyvtár, ami három példát is tartalmaz, a törlésre, az olvasásra és az írásra.

Az EEPROM eléréséhez az első lépés a könyvtár beolvasása:
#include <EEPROM.h>

A Setup részben a EEPROM.begin(512); paranccsal megadjuk, hogy az EEPROM memória mekkora méretét kívánjuk használni - bevett szokás az 512-es érték, mert ezt minden mikrovezérlő kezelni tudja, indokolt esetben természetesen az adott mikrovezérlő maximális méretéig címezhetünk.

Ezután az olvasáshoz: value = EEPROM.read(address);
(ahol az adress a cím a value változóba pedig a beolvasott érték kerül)

Íráshoz a két paramétert az alábbi formában kell megadni: EEPROM.write(addr, val);
Az EEPROM.commit(); paranccsal tulajdonképpen frissítjük (valóban "elmentjük") a változásokat.

A fenti utasításokkal és a beágyazott példákkal bármilyen értéket elmenthetünk majd visszaolvashatunk, amit gyakran használunk is állapotok rögzítésére, vagy értékek megőrzésére egy esetleges tápkimaradás esetére.

Mivel az EEPROM mérete igencsak korlátozott, lehetőség van a programmemória (FLASH) további részekre bontására, így ott is elkülöníthetünk magunknak memóriát, amiben nagyobb méretű adatot (pl kis weblap) tárolhatunk. Ezzel majd a WEMOS-nál foglalkozunk.

Továbbá meg kell említeni, hogy az Arduino támogatja a külső memóriakezelést, akár a beépített memória bővítéseként, akár külső SD kártya kezelés formájában...

0

53

Fizikai billentyűzet kezelése

A csomagban kapott numerikus billentyűzet kezelésével prezentáljuk a mátrix kapcsolás előnyeit.

Alap esetben minden billentyűzet gomb egy-egy nyomógombként fogható fel, azaz minden egyes gombhoz két vezetéket kellene csatlakoztatnunk (egy közös pl tápvezetéket, és egy bemenetet az Arduino felé, aminek fel/lehúzó ellenállással stabilizáljuk az állapotát) Belátható, hogy ez rengeteg lábat foglalna le a mikrovezérlőn így más megoldást kell találni. Ha egy tetszőleges billentyűzet gombjait felosztjuk oszlopokra és sorokra, akkor egy gomb lenyomását ezek metszéspontjában való kapcsolatként is érzékelhetjük, így csak annyi vezetékre van szükségünk ahány sorunk és oszlopunk van a billentyűzetben - ez a mátrix kapcsolás.
http://www.circuitstoday.com/wp-content/uploads/2014/05/hex-keypad-arduino.png

A 3x4-es numerikus billentyűzetünkhöz jó példát találunk itt: Billentyűzet kapcsolás és példa
(columns: oszlopok, rows: sorok)

Feladat:
A fenti két témát felhasználva készítsünk egy kapcsolást és programot, amely a numerikus billentyűzeten beérkező 4 db számot (PIN-kódot) összehasonlítja az EEPROM-ban tárolttal, majd ha a kettő egyezik, bekapcsol egy zöld ledet (helytelen kód esetén pirosat) majd 2 másodperc után újrakezdi.

0

54

Keypad.h letöltése:
Link

telepítése:
a zip fájl tartalmát (könyvtárral együtt) másoljuk a dokumentumok/Arduino/Library mappába

Program:

#include "Keypad.h"

const byte ROWS = 4; //four rows
const byte COLS = 4; //three columns
char keys[ROWS][COLS] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
byte rowPins[ROWS] = {9, 8, 7, 6}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {5, 4, 3, 2}; //connect to the column pinouts of the keypad

Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

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

void loop()
{
char key = keypad.getKey();

if (key != NO_KEY){
Serial.println(key);
}
}

0

55

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

0

56

#include "Keypad.h"
#include <EEPROM.h>

const byte ROWS = 4; //four rows
const byte COLS = 4; //three columns
char keys[ROWS][COLS] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
byte rowPins[ROWS] = {9, 8, 7, 6}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {5, 4, 3, 2}; //connect to the column pinouts of the keypad
char pinkod[4];
byte szamlalo = 0;

Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

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

void torles()
{
szamlalo=0;
  for (byte x =0; x<4; x++) {
    pinkod[x]=0;   
}
}

void loop()
{
char key = keypad.getKey();

if (key != NO_KEY){
Serial.println(key);
if ((key>=48) and (key<=57)) {
  pinkod[szamlalo]=key;
  szamlalo++;   
} //gyujtes vege

//tarolas
if ((key=='A') and (szamlalo>3)) {
  for (byte x =0; x<4; x++) {
   EEPROM.write(x, pinkod[x]);   
  }
  torles();
} //A vege

//torles
if (key=='C') {
  torles();
  }

   // ellenorzes
  if (key=='*')  {
    if (szamlalo>3) {
    boolean helyes = true;
    for (byte x =0; x<4; x++) {
      if (EEPROM.read(x)!= pinkod[x]) { helyes=false; x=5; }
    }
    if (helyes==true) { Serial.println("Bejohetsz"); torles(); }
     else { Serial.println("Rossz a kod"); torles();}
  }
  else { Serial.println("Rossz a kod"); torles(); }
}

}
}

0


You are here » Robotika tanfolyam » Tanfolyam » Tananyagok