Az Arduino egy könnyen használható hardveren és szoftveren alapuló nyílt forrású elektronikai platform...Az Arduino egy az Atmel AVR mikrovezérlő családra épülő, szabad szoftveres elektronikai fejlesztőplatform, arra tervezve, hogy a különböző projektekben az elektronikus eszközök könnyebben hozzáférhetőek, kezelhetőek legyenek. Széles tömegek számára elérhető, mivel olcsó, könnyen beszerezhető, egyszerűen programozható, és csatlakoztatható más eszközökhöz.
(nem csak) Azoknak tervezték, akik interaktív projekteket készítenek. Az Arduino képes érzékelni a környezetet a bemeneteire kötött különféle szenzorok, érzékelők által. Így gyakorol hatást a környezetére azáltal hogy vezérli a körülötte lévő fényeket, világítást, motorokat és egyéb vezérlő eszközöket. Többféle változatban, méretben és tudással gyártják. Illetve léteznek az úgynevezett Arduino kompatibilis eszközök, amelyek nagyban hasonlítanak vagy teljesen megegyeznek az Arduinoval. Itt főleg a kínai replikákra gondolok. Ezek gyakorlatilag megegyeznek, kompatibilisek az Arduinoval, és programozhatók az az Arduino saját fejlesztésű szoftverével, fejlesztő környezetével. Ez is annak köszönhető, hogy mind a hardver, mind a szoftver környezet nyílt forrású, szabad szoftveres fejlesztő platform. Használata könnyen megtanulható, a felhasználó által megírt program egyszerűen usb csatlakozón keresztül az eszközre tölthető.
A legelterjedtebb az Arduino Uno és a Nano panel. Ezek az Atmel AVR ATMega328-as mikrovezérlőre épülnek. Az ATMega328-as egy 28 lábú mikrovezérlő, ami 20db felhasználható I/O lábbal rendelkezik. Ebből a 20-ból 6db használható analóg bemenetnek, 6db használható PWM kimenetnek és két láb használható külső megszakításokhoz. Az Arduino panel a számítógéphez egy USB kábellel csatlakoztatható. Ezen keresztül történik a panel tápellátása, a mikrovezérlő programozása és a PC-vel történő kommunikáció. A panelen lévő mikrovezérlő több ezerszer újraprogramozható.
Az Arduino nemcsak a hardvert takarja, hanem az egész fejlesztőkörnyezetet is magában foglalja. A PC-n futó Arduino nevű programmal könnyen írható a mikrovezérlőre kód, ami lefordítás után az USB kábelen keresztül az Arduino panelre tölthető. A fejlesztőkörnyezet által használt Arduino programnyelv a C++ egy egyszerűsített változata, amely rengeteg beépített könyvtárat tartalmaz. Ezek a bonyolultabb programozási feladatokat nagymértékben leegyszerűsítik. Az Arduino panel programozásához nem szükséges ismerni a rajta található AVR mikrovezérlő részletes működését (pedig ez is igen izgalmas téma), mert a fejlesztőkörnyezet elfedi előlünk a hardvert. Ez nagyon megkönnyíti a kezdők dolgát, mert a robotikával való ismerkedés elkezdéséhez nem szükséges a mikrovezérlők és a bennük integrált perifériák működésének regiszter szintű ismerete. A perifériák használata legtöbbször néhány egyszerű paranccsal megoldható. (pl. az ADC, PWM, soros kommunikáció szinte egy-egy utasítással megoldható).
Az alábbi kép az Arduino Uno lábkiosztását és kivezetéseit mutatja.z Arduino nagyon népszerű az elektronikával és robotikával hobbi szinten foglalkozók körében, mert nagyon egyszerű a használata.
A legelterjedtebb az Arduino Uno és a Nano panel. Ezek az Atmel AVR ATMega328-as mikrovezérlőre épülnek. Az ATMega328-as egy 28 lábú mikrovezérlő, ami 20db felhasználható I/O lábbal rendelkezik. Ebből a 20-ból 6db használható analóg bemenetnek, 6db használható PWM kimenetnek és két láb használható külső megszakításokhoz. Az Arduino panel a számítógéphez egy USB kábellel csatlakoztatható. Ezen keresztül történik a panel tápellátása, a mikrovezérlő programozása és a PC-vel történő kommunikáció. A panelen lévő mikrovezérlő több ezerszer újraprogramozható.
AUno csatlakozóit tartalmazó hüvelysorra könnyen, forrasztás nélkül csatlakoztathatunk vezetékeket.
Az Arduino Nano sokkal kisebb méretű mint az Uno. A Nano csatlakozóit tüskesorra cserélték, és úgy alakították ki, hogy egyszerűen rádugható legyen egy dugdosós próbapanelre. Ezáltal nagyon egyszerűen, forrasztás nélkül egészen bonyolult kapcsolások is összeállíthatóak és tesztelhetőek.
Az Arduino nemcsak a hardvert takarja, hanem az egész fejlesztőkörnyezetet is magában foglalja. PC-n futó Arduino nevű programmal könnyen írható a mikrovezérlőre kód, ami lefordítás után az USB kábelen keresztül az Arduino panelre tölthető. A fejlesztőkörnyezet által használt Arduino programnyelv a C++ egy egyszerűsített változata, amely rengeteg beépített könyvtárat tartalmaz. Ezek a bonyolultabb programozási feladatokat nagymértékben leegyszerűsítik. Az Arduino panel programozásához nem szükséges ismerni a rajta található AVR mikrovezérlő részletes működését, mert a fejlesztőkörnyezet elfedi előlünk a hardvert. Ez nagyon megkönnyíti a kezdők dolgát, mert a robotikával való ismerkedés elkezdéséhez nem szükséges a mikrovezérlők és a bennük integrált perifériák működésének regiszter szintű ismerete. A perifériák használata legtöbbször néhány egyszerű paranccsal megoldható. (pl. az ADC, PWM, soros kommunikáció szinte egy-egy utasítással megoldható).
z alábbi kép az Arduino Uno lábkiosztását és kivezetéseit mutatja.
Az Uno csatlakozóit tartalmazó hüvelysorra könnyen, forrasztás nélkül csatlakoztathatunk vezetékeket.
Az Arduino Nano sokkal kisebb méretű mint az Uno. A Nano csatlakozóit tüskesorra cserélték, és úgy alakították ki, hogy egyszerűen rádugható legyen egy dugdosós próbapanelre. Ezáltal nagyon egyszerűen, forrasztás nélkül egészen bonyolult kapcsolások is összeállíthatóak és tesztelhetőek.
Arduino fejlesztőkörnyezet
A programot először elindítva az alábbi képernyő fogad:
A File/Preferences/Editor language menüpontban állíthatjuk át Magyar nyelvűre a programot.
Mielőtt az Arduino panelt elkezdenénk használni, ahhoz hogy programozni tudjuk, az Eszközök/Alappanel menüpontban be kell állítani, hogy milyen típusú panelt használunk.
Az Eszközök/Soros port menüpontban pedig azt kell beállítani hogy a panel melyik COM portra van csatlakoztatva.
A fentiek beállítása után a panelt már tudjuk programozni.
Az eszközsorban az alábbi 7 gomb található:
Ellenőrzés: mielőtt a programot az Arduino panelba töltenénk, le kell fordítanunk. Ezzel a gombbal fordítható le a kód és ellenőrizhető, hogy a programunk hibamentes-e.
Új: új projektet létrehozása
Megnyitás: korábban létrehozott projek megnyitása
Mentés: a jelenlegi projekt elmentése
Feltöltés: a lefordított kód feltöltése az Arduino-ba
Soros Monitor: az Arduino panel által küldött soros adatok megjelenítése egy terminálablakban
A program felépítése
Az Arduino programokat vázlatnak/skicc-nek (Sketch) hívják.
A program nem más mint az Arduino által végrehajtandó utasítások sorozata.
A program három fő részből áll:
•
Változók megadása
•
Setup () – Általános Beállítások
•
Loop () – Főprogram
Változók megadása
Az Arduino programban használt változókat és azok típusát kell itt megadni. PL. bármelyik Arduino lábat átnevezhetjük, és a programban a későbbiek során ezzel az egyedi névvel hivatkozhatunk rá.
Setup(){ }
A kapcsos zárójelen belül lévő kód az Arduino bekapcsolása után csak egyetlen egyszer fut le, mielőtt a programunk fő ciklusa elindulna. Ezért a steup() részben adhatjuk meg a főbb beállításokat, általános utasításokat, eszköz inicializálásokat (pl. itt adjuk meg hogy mely lábak legyenek ki vagy bemenetek, a soros kommunikáció sebességét is itt kell beállítani stb…). Alapértelmezettként minden láb bemenet, ezért általában csak a kimeneteket definiáljuk.
Loop(){ }
Ez a függvény lényegében a főprogram. Itt adjuk meg az Arduino-nak hogy mit is csináljon. Ez a függvény a setup() függvény lefutása után indul, és folyamatosan ismétlődik mindaddig amíg az Arduino panel be van kapcsolva. Minden egyes alkalomkor, amikor a program a Loop függvény végére ér, átugrik a loop függvény eléjere és kezdi újra előről.
Analóg és Digitális Jelek
Az Arduino többfajta különböző jelet tud érzékelni és kiadni. A jeleket alapvetően két csoportra szoktuk osztani: analóg és digitális jelekre. A digitális jel csak kétfele értéket vehet fel: 0V vagy +5V. Az analóg jel ellenben bármilyen feszültségérték lehet 0V és +5V között.
Digitális jelek
Az Arduino Uno és Nano 14 darab digitális ki/bemenettel rendelkezik (D0-D13). A Setup részben minden egyes digitális láb a pinMode() parancs használatával külön-külön beállítható bemenetnek (INPUT) vagy kimenetnek (OUTPUT). Az Arduino-n a digitális jel logikai magas (HIGH) vagy logikai alacsony (LOW) szintű lehet. Attól függetlenül hogy a láb kimenet vagy bemenet, ha a láb 5V-os feszültségszinten van, akkor magas logikai szintnek értelmezzük, és ha 0V-on van (föld / GND), akkor pedig logikai alacsony szintnek tekintjük.
pinMode(láb, mód); - a lábak adatirányát állíthatjuk be ezzel az utasítással (INPUT: bemenet, OUTPUT: kimenet).
Digitális kimenet
A digitális kimenetekkel azt tudjuk megadni, hogy a kimeneti lábon magas szint (5V) vagy alacsony (0V) legyen. Így vezérelhetünk különféle eszközöket az Arduino-val.
digitalWrite(láb, érték); - ha egy lábat kimenetnek állítottunk be, akkor ezzel az utasítással az állapotát magasra (HIGH - +5V), vagy alacsonyra (LOW – 0V) állíthatjuk.
Azt azért figyelembe kell venni, hogy az Arduino lábanként maximum 40mA-es áramot képes felvenni vagy leadni, ezért a lábakra kötött eszközöket is ennek megfelelően kell megválasztani (nem köthetünk közvetlenül az Arduino-ra nagy áramigényű eszközöket pl. a robot meghajtását szolgáló villanymotorokat).
A digitális kimenetek használatára nézzünk egy egyszerű példát, amiben egy LED-et villogtatok. A kapcsolást az alábbi ábra mutatja:
/*
LED villogtatas
*/
int ledPin = 9; // LED Pin9-re kotve
void setup()
{
pinMode(ledPin, OUTPUT); // a LED-hez tartozo lab kimenet
}
void loop()
{
digitalWrite(ledPin, HIGH); // LED bekapcsolasa
delay(1000);
// varakozas 1 masodpercig
digitalWrite(ledPin, LOW); // LED kikapcsolasa
delay(200);
// varakozas 1/5 masodpercig
digitalWrite(ledPin, HIGH); // LED bekapcsolasa
delay(200);
// varakozas
1/5 masodpercig
digitalWrite(ledPin, LOW); // LED kikapcsolasa
delay(200);
// varakozas 1/5 masodpercig
digitalWrite(ledPin, HIGH); // LED bekapcsolasa
delay(200);
// varakozas 1/5 masodpercig
digitalWrite(ledPin, LOW); // LED kikapcsolasa
delay(1000);
// varakozas 1 masodpercig
}
A LED-del sorba kell kötni egy 220-680 ohm közé eső áramkorlátozó ellenállást. A LED polaritására is ügyelni kell (a LED hosszabbik lába legyen a Pin9-re kötve).
Az alábbi programot kell az Arduino panelbe programozni (kattintsunk az Ellenőrzés majd a Feltöltés gombokra)
/*
LED villogtatas
*/
int ledPin = 9; // LED Pin9-re kotve
void setup()
{
pinMode(ledPin, OUTPUT); // a LED-hez tartozo lab kimenet
}
void loop()
{
digitalWrite(ledPin, HIGH); // LED bekapcsolasa
delay(1000); // varakozas 1 masodpercig
digitalWrite(ledPin, LOW); // LED kikapcsolasa
delay(200); // varakozas 1/5 masodpercig
digitalWrite(ledPin, HIGH); // LED bekapcsolasa
delay(200); // varakozas 1/5 masodpercig
digitalWrite(ledPin, LOW); // LED kikapcsolasa
delay(200); // varakozas 1/5 masodpercig
digitalWrite(ledPin, HIGH); // LED bekapcsolasa
delay(200); // varakozas 1/5 masodpercig
digitalWrite(ledPin, LOW); // LED kikapcsolasa
delay(1000); // varakozas 1 masodpercig
}
A program legelején a könnyebb érthetőség miatt elnevezem a 9-es lábat ledPin-nek, majd a setup() részben a pinMode paranccsal kimenetnek állítom be (a lábak alapértelmezésben bemenetnek vannak definiálva).
A loop() részben a ledPin lábra a digitalWrite() utasítással 5V-ot adok (bekapcsolom a LED-et). A delay(1000) utasítással várok egy másodpercet (1000ms), majd a ledPin lábra 0V-ot kapcsolok (kikapcsolom a LED-et). Ezután ugyanezt a folyamatot ismétlem meg még kétszer egymás után csak 1/5-od másodperces (200ms) időzítésekkel.
Digitális bemenet
A digitális bemenetek külső jelek vizsgálatára használhatóak. Akkor hasznosak, ha pl. el akarjuk dönteni hogy egy gomb le van-e nyomva, vagy egy kapcsoló be van-e kapcsolva vagy nincs. A digitalRead() parancsot használhatjuk annak megvizsgálására hogy egy digitális bemeneti láb magas vagy alacsony szinten van-e. A határéték 3V környékén van, minden ennél magasabb feszültség logikai magas értéknek számít, és minden ennél alacsonyabb feszültség logikai alacsony szintnek számít.
digitalRead(láb); - ha egy lábat bemenetnek állítottunk be, akkor ezzel az utasítással lehet a láb állapotát lekérdezni. (magas vagy alacsony (HIGH / +5V vagy LOW / 0V) .
A digitális bemenetek használatára is nézzünk egy egyszerű példát:
/*
* Nyomogomb
*/
int ledPin = 9; // LED Pin9-re kotve
int inputPin = 2; // nyomogomb Pin2-re kotve
int val = 0; // a nyomogomb allapotat tarolo valtozo
void setup()
{
pinMode(ledPin, OUTPUT); // a LED-hez tartozo lab kimenet
pinMode(inputPin, INPUT); // a nyomogombhoz tartozo lab bemenet
digitalWrite(ledPin, LOW); // LED kikapcsolasa
}
void loop()
{
val = digitalRead(inputPin); // nyomogomb allapotanak lekerdezese
if (val == HIGH) // ha a nyomogomb nincs lenyomva
{
digitalWrite(ledPin, HIGH); // LED bekapcsolasa
}
else // kulonben
{
digitalWrite(ledPin, LOW); // LED kikapcsolasa
}
}Az előző példához képest csak annyi a változás, hogy a Pin2 láb és GND közé egy nyomógombot kötöttem.
/*
* Nyomogomb
*/
int ledPin = 9; // LED Pin9-re kotve
int inputPin = 2; // nyomogomb Pin2-re kotve
int val = 0; // a nyomogomb allapotat tarolo valtozo
void setup()
{
pinMode(ledPin, OUTPUT); // a LED-hez tartozo lab kimenet
pinMode(inputPin, INPUT); // a nyomogombhoz tartozo lab bemenet
digitalWrite(ledPin, LOW); // LED kikapcsolasa
}
void loop()
{
val = digitalRead(inputPin); // nyomogomb allapotanak lekerdezese
if (val == HIGH) // ha a nyomogomb nincs lenyomva
{
digitalWrite(ledPin, HIGH); // LED bekapcsolasa
}
else // kulonben
{
digitalWrite(ledPin, LOW); // LED kikapcsolasa
}
}
A program elején elnevezem a 2-es lábat inputPin-nek és létrehozok egy egész típusú, a nyomógomb állapotát tároló val nevű változót.
A setup() részben LED-hez tartozó lábat kimenetnek, a nyomógombhoz tartozó lábat pedig bemenetnek állítom be.
A loop() részben a digitalRead() utasítással lekérdezem a nyomógomb állapotát, majd egy cikluson belül megvizsgálom hogy le van-e nyomva a gomb és a gomb állapotától függően kapcsolom ki/be a LED-et.
Analóg Jelek
Korábban láthattuk, hogy az analóg jelek csak alacsony (0V) vagy magas (5V) szintűek lehetnek. Az analóg jelek ezzel szemben a 0V és 5V között bármilyen értéket felvehetnek. Az Arduino hat speciális bemeneti lábbal rendelkezik, amelyek képesek ezeket a feszültségértékeket beolvasni. Ez a hat speciális bemenet rendelkezik egy 10 bites analóg-digitális átalakítóval (ADC), ami képes a 0V és 5V közé eső feszültséget mérni és egy ezzel arányos 0 és 1023 közé eső 10 bites számmá alakítani.
Analóg bemenet
Az analóg lábak alapértelmezettként bemenetek, és az analogRead() utasítással lehet a rajtuk lévő feszültséget mérni.
analogRead(láb); - ezzel az utasítással mérhető meg ADC-vel egy analóg lábon lévő feszültség. A függvény 0 - 1023 közötti értéket ad vissza eredményül.
Az alábbiakban az analóg bemenetek használatára mutatok példát:
A potenciométer úgy viselkedik mint egy feszültségosztó kapcsolás, amiben az ellenállások értékét változtatjuk. Ezáltal a potenciométer kimenetén megjelenő feszültség függ a tekerőgomb állásától.
/*
* ADC hasznalata potenciometer-rel
*/
int potPin = 5; // potenciometer A5-re kotve
int val; // valtozo a mert ADC ertek tarolasara
void setup()
{
Serial.begin(9600); // 9600 baud-os soros port beallitasa
}
void loop()
{
val = analogRead(potPin); // ADC ertek beolvasasa
Serial.println(val, DEC); // a mert ADC ertek PC-re kuldese
delay(100); // varakozas
}
A setup() részben a serial.begin() paranccsal egy 9600 baud sebességű soros kommunikációs portot hozok létre, amivel adatokat lehet küldeni/fogadni az Arduino és pl. a PC között.
A loop() részben a kód megméri a potenciométer feszültségét az analogRead() utasítással, és a mért ADC értéket a Serial.println() paranccsal elküldi a PC-re.
Az adatokat a PC-n a Soros monitoron keresztül követhetjük figyelemmel.
Analóg kimenet (PWM)
Technikai értelemben ez nem egy hagyományos analóg kimenet, mert a kimeneten nem egy 0V és 5V közé eső feszültség jelenik meg. A PWM jel (impulzus szélesség moduláció) az analóg kimeneti lábra meghatározott ideig felváltva 0V-ot és 5V-ot kapcsol. A két feszültség idejének az egymáshoz viszonyított arányát változtatva tudjuk a jel kitöltési tényezőjét változtatni, ezáltal változtatni a lábon lévő átlagfeszültség szintjét.
Az Arduino hat digitális lába képes PWM jelet előállítani (Pin 3, 5, 6, 9, 10 és 11). Az analoWrite(PWM_Pin, szám) parancsnak egy 0-255 közé eső számot adva paraméterül könnyen változtatható a PWM jel kitöltési tényezője.
analogWrite(láb, érték); - ha egy lábat kimenetnek állítottunk be, és a láb képes PWM-re, akkor ezzel az utasítással adhatunk rá PWM jelet. A függvénynek paraméterként egy 0 - 255 közötti értéket kell megadni a kitöltési tényező beállításához (0=0%=0V, 255=100%=5V)
Az alábbi példa a PWM használatát mutatja be:
/*
* LED fenyerejenek valtoztatasa potenciometer-rel
*/
int potPin = 5; // potenciometer A5-re kotve
int val; // valtozo a mert ADC ertek tarolasara
int ledPin = 9; // LED Pin9-re kotve
void setup()
{
pinMode(ledPin, OUTPUT); // a LED-hez tartozo lab kimenet
}
void loop()
{
val = analogRead(potPin); // ADC ertek beolvasasa
analogWrite(ledPin,val/4); // LED-nek PWM jel
delay(100); // varakozas
}
A kód megméri a potenciométer feszültségét, és egy azzal arányos kitöltési tényezőjű PWM jelet ad a LED-re. Az ADC 0-1023 közé eső számot ad végeredményül, a PWM-nek az analogWrite() utasításban viszont egy 0-255 közé eső számot kell megadni paraméterként. Ezért az ADC eredményét el kell osztani 4-el, hogy 0-255 közé eső számot kapjunk. A potencimétert tekergetve a LED fényereje változtatható.
Analóg kimenet (Szervóvezérlés)
A hobbiszervók vezérléséhez szükséges jel, tekinthető egy speciális PWM jelnek is, ahol a jel impulzusszélessége és periódusideje a szervó adatlapjában megadott értékek köze kell hogy essen (impulzusszélesség: 1-2ms közötti érték, periódusidő: max. 20ms).).
Nézzünk a szervóvezérlésre is egy példát:
/*
* Szervo poziciojanak valtoztatasa potenciometer-rel
*/
#include <Servo.h> // szervokonyvtar
Servo mikroszervo; // mikroszervo nevu szervo objektum
int potPin = 5; // potenciometer A5-re kotve
int val; // valtozo a mert ADC ertek tarolasara
void setup()
{
mikroszervo.attach(9); // mikroszervo Pin9-re kotve
}
void loop()
{
val = analogRead(potPin); // ADC ertek beolvasasa
val = map(val, 0, 1023, 0, 179); // ADC ertek atalakitasa
mikroszervo.write(val); // szervopozicio beallitasa
delay(100); // varakozas
}
/*
* Szervo poziciojanak valtoztatasa potenciometer-rel
*/
#include
<Servo.h> // szervokonyvtar
Servo mikroszervo; // mikroszervo nevu szervo objektum
int potPin = 5; // potenciometer A5-re kotve
int val; // valtozo a mert ADC ertek tarolasara
void setup()
{
mikroszervo.attach(9); // mikroszervo Pin9-re kotve
}
void loop()
{
val = analogRead(potPin); // ADC ertek beolvasasa
val = map(val, 0, 1023, 0, 179); // ADC ertek atalakitasa
mikroszervo.write(val); // szervopozicio beallitasa
delay(100); // varakozas
}
A program elején belinkelem az Arduino szervókonyvtárat és létrehozok egy mikroszervo nevű szervóobjektumot. A mikroszervo.attach(9) utasítással hozzárendelem a szervót a 9-es lábhoz.
A kód megméri a potenciométer feszültségét, és egy ezzel arányos pozícionáló jelet ad a szervóra. Az ADC 0-1023 közé eső számot ad végeredményül, a szervópozíció beállításához viszont 0-179 közé eső szögértéket kell megadni paraméterként. A map() utasítással lehet a 0-1023 közé eső ADC eredményt 0-179 közé eső számmá alakítani.
Elérkeztünk a vonalkövető robot építéséről szóló cikksorozat befejező részéhez, amelyben a robot programozásáról, teszteléséről és a továbbfejlesztési lehetőségekről lesz szó.
Ehhez legelőször a vonalérzékelő szenzorokat kell kalibrálni, hogy meghatározzuk azokat a konstansokat, amelyek a robotvérlő program számára szükségesek. A robot pontos irányítása érdekében azt is meg kell vizsgálni, hogy a motorvezérlő parancsokra hogyan reagál a robot.
Vonalérzékelő szenzor tesztélese
Mielőtt a vonalérzékelő szenzorokat használni tudnánk, elemezni kell az általuk szolgáltatott jeleket, hogy el tudjuk dönteni mikor van egy adott szenzor a vonal felett és mikor a padló felett. Az LDRteszt.ino Arduino programmal beolvastam a bal és jobb oldali szenzorok jeleit, majd a mért értékeket soros porton elküldtem a PC-nek. A mért értékeket az Arduino soros monitorán jelenítettem meg. A vonalérzékelő szenzorokat először a vonal, majd a padló fölé helyeztem. A mért értékeket az alábbi táblázat mutatja:
Szenzor pozíció
Bal LDR
Jobb LDR
Sötét vonal felett
770
780
Világos padló felett
910
920
Középérték:
840
850
Ha a szenzor a vonal felett van, akkor az ADC értéke 770-780 körül van. Ha a padló felett, akkor pedig 910-920 körül. Ezért határértéknek 820-at választottam. Ha egy szenzor értéke ezen határértéknél kisebb, akkor azt úgy értelmezem, hogy a szenzor a vonal felett van. Ha a határértéknél nagyobb, akkor pedig úgy hogy a padló felett van.
Motorvezérlés tesztelése
A robotnál ugyanolyan áttétellel rendelkező, megegyező típusú DC motorokat használtam. Ettől függetlenül a két motor működési paraméterei eltérőek. Ugyanazzal a PWM jellel meghajtva őket más-más sebességgel fognak forogni. Ha azt akarjuk hogy a robot egyenesen tudjon haladni, akkor ezt mindenképpen ki kell küszöbölni. Ez is többféleképpen tehető meg.
Használhatunk pl. a motorok tengelyére erősített, résekkel ellátott tárcsát, amelyek forgását egy optokapuval detektálhatjuk. Ezáltal gondoskodhatunk arról, hogy előre haladásnál a két motor azonos sebességgel forogjon. Ha a két motor különböző sebességgel forog, akkor a gyorsabbat lassítani kell, vagy a lassabbat gyorsítani.
A vonalkövető robotnál ennél egyszerűbb, bár kevésbé megbízható megoldást használtam. A motorok teszteléséhez egy potenciométert kötöttem az A0 analóg bemeneti lábra, és azzal változtattam a motorokat meghajtó PWM jelet. A motormeghajtó függvények értékét kiírattam a PC-re is. A motorok elindulásához tartozó értékeket az alábbi táblázat tartalmazza:
-
Bal Motor
Jobb Motor
Előre
45%
65%
Hátra
-45%
-65%
Látható, hogy a két motor közötti különbség kezdetben 20 körül van, de ez a sebesség növekedésével fokozatosan csökken. A motorokra adott PWM jeleket egy offszet értékkel megváltoztattam egymáshoz viszonyítva. A kerekekre ragasztotam egy markert, és megkerestem azt az értéket, amelynél a 2 kerék azonos sebességgel forgott. Ekkor a bal motor sebessége 98%, a jobb motoré pedig 100% volt
Ennek a megoldásnak az a hátránya, hogy az offszet értéke sok paramétertől függ (például a motorokat meghajtó telepek feszültségétől), ezért ahogy az elemek merülnek, a robot irányítását is korrigálni kell (tehetünk a robotra például egy potenciométert, amivel a 2 motor közötti offszet értékét változtathatjuk, de a robot egyszerűbbé tétele miatt ezt elhagytam...).
Vonalkövető algoritmus
Miután már tudjuk értelmezni a vonalérzékelő szenzor adatait, és a robotunk tud egyenesen haladni. Nekiállhatunk a vonalkövető algoritmus és a robotvezérlő program elkészítésének.
Bekapcsolás után az ADC-vel beolvassuk először a jobb, majd a bal oldali LDR érzékelővel mért fényerősséget (a fényerősséggel arányos feszültséget). A mikrovezérlő a vonal pozíciójától függően úgy irányítja a robotot (úgy változtatja a robotot meghajtó DC motorok sebességét és forgásirányát), hogy a vonal mindig a két szenzor között maradjon. Ha a bal oldali szenzor van a vonal felett (a bal oldali szenzor által mért fényerősség a beállított határértéknél kisebb), akkor a robot balra fordul (C). Ha a jobb oldali szenzor van a vonal felett (a jobb oldali szenzor által mért fényerősség a beállított határértéknél kisebb), akkor a robot jobbra fordul (D). Ha mindkét detektor jele a megadott határértéknél nagyobb (a vonal a két érzékelő között van), vagy ha mindkét detektor jele a megadott határértéknél kisebb ( a robot kereszteződéshez ért), akkor a robot megy előre (A és B). A határérték változtatásával lehet a robotot a környezeti fényviszonyokhoz hangolni. A következő ADC mérés előtt a mikrovezérlő várakozik 50 ms-ig. Ez az esetlegesen fellépő oszcillációk csökkentésére szolgál.
A robotot irányító algoritmust az alábbi táblázatban foglahatjuk össze (Ha a szenzor a vonal felett van, akkor az ADC értéke a határértéknél kisebb. Ezt az állapotot 1-essel jelöltem. Ha a szenzor a padló felett van, akkor az ADC értéke a határértéknél nagyobb. Ezt az állapotot 0-val jelöltem):
Bal szenzor
Jobb szenzor
Robot válasz
Bal motor
Jobb motor
0
0
Előre
Előre
Előre
1
0
Balra fordulás
Stop
Előre
0
1
Jobbra fordulás
Előre
Stop
1
1
Előre (kereszteződés)
Előre
Előre
Folyamatábrán is ábrázolható a vonalkövető robotot irányító algoritmus:
A fenti algoritmust kell lekódolni az Arduino nyelvre.
Arduino fejlesztőkörnyezet
Az Arduino hardvert és fejlesztői környezetet nem ismertetem részletesen, mert a TavIR Ha elindítjuk az Arduino fejlesztőkörnyezetet, az alábbi képernyő fogad:
Az eszközsorban az alábbi 7 gomb található:
Verify: mielőtt a programot az Arduino panelba töltenénk, le kell fordítanunk. Ezzel a gombbal fordítható le a kód és ellenőrizhető, hogy a programunk hibamentes-e.
New: ezzel a gombbal egy új projektet hozhatunk létre
Open: ezzel a gombbal nyithatjuk meg a korábban létrehozott projekteket
Save: a jelenlegi projekt elmentése
Upload: a lefordított kód feltöltése az Arduino-ba
Serial Monitor: az Arduino panel által küldött soros adatok megjelenítése egy terminálablakban
Az Arduino-val most ismerkedőknek egy kis segítség (az alábbi PDF dokumentumokban sok egyszerű, kezdőknek való példa található):
Vonalkövető Robot Arduino-val (Programozás/Tesztelés)
Arduino használata esetén elég egyszerű dolgunk van. A fejlesztői környezet eltakarja előlünk a hardvert, ezért nem kell részletesen ismerni a mikrovezérlő működését. Az AVR mikrovezérlő és a beépített perifériák használata legtöbbször néhány egyszerű paranccsal megoldható. A robotunk programozásához is csak azt kell tudnunk, hogy az I/O lábak állapotát hogyan tudjuk változtatni (a motorok forgásirányának a beállítsához), hogyan tudunk PWM jelet létrehozni (a motorok sebességének a beállítsához), és hogyan tudjuk megmérni ADC-vel a két szenzoron lévő feszültséget (a vonal érzékeléséhez).
Az Arduino programnak tartalmaznia kell egy setup() és egy loop() függvényt, különben nem fog működni. A (void) arra utal, hogy a függvény a meghívása után nem ad vissza eredményül semmilyen adatot. Az üres zárójel pedig arra utal, hogy a függvény hívásakor mi sem adunk meg semmilyen paramétert a függvénynek. A setup() csak egyetlen egyszer fut le a program legelején, mielőtt a programunk fő ciklusa elindulna. Ezért a steup() részben adhatjuk meg a főbb beállításokat, általános utasításokat, eszköz inicializálásokat (pl. lábak adatirányának beállítása, soros kommunikáció sebességének beállítása stb…). A loop() függvény lényegében a főprogram, ami folyamatosan fut és ismétlődik mindaddig amíg az Arduino panel be van kapcsolva.
A robotvezérlő program feladata egyszerű: beolvassa a vonalérzékelő szenzorok jeleit, amelyek alapján meghatározza a robot válaszát és ennek megfelelően vezérli a motorokat.
Klikk a nagyobb képért!
A program legelején a könnyebb érthetőség miatt elnevezem a motorvezérlő Pin4 - Pin7 lábakat, majd a setup() részben a pinMode paranccsal kimenetnek definiálom őket (a lábak alapértelmezésben bemenetnek vannak definiálva, ezért azokat nem kell megadni).
Az alábbi függvények szükségesek az Arduino lábak beállításához és kezeléséhez:
pinMode(láb, mód); - a lábak adatirányát állíthatjuk be ezzel az utasítással (INPUT: bemenet, OUTPUT: kimenet).
digitalWrite(láb, érték); - ha egy lábat kimenetnek állítottunk be, akkor ezzel az utasítással az állapotát magasra (HIGH - +5V), vagy alacsonyra (LOW – 0V) állíthatjuk.
analogWrite(láb, érték); - ha egy lábat kimenetnek állítottunk be, és a láb képes PWM-re, akkor ezzel az utasítással adhatunk rá PWM jelet. A függvénynek paraméterként egy 0 - 255 közötti értéket kell megadni a kitöltési tényező beállításához
analogRead(láb); - ezzel az utasítással mérhető meg ADC-vel egy analóg lábon lévő feszültség. A függvény 0 - 1023 közötti értéket ad vissza eredményül.
A főprogram legelején, a loop() végtelen cikuls folyamatosan beolvassa az analogRead() utasítással a jobb és bal szenzor jeleit a BalLDR és JobbLDR nevű változókba. Az if() és else if() utasítások azt vizsgálják, hogy melyik szenzor van a vonal vagy a padló felett, és ettől függően a korábban tárgyalt vonalkövető algoritmusnak megfelelően úgy vezéreli az Arduino a motorokat, hogy a követendő vonal mindig a két szenzor között legyen.
A robot irányításának a leegyszerűsítése érdekében létrehoztam a MotorBal és MotorJobb motorvezérlő függvényeket. A függvényeknek 100 és -100 közé eső számot kell megadni paraméternek (előre 100% - hátra 100%). Azt figyelembe kell venni, hogy amint azt a motorvezérlés teszteléséről szóló részben már tárgyaltam, a súrlódás miatt kb. ±65%-os érték felett indulnak csak el a motorok (ez az érték függ a motoroktól és a motorok tápfeszültségétől is). A motorvezérlő függvényeken belül a motorok forgásirányát a digitalWrite() utasítás, a motorok sebességét pedig az analogWrite()utasítás állítja be.
Továbbfejlesztés
A videón látható, hogy a robot viszonylag lassan haladva követi a vonalat. Ha a motorokat teljes, 100%-os sebességre állítom, akkor a túl nagy sebesség miatt, a kanyarodás során a vonal kikerül a két szenzor közül, és a robot elvéti a vonalat. Tehát bőven van továbbfejleszteni való még a roboton. Az alábbiakban megemlítek néhány lehetőséget:
Több szenzor alkalmazása esetén nagymértékben csökkenthető annak a valószinűsége, hogy a robot elveszítse a vonalat. Ráadásul így sokkal fejlettebb vonalkövető algoritmusok is használhatók. Ezáltal a vonalkövetési sebesség is növelhető. Infravörös LED-ek alkalmazásával pedig a környezeti fényviszonyok által keltett zavar csökkenthető.
Pl. 5 db TCRT5000-es infravörös reflektív optocsatoló szenzort az alábbi ábra szerint elrendezve építhetünk egy vonalérzékelő detektorsort.
Ez már sokkal több információt szolgáltat a követendő vonalról. Ezáltal olyan vonalkövető algoritmusok is használhatók ahol a robot sebessége és a kanyarodás íve a vonal pozíciójától függően változtatható. Egy ilyen algoritmus egyszerűsített vázlata látható az alábbi rajzon:
Szenzor pozíció
|
Bal LDR
|
Jobb LDR
|
Sötét vonal felett
|
770
|
780
|
Világos padló felett
|
910
|
920
|
Középérték:
|
840
|
850
|
Ha a vonal a középső detektor alatt van (A), akkor a robot teljes sebességgel haladhat előre. Ha a vonal kicsit eltér a középső helyzettől (B), akkor kicsit lelassítva, enyhe ívben kanyarodva követhető a vonal. Ha a vonal valamelyik szélső detektor alatt van (C), akkor a robotot teljesen lelassítva, élesen kell kanyarodni.
Az általam használt DC motorok áttétele elég nagy (1:200), ez nagymértékben korlátozza az elérhető végsebességet. Egy kisebb áttételű és erősebb motort használva tovább növelhető a sebesség.
Egyik kedvenc vonalkövető robotom a Kerényi Pál által épített F-1 vonalkövető robot, ami 9db TCRT5000-ből épített érzékelősort használ. A robot meghajtása 12V-os PC hűtőventillátor motorokból készült. Az irányítást pedig egy PIC18F2520-as mikrovezérlő látja el:
A fent említett továbbfejlesztési lehetőségek sora korántsem teljes, csak gondolatébresztő szándékkal írtam. Látható, hogy a vonalkövető robot megépítése csak a kezdet, és innen nagyon sokféle irányba haladhatunk tovább...
-
|
Bal Motor
|
Jobb Motor
|
Előre
|
45%
|
65%
|
Hátra
|
-45%
|
-65%
|
Vonalkövető
Ebben a cikkben a robotika alapjait tekintem át egy egyszerű kis robot
építésén keresztül bemutatva.
A robotépítés 4 főbb fázisra bontható:
•
Tervezés
•
Építés
•
Tesztelés
•
Módosítás és továbbfejlesztés
Miután elhatároztuk, hogy építünk egy robotot, már csak azt kell eldönteni milyen feladatot tudjon önállóan végrehajtani. Ezzel el is érkeztünk a robotépítés első lépéséhez, a tervezéshez.
Tervezés:
Legelőször a megoldandó feladatot kell pontosan definiálni. El kell dönteni hogy mit is tudjon a robot. Érdemes először egyszerűbb, kisebb tudású robotokkal kezdeni és fokozatosan haladni az egyre bonyolultabbak felé.
A cikkben egy vonalkövető robot építését mutatom be. A feladat elég egyszerűnek hangzik: a robot kövesse a padlón lévő vonalat (világos padlón fekete szigetelőszalag csík). Amint látni fogjuk, a megvalósítás már nem is lesz olyan egyszerű. A végeredmény viszont egy teljesen autonóm robot lesz.
A robot fő feladata, miszerint kövesse a vonalat, több részfeladatra bontható le:
1. Vonalérzékelés (szenzorok)
Ahhoz hogy egyáltalán követni tudja a robot a vonalat, először is érzékelnie kell azt. A szenzornak érzékelnie kell a vonalat, és olyan válaszjelet kell adnia amit a robotvezérlő értelmezni tud.
2. Adatfeldolgozás és vezérlés
A robotnak kell egy “agy”, ami beolvassa, feldolgozza és értelmezi az érzékelők adatait. Ezek alapján döntéseket végez és ezektől függően a megfelelő kormányparancsok kiadásával vezérli a robotot hogy a vonalat követni tudja. A végrehajtandó parancsokat olyan vezérlőjelekké kell alakítania, amit a motorsebesség szabályozó és/vagy a kormányszervek értelmezni tudnak. Vonalkövető robot építhető tranzisztorokkal ( http://www.ermicro.com/blog/?p=1097 ), vagy műveleti erősítőkkel is ( http://www.ermicro.com/blog/?p=1908 ). De erre a feladatra a mikrovezérlők (mikrokontrollerek) lesznek a legalkalmasabbak.
3. Haladás (meghajtás)
A vonal követéséhez a robotnak nemcsak haladnia kell, hanem a haladási irányát is meg kell tudnia változtatni (kanyarodás). Ehhez valamilyen meghajtási és kormányzási módra lesz szükség.
A fentiekben említett részfeladatokat nem kezelhetjük különálló részekként, mert kölcsönösen meghatározzák egymást. Például az érzékelők által szolgáltatott jel meghatározza, hogy a robotot vezérlő mikrokontrollernek milyen jeleket kell tudnia feldolgozni. Hasonló módon a meghajtás kiválasztása meghatározza hogy a robotvezérlőnek milyen jellegű kormányparancsokat kell kiadnia. A robot mérete és súlya pedig az alváz és a meghajtás méretezésére van hatással.
Most részletesebben is megvizsgálom az egyes részfeladatokat és leírom, hogy a robotnál milyen megoldások használata mellett döntöttem. Mivel ez a cikk főleg a robotikával most ismerkedőknek szól, ezért a lehető legegyszerűbb megoldásokat fogom választani.
Szenzorok
Először azt kellene eldönteni, hogy milyen érzékelővel detektáljuk a vonalat. A vonal érzékelése többféleképpen tehető meg. Az alábbiakban felsorolok néhány példát.
A vonal érzékelésére használhatunk pl. egy kamerát. Ekkor a kamera által készített képek eldolgozásával és elemzésével határozhatjuk meg a vonal helyét. Ez a módszer elég bonyolult, ezért inkább egy egyszerűbb megoldást alkalmazok.
A vonalkövető robotok általában a padlóról visszaverődött fény mérésével érzékelik a vonalat. A fekete vonal ugyanis kevesebb fényt ver vissza, a világos/fehér padló pedig többet. A megvilágításhoz használt fény hullámhosszától, és a detektor típusától függően többféle megoldás is létezhet:
•
LED fényforrás + fotoellenállas (LDR) (látható fény)
•
LED fényforrás + fototranzisztor (látható fény)
•
IR LED fényforrás + fototranzisztor (infravörös fény)
A látható fény tartományában működő érzékelők teljesítményét a környezeti fényviszonyok nagyban befolyásolják. Az infravörös tartományban működő érzékelők erre kevésbé érzékenyek.
Az érzékelési mód kiválasztása után már "csak" azt kell eldönteni, hogy hány darab érzékelőt (1, 2, 3, 4, 5, 6 stb...) és milyen elrendezésben akarunk használni. A neten sokfele változatra találhatunk példát...
A robotnál fehér fényű LED-eket és fotoellenállásokat (LDR) fogok használni a vonal érzékelésére, mert ezek olcsón és könnyen beszerezhetőek.
Fotoellenállás (LDR)
A robot a vonal érzékelésére egy fényérzékelő szenzort (fotoellenállást - LDR) használ. A fotoellenállás lényegében egy kadmium szulfid (CdS) ellenálláscsík, aminek az ellenállása a rá eső fény intenzitásától függően változik. Nagy fényerősség esetén az ellenállása alacsony, sötétben pedig nagy. Amikor a fotoellenállás a fekete vonal felett van, a kevés visszavert fény miatt az LDR ellenállása nagy, amikor pedig a fehér padló felett van, akkor a több visszavert fény miatt az LDR ellenállása alacsony. Ezt az ellenállás változást kell olyan érték változásává alakítani, amit a mikrovezérlő mérni tud. Ezt egy ún. feszültségosztó kapcsolással tehetjük meg (a vonalérzékelő szenzor felépítését részletesen a második részben ismertetem majd). Így a szenzor az LDR-re érkező fény erősségétől függő feszültséget ad válaszul, amit a robotvezérlő már tud kezelni. A talajt megvilágító állandó nagyságú fényerősségről egy fehér fényű LED gondoskodik.
Analóg és digitális jelek
A vonalérzékelő szenzor a mérendő jellel (jelen esetben a fényerősséggel) arányos analóg feszültségjelet állít elő, ami két szélső érték között végtelen sok értéket vehet fel. Ahhoz hogy ezt a jelet mérni tudjunk és a mikrovezérlők digitális világában fel tudjuk dolgozni, egy analóg-digitális átalakítóra (ADC) van szükség. A legtöbb modern mikrokontroller rendelkezik beépített ADC átalakítóval. Az ADC a bemeneti analóg feszültségjelet átalakítja egy digitális jellé (bináris számmá). Ennek a számnak a lehetséges maximális értékét az ADC felbontása határozza meg. A robotnál használt AVR mikrovezérlő analóg-digitális átalakítója 10 bites, azaz 0-1023 között vehet fel értékeket (210 = 1024).
Az ADC két referencia feszültségszint közötti feszültségtartományban mér. Az alsó a föld (GND) a felső pedig ARef . Tehát az ADC a 0 – ARef feszültségtartományba eső analóg bemeneti jelet alakítja át egy 0 – 1023 közötti digitális jellé (bináris számmá). Ha a bemenő feszültség 0V (GND), akkor a kimenet 0, ha a bemenő feszültség ARef-el egyezik meg, akkor a kimenet értéke 1023, ha pedig a bemenő feszültség pl. a referenciafeszültség fele, akkor a kimenet értéke ezzel arányosan 512 lesz. Az alábbi ábra ezt szemlélteti ahol ARef= 5V.
Az AVR mikrovezérlő egy kifinomult elektronikus eszköz, amely csak bizonyos határértékek közé eső feszültséget tud mérni. A határértéken kívül eső feszültségek károsíthatják a mikrokontrollert. Az AVR adatlapján az szerepel, hogy az ADC lábon a mérendő bemeneti jelnek AGND (0V) és Vcc (5V) között kell lenni (az ARef referencia feszültség maximális értéke 5V). Ha a referencia feszültségnél nagyobb feszültséget akarunk mérni, akkor egy feszültségosztó kapcsoláson keresztül kell a bemeneti jelet a mikrovezérlőre kötni.
Meghajtás:
A vonalkövetéséhez a robotnak haladnia kell tudni. Ehhez valamilyen motorra lesz szükség. Itt is többféle lehetőség kínálkozik. Használhatunk pl. áttételes DC motort, léptető motort vagy szervomotort. Mindegyik motor más-más feladatra a legideálisabb. Mivel ezek a motorok különböző módon működnek és teljesen különböző jelekkel vezérelhetőek, ezért a motorok kiválasztása eleve meghatározza a motorvezérlési módot is. A motorok eltérő feszültség és áram szükséglete pedig az áramforrásra vonatkozó követelményeket határozza meg.
A motorok kiválasztását az is befolyásolhatja, hogy milyen meghajtási módot választunk. Ez a robot által elvégzendő feladattól is függhet. Például milyen terepen kell majd a robotnak mozognia (szárazföld, víz esetleg mindkettő)? Lánctalpat használjon-e a robot vagy kerekeket. A kerekek elrendezése is sokféle lehet (3, 4 esetleg 6 kerék). Ezek közvetve a kormányzás módját is meghatározhatják. Például a lánctalpas meghajtásból eleve következik a differenciális hajtás. Ha nem használunk bolygókereket és omniwheel-t, akkor 3 kerék esetén pedig következik, hogy legalább az egyik kereket kormányozni kell majd.
A DC motorokkal összehasonlítva a léptetőmotorok és a szervómotorok vezérlése bonyolultabb, ezért a vonalkövető robot meghajtásához két darab áttételes DC motort fogok használni. A kerekek kormányzását elkerülendő, a robot egy differenciális meghajtást használó 3 kerekű konstrukció lesz (két egymástól függetlenül meghajtott kerék és egy bolygókerék). A motorok tápellátásáról 4db ceruzaelem fog gondoskodni.
Most nézzük meg hogyan lehet a differenciális meghajtással egy robotot mozgatni és kormányozni.
Differenciális meghajtás
A diferenciális meghajtású robot úgy működik mint egy lánctalpas jármű. A különböző oldalon lévő kerekek egymástól függetlenül vannak meghajtva. Ezek biztosítják a meghajtást és a kormányzást is, ezért nem szükséges az első kerekek elfordítása, mint pl. egy hagyományos autó vagy kerékpár esetén. A két oldalon lévő kereket azonos sebességgel hajtva, a robot az adott irányba egyenesen halad. A robot kormányzásához elegendő a jobb és bal oldali kereket különböző sebességgel meghajtani.
Például ha a jobb oldali kerék gyorsabban forog mint a bal oldali kerék, akkor a robot balra fordul. A fordulás ívenék nagysága a kerekek forgási sebességének a különbségétől függ. Ha az egyik motor áll, akkor az álló kerék körül elfordulva kanyarodik a robot. Az alábbi ábráról látható hogy akár a helyben fordulás is megvalósítható, ha a motorok forgásiránya ellentétes.
A differenciális meghajtás esetén a robot mozgatása és kormányzása a két DC motor forgásirányának és sebességének a változtatásával történik.
Most nézzük meg részletesen hogyan tehető ez meg.
Motorvezérlés (DC motor)
Egy DC villanymotor meghajtása könnyű, elég csak a motorhoz csatlakozó két vezetéket egy elemre kötni és a motor működni fog. Ez nagyszerű, de egyetlen irányba forog csak a motorunk. Mi a teendő, ha a másik irányba szeretnénk a motorunkat hajtani? A válasz most is igen egyszerű, cseréljük fel az elem pólusaira kötött vezetékeket és a motor az ellenkező irányba fog forogni.
A robotunknál viszont menet közben nem tudjuk az elemre kötött vezetékeket mindíg leválasztani és fordítva visszakötni, ha irányt akarunk váltani. Ez a probléma 4 kapcsoló használatával könnyedén megoldható egy H-híd (H-bridge) kapcsolással.
A H-bridge működési elve: A) H-bridge áramkör, B) a K1 és K4 kapcsolók zárásakor a motor az egyik irányba forog, C) a K2 és K3 kapcsolók zárásakor a motor a másik irányba forog.
Az A ábrán, amikor mind a négy kapcsoló nyitva van, egyik motorvezeték sem kapcsolódik az elemhez. A motor elindításához kapcsoljuk be a K1 és a K4 kapcsolót (B ábra). Figyeljük meg hogy a motor bal vezetéke az elem pozitív pólusához csatlakozik, a jobb oldali vezeték pedig a negatív pólushoz. Ahhoz, hogy a motor az ellenkező irányba forogjon, a K2 és K3 kapcsolókat kell zárni a K1 és K4 kapcsolókat pedig kinyitni. Figyeljük meg hogy a motor bal vezetéke most az elem negatív pólusához csatlakozik, a jobb oldali vezeték pedig a pozitív pólusához, a vezetékek bekötése az előző fordítottja.
A motorok elektronikus úton történő kapcsolását megtehetjük pl. hagyományos tranzisztoros vagy FET-es H-híd kapcsolásokkal, de a robotnál egy egyszerűbb megoldást fogok alkalmazni. A motorok vezérlését egy erre a célra tervezett motorvezérlő IC-vel valósítom meg (részletek a 2.-ik részben). Az L293D IC két H-híd kapcsolást tartalmaz, ezért egyetlen IC-vel két darab DC motor vezérlehető. Ezáltal a motorvezérlő kapcsolás sokkal egyszerűbb lesz.
Ez minden, amit tudunk kell a DC motorok vezérléséhez? Ha a motorokat csak két irányba akarjuk hajtani maximális sebességgel, akkor ennyi elég is. Bár néhány alkalmazás esetében (amilyen például a vonalkövető robotnál is használt differenciális meghajtás), nagyon hasznos tud lenni, ha a motorokat különböző sebességekkel tudjuk eghajtani.
Adott feszültség esetén a motorok sebessége egy nagyon egyszerű és szellemes megoldással változtatható, ez az ún. impulzusszélesség moduláció (Pulse Width Modulation - PWM). Ha a motorra adott feszültséget a motorvezérlővel nagyon gyorsan percenként akár több ezerszer) ki/be kapcsolgatjuk és a ki/bekapcsolási idők egymáshoz viszonyított arányát változtatjuk, akkor a motor sebessége is változni fog.
Az impulzusszélesség moduláció (PWM) elve: Egy rövid impulzusokból álló jelsorozatban a ki/be kapcsolási idők egymáshoz viszonyított arányának változtatásával a jel átlagfeszültsége változtatható: a) impulzusszélesség = 2ms, Vátlag = 2,5V, b) impulzusszélesség = 3ms, Vátlag = 3,75V, c) impulzusszélesség = 1ms, Vátlag = 1,25V.
Adatfeldolgozás és vezérlés
A robot vezérlését egy mikrovezérlővel fogom megoldani. A mikrovezérlőt (mikrokontrollert) úgy is definiálhatjuk, mint egy, egyetlen chip-ből álló számítógépet, ami rendelkezik saját központi vezérlő egységgel, memóriával, Aritmetikai Logikai Egységgel (ALU), némi EPROM-mal (másodlagos háttértár, ami az adatokat kikapcsolás után is megőrzi), sokféle chipre integrált perifériával (Timer, Soros kommunikáció, Analóg- Digitális átalakító (ADC) stb…).
A mikrokontroller a végrehajtandó programot egy flash memóriában tárolja. Ez a memória könnyedén törölhető és újraprogramozható - akár több ezerszer is. Ez nagyon rugalmassá teszi a mikrokontrollerek használatát.
A mikrokontroller legtöbb lába lehet digitális kimenet, digitális bemenet, és néhány láb analóg bemenet is. A bemeneti lábakat arra használhatjuk, hogy a külvilágból érkező adatokat olvassunk be. A legegyszerűbb esetekben pl. lekérdezhetjük kapcsolók, vagy érzékelők állapotát. Az érzékelt adatoktól függően a mikrovezérlő az általunk beprogramozott módon válaszol (az adott kimeneti lábakra 5V-os, 0V-os feszültséget vagy PWM jelet ad). Ezekkel vezérelhetünk különböző eszközöket Pl. LED-eket, motorokat, kijelzőket stb...
Ne felejtsük el azonban, hogy ezek a lábak csak kismértékű áramot képesek elnyelni/leadni, tehát nagyobb áramigényű eszközöket (mint pl. a robotunk DC motorjai) már nem képes meghajtani. De megfelelő kapcsolás/relé közbeiktatásával már bármekkora áramú/feszültségű/teljesítményű eszközt vezérelhetünk.
Az előző fejezetekben láthattuk, hogy a robot vezérléséhez olyan mikrokvezérlőre lesz szükségünk, ami rendelkezik ADC átalakítóval a vonalérzékelő szenzor jeleinek a feldolgozásához, ugyanakkor tud PWM jeleket is előállítani a motorvezérlés megvalósításához.
Rengeteg mikrovezérlő közül választhatunk. Létezik 8 bites, 16 bites, 32 bites stb... El kell döntenünk, hogy melyik gyártó termékét akarjuk használni, melyiket tudjuk könnyen beszerezni (PIC, AVR , ARM, BASIC STAMP, PICAXE, Texas Instruments stb...). Azt is meg kell vizsgálni hogy mennyire rugalmasan bővíthető vagy változtatható az adott hardver. Ingyenesen elérhető-e hozzá a fejlesztői környezet vagy fizetni kell érte? Milyen programnyelven lehet a mikrovezérlőt programozni? (Assembly, Basic, Pascal, C stb...)
A vonalkövető robot építéséhez egy Arduino Nano panelt használok, mert az Arduino hardver felépítése és a fejlesztői környezet nyílt jogállású, szabadon felhasználható, változtatható és ingyenesen hozzáférhető. Akár építhetünk is egyet, ha rendelkezünk a szükséges eszközökkel.
Az Arduino Nano egy ATMEGA328-as AVR mikrokontrollert tartalmazó panel, melyet egy egyszerűsített C - nyelven lehet programozni. A megírt programot USB-n keresztül tölthetjük a mikrovezérlőbe. Egy kevés programozási ismerettel és minimális elektronikai tudással már el lehet kezdeni robotot építeni vele. Az Arduino használatához nem szükséges részletesen ismernünk a rajta található mikrovezérlő működését, ugyanis a fejlesztői környezet ezt elfedi előlünk (pl. az I/O műveletek, ADC, PWM egy-egy utasítással megoldható). Ez egy egyszerű es gyors megoldás, ezért ideális választás kezdésnek egy Arduino panel.
Összefoglalás
A korábban említett tervezési szempontok figyelembevétele alapján véglegesíthetjük a vonalkövető robotunk felépítését:
•
A robot hely- és irányváltoztatását legegyszerűbben 2 db áttételes DC motor alkalmazásával, differenciális meghajtással tudjuk elérni (2 külön hajtott kerek + egy bolygókerék).
•
A robot a vonalat 2db szenzorral, a padlóról visszaverődött fény mérésével érzékeli.
•
A LED-ből és fotoellenállásból alló vonalérzékelő szenzorok a fényerősséggel arányos analóg feszültségjelet állítanak elő.
•
Az ATMega328-as mikrovezérlő ezeket a változó feszültségjeleket az ADC átalakító segítségével feldolgozza.
•
Ahhoz hogy a robot a vonalat követni tudja, a mikrovezérlő a mért értékektől függően változtatja a robotot kormányzó DC motorok sebességét a motorvezérlőnek küldött PWM jelekkel.
Bal szenzor
|
Jobb szenzor
|
Robot válasz
|
Bal motor
|
Jobb motor
|
0
|
0
|
Előre
|
Előre
|
Előre
|
1
|
0
|
Balra fordulás
|
Stop
|
Előre
|
0
|
1
|
Jobbra fordulás
|
Előre
|
Stop
|
1
|
1
|
Előre (kereszteződés)
|
Előre
|
Előre
|
A mikrovezérlő és a motorvezerlő IC kis áramigényű, meghajtásukhoz szabályozott stabil 5V-os tápfeszültség kell, amit az Arduino panel biztosít majd. A motorok áramigénye viszont nagy, meghajtásukhoz nem kell szabályozott stabil 5V. A szénkefés DC motorok ráadásul nagymértékű zajt is generálhatnak. Ezért célszerű feladatonként szétválasztani a tápellátást és két áramforrást használni, egyet külön a DC motoroknak,és egyet külön az elektronikának.
A robot blokkvázlata az alábbi ábrán látható:
Az alábbi ábra egy lehetséges robotelrendezést mutat:
