Sziasztok!
Elindult a másik blogom a magyarraspberry.blog.hu
Ha van kedvetek nézzetek fel ide is! :)
Arduino kapcsolások
Magyar Arduino
Elektromos kisautó/Arduino kapcsolások/
Elektromos kisautó
Mindenki ismeri azt a kisautót amelyiket egy kontrolleren keresztül lehet irányítani.De, a világ egyre inkább a felé kezd menni, hogy mindent a telefonodon keresztül lehessen irányítani.Akkor meglehet csinálni azt hogy telefonon keresztül tudjam irányítani a kiskocsimat?Természetesen igen. Ez itt az "Elektromos kisautó Bluetooth-al" vezérleve.
Ami szükséges hozzá:
- 1 db Arduino(Uno,egyébként mindegy melyik változat)
- L293D IC
- Bluetooth modul(Bluetooth modulról itt tudtok kapni egy részletes leírást!)
- Próbapanel
- Kocsi
- Kábelek
- 2 db motor
Leírás:
Úgy gondoltam egy kis áttekintésben megnézzük az IC-ket,ha már jártas vagy ebben vagy ebben vagy nem érdekel nyugodtan lép át.
Az integrált áramkör (röviden IC, az angol Integrated Circuit rövidítéséből) félvezető lapkán (esetleg lapkákon) kialakított nagyon kis méretű áramkör. Tipikus alkatrésze az integrált tranzisztor. Ebbe a kategóriába sorolhatóak a multichip modulok is, melyek egyetlen tokban több chipet is tartalmazó áramkörök.
Az első integrált áramkört Jack Kilby, a Texas Instruments mérnöke készítette 1958-ban.
Egy integrált formában megvalósított áramkör előnyei egy azonos funkciót megvalósító hagyományos áramkörrel szemben:
- Nagyobb megbízhatóság
- Kompakt kivitel, nagy funkciósűrűség kis helyen
- Nagyobb sebesség
- Kisebb fogyasztás
- Gazdaságosabb tömeggyártás
AZ L293D ic pedig egy motorvezérlő ic-nek felel meg.
Kocsi váz:
Egy ilyet ebayről pár ezer forintért meglehet rendelni.
Kapcsolási rajz:
Androidra a szoftver:
RGB led vezérlés Arduinoval /Alapok/
RGB led vezérlés Arduinoval
Egy példa analóg kimenet kezelésére. Az RGB LEDeket három LED összeépítéséből hozták
létre. Egy tokban egy vörös(R), egy zöld(G), és egy kék(B) led közös anóddal vagy katóddal ellátva. A három szín keverékéből bármilyen szín előállítható, hasonló elv alapján mint ahogy
a színes tv-k képernyőjén is.
Egy egy szín fényerejének csökkentésével vagy növelésével más és
más színt kapunk. A színek fényerejének változtatását impulzus szélesség modulációval, PWM-el
valósítjuk meg. A PWM -nél a kitöltési tényező számít, ez azt jelenti, hogy azonos frekvencián, azonos amplitúdójú jel mennyi ideig van maximumon, vagyis tápfeszültségen:
100%-os a jel erősség ha folyamatos a tápfeszültség, 80%-os ha 8 egység szélességű tápfeszültség impulzust 2 egység szélességű GND impulzus követ.
50%-os ha a két impulzust szélessége fele-fele, és 0%-os ha nincs tápfeszültség impulzus.
Tehát ha 1 sec alatt csak 200ms ideig van bekapcsolt állapotba a fogyasztó akkor a teljesítménye
is csak 20%-os lesz, ez a PWM lényege.
Ennyit az elméletről, most nézzük a gyakorlatot.
A projektünkhöz a következő alkatrészek szükségesek:
-
Arduino Uno
-
Usb kábel
-
Próbapanel
-
Összekötő vezetékek
-
RGB led (közös katódos)
-
3db 270ohm-os ellenállás
Most nézzük a kapcsolást:
RGB lednél mindig a leghosszabb láb a közös, a többi lábkiosztása típusonként változik, itt
van egy sematikus ábra a led belső áramköréről:
Most nézzük a beírandó sketchet:
/*
Adafruit Arduino - Lesson 3. RGB LED
*/
int redPin = 11;int greenPin = 10; //változók csatlakozó lábakhoz rendelése
int bluePin = 9;
//a következő sort akkor kell aktíválni ha közös anódos a led
//#define COMMON_ANODE
void setup()
{
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT); //a lábak beállítása kimenetnek
pinMode(bluePin, OUTPUT);
}// főciklus
void loop()
{
setColor(255, 0, 0); // red ; értékadás a meghívott setColor függvénynek
delay(1000); //várakozás 1sec-ig
setColor(0, 255, 0); // green
delay(1000);
setColor(0, 0, 255); // blue
delay(1000);
setColor(255, 255, 0); // yellow
delay(1000);
setColor(80, 0, 80); // purple
delay(1000);
setColor(0, 255, 255); // aqua
delay(1000);
}// ez a függvény 3 értéket fogad, amit aztán a 3 kimeneti változóhoz rendel
void setColor(int red, int green, int blue)
{// ez a ciklus csak akkor lép érvénybe ha definiálva van a COMMON_ANODE
#ifdef COMMON_ANODE
red = 255 - red;
green = 255 – green; // common_anode-nál visszafelé számlálunk
blue = 255 - blue;
#endif //common_anode ciklus vége
analogWrite(redPin, red);
analogWrite(greenPin, green); //a függvény értékeinek kiíratása a kimenetekre
analogWrite(bluePin, blue);
}
A mi kis programunk a beállított színek közt váltogat másodpercenként, lehet próbálkozni
különböző színkeverésekkel, eltérő várakozási időkkel. Meglehet adni a színeket hexadecimális
számokban is(ahogy a PC-k is használják), pl.:
A fehér - #FFFFFF, vagy a fekete - #000000, vagy sötétsárga - #FFCC00
ez a proginkba így adható meg: setColor(0xFF,0xCC,0x0);
További jó kísérletezést!
Bemutatkozás!
Mindenkit szeretettel köszöntök itt!
Az oldal a szeretné bemutatni(összegyűjteni),mennyi dolgot lehet létre hozni az Arduino segítségével. Mivel ilyen magyar oldal még nem található az interneten vagy nagyon kis számban vannak fent cikkek,úgy gondoltam indítok egyet.
Remélem mindenki megtalálja itt a számára megfelelő tartalmat! :)
Analóg kimenet (Szervóvezérlés) /Alapok/
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) /Alapok/
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 / Alapok/
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 /Alapok/
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 /Alapok/
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ői 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.