Arról írok egy kezdő szintű összefoglalást, miként lehet házilag piti pénzeken vezérléseket építeni. Miként működnek ezek a vezérlők, melyek nagyon olcsón hozzáférhetőek, de a hozzá tartozó ki- és bemeneti egységek megfelelő kiválasztásával egészen a csúcskategóriáig fejleszthetőek. Tehát, ez azt jelenti, hogy professzionális gépek vezérlését is megoldhatjuk ezekkel.

Működés

Alap áramkörök, az agy

Nyílt forrású programcsomaggal rendelkező mikrovezérlő csomagokat talált ki anno decimále, 2005 körül két diák. Ezek elérhetővé tették a hobbistáknak, hogy építhessenek ilyen-olyan vezérlést anélkül, hogy saját programozó egységeket kellene venniük drága pénzekért. Vagyis a készletek önmagukban képesek arra, hogy a programot feltöltsük rá, és akár kiegészítők nélkül is köthetünk rá különféle eszközöket, amiket vezérel, szabályoz.
A mikrovezérlő köré van illesztve egy program feltöltő áramkör, IO egységek, kivezetések, feszültségstabilizátor. Ezek biztosítják az 5 vagy 3,3V-os vezérlőjeleket. Van amelyiknek saját EEPROM-ja is van, ami biztosítja számunkra a beállítások menthetőségét, aktuális állapot tárolását, hogy kikapcsolás után a következő bekapcsolás és használat során zökkenőmentesen folytathassuk a műveletet a gépünkkel. Továbbá lehetőségünk van SD/TF memóriakártyák használatára is.
Órajel szintjén nem kell sokat várni ezektől az áramköröktől, hisz az alacsony szintű logika nem igényel nagy órajelet, vagyis több GHz-es processzorokat, mint azt megszoktuk a telefonoknál, számítógépeknél. Ahhoz, hogy motorokat, reléket vezérejünk, vagy szabályzási köröket valósítsunk meg, elegendő 10-20-70MHz-es processzorokat alkalmaznunk, hisz az egységek reakcióideje, frissítési ciklusa max. 10-20ms.

Kimenetek és bemenetek

Ezeket egyszerűen IO-nak vagy IO jeleknek szoktuk hívni. Vannak digitális IO-k és analóg IO-k. A digitális IO annyit tesz, hogy HIGH szint esetén egy dróton (a nullához képest) kiadja a vezérlő feszültseget (5VDC), vagy LOW szint esetén nullára húzza a kimenetet. Mindig van egy áramkorlát is, amit fontos figyelembe vennünk! Max. 40mA. Bemenet esetén ugyanez fordítva történik, vagyis 0VDC körüli értéknél LOW szintet olvas a vezérlő, 5VDC körüli értéknél HIGH szintet. Analóg jeleknél már nem csak egy bit társul egy jelhez, mint a digitálisnál, hanem pl. az ArduinoMega256-nál 10 bit. Vagyis a bemenetet 0 és 5VDC között skálázza és a feszültségszintnek megfelelően 0-1024 közötti értéket ad. Kimenet esetén egy úgynevezett PWM jelet generál, ami annyit tesz, hogy impulzus szélesség modulálással 0 és 255 közötti értéknek megfelelően kiad egy 0-5VDC effektív feszültségszintet. Tehát, 5V-os tüskéket ad ki, amelyek effektív egyenfeszültségértéke adja az analóg kimenetet. Minél sűrűbben adja ki a tüskéket, annál közelebb lesz az 5V-hoz az effektív érték. 255 esetén 5VDC egyenfeszültséget ad ki. Szóval, az ArduinoMega esetében a PWM jelek 8 bitesek.

Reakcióidők, megszakítások

Amikor kiad egy jelet a vezérlő, nem árt tudnunk, milyen sebességre képes a rendszerünk. Legtöbbször bőven ráér a bemenet beolvasására, a kimenet gyorsaságát pedig inkább a végrehajtóegységek képessége szabja meg, hisz sokkal lassabbak, mint a mikrovezérlő. Vagyis egy mágneskapcsoló mire meghúz, több száz ciklus lefut, arról nem is beszélve, hogy amit vezérel szintén lassabb szokott lenni, mint pl. a levegő nyomás kialakulása egy pneumatika tömlőben. Vannak viszont olyan esetek, amikor szükség van a gyors reakcióidőre és jelfeldolgozásra. Ilyen esetekben használhatjuk a gyors PWM kimeneteket és az úgynevezett megszakításjeleket. Mit is jelent ez? A megszakításjel egy olyan speciális bemenet, amit a programban úgy állíthatunk be, hogy bármikor (egy bizonyos ciklusidőnek megfelelően) beérkezik a jel, a vezérlő félbeszakítja a programot és az ahhoz társított programlészletet futtatja le. Azután persze ismét folytatja a programot onnan, ahol azt félbehagyta. Ezzel a funkcióval enkóder jelek számolását oldhatjuk meg. Kimenet esetében pedig pl. léptetőmotorok vezérlését.

Kommunikáció, buszok

A gyors jelek alkalmasak továbbá különféle kommunikációs protokollok megvalósítására is. Amikor egy IO egység nem közvetlenül az IO-ra csatlakoztatható, mint egy kimenet erősítő vagy bemenet leválasztó, hanem valamilyen soros kommunikációs protokollal vezérelhető, használjuk a soros Rx/Tx jeleket vagy I2C vagy ISP buszokat. Ezek a jelek egy vagy két vezetéken történő adatátvitelt biztosítanak, illetve ISP-nél külön órajel biztosítja az egységek szinkronizálását. Mindegyiknek megvan a maga szabványa, vagyis előre deifinált működési folyamatot, protokollt adunk meg mind a főegységnek, mind az alegységeknek. Főegység a master, jelen esetben az Arduino mikrovezérlőnk, alegységek a slave végrehajtó vagy bemeneti egységek. Amikor buszról van szó, akkor több egység fűzhető fel ugyanarra a vezetékre, és cím vagy csip kiválasztó jel segítségével adjuk meg, melyik egység vegye figyelembe éppen a vezetékeken lévő soros kommunikációs jeleket. I2C busz esetében a címet a slave-en állítjuk be, tehát a soros porton megy a cím is. ISP esetében egy külön vezetéken kell kiválasztani a slave-et. Léteznek lassabb működést biztosító áramkörök is, ahol pufferbe kerül a gombnyomás vagy kijelzés, megengedett bármilyen tetszőleges jel felhasználása órajelként, adatjelként és úgynevezett strobe jelként, ami kiválassza az egységet. TM1638 / TM1640 áramkörök ilyenek, amiket HMI egységként használhatunk, vagyis (Human-Mashine Interface) ember-gép kapcsolatnak.

Építés

Kezdjük el!

Miután sikerült kiválasztanunk a megfelelő áramkört, vettünk pár tüskét, LED-et, ellenállásokat, motor hajtás vezérlőt, motort, stb. a hobbi elektronikai üzletből, mindjárt dobálhatjuk össze az áramkörünket. Persze az első tesztelésekhez elegendő maga az Arduino kártya is. Adnak hozzá USB kábelt is, amit a számítógépbe kötve programozhatjuk a kütyünket. Mivel beviteli eszköz mindig kell, érdemes venni például egy TM1638-as 8×7 szegmenses, 8 gombos, 8 LED-es HMI panelt. Egy ilyen panel programozása nagy örömet jelent, mert láthatjuk, nyomkodhatjuk.

 

Program feltöltés

Kell hozzá az Arduino 1.0.5 r2 és a HMI Library. Ezeket töltsd le. Telepítés után másold be a Library-t a “libraries” könyvtárba. Indítás után ki kell választanod az “Eszközök-Programozó-AVRISK mkII”, “Eszközök-Alappanel-Arduino Mega 2560 or Mega ADK” és “Eszközök-Soros port-.. com”.

Itt egy mintaprogram a fent említett HMI-re és egy motor vezérléshez:

#include <TM1638.h>
#include <TM16XXFonts.h>
//HMI jel deklarálás
int mapClk=A4;
int mapData=A5;
int mapStrobe[2]={A6,A7};
//HMI modul társítás
TM1638 module0(mapData,mapClk,mapStrobe[0],1,3);
TM1638 module1(mapData,mapClk,mapStrobe[1],1,3);
//HMI deklarálások
byte getButtons();
void setLED(byte color, byte pos);
void setDisplayToString(const char* string, const word dots, const byte pos, const byte font[]);
//Tengelyek: 1 2
int mapDCFwdAx[3] = {0, 11, 13};
int mapDCBwdAx[3] = {0, 10, 12};
//Motor engedélyező jelek
int mapMotorEnAx[3]={0,A0,A1};

void setup()
{
//Kijelzők
module0.setDisplayToString(“Body”,0,0,FONT_DEFAULT);
module1.setDisplayToString(“HELLO”,0,0,FONT_DEFAULT);
//Motorok
for (int i=1; i<=2; i++)
{
pinMode(mapDCFwdAx[i], OUTPUT);
pinMode(mapDCBwdAx[i], OUTPUT);
pinMode(mapMotorEnAx[i], OUTPUT);
}
}

void loop()
{
digitalWrite(mapMotorEnAx[1],HIGH);
digitalWrite(mapDCBwdAx[1],LOW);
analogWrite(mapDCFwdAx[1],100);
delay(2000);
digitalWrite(mapDCFwdAx[1],LOW);
analogWrite(mapDCBwdAx[1],100);
delay(2000);
digitalWrite(mapDCBwdAx[1],LOW);
delay(2000);
digitalWrite(mapDCFwdAx[1],HIGH);
delay(2000);
digitalWrite(mapDCFwdAx[1],LOW);
digitalWrite(mapDCBwdAx[1],HIGH);
delay(2000);
digitalWrite(mapDCBwdAx[1],LOW);
delay(2000);
}

 

Program futtatás

Reset gomb megnyomására az alábbiaknak kéne történnie.

Kiírja a “Body”-t a kijelzőre és pörgeti a motort jobbra-balra 2s-es időközönként 2s-ig, közepes sebességgel. Majd teljes sebességgel jobbra-balra ismét. Aztán elölről…

A motor az akkumulátorról vagy elemről működik, nem az USB portról. Tehát, addig amíg nincs rákötve az akku, nem fog pörögni, csak a kijelző működik, de az viszont már az USB portról. Amikor kihúzzuk az USB-t és rákötjük az akkut, a DC-motor hajtó áramkörön lévő kapcsolóval bekapcsolhatjuk a működést PC nélkül is, mivel a DC-motor vezérlőhöz generált 5V-ot kötöttük rá az Arduino 5V bemenetére (Vin).

Beavatkozás soros portról

A <CTRL>+<SHIFT>+M lenyomásával bejön a soros port ablak a gépeden és egy beírt szöveget enterrel küldhetsz is a vezérlődnek.

Az alábbi bővítést írd be a programba:

void setup-ba:

//Soros kommunikáció megnyitása
Serial.begin(9600);

void loop elejére:

int nSpeed=100;
String strAgyIntf1In=Serial.readStringUntil(‘\n’);
if (strAgyIntf1In.toInt()>0 && strAgyIntf1In.toInt()<256)
{
nSpeed=strAgyIntf1In.toInt();
Serial.println(strAgyIntf1In+” OK”);
}
else
{
Serial.println(strAgyIntf1In+” NOK”);
}
Serial.println(“Speed: “+String(nSpeed));
digitalWrite(mapMotorEnAx[1],HIGH);
digitalWrite(mapDCBwdAx[1],LOW);
analogWrite(mapDCFwdAx[1],nSpeed);
delay(2000);
digitalWrite(mapDCFwdAx[1],LOW);
analogWrite(mapDCBwdAx[1],nSpeed);
delay(2000);
digitalWrite(mapDCBwdAx[1],LOW);
return;

Próbáld ki, hogyan tudod így befolyásolni a működést.

 

Írd át magadtól

Azt a részt, ahol a soros porton kapott adatokat használva módosítja a program a paramétereket, írd át valamelyik nyomógombra a HMI-n. Itt egy doksi hozzá. Saját kútfőből oldd meg!

További jó szórakozást!

Következő cikkben már visszacsatolás is lesz a motortól.

 

Készítette: Kertész Péter

Mintaprogramhoz az alkatrészek

1 csomagban tőlem is megvásárolható egy 6 (max. 14) motorhajtásra épített “Shield”-el, illetve kompletten a mikrovezérlővel együtt is. Keress emailben.

Videó