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.

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

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

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

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

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:

(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

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

Á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ó)

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.

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.

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.

Kapcsolat a HC-06 Bluetooth modullal:

Beállítások a számítógépen:
Baud: 9600
Nincs enter se soremelés!

Parancsok:
Parancs               válasz
AT                      OK
AT+VERSION      OKKlinkovV1.8
AT+NAMEvalami OKsetnamevalami

Állítsunk be saját nevet a modulnak!

Android program letöltési link-je:
https://drive.google.com/open?id=1JyhfZ … E5HWV4deNt