A robotokat, gépeket azonban motorok mozgatják, így ebben a részben a motorokkal fogunk foglalkozni!
Általános tudnivalók:
-Arduino lábait max. 40mA-rel lehet terhelni,
-Az Arduino-t összességében maximum 200mA -t vehet fel, illetve a 3,3V kivezetése 50mA önmagában, de ezeknek nézz utána!
-USB port általánosságban max. 500 mA-re van tervezve, ennél jobban nem szabad megterhelni!
Teljesítmény = feszültség x áram
P = V x I
P max az USB esetén = 5V x 0,5A = 2,5Watt
-Például a mikró szervomotorok is 200-400mA-t vesznek fel,
ezért pl egy Arduino kivezetésével nem szabad meghajtani őket, a digitális kivezetéssel csak vezéreljük a motort, a tápot külön forrásból szolgáltatjuk neki.
Szétválasztás (vagy leválasztás, ahogy tetszik):
A motorok általában nagyobb áramerősséget vesznek fel, mint amit az arduino megenged, sőt, sokszor amit az USB tápja megenged, ezért a motorokat néhány mikró szervomotor kivételével, nem az arduino, vagy az USB tápjáról, hanem külön tápról üzemeltjük. Egyszerű esetben elemről, vagy adapterről. Az, hogy nagyobb ármérősséget vesz fel, azt jelenti, hogy kicsi az ellenállása, és az áram a feszültség hatására, a kis ellenállás miatt nagyon megindul, ami miatt a vezeték, vagy az arduino végzetesen felmelegszik.
Szétválasztani azért kell, hogy még véletlenül se terheljük túl az arduinot vagy, a párhuzamos, vagy a soros portot, vagyis még véletlenül se kerüljön rá nagy áramerősség, vagy/és feszültség.
Szétválasztás relével:
Talán ennek a példájával lehet a legegyszerűbben bemutatni mi a szétválasztás.
Képzeljük el, hogy arduinoval akarjuk a villanyt a szobában előre programozva pont este 22:00-kor felkapcsolni, és reggel 5:00-kor le.
Az arduino, mint a többi vezérlő áramkör kis feszültséggel működik, 5V-al, ezt pedig hiába kapcsolom rá az adott időpontban a 230 V hálózati feszültséggel működő 60W-os villanykörtére, az nem fog világítani. Ezért például egy relét használunk.
A relé áll egy tekercsből, a közepében egy vasmaggal, és egy érintkezőpárból. Ha a tekercs a kis 5V-os áramot megkapja, akkor a kialakuló mágneses tér összehúzza az érintkezőpárokat. Az érintkező egy másik áramkört kapcsol össze, mégpedig a 60W-os villanykörtét, a hálózati 230V-os feszültséggel. Tehát a kicsi feszültségű arduino áramkörrel, ami nem rázz, kapcsolgatom a nagyfeszültségű áramkört, de a nagyfeszültség még véletlenül sem kerülhet az arduinora.
Motoroknál meg a motor ellenállása olyan kicsi, akár csak 10 ohm, hogy rövid zárnak tekinthető. Ha az arduino 5V -os áramkörét rövidre zárjuk, akkor avval túl nagy lesz az áramerősség, az eszköz elfüstöl, kinyiffan. Ezért a motorokat is külön tápról, elemről, adapterről látjuk el energiával, amik jobban bírják a majdnem hogy "rövidrezárást".
A szétválasztás történhet:
- vagy általában az adott motorhoz adott meghajtókat, drivereket, vagy vezérlőmodulokat használunk (amelyekben tranzisztor vagy optocsatoló van). Lejjebb ezeket fogjuk kipróbálni, és használni, de az érdekesség kedvéért néhány szót ejtünk arról, hogy történhet:
- optocsatolóval,
- laikusok számára bonyolultabb tranzisztorral,
- vagy a már említett relével.
Leválasztás optocsatolóval:
Hogy még véletlenül se kerüljön nagyobb áram a vezérlésre, a legjobb megoldás szerintem az optocsatoló. Ebben van egy fényt adó LED, és egy fényt vevő egység. Ugyanúgy vezéreljük, mintha sima LED-et tennénk. Amikor a LED világít, persze ebből nem látunk semmit, mert fekete tokban van, lásd a képen, akkor a vevő vezeti az áramot. Ha nem világit, akkor nem. Ha kicsit világít, akkor a vevő is csak kisebb mértékben engedi át magán az áramot. A LED oldalán, az arduino áramkörében, így csak a megszokott LED vezérléshez használt kis áram folyik (azért a 220ohm-os ellenállásról ne feledkezzünk meg, de a vevő áramkörében sokkal nagyobb feszültség, áramerősség lehet, amely már meg tud hajtani motorokat is (35V, 50mA, 150mW ).
Kezdőknek szerintem nagyon jó, a PC817, (LTV817, K817) optocsatoló, mivel csak négy lába van,
így egyszerű a használata.
https://www.arwill.hu/termekek/optotechnika-kijelzes/optocsatolok/pc817-ltv817-k817-optocsatolo-964050/
Egy hasonló példaprojekt:
http://www.instructables.com/id/Isolating-circuits-from-your-arduino-with-optocoup/
A szétválasztás történhet tranzisztorral, vagy azt tartalmazó gyárilag megtervezett, és összerakott motor driver-rel:
-Ha nem akarunk egyesével vacakolni tranziszorokkal, egyszerűen csak használjuk az ULN2308A jelű 8 csatornás tranzisztormezőt. 2-2 csatorna közösíthető, így 1 A is kapcsolható a chippel, csatornánként!
https://teachmetomake.wordpress.com/how-to-use-a-transistor-as-a-switch/
Vagy a készletekben általában benne van ULN2003 modul, a készletekben szintén megtalálható 28BYJ-48 léptetőmotorhoz!
http://domoticx.nl/webwinkel/index.php?route=product/product&product_id=132
Önindukció, egyebek:
A motorokban tekercsek vannak, amelyek elektromágnesek. A mágneses erő mozgatja a motorokat. Amikor egy motor tekercsében hirtelen megszűnik a feszültség, vagyis kikapcsoljuk, a mágneses tere, miközben összeomlik, feszültséget gerjeszt a tekercsben, de ennek az áramiránya ellentétes. Viszont akár 150V-tal is visszarúghat egy kisebb motor tekercse is. Ez a nagy feszültség veszélyeztetheti a félvezetőkből készült elektronikát, így sok esetben kell valamit csinálni vele. A motorokhoz használt driverekbe, vezérlőmodulokba bele van építve ennek a kezelése (pl. szétválasztás).
Bővebben hamarosan.
A motorokban tekercsek vannak, amelyek elektromágnesek. A mágneses erő mozgatja a motorokat. Amikor egy motor tekercsében hirtelen megszűnik a feszültség, vagyis kikapcsoljuk, a mágneses tere, miközben összeomlik, feszültséget gerjeszt a tekercsben, de ennek az áramiránya ellentétes. Viszont akár 150V-tal is visszarúghat egy kisebb motor tekercse is. Ez a nagy feszültség veszélyeztetheti a félvezetőkből készült elektronikát, így sok esetben kell valamit csinálni vele. A motorokhoz használt driverekbe, vezérlőmodulokba bele van építve ennek a kezelése (pl. szétválasztás).
Bővebben hamarosan.
Motorok:
3 félét vizsgálunk:
-DC motor,
- stepper motor,
- servo motor,
DC motor:
Egyszerűen működik. Áramot kap, és forog. Fordított bekötéssel fordított irányban. H-híddal lehet vezérelni a fogásirányt. Kicsi áramra gyengén és lassan, nagyobbra erősebben, és gyorsabban. Például használhatjuk egy modell autó motorjaként.
PWM
http://www.dwengo.org/sites/default/files/tutorials/pwm.png
Stepper (léptető)motor
nyomtató, floppy, winchester, scanner, CD-rom-ba, robotokba használják.
Ott, ahol amúgy is digitális jeleket használnak, hiszen digitálisan lehet elég precízen vezérelni, és a kívánt pozitívba állítani.
Ha egy motorra szűkíteném a választást, akkor a léptetőmotor az, amire nekünk szükségünk van a robotjainkhoz, gépeinkhez!
Alapvetően kétféle léptetőmotor van, a bipoláris, és az unipoláris,
https://www.youtube.com/watch?v=IEmGOuMFPKQ
http://42bots.com/tutorials/bipolar-stepper-motor-control-with-arduino-and-an-h-bridge/
Unipoláris motor:
A készletekben általában ez az unipoláris motor van benne:
28BYJ-48 a hozzá való ULN2003 as vezérlőmodullal.
http://www.dx.com/p/28byj-48-5v-4-phase-5-wire-stepper-motor-for-28byj-48-5v-microcontroller-silver-151607
Az első tapasztalatom, hogy nem gyors, de kis feszültséggel működtethető. Én az alábbi példaprojektben tápnak 3db. 1,5 V -os elemet kötöttem össze sorba, tehát 4,5V-tal hajtottam meg (3V-tal nem működött), és nem tudtam lefogni! Kikapcsolt állapotban sem lehet elforgatni. Az eredeti példaprojektben egy 5V-ot adó tápjáról hajtják meg:
http://domoticx.com/arduino-stappenmotor-28byj-48/
Csináljunk akkor erre a 28BYJ-48-as motorra egy példaprojektet, ahol tudjuk vezérelni visual basicből három gombbal (jobbra, balra, stop). A leválasztást ULN2003 modullal csináljuk (amit a készletekben amúgy is e motor mellé adnak), és így kötjük be:
http://domoticx.com/wp-content/uploads/ULN2003A-Arduino-naar-stappenmotor-schema.jpg
Tápellátásnak 3 db 1,5 V-os ceruzaelemet sorba kötve használhatunk, vagyis 4,5V-ot.
Visual basic kód:
Húzzunk az üres formra egy serialport-ot, és a tulajdonságaiban a PORTNAME -et írjuk át arra a portra, amellyel csatlakozunk, és amit beállítottunk anno az arduino szoftverbe, nálam a COM4. Az alábbi kódban is (pirossal jelöltem), írd át a com4-et arra, amit te használsz. Húzz rá még a formra három gombot. Az egyikre írd rá, hogy jobbra, a másikra, hogy balra, a harmadikra hogy stop. Az alábbi kód kell hozzá:
Imports System.IO.Ports
Imports System.Threading
Public Class Form1
Shared _continue As Boolean
Shared _serialPort As SerialPort
Private Sub Button3_Click(sender As Object, e As EventArgs) Handles Button3.Click
SerialPort1.Open()
SerialPort1.Write("1")
SerialPort1.Close()
End Sub
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
SerialPort1.Close()
SerialPort1.PortName = "com4" 'change com port to match your Arduino port
SerialPort1.BaudRate = 9600
SerialPort1.DataBits = 8
SerialPort1.Parity = Parity.None
SerialPort1.StopBits = StopBits.One
SerialPort1.Handshake = Handshake.None
SerialPort1.Encoding = System.Text.Encoding.Default 'very important!
End Sub
Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click
SerialPort1.Open()
SerialPort1.Write("2")
SerialPort1.Close()
End Sub
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
SerialPort1.Open()
SerialPort1.Write("3")
SerialPort1.Close()
End Sub
End Class
Arduino kód:
int grade = 0;
int marker = 0;
int mill = 1;
// soros
void setup() {
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
Serial.begin(9600);
}
void loop() {
int marker = Serial.read() - '0';
if (marker == 1) {
mill = 1;
}
if (marker == 2) {
mill = 2;
}
if (marker == 3) {
mill = 3;
}
if (mill == 1){
grade = 0;
}
if (mill == 2){
grade++;
}
if (mill == 3){
grade--;
}
if (grade == 0){
digitalWrite(8, LOW);
digitalWrite(9, LOW);
digitalWrite(10, LOW);
digitalWrite(11, LOW);
}
if (grade == 1){
digitalWrite(8, LOW);
digitalWrite(9, LOW);
digitalWrite(10, LOW);
digitalWrite(11, HIGH);
}
if (grade == 2){
digitalWrite(8, LOW);
digitalWrite(9, LOW);
digitalWrite(10, HIGH);
digitalWrite(11, HIGH);
}
if (grade == 3){
digitalWrite(8, LOW);
digitalWrite(9, LOW);
digitalWrite(10, HIGH);
digitalWrite(11, LOW);
}
if (grade == 4){
digitalWrite(8, LOW);
digitalWrite(9, HIGH);
digitalWrite(10, HIGH);
digitalWrite(11, LOW);
}
if (grade == 5){
digitalWrite(8, LOW);
digitalWrite(9, HIGH);
digitalWrite(10, LOW);
digitalWrite(11, LOW);
}
if (grade == 6){
digitalWrite(8, HIGH);
digitalWrite(9, HIGH);
digitalWrite(10, LOW);
digitalWrite(11, LOW);
}
if (grade == 7){
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
digitalWrite(10, LOW);
digitalWrite(11, LOW);
}
if (grade == 8){
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
digitalWrite(10, LOW);
digitalWrite(11, HIGH);
}
if(grade>8){
grade=1;
}
if(grade<1){
grade=8;
}
delay(1);
}
Szerintem ezt a projektet ki lehet próbálni merevlemez motorral is, annyi különbséggel, hogy annak csak három tekercse van, nem négy, és értelemszerűen ennek megfelelően kell változtatni...
Bipoláris motor:
(Ennél a projektnél inkább ne az arduino 5 Voltját használjuk, hanem külső tápot (9V), akár 6db. 1,5V-os elemet sorba kötve 9V-ot)
Különböző kisebb bipoláris léptetőmotorokhoz CNC vagy 3D nyomtató projektekhez még olcsó vezérlő megoldás a L293D ( H-híd) léptetőmotor driver is:
https://www.hestore.hu/prod_10028538.html
Próbáljuk ki a bipoláris motor vezérlését az L293d h-HÍDDAL!
Motornak használhatjuk a 28BYJ-48 unipoláris motorunkat, és úgy alakíthatjuk át bipolárissá, hogy a tekercsek közös vezetékét, azaz a pirosat nem használjuk fel (nem kell kivágni, de a két tekercs összekötését el kell vágni:
http://www.jangeox.be/2013/10/change-unipolar-28byj-48-to-bipolar.html.
Az L293 bekötése:
Az 1-es, 8-as, 9-es és 16-os kivezetését a külső táp + pólusára kössük!
a 2-es kivezetését az arduino 12 lábára
a 3-as kivezetését az motor citrom színű vezetékére
a 4-es és 5-ös, 12-es, és 13-as kivezetését a külső tápunk - pólusára, és az arduino földjére (GND) kössük!
az 6-ös kivezetését a motor kék színű vezetékére
a 7-es kivezetését az arduino 11-es lábára
a 10-es kivezetését az arduino 10-es lábára
a 11-es kivezetését a motor rózsaszínű színű vezetékére
14-es kivezetését a motor narancs színű vezetékére
15-ös kivezetését az arduino 9-es lábára
Az alábbi képen az arduino 5V-ját használják, de mi a biztonság kedvéért ne azt, hanem külső tápot használjunk, főleg nano esetében!
http://www.elektromanoid.hu/img/Stepper_Motor_bb.jpg
Arduino kód:
#include <Stepper.h>// stepper könyvtár megnyitása
int in1Pin = 12;
int in2Pin = 11;//változók hozzárendelése a lábakhoz
int in3Pin = 10;
int in4Pin = 9;
Stepper motor(512, in1Pin, in2Pin, in3Pin, in4Pin); //kimenetek hozzárendelése a stepper motorhoz
//512 a stepper motor 360fokos elmozdulásának felosztása
void setup()
{
pinMode(in1Pin, OUTPUT);
pinMode(in2Pin, OUTPUT);//beállítás kimenetként
pinMode(in3Pin, OUTPUT);
pinMode(in4Pin, OUTPUT);
while (!Serial);
Serial.begin(9600);//soros monitor bitsebességének beállítása
motor.setSpeed(20);//a motor sebessége
}
void loop()
{
if (Serial.available())
{
int steps = Serial.parseInt();//bekéri az értéket a serial monitorból
motor.step(steps);//kiíratás a stepper motorra
}
}
A soros monitorba be kell gépelni hány lépést tegyen meg a motor. Ha negatív számot írunk be, akkor ellenkező irányba fog fordulni.
Bővebben:
http://www.elektromanoid.hu/ardu14.html
http://moodle.autolab.uni-pannon.hu/Mecha_tananyag/mikrovezerlok_programozasa/ch24.html
A szervomotor:
Igen használt a távirányításnál (RC-rádió kontroll) világban!
Tipikusan csak 180 fokban működik, tehát például egy modell autó kormányművét mozgathatjuk vele jobbra, vagy balra.
Ugyanakkor léteznek gyorsabban, és 360 fokban forgó szervomotorok is!
Nagy előnye, hogy egy vezérlővezetéke van, és hogy nem lépés téveszt, azaz mindig tudjuk hol áll a motor. Ott, ahová küldtük...
Működése:
Ezt is vezérelni kell, de nem digitek sorozatával, hanem egy elektromos négyzetjel hosszával, ami meghatározza, hogy milyen pozícióba álljon.
http://www.robotshop.com/blog/en/arduino-5-minute-tutorials-lesson-5-servo-motors-3636
A szervo vezérlőjelének tipikus időtartama 20 ms, az impulzus szélessége 0,7 és 2,3 ms között változik.
Micro servo: 9g SG90:
Ezt a típust leválasztás nélkül használják az arduinohoz.
Én mindenesetre először optocsatolós leválasztással próbáltam ki...
http://www.ebay.in/itm/Mini-Servo-Motor-SG90-for-Arduino-Raspberry-Pi-RC-Planes-9-gram-/131971968274
Aztán később bátrabb voltam, és tényleg nem füstölt el az arduino, amikor a piros vezetékét az 5V-ra kötöttem be. Lásd lejjebb a projektet...
3 vezetéke van, ha tápot használsz, 5V-ot, akkor a
-fekete vagy barna a föld, vagyis a táp negatív sarkára
-Piros vezeték a táp 5V+ pólusára kell kötni
-A sárga, narancssárga vezetéket az arduino adott vezérlő kivezetésére kell kötni.
Klassz dolog benne az, hogy egyetlen egy I/O kivezetést foglal el az arduino-n!
-És a földet az arduino földjére is hozzá kell kötni, hogy a sárga vezetékünk köre is záródjon...
4. Amikor feszültség alá helyezed a servo motorodat, akkor gyakran tapasztalhat ugrálást. A hirtelen feszültséget vezérlésnek veszi, és felvesz valamilyen kezdő pozíciót. Ez főleg akkor zavaró, ha robotkarról van szó, és a robotkar a kezdeti "jeltől" furcsa kifacsart állapotba áll be.
Ezt el lehet kerülni, ha a táp pozitív és negatív pólusa közé egy 100uF értékű kondenzátort kötsz be.
Jellemző vezérlése a knob és a sweep (söprés).
A sweep-nél oda-vissza mozgást produkálunk:
0 fok-90 fok- és 180 fokba áll be ilyenkor a motor. Igazából megadhatunk 0 és 180 fok között bármilyen szöget...
Példa:
http://www.instructables.com/id/Arduino-Servo-Motors/
A knob-nál egy potenciométerrel változtatjuk a motor helyzetét, és nem csak fokokban tudjuk beállítani, hanem a 0 és 180 fokot tulajdonképpen átalakítjuk 0 és 1024 jellé, így még finomabban tudjuk állítani, amihez potmétert használunk. A két kód között a potenciométer és a map kód a különbség...
Példa:
https://www.youtube.com/watch?v=8-w_8izUO38
http://www.instructables.com/id/ArduinoServoPotentiometer/
Még finomabb vezérlés:
A szervo vezérlését be tudjuk állítani úgy is, hogy nem fokokban (0-180),hanem a 0 és 180 fok közötti vezérlőjel időtartamával vezérlünk. Alapértéknek 544 és 2400 µs van beállítva, és ezt kihasználva a kódban lassú mozgást, vagy/és igen precíz vezérlést is megvalósíthatunk. Pl lassú sweep:
#include <Servo.h>
Servo myservo;
int val1 = 650;
int val2;
int val3 = 0;
void setup()
{
myservo.attach(9,640,2400);
}
void loop()
{
val2 = val1;
if(val3 == 0){
val1 = val1 + 1;
}
if(val3 == 1){
val1 = val1 - 1;
}
if (val1 == 2390) {
val3 = 1;
}
if (val1 == 650) {
val3 = 0;
}
myservo.write(val2);
delay(10);
}
Ezzel pedig a sorosmonitorral vezérelhetjük igen pontosan. Az 1-es, 2-es klaviatúra gombokkal lehet jobbra, balra forgatni lassan és simán, a 3-asal pedig megállítani:
#include <Servo.h>
Servo myservo;
int val1 = 651;
int val2;
int val3;
int val4;
void setup()
{
myservo.attach(9,640,2400);
Serial.begin(9600);
}
void loop()
{
if (Serial.available()){
val3 = Serial.parseInt();
}
val2 = val1;
if(val3 == 1 && val1 < 2390){
val1 = val1 + 1;
}
if(val3 == 2 && val1 > 650){
val1 = val1 - 1;
}
if(val3 == 3){
val1 = val2;
}
myservo.write(val2);
if(val3 != val4){
Serial.println(val1);
}
val4 = val3;
delay(10);
}
Bővebben itt:
http://megtestesules.info/hobbielektronika/2013/talk14.pdf
Servo vezérlése javascirpttel, böngészőből:
https://circuitdigest.com/microcontroller-projects/iot-web-controlled-servo-motor
Egyelőre ennyi, talán még folytatom! A többi oldal a kapcsolódó projektek bemutatása.
Remélem azért volt hasznosítható dolog! Ha igen, írj néhány ösztönző, vagy akár ostorozó sort, itt a lap alján nekem!
Vége!
