Analóg kimenet (Szervóvezérlés) /Arduino kapcsolások #5/

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

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

Analóg kimenet (PWM) /Arduino kapcsolások #4/

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 bemenet / Arduino kapcsolások #3/

Analóg bemenet

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 
}

 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. 

Digitális bemenet /Arduino kapcsolások #2/

Digitális bemenet

A digitális bemenetek használatára is nézzünk egy egyszerű példát: 

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. 

LED villogtatás /Arduino kapcsolások #1/

LED villogtatás

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:

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

Arduino fejlesztőkörnyezet

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:

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 programozásról nem szeretnék többet írni,de megosztok veletek egy könyvet ahol részletesen le van írva.

Innen letölthető!

Alapok

Alapok

Mi is pontosan az az Arduino?

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. A fejlesztői platform az úgynevezett IDE-ből (integrált fejlesztői környezet), és az Arduino Board-okból áll. Előbbi segítségével programokat írhatunk és tesztelhetünk számítógépen, utóbbi pedig egy előre összeszerelt elektronikus eszköz, amelyre az előzőleg elkészített programokat feltölthetjük USB porton keresztül, majd elektronikus eszközöket vezérelhetünk a segítségével.

Milyen szoftver van rajta?

 Az Arduino IDE egy kereszt-platformos Java nyelven írt fejlesztőkörnyezet, amely segítségével Arduino programokat készíthetünk, tesztelhetünk, majd az Arduino Board-okra tölthetjük. Az induláshoz a fejlesztőeszköz több mintaprogramot tartalmaz, amelyek segítségével egyszerűen megtanulhatjuk, hogyan tudunk LED-et villogtatni, fényerőt szabályozni, vagy a számítógéppel kommunikálni USB-n keresztül. Az Arduino programokat egy C/C++ alapú programozási nyelven írhatjuk, így az ezeket a nyelveket ismerők könnyen kiismerhetik magukat a környezetben. AZ IDE-hez tartozik a "Wiring" nevezetű C/C++ programkönyvtár, amellyel egyszerűen végezhetjük el a leggyakoribb input/output műveleteket.

Shield-ek

Az Arduino-k funkcionalitását könnyedén kiegészíthetjük az úgynevezett Shield-ekkel, amelyek a Board-okhoz egyszerűen illeszthető elektronikai áramkörök. Ezek segítségével azt Arduino-t akár közvetlenül az internetre csatlakoztathatjuk, motorokat vezérelhetünk vele, vagy WiFi hálózatra kapcsolódhatunk. A jelenlegi hivatalos Arduino Shield-ek:

·         Arduino Ethernet Shield

·         Arduino WiFi Shield

·         Arduino Proto Shield

·         Arduino GSM Shield

·         Arduino Motor Shield

Ezeken kívül több cég gyárt világszerte Arduino kompatibilis Shield-eket, különböző célokra.

 

Arduino Duemilanove részei

A Duemilanove 2009-es modell, ATmega168 típusú vagy ATmega328 típusú mikrokontrollerrel felszerelt verzióban létezik. 14 digitális ki-/bemenete van amiből 6 speciális PWM funkciót is képes ellátni, 6 analóg bemenettel rendelkezik, valamint egy 16 MHz-es osszcillátorral, egy USB, egy hálózati és egy ICSP csatlakozóval rendelkezik. Egy reset (újraindító) gomb is található rajta. Minden alkatrészt tartalmaz, ami a mikrokontroller működéséhez szükséges, így ha csatlakoztatjuk USB kábelünkkel (5V) a számítógéphez, megkezdhetjük használatát, de akár elemet, akkumulátort vagy AC-to-DC adaptert (a nagyfeszültséget átalakítja kisfeszültségű egyenárammá) dughatunk a hálózati csatlakozójába, ezek ajánlott feszültség értéke maximum 12V lehet. A DC a Direct Current rövidítése, ami kisfeszültségű egyenáramot jelent, ezzel fogunk dolgozni.

A Duemilanove adatai:

Mikrokontroller típusa: ATmega 168 vagy ATmega 328

Működtető feszültségérték: 5V

Bementi feszültség – ajánlott értéke: 7-12V

Bemeneti feszültség – határ értéke: 6-20V

Digitális ki-/bemeneti pinek száma: 14, ebből 6 PWM. 5V-on működnek, mindegyik rendelkezik egy belső felhúzó (pull-up) ellenállással, ami egy speciális paranccsal bekapcsolható (alap állapotban ki van kapcsolva), értéke 20-50 kOhm lehet.

Analóg bemeneti pinek száma: 6, ezek 10 bites felbontáson tudnak egy értéket felvenni 0-1023             között.

Az egyes pinekre jutó áramerősség értéke:  40mA

A 3.3V elnevezésű pinre jutó áramerősség értéke:  50mA

Flashmemória mérete: 16KB (ATmega168), 32KB (ATmega328) amiből 2KB-ot a bootloader foglal el. A flashmemória egy olyan újraprogramozható, adattárolásra alkalmas eszköz, aminek nincs szüksége tápfeszültségre ahhoz, hogy megtartsa a benne tárolandó adatot. A bootloader magyarul rendszer betöltő program, ezzel képes elindulni az eszköz.

SRAM mérete: 1 KB (ATmega168), 2 KB (ATmega328).Ez egy statikus memória, amiben a tárolt adat a tápfeszültség megszűnéséig marad meg.

EEPROM mérete: 512 byte (ATmega168), 1 KB (ATmega328).Elektronikusan törölhető és újraírható, azaz programozható tároló memória. Olyan mint a flashmemória.

Órajel sebessége: 16 MHz. Ez egy olyan jel, amely két vagy több áramkör tevékenységét koordinálja, szinkronizálja. Egy alacsony és egy magas jelszint között osszcillál.

Áramot kezelő pinek:

Vin: bemeneti feszültség, ha külső áramforrást használunk az üzemeltetéshez.

Gnd: földelés.

5V: értelemszerűen 5V jön belőle.

3V3: az alaplapra szerelt FTDI chip által termelt 3,3 V feszültség.

Némelyik pin speciális funkciók ellátására is képes, ezeket a későbbiekben használat közben ismerjük meg.

Speciális funkciókkal ellátott pinek:

Digitális 0(RX) és 1(TX): Ezek a pinek össze vannak kötve a FTDI USB-to-TTL nevű soros chip megfelelő részeivel, ezért soros port kommunikációhoz használhatjuk őket. Az RX fogadja, a TX pedig küldi az adatot.

Digitális 2 és 3 pin külső megszakításhoz: a csatlakozón fellépő fel- vagy lefutó él hatására fellépő megszakításkéréshez használható, ez a mikrovezérlő valamelyik bemenetének értékváltozására generálódik. Az attachInterrupt() funkcióval használjuk.

Digitális PWM pinek: 3, 5, 6, 9, 10, és 11 (pulse width modulation = impulzus-szélesség moduláció). Az analogWrite() paranccsal 8 biten küldhetünk rá adatot.

SPI pinek:10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK), SPI busz (Serial Peripheral Interface = soros periféria illesztő) kommunikációhoz használhatjuk, az SPI Library meghívásával.

LED 13 pin: a beépített LED van ide kivezetve ide.

Analóg A4 (SDA) és A5 (SCL) pinek: I2C (TWI) busz kommunikációra alkalmasak, Wire Library meghívásával.

 

Egyéb pinek:

AREF pin: Alapvetően az analóg pinek 0-5V között mérik a bementi adatot. Ennek felső értéke ezzel a pinnel és az analogReference() paranccsal megváltoztaható.

Reset pin: ha a shieldet használunk és van rajta reset gomb, akkor használjuk ezt a pint. LOW-ra állítva működik.