Robotépítés kezdőknek

Robotépítés kezdőknek

ARDUINO alapok

2017. november 12. - FizikusRobotBlog

Az Arduino panel nagyon népszerű az elektronikával és robotikával hobbi szinten foglalkozók körében, mert nagyon egyszerű a használata. A neten rengeteg angol nyelvű Arduino-s robotprojekt és tutorial található. Ez a cikk az Arduino használatának alapjait mutatja be.

Arduino Hardver
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, 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.

arduinopanel.jpg

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.

arduinonano.jpg

Arduino fejlesztőkörnyezet
Az Arduino fejlesztőkörnyezet legfrissebb verziója letölthető az alábbi linkről: http://arduino.cc/en/Main/Software
A programot először elindítva az alábbi képernyő fogad:

ide.jpg

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.

ide2.jpg

 

Az Eszközök/Soros port menüpontban pedig azt kell beállítani hogy a panel melyik COM portra van csatlakoztatva.

ide3.jpg

 

A fentiek beállítása után a panelt már tudjuk programozni.

Az eszközsorban az alábbi 7 gomb található:

idemenu.jpg

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

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:

ledgomb.jpg

 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:

potmeter.jpg

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. 

sorosadat.jpg

 

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:

pwm.jpg

 

 
/*
* 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). Az RC szervómotorok vezérléséről az Akadály KiKerülő Robot 2.0 cikkemben részletesebben fogok írni.

Nézzünk a szervóvezérlésre is egy példát:

servo.jpg

 

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

Ez a cikk csak az alapokat mutatta meg. A téma iránt érdeklődőknek tudom ajánlani  a megújult TavIR weboldal ingyenes, 60 napos Arduino tanfolyamát ( http://www.tavir.hu/60nap ).

Az alábbi magyar és angol nyelvű dokumentumok is hasznosak lehetnek:

 

TavIR

tavir.jpg

 

Earthshine

earthshine.jpg

 

ARDX

ardx.jpg

 

Üdvözlettel: Fizikus

A bejegyzés trackback címe:

https://robotepites.blog.hu/api/trackback/id/tr713244807

Kommentek:

A hozzászólások a vonatkozó jogszabályok  értelmében felhasználói tartalomnak minősülnek, értük a szolgáltatás technikai  üzemeltetője semmilyen felelősséget nem vállal, azokat nem ellenőrzi. Kifogás esetén forduljon a blog szerkesztőjéhez. Részletek a  Felhasználási feltételekben és az adatvédelmi tájékoztatóban.

Nincsenek hozzászólások.
süti beállítások módosítása