- Kördiagramm
- PWM jelek generálása GPIO csapon a szervomotor vezérléséhez
- A PIC16F8771A programozása robotkarhoz
- A PIC robotkar kódjának szimulációja
- NYÁK-tervezés az EasyEDA segítségével
- Minták kiszámítása és megrendelése online
- A PIC robotkar működése
A gépjárműgyártó gépek futószalagjától kezdve az űr teletermelő robotjain mindenhol megtalálhatók a Robotfegyverek. Ezeknek a robotoknak a mechanizmusai hasonlóak az emberhez, amelyet hasonló funkciókra és megnövelt képességekre lehet programozni. Használhatók ismételt műveletek gyorsabb és pontosabb végrehajtására, mint az emberek, vagy zord környezetben is felhasználhatók, anélkül, hogy kockáztatnák az emberi életet. Már építettünk egy Record and Play robot karot az Arduino segítségével, amelyet ki lehet oktatni egy adott feladat elvégzésére, és örökké ismételhetővé tenni.
Ebben az oktatóanyagban az ipari szabványú PIC16F877A 8-bites mikrovezérlőt használjuk ugyanazon robotkar potenciométerekkel történő vezérléséhez. Ennek a projektnek az a kihívása, hogy a PIC16F877A-nak csak két PWN-képes csapja van, de körülbelül 5 szervomotort kell vezérelnünk robotunkhoz, amelyhez 5 egyedi PWM-csap szükséges. Tehát ki kell használnunk a GPIO érintkezőket, és PWM jeleket kell generálnunk a PIC GPIO csapokon az időzítő megszakításokkal. Most természetesen frissíthetünk egy jobb mikrovezérlőre, vagy használhatunk egy multiplexer IC-t, hogy itt sokkal könnyebbé tegyük a dolgokat. De mégis érdemes kipróbálni ezt a projektet a tanulási élmény érdekében.
A robotkar mechanikai felépítését, amelyet ebben a projektben használok, teljesen 3D-ben nyomtattam az előző projektemhez; a teljes tervfájlokat és az összeszerelési eljárást itt találja. Alternatív megoldásként, ha nincs 3D nyomtatója, akkor egy egyszerű robotkarot is készíthet kartonok segítségével, amint az a linken látható. Ha feltételezzük, hogy valamiképpen megszerezte robotkarját, folytathatja a projektet.
Kördiagramm
A PIC mikrokontroller alapú robotkar teljes kapcsolási rajza az alábbiakban látható. A sémákat az EasyEDA segítségével készítettük.
A kapcsolási rajz meglehetősen egyszerű; a teljes projektet a 12 V-os adapter táplálja. Ezt a 12 V-ot két 7805 feszültségszabályozóval + 5 V-ra alakítják át. Az egyiket + 5V, a másikat + 5V (2) jelöli. Két szabályozónak az az oka, hogy amikor a szervo forog, nagy áramot húz be, ami feszültségesést okoz. Ez a feszültségesés arra kényszeríti a PIC-t, hogy újrainduljon, ezért nem működtethetjük a PIC-t és a szervomotort sem ugyanazon az + 5 V-os sínen. Tehát a + 5V jelöléssel ellátott a PIC mikrovezérlő, az LCD és a potenciométerek áramellátására szolgál, és egy külön szabályozó kimenetet, amelyet + 5V (2) címkével látnak el, a szervomotorok táplálására szolgál.
A potenciométerek öt kimeneti csapja, amelyek 0–5 V közötti változó feszültséget szolgáltatnak, a PIC An0 – AN4 analóg csapjaihoz vannak csatlakoztatva. Mivel időzítők használatát tervezzük a PWM előállítására, a szervomotorok bármely GPIO tűhöz csatlakoztathatók. Kiválasztottam az RD2 és RD6 közötti csapokat a szervomotorokhoz, de ez tetszőleges GPIO lehet.
Mivel a program sok hibakeresést igényel, egy 16x2 LCD-kijelző is csatlakozik a PIC portB-jéhez. Ez megjeleníti a vezérelt szervomotorok működési ciklusát. Ezen kívül kiterjesztettem az összes GPIO és analóg érintkező csatlakozását, arra az esetre, ha a jövőben bármilyen érzékelőt interfészre lenne szükség. Végül csatlakoztattam a H1 programozó csapot is, hogy közvetlenül programozzam a PIC-t a pickit3-mal az ICSP programozási opcióval.
PWM jelek generálása GPIO csapon a szervomotor vezérléséhez
Miután az áramkör készen áll, ki kell találnunk, hogyan lehet PWN jeleket előállítani a PIC GPIO tűjén a szervomotor vezérléséhez. A Timer megszakítási módszerrel már elfáradtunk valami hasonlóval, és sikeresek voltunk. Itt építeni fogunk a tetejére, ezért ha új vagy itt, akkor erősen ajánlom, hogy olvassa el ezt a korábbi oktatóanyagot, mielőtt tovább folytatná.
Minden hobbi szervomotor 50Hz frekvenciával működik. Ez azt jelenti, hogy egy teljes impulzusciklus egy szervomotornál 1/50 (F = 1 / T) lesz, ami 20 ms. Ebből a teljes 20 ms-ból a vezérlőjel csak 0 és 2 ms között van, míg a többi jel mindig ki van kapcsolva. Az alábbi ábra azt mutatja be, hogy az ON idő csak 0 és 2 ms között változik-e a motor 0 és 180 fok közötti forgatásához a teljes 20 ms időtartam alatt.
Ezt szem előtt tartva úgy kell megírnunk a programot, hogy a PIC 0-1204-ig beolvassa a potenciométert, és 0-tól 100-ig feltérképezi, amely a szervomotor munkaciklusa lesz. Ennek az üzemi ciklusnak a segítségével kiszámíthatjuk a szervomotor BE idejét. Ezután inicializálhatjuk az időzítő megszakítását, hogy rendszeres időközönként túlcsorduljon, úgy, hogy az az Arduino millis () függvényéhez hasonlóan működjön. Ezzel a GPIO státust a kívánt időtartamra magasra kapcsolhatjuk, és 20 ms (egy teljes ciklus) után kikapcsolhatjuk, majd megismételhetjük ugyanezt a folyamatot. Most, hogy megértettük a logikát, menjünk be a programba.
A PIC16F8771A programozása robotkarhoz
Mint mindig , a Videóval ellátott teljes program megtalálható ennek az oldalnak a végén, innen is letölthető a kód az összes szükséges fájllal együtt. Ebben a részben megvitatjuk a program logikáját. A program az ADC modult, az Időzítő modult és az LCD modult használja a robotkar vezérléséhez. Ha még nem ismeri az ADC vagy az Időzítő funkcióinak használatát, vagy az LCD és a PIC összekapcsolását, akkor visszatérhet a megfelelő hivatkozásokhoz, hogy megtanulja őket. Az alábbi magyarázat abból indul ki, hogy az olvasó ismeri ezeket a fogalmakat.
0. időzítő portjának konfigurálása
A kód legfontosabb része az, hogy a Timer 0-t minden egyes késleltetés esetén túlfolyásra állítja. A késleltetés kiszámítására szolgáló képletek megadhatók
Késleltetés = ((256-REG_val) * (Prescal * 4)) / Fosc
Az OPTION_REG és TMR0 regiszter használatával a 0 időzítőt úgy állítottuk be, hogy 32 prescalar értékkel működjön, a REG val értéke pedig 248. A hardverünkben használt kristályfrekvencia (Fosc) 20Mhz. Ezekkel az értékekkel a késleltetés kiszámítható
Késleltetés = ((256-248) * (32 * 4)) / (20000000) = 0,0000512 másodperc (vagy) = 0,05 ms
Tehát most úgy állítottuk be az időzítőt, hogy minden 0,05 ms-on túlcsorduljon. Az ehhez szükséges kód az alábbiakban található
/ ***** Portkonfiguráció az időzítőhöz ****** / OPTION_REG = 0b00000100; // Timer0 külső frekvenciával és 32 mint prescalar // Engedélyezi a PULL UPs TMR0 = 248 értéket is; // Az időérték betöltése 0,0001 másodpercig; a delayValue csak 0-256 között lehet, TMR0IE = 1; // Időzítő megszakítási bit engedélyezése a GIE = 1 PIE1 regiszterben ; // Globális megszakítás engedélyezése PEIE = 1; // Engedélyezze a perifériás megszakítást / *********** ______ *********** /
A szervomotor 0 ms-tól 2 ms-ig terjedő vezérlőablakából 0,05 ms-os felbontással vezérelhetjük, ami lehetővé teszi számunkra, hogy (2 / 0,05) 40 különböző pozíciót kapjunk a motor számára 0 és 180 fok között. Ezt az értéket tovább csökkentheti, ha az MCU támogatná azt, hogy több pozíciót és pontos irányítást érjen el.
Szolgáltatás megszakítása (ISR)
Most, hogy az időzítő 0 0,05 ms-onként túlfolyásra van állítva, a TMR0IF megszakítási jelzőt 0,05 ms-ra állítjuk be. Tehát belsejében ISR funkció tudjuk állítani, hogy a zászló, és eggyel növeli a változó nevű száma szerint egy. Tehát most ez a változó 1-gyel növekszik minden 0,05 ms-onként.
void megszakítás timer_isr () { if (TMR0IF == 1) // Az időzítő jelző az időzítő túlcsordulása miatt aktiválódott -> 0,05 ms- onként túlcsordulásra állítva { TMR0 = 248; // Az időzítő betöltése: TMR0IF = 0; // Az időzítő megszakításának jelzőszámának törlése ++; // 1-es lépések számlálása 0,05 ms-onként }
A munkaciklus és a bekapcsolási idő kiszámítása
Ezután ki kell számolnunk mind az öt szervomotor működési ciklusát és idejét. Öt szervomotorunk van, amelyek mindegyike az egyes karszakaszok vezérlésére szolgál. Tehát le kell olvasnunk mind az öt ADC értékét, és mindegyikre ki kell számítani a munkaciklust és az időt.
Az ADC értéke 0 és 1024 közötti tartományba esik, amelyet 0% és 100% közötti ciklusra lehet átalakítani, ha egyszerűen megszorozzuk a 0,0976 értéket (100/1024 = 0,0976) a kapott értékre. Ezt a 0 és 100% közötti munkaciklust ON időre kell átalakítani. Tudjuk, hogy 100% -os üzemi ciklus esetén az ON időnek 2 ms-nak kell lennie (180 fok esetén), így 0,02 (2/100 = 0,02) szorzása 0 és 100 közötti ciklust 0 és 2 ms közötti értékre konvertál. De ekkor az időzítő változóink száma 0,05 ms-onként egyszer növekszik. Ez azt jelenti, hogy a számlálás értéke 20 (1 / 0,05 = 20) lesz 1 ms-onként. Tehát meg kell szoroznunk 20-at 0,02-vel, hogy kiszámítsuk a programunk pontos idejét, amely 0,4 (0,02 * 20 = 0,4) értéket kap. A kód az alábbiakban látható, láthatja, hogy ötször megismétli mind az 5 potnál egy for ciklust. A kapott értékeket a T_ON tömb tárolja.
mert (int pot_num = 0; pot_num <= 3; pot_num ++) { int Pev_val = T_ON; POT_val = (ADC_Read (pot_num)); // Olvassa el a POT értékét az ADC Duty_cycle = (POT_val * 0,0976) használatával; // 0-1024 és 0-100 közötti térkép T_ON = Duty_cycle * 0,4; // 20 * 0,02
Forgatni kívánt motor kiválasztása
Nem tudjuk mind az öt motort együtt irányítani, mivel ez az ISR kódot erősen lelassítja az egész mikrovezérlőt. Tehát egyszerre csak egy szervomotort kell forgatnunk. Az elforgatandó szervo kiválasztásához a mikrovezérlő figyeli mind az öt szervomotor bekapcsolási idejét, és összehasonlítja azt a korábbi időben. Ha megváltozik az ON idő, akkor arra a következtetésre juthatunk, hogy az adott szervót mozgatni kell. Ugyanennek a kódja az alábbiakban látható.
if (T_ON! = Pev_val) { Lcd_Clear (); szervo = pot_num; Lcd_Set_Cursor (2,11); Lcd_Print_String ("S:"); Lcd_Print_Char (szervo + '0'); if (pot_num == 0) {Lcd_Set_Cursor (1,1); Lcd_Print_String ("A:");} else if (pot_num == 1) {Lcd_Set_Cursor (1,6); Lcd_Print_String ("B:");} else if (pot_num == 2) {Lcd_Set_Cursor (1,11); Lcd_Print_String ("C:");} else if (pot_num == 3) {Lcd_Set_Cursor (2,1); Lcd_Print_String ("D:");} else if (pot_num == 4) {Lcd_Set_Cursor (2,6); Lcd_Print_String ("E:");} char d2 = (Duty_cycle)% 10; char d1 = (Duty_cycle / 10)% 10; Lcd_Print_Char (d1 + '0'); Lcd_Print_Char (d2 + '0');
Ezenkívül kinyomtatjuk a szervo munkaciklust az LCD képernyőn, hogy a felhasználó tisztában legyen az aktuális helyzetével. Az ON idő változása alapján a változó szervo 0 és 4 közötti számokkal frissül, amelyek mindegyike az egyes motorokat képviseli.
A szervomotor vezérlése az ISR-en belül
Az ISR-en belül a változó száma növekszik minden 0,05 ms-onként, ez azt jelenti, hogy minden 1 ms-onként a változó 20-mal növekszik. Ennek használatával ellenőriznünk kell a csapokat a PWM jel előállításához. Ha a számlálás értéke kisebb, mint a bekapcsolási idő, akkor a motor GPIO-ját az alábbi sor segítségével kapcsolják be
PORTD = PORTD - szervo_kód;
Itt a szervo_code tömbben megtalálható mind az öt szervomotor tüske részlete, és a változó szervo értéke alapján az adott szervomotor kódját kell használni. Ez akkor logikailag VAGY (-) a meglévő PORTD bitekkel, hogy ne zavarjuk meg a többi motor értékeit, és csak ezt a bizonyos motort frissítsük. Hasonlóan a csap kikapcsolásához
PORTD = PORTD & ~ (szervo_kód);
Megfordítottuk a bitértéket a logikai inverz (~) operátor segítségével, majd AND (és) műveletet hajtottunk végre a PORTD-on, hogy csak a kívánt csapot kapcsoljuk ki, miközben a többi csapot az előző állapotukban hagytuk. A teljes kódrészlet alább látható.
void megszakítás timer_isr () { if (TMR0IF == 1) // Az időzítő jelzőt az időzítő túlcsordulása miatt aktiválták -> 0,05 ms- onként túlfolyásra állítva { TMR0 = 248; // Az időzítő betöltése: TMR0IF = 0; // Az időzítő megszakításának jelzőszámának törlése ++; // Számoljon 1-es lépéseket 0,05 ms-onként -> a számlálás 1 ms-onként 20 lesz (0,05 / 1 = 20)) } int servo_code = {0b01000000, 0b00100000, 0b00010000, 0b00001000, 0b00000100}; if (szám> = 20 * 20) szám = 0; if (szám <= (T_ON)) PORTD = PORTD - szervo_kód; else PORTD = PORTD & ~ (szervo_kód); }
Tudjuk, hogy a teljes ciklusnak 20 ms-nak kell lennie, mire a GPIO pin újra bekapcsol. Tehát ellenőrizzük, hogy a számlálás túllépte-e a 20 ms-ot, összehasonlítva a számlálás értékét a 400-zal (ugyanaz a számítás, mint a fentiekben tárgyaltuk), és ha igen, akkor inicializálnunk kell a nullát újra.
A PIC robotkar kódjának szimulációja
A kódot mindig jobb szimulálni, mielőtt a valódi hardverre viszi. Tehát a Proteus segítségével szimuláltam a kódomat, és ellenőriztem, hogy megfelelően működik-e. A szimulációhoz használt áramkört az alábbiakban mutatjuk be. Oszcilloszkóp segítségével ellenőriztük, hogy a PWM jelek a szükség szerint keletkeznek-e. Azt is ellenőrizhetjük, hogy az LCD és a Servo motorok a várt módon forognak-e.
Amint láthatja, az LCD kijelző a D motor működési ciklusát 07-nek mutatja a pot értéke alapján, amely a harmadik motor. Hasonló, ha egy másik edényt mozgatunk, és ennek motorja megjelenik az LCD-n. Az oszcilloszkópon látható PWM jel az alábbiakban látható.
A teljes ciklus periódust 22,2 ms-nak mérik az oszcilloszkóp kurzoropciójával, amely nagyon közel van a kívánt 20 ms-hoz. Végül biztosak vagyunk abban, hogy a kód működik, így az áramkör folytatásához vagy forraszthatjuk egy tökéletes táblára, vagy használhatunk egy NYÁK-t. A kenyérlapon nem fog könnyen működni, mert a POT mindig problémákat okoz a gyenge kapcsolatok miatt.
NYÁK-tervezés az EasyEDA segítségével
Ennek a PIC robotkarnak a tervezéséhez az online EDA eszközt választottuk az EasyEDA néven. Már régóta használom, és nagyon kényelmesnek találom, mivel hatalmas a rendelkezésre álló hely és könnyen használható természet. A NYÁK megtervezése után megrendelhetjük a NYÁK-mintákat olcsó PCB-gyártási szolgáltatásaikkal. Komponens beszerzési szolgáltatást is kínálnak, ahol nagy mennyiségű elektronikus alkatrész áll rendelkezésükre, és a felhasználók megrendelhetik a szükséges alkatrészeket a NYÁK megrendeléssel együtt.
Az áramkörök és a NYÁK-k tervezése közben az áramköri és a NYÁK-terveket is nyilvánossá teheti, hogy más felhasználók másolhassák vagy szerkeszthessék azokat, és kihasználhassák munkáját, mi is az egész áramkör- és NYÁK-elrendezésünket nyilvánossá tettük ehhez az áramkörhöz, ellenőrizze az alábbi link:
easyeda.com/circuitdigest/pic-development-board-for-robotic-arm
Ezen a linken keresztül közvetlenül megrendelheti ugyanazt a nyomtatott áramköri lapot, amelyet ebben a projektben használunk, és felhasználhatja. Miután a tervezés befejeződött, a tábla 3D modellként tekinthető meg, ami nagyon hasznos lesz annak megjelenítésében, hogy a tábla hogyan jelenik meg a gyártás után. Az általunk használt tábla 3D modellje az alábbiakban látható. Ettől eltekintve a tábla felső és alsó rétegét is megtekintheti, hogy ellenőrizze, hogy a csúszós képernyő a vártnak megfelelő-e.
Minták kiszámítása és megrendelése online
A PIC Robot NYÁK tervezésének befejezése után megrendelheti a NYÁK-t a JLCPCB.com oldalon keresztül. A NYÁK megrendeléséhez a JLCPCB-től Gerber File szükséges. A NYÁK-ból származó Gerber fájlok letöltéséhez kattintson az EasyEDA szerkesztő oldalán a Gyártási fájl előállítása gombra, majd töltse le onnan a Gerber fájlt, vagy kattintson a Rendelés a JLCPCB-n gombra , az alábbi kép szerint. Ez átirányítja a JLCPCB.com webhelyre, ahol kiválaszthatja a megrendelni kívánt NYÁK-k számát, hány rézréteget, a NYÁK vastagságát, a réz súlyát és még a NYÁK színét is, például az alább látható pillanatképet:
Miután kiválasztotta az összes lehetőséget, kattintson a „Mentés a kosárba” gombra, és akkor arra az oldalra kerül, ahol feltöltheti Gerber fájlját, amelyet letöltöttünk az EasyEDA-ból. Töltse fel Gerber fájlját, és kattintson a „Kosárba mentés” gombra. Végül kattintson a Checkout Secure gombra a megrendelés befejezéséhez, majd néhány nappal később megkapja a NYÁK-kat. Nagyon alacsony áron gyártják a NYÁK-t, ami 2 dollár. Gyártási idejük szintén rövidebb, ami 48 óra 3-5 napos DHL szállítás esetén, alapvetően a PCB-ket a megrendeléstől számított egy héten belül megkapja.
A NYÁK megrendelése után ellenőrizheti a NYÁK előrehaladását dátummal és idővel. A Fiók oldalon a "Feldolgozás" gombra kattintva ellenőrizheti.
Néhány napos PCB-k megrendelése után kaptam a PCB-mintákat szép csomagolásban, az alábbi képeken látható módon.
Miután megszereztem ezeket a darabokat, az összes szükséges alkatrészt forrasztottam a NYÁK-ra. Én is közvetlenül forrasztottam a POT-ot, ahelyett, hogy összekötő vezetékeket használtam volna, mert a női-női vezetékeket, amelyeket eredetileg használtam, ahol furcsa analóg kimeneti feszültségeket adtam, valószínűleg a laza érintkezők miatt. Miután az összes alkatrészt összeszerelték, a NYÁK ilyesminek tűnt.
Talán észrevette, hogy ezen a táblán csak egy 7805 van. Ennek oka az volt, hogy kezdetben azt hittem, hogy megúszom a szabályozót mind a PIC, mind a szervomotor táplálásához, és később rájöttem, hogy kettőre van szükségem. Tehát egy külső áramkört használtam a szervomotorok táplálásához az itt látható zöld vezetéken keresztül.
Ennek ellenére nem kell sokat aggódnia miatta, mert; A PCB-n most végrehajtottam a változtatásokat. Használhatja a módosított NYÁK-ot, és forraszthatja mindkét szabályozót a fedélzeten.
A PIC robotkar működése
A fárasztó munka után ideje a megtérülésnek. Forrasztja össze az összes alkatrészt a táblán, és töltse fel a programot a PIC vezérlőbe. A teljes kód az alábbiakban található, vagy innen letölthető. A táblán található programozó csatlakozónak segítenie kell a programot a Pickit 3 segítségével közvetlenül feltölteni különösebb gond nélkül. Miután feltöltötte a programot, látnia kell az LCD-t, amely a jelenleg vezérelt szervót jeleníti meg. Ha többet szeretne megtudni a PIC mikrokontroller programozásáról, kövesse az előző oktatóanyagot.
Innen egyszerűen elforgathatja az edényt, és ellenőrizheti, hogy a szervomotorok hogyan reagálnak az egyes potenciométerekre. Miután megértette a formátumot, vezérelheti a robotkart, hogy bármilyen műveletet hajtson végre, amire szüksége van a szórakozáshoz. A projekt teljes működését az alábbi linkre kattintva találja meg.
Ez az, hogy srácok remélik, hogy megértették a projektet, és valami újat tanultak belőle. Ha bármilyen kérdése van, hagyja őket a megjegyzés részben, vagy használja a fórumokat más technikai megbeszélésekhez.