Pagkontrol sa robotic braso gamit ang pic microcontroller

Mula sa linya ng pagpupulong ng mga industriya ng pagmamanupaktura ng sasakyan hanggang sa mga robot ng telesurgery sa kalawakan, ang Robotic Arms ay matatagpuan kahit saan. Ang mga mekanismo ng mga robot na ito ay katulad ng isang tao na maaaring mai-program para sa katulad na pagpapaandar at pagtaas ng mga kakayahan. Maaari silang magamit upang maisagawa ang paulit-ulit na mga aksyon nang mas mabilis at tumpak kaysa sa mga tao o maaaring magamit sa matitigas na kapaligiran nang hindi ipagsapalaran ang buhay ng tao. Nakagawa na kami ng isang Record at Play Robotic Arm gamit ang Arduino na maaaring sanayin na gumawa ng isang partikular na gawain at gawin na ulitin magpakailanman.

Sa tutorial na ito, gagamitin namin ang pamantayan ng industriya na PIC16F877A 8-bit Microcontroller upang makontrol ang parehong robotic arm na may potentiometers. Ang hamon sa proyektong ito ay ang PIC16F877A ay mayroon lamang dalawang PWN na may kakayahang mga pin, ngunit kailangan naming kontrolin ang tungkol sa 5 servo motor para sa aming robot na nangangailangan ng 5 indibidwal na PWM pin. Kaya kailangan nating gamitin ang mga GPIO pin at bumuo ng mga signal ng PWM sa mga PIC GPIO pin gamit ang mga interrupts ng timer. Ngayon, syempre maaari kaming mag-upgrade sa isang mas mahusay na microcontroller o gumamit ng isang de-multiplexer IC upang gawing mas madali ang mga bagay dito. Ngunit pa rin, sulit na subukan ang proyektong ito para sa karanasan sa pag-aaral.

Ang istrakturang mekanikal ng robotic arm na ginagamit ko sa proyektong ito ay ganap na naka-print sa 3D para sa aking nakaraang proyekto; mahahanap mo ang kumpletong mga file ng disenyo at pag-assemble ng pamamaraan dito. Bilang kahalili, kung wala kang isang 3D printer maaari ka ring bumuo ng isang simpleng Robotic Arm gamit ang mga karton tulad ng ipinapakita sa link. Ipagpalagay na nakuha mo sa paanuman ang iyong robotic Arm ay hinahayaan na magpatuloy sa proyekto.

Diagram ng Circuit

Ang Kumpletong diagram ng circuit para sa nakabatay sa PIC Microcontroller na batay sa Robotic Arm ay ipinapakita sa ibaba. Ang mga iskema ay iginuhit gamit ang EasyEDA.

Ang circuit diagram ay medyo simple; ang kumpletong proyekto ay pinalakas ng 12V adapter. Ang 12V na ito ay nai-convert sa + 5V gamit ang dalawang 7805 Boltahe na mga regulator. Ang isa ay may label na bilang + 5V at ang isa ay may label na bilang + 5V (2). Ang dahilan para sa pagkakaroon ng dalawang mga regulator ay kapag umiikot ang servo ay kumukuha ito ng maraming kasalukuyang na lumilikha ng isang drop ng boltahe. Pinipilit ng drop ng boltahe na ito ang PIC na muling simulan ang sarili, kaya't hindi namin mapapatakbo ang parehong PIC at ang mga servo motor sa parehong + 5V rail. Kaya't ang isa na may label na bilang + 5V ay ginagamit upang paandarin ang PIC Microcontroller, LCD at Potentiometers at isang hiwalay na output ng regulator na kung saan ay may label na + 5V (2) ay ginagamit upang mapatakbo ang mga motor na servo.

Ang limang output pin ng potentiometers na nagbibigay ng isang variable na boltahe mula 0V hanggang 5V ay konektado sa mga analog pin na An0 hanggang AN4 ng PIC. Dahil pinaplano naming gumamit ng mga timer upang makabuo ng PWM ang servo motors ay maaaring konektado sa anumang GPIO pin. Pinili ko ang mga form ng pin na RD2 hanggang RD6 para sa mga servo motor, ngunit maaari itong maging anumang GPIO na iyong pinili.

Dahil ang programa ay nagsasangkot ng maraming pag-debug, ang isang 16x2 LCD display ay naka-interfaced din sa portB ng PIC. Ipapakita nito ang cycle ng tungkulin ng mga motor na servo na kinokontrol. Bukod sa ito ay mayroon din akong pinalawig na mga koneksyon para sa lahat ng mga GPIO at analog na pin, kung sakali kung may mga sensor na kailangang ma-interfaced sa hinaharap. Sa wakas ay konektado ko rin ang programmer pin H1 upang direktang programa ang PIC na may pickit3 gamit ang pagpipiliang programa ng ICSP.

Bumubuo ng mga signal ng PWM sa GPIO pin para sa Servo Motor Control

Kapag handa na ang circuit kailangan nating malaman kung paano makabuo ng mga signal ng PWN sa GPIO pin ng PIC upang makontrol ang servo motor. Nakapagod na kami ng isang bagay na katulad gamit ang Pamamaraan ng nakakagambala na pamamaraan at matagumpay. Dito na lang kami magtatayo sa itaas, kaya kung bago ka dito, masidhi kong inirerekumenda na basahin mo ang dating tutorial na ito bago magpatuloy.

Ang lahat ng mga libangan na servo motor ay gumagana na may dalas na 50Hz. Ibig sabihin ang isang kumpletong ikot ng pulso para sa isang motor na servo ay magiging 1/50 (F = 1 / T) na 20ms. Sa kumpletong 20ms na ito ang control signal ay mula 0 hanggang 2ms habang ang natitirang signal ay palaging naka-off. Ipinapakita ng numero sa ibaba kung paano nag-iiba ang ON time mula 0 hanggang 2ms upang paikutin ang motor mula 0 degree hanggang 180 degree ng kabuuang tagal ng 20ms.

Sa pag-iisip na ito kailangan naming isulat ang programa sa isang paraan na ang PIC ay nagbabasa sa 0 hanggang1204 mula sa potentiometer at nai-map ito sa 0 hanggang 100 na magiging duty cycle ng servo motor. Gamit ang duty cycle na ito maaari nating kalkulahin ang ON time ng servo motor. Pagkatapos ay maaari nating gawing simula ang timer makagambala upang mag-overflow sa isang regular na agwat na tulad nito kumikilos katulad ng paggana ng millis () sa Arduino. Sa pamamagitan nito, maaari naming i-toggle ang status GPIO pin upang maging mataas para sa isang nais na tagal at patayin ito pagkatapos ng 20ms (isang kumpletong cycle) at pagkatapos ay ulitin ang parehong proseso. Ngayon, na naintindihan natin ang lohika ipaalam sa amin na pumasok sa programa.

Programming PIC16F8771A para sa Robotic Arm

Tulad ng palaging ang kumpletong programa na may isang Video ay maaaring matagpuan sa dulo ng pahinang ito, maaari ring mai-download ang code mula dito kasama ang lahat ng kinakailangang mga file. Sa seksyong ito tatalakayin namin ang lohika sa likod ng programa. Gumagamit ang programa ng module ng ADC, Timer Module at LCD Module upang makontrol ang Robotic Arm. Kung hindi mo alam kung paano gamitin ang mga tampok ng ADC o mga tampok na Timer o upang i-interface ang isang LCD na may PIC, maaari kang bumalik sa kani-kanilang mga link upang malaman ang mga ito. Ang paliwanag sa ibaba ay ibinigay na ipinapalagay na ang mambabasa ay pamilyar sa mga konseptong ito.

Pag-configure ng Timer 0 Port

Ang pinakamahalagang seksyon sa code ay ang pagtatakda ng Timer 0 sa labis na daloy para sa bawat tukoy na pagkaantala. Ang mga formula upang makalkula ang pagkaantala na ito ay maaaring ibigay bilang

Pagkaantala = ((256-REG_val) * (Prescal * 4)) / Fosc

Sa pamamagitan ng paggamit ng OPTION_REG at TMR0 rehistro naitakda namin ang Timer 0 upang mapatakbo na may prescalar na halaga na 32 at ang REG val ay nakatakda sa 248. Ang dalas ng kristal (Fosc) na ginamit sa aming hardware ay 20Mhz. Sa mga halagang ito ang pagkaantala ay maaaring makalkula bilang

Delay = ((256-248) * (32 * 4)) / (20000000) = 0.0000512 segundo (o) = 0.05 msec

Kaya't itinakda namin ang timer upang mag-overflow sa bawat 0.05ms. Ang code upang gawin ang pareho ay ibinibigay sa ibaba

/ ***** Configure ng Port para sa Timer ****** / OPTION_REG = 0b00000100; // Timer0 na may panlabas na freq at 32 bilang prescalar // Pinapagana din ang Pull UPs TMR0 = 248; // Load ang halaga ng oras para sa 0,0001s; ang delayValue ay maaaring nasa pagitan ng 0-256 lamang TMR0IE = 1; // Paganahin ang timer makagambala nang kaunti sa PIE1 rehistro GIE = 1; // Enable Global Interrupt PEIE = 1; // Paganahin ang Peripheral Interrupt / *********** ______ **** ***** /

Sa kabuuang 0ms hanggang 2ms control window ng servo motor maaari naming makontrol ito sa isang resolusyon na 0.05msec, na nagbibigay-daan sa amin na magkaroon (2 / 0.05) ng 40 magkakaibang posisyon para sa motor sa pagitan ng 0 degree hanggang 180 degree. Maaari mong bawasan pa ang halagang ito kung maaaring suportahan ito ng iyong MCU upang makakuha ng mas maraming posisyon at tumpak na kontrol.

Makagambala sa Rutin ng Serbisyo (ISR)

Ngayon na mayroon kaming Timer 0 na nakatakda sa higit na daloy para sa bawat 0.05ms, magkakaroon kami ng TMR0IF makagambala na flag na nakatakda sa 0.05ms. Kaya sa loob ng pag-andar ng ISR maaari naming i-reset ang watawat na iyon at dagdagan ang isang variable na tinatawag na bilang ng isa. Kaya ngayon ang variable na ito ay magiging pagtaas ng 1 para sa bawat 0.05ms.

Kinakalkula ang Ikot ng Duty at Sa Oras

Susunod kailangan nating kalkulahin ang duty cycle at sa oras para sa lahat ng limang servo motor. Mayroon kaming limang servo motor na ang bawat isa ay ginagamit upang makontrol ang indibidwal na seksyon ng braso. Kaya kailangan nating basahin ang halaga ng ADC ng lahat ng limang at kalkulahin ang cycle ng tungkulin at sa oras para sa bawat isa.

Ang halaga ng ADC ay nasa saklaw ng 0 hanggang 1024 na maaaring mai-convert sa 0% hanggang 100% na cycle ng tungkulin sa pamamagitan lamang ng pag-multiply ng 0.0976 (100/1024 = 0.0976) sa nakuha na halaga. Ang 0 hanggang 100% na cycle ng tungkulin na ito ay kailangang mai-convert sa ON time. Alam namin na sa 100% na cycle ng tungkulin ang ON time ay dapat na 2ms (para sa 180 degree) kaya ang pag-multiply ng 0.02 (2/100 = 0.02) ay magko-convert ng 0 hanggang 100 duty cycle sa 0 hanggang 2ms. Ngunit pagkatapos ang aming bilang ng variable ng timer ay nakatakda upang madagdagan nang isang beses para sa bawat 0.05ms. Nangangahulugan ito na ang halaga ng bilang ay 20 (1 / 0.05 = 20) para sa bawat 1ms. Kaya kailangan nating paramihin ang 20 na may 0.02 upang makalkula ang eksaktong oras para sa aming programa na magbibigay sa amin ng halagang 0.4 (0.02 * 20 = 0.4). Ang code para sa pareho ay ipinapakita sa ibaba, makikita mo itong paulit-ulit nang 5 beses para sa lahat ng 5 palayok gamit ang isang para sa loop. Ang mga nagresultang halaga ay nakaimbak sa T_ON array.

para sa (int pot_num = 0; pot_num <= 3; pot_num ++) { int Pev_val = T_ON; POT_val = (ADC_Read (pot_num)); // Basahin ang halaga ng POT gamit ang ADC Duty_cycle = (POT_val * 0.0976); // Map 0 to 1024 to 0 to 100 T_ON = Duty_cycle * 0.4; // 20 * 0.02

Pagpili kung aling motor ang paikutin

Hindi namin makontrol ang lahat ng limang mga motor na magkasama dahil gagawin nitong mabibigat na pagbagal ng ISR code ang buong microcontroller. Kaya kailangan nating paikutin lamang ang isang servo motor nang paisa-isa. Upang mapili kung aling servo ang paikutin ang microcontroller sinusubaybayan ang ON oras ng lahat ng limang servo motor at inihambing ito sa naunang oras. Kung mayroong isang pagbabago sa ON oras pagkatapos maaari naming tapusin na ang partikular na servo ay dapat ilipat. Ang code para sa pareho ay ipinapakita sa ibaba.

kung (T_ON! = Pev_val) { Lcd_Clear (); servo = pot_num; Lcd_Set_Cursor (2,11); Lcd_Print_String ("S:"); Lcd_Print_Char (servo + '0'); kung (pot_num == 0) {Lcd_Set_Cursor (1,1); Lcd_Print_String ("A:");} iba pa kung (pot_num == 1) {Lcd_Set_Cursor (1,6); Lcd_Print_String ("B:");} iba pa kung (pot_num == 2) {Lcd_Set_Cursor (1,11); Lcd_Print_String ("C:");} iba pa kung (pot_num == 3) {Lcd_Set_Cursor (2,1); Lcd_Print_String ("D:");} iba pa kung (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');

Nai-print din namin ang ikot ng servo duty sa LCD screen upang maalaman ng gumagamit ang kasalukuyang posisyon nito. Batay sa pagbabago sa ON time na na-update ang variable servo na may mga numero mula 0 hanggang 4 bawat isa na kumakatawan sa mga indibidwal na motor.

Pagkontrol sa Servo Motor sa loob ng ISR

Sa loob ng ISR mayroon kaming variable count na nakakakuha ng dagdag para sa bawat 0.05ms, nangangahulugan ito na para sa bawat 1ms ang variable ay madaragdagan ng 20. Gamit ito kailangan naming kontrolin ang mga pin upang makabuo ng PWM signal. Kung ang halaga ng bilang ay mas mababa kaysa sa oras sa gayon ang GPIO ng motor na iyon ay nakabukas gamit ang linya sa ibaba

PORTD = PORTD - servo_code;

Narito ang array servo_code ay may detalye ng pin ng lahat ng limang servo motor at batay sa halaga sa variable servo, gagamitin ang code para sa partikular na servo motor na iyon. Pagkatapos ito ay lohikal na O (-) na may mga umiiral na PORTD bits upang hindi namin makagambala ang mga halaga ng iba pang motor at i-update lamang ang partikular na motor na ito. Katulad nito para sa pag-off ng pin

PORTD = PORTD & ~ (servo_code);

Binaliktad namin ang halaga ng bit gamit ang logiko inverse (~) operator at pagkatapos ay nagsagawa ng isang operasyon na AT (&) sa PORTD upang i-off lamang ang nais na pin habang iniiwan ang iba pang mga pin sa kanilang dating estado. Ang kumpletong snippet ng code ay ipinapakita sa ibaba.

void interrupt timer_isr () { if (TMR0IF == 1) // Timer flag was been trigered dahil sa timer overflow -> itinakda sa overflow para sa bawat 0.05ms { TMR0 = 248; // Load the timer Halaga TMR0IF = 0; // Clear timer makagambala bilang ng flag ++; // Count increment by 1 para sa bawat 0.05ms -> bilang ay magiging 20 para sa bawat 1ms (0.05 / 1 = 20)) } int servo_code = {0b01000000, 0b00100000, 0b00010000, 0b00001000, 0b00000100}; kung (count> = 20 * 20) bilang = 0; kung (count <= (T_ON)) PORTD = PORTD - servo_code; iba pa PORTD = PORTD & ~ (servo_code); }

Alam namin na ang kabuuang siklo ay dapat tumagal ng 20ms bago muling buksan ang pin ng GPIO. Kaya't suriin namin kung ang bilang ay lumampas sa 20ms sa pamamagitan ng paghahambing ng halaga ng bilang sa 400 (parehong pagkalkula tulad ng tinalakay sa itaas) at kung oo kailangan nating isimulan ang bilang upang maging zero muli.

Simulation ng PIC Robotic Arm Code

Palaging mas mahusay na gayahin ang code bago dalhin ito sa totoong hardware. Kaya ginamit ko ang Proteus upang gayahin ang aking code at na-verify ito upang gumana nang tama. Ang circuit na ginamit para sa simulation ay ipinapakita sa ibaba, Gumamit kami ng isang oscilloscope upang suriin kung ang mga signal ng PWM ay nabubuo ayon sa kinakailangan. Maaari din naming mapatunayan kung ang LCD at Servo motors ay umiikot tulad ng inaasahan.

Tulad ng nakikita mo na ipinapakita ng LCD ang duty cycle ng motor D na 07 batay sa halaga ng palayok na kung saan ay ang ^3rd motor. Katulad kung ang isa pang palayok ay inilipat ang cycle ng tungkulin ng palayok na iyon at ang numero ng motor nito ay ipapakita sa LCD. Ang PWM signal na ipinapakita sa oscilloscope ay ipinapakita sa ibaba.

Ang kabuuang panahon ng pag-ikot ay sinusukat na 22.2ms gamit ang pagpipilian na cursor sa oscilloscope, na malapit sa nais na 20ms. Sa wakas natitiyak namin na gumagana ang code, kaya upang magpatuloy sa circuit maaari naming solder ito sa isang perf board o gumamit ng PCB. Hindi ito gagana nang madali sa breadboard sapagkat ang POT ay laging may posibilidad na magbigay ng ilang mga problema dahil sa hindi magandang koneksyon.

Disenyo ng PCB gamit ang EasyEDA

Upang idisenyo ang PIC Robotic Arm na ito, pinili namin ang online na tool ng EDA na tinatawag na EasyEDA. Matagal ko nang ginagamit ito ngayon at nahanap na napaka-maginhawa dahil sa malawak na pagkakaroon ng bakas ng paa at madaling gamitin ang kalikasan. Matapos ang pagdidisenyo ng PCB, maaari kaming mag-order ng mga sample ng PCB sa pamamagitan ng kanilang mga serbisyong paggawa ng mababang gastos sa PCB. Nag-aalok din sila ng serbisyong sourcing ng bahagi kung saan mayroon silang isang malaking stock ng mga elektronikong sangkap at ang mga gumagamit ay maaaring mag-order ng kanilang mga kinakailangang sangkap kasama ang order ng PCB.

Habang dinidisenyo ang iyong mga circuit at PCB, maaari mo ring gawing publiko ang iyong mga disenyo ng circuit at PCB upang ang ibang mga gumagamit ay maaaring kopyahin o mai-edit ang mga ito at maaaring makinabang mula sa iyong trabaho, ginawa rin naming pampubliko ang aming buong mga layout ng Circuit at PCB para sa circuit na ito, suriin ang link sa ibaba:

easyeda.com/circuitdigest/pic-development-board-for-robotic-arm

Gamit ang link na ito maaari mong direktang mag-order ng parehong PCB na ginagamit namin sa proyektong ito at gamitin ito. Kapag ang disenyo ay nakumpleto ang board ay maaaring matingnan bilang isang 3D na modelo na magiging napaka kapaki-pakinabang sa pag-visualize kung paano lilitaw ang board pagkatapos ng katha. Ang modelo ng 3D ng board na ginagamit namin ay ipinapakita sa ibaba. Bukod sa ito maaari mo ring tingnan ang tuktok at ilalim na layer ng board upang suriin kung ang slick screen ay inaasahan.

Pagkalkula at Pag-order ng Mga Sampol sa online

Matapos makumpleto ang disenyo ng PIC Robot PCB na ito, maaari kang mag-order ng PCB sa pamamagitan ng JLCPCB.com. Upang mag-order ng PCB mula sa JLCPCB, kailangan mo ng Gerber File. Upang ma-download ang mga Gerber file ng iyong PCB i-click lamang ang pindutang Bumuo ng Pabrika ng Pabrika sa pahina ng editor ng EasyEDA, pagkatapos ay i-download ang Gerber file mula doon o maaari kang mag-click sa Order sa JLCPCB tulad ng ipinakita sa larawan sa ibaba. Ire-redirect ka nito sa JLCPCB.com, kung saan maaari mong piliin ang bilang ng mga PCB na nais mong mag-order, kung gaano karaming mga layer ng tanso ang kailangan mo, ang kapal ng PCB, bigat ng tanso, at kahit ang kulay ng PCB, tulad ng snapshot na ipinakita sa ibaba:

Matapos mong mapili ang lahat ng mga pagpipilian, i-click ang "I-save sa Cart" at pagkatapos ay dadalhin ka sa pahina kung saan maaari mong i-upload ang iyong Gerber File na na-download namin mula sa EasyEDA. I-upload ang iyong Gerber file at i-click ang "I-save sa Cart". At sa wakas mag-click sa Checkout na Ligtas upang makumpleto ang iyong order, pagkatapos ay makukuha mo ang iyong mga PCB makalipas ang ilang araw. Ginagawa nila ang PCB sa napakababang rate na $ 2. Ang kanilang oras sa pagbuo ay napakaliit din na kung saan ay 48 na oras sa paghahatid ng DHL ng 3-5 araw, karaniwang makukuha mo ang iyong mga PCB sa loob ng isang linggo ng pag-order.

Matapos ang pag-order ng PCB, maaari mong suriin ang Production Progress ng iyong PCB na may petsa at oras. Suriin mo ito sa pamamagitan ng pagpunta sa pahina ng Account at mag-click sa "Pag-usad ng Production".

Matapos ang ilang araw ng pag-order ng PCB nakuha ko ang mga sample ng PCB sa magandang balot tulad ng ipinakita sa mga larawan sa ibaba.

At pagkatapos makuha ang mga piraso na ito ay nahinang ko ang lahat ng kinakailangang mga sangkap sa PCB. Direkta din akong naghinang ng POT sa halip na gumamit ng mga wires dahil ang babae sa mga babaeng wires na una kong ginamit kung saan nagbibigay ng kakaibang mga analog output voltages marahil dahil sa mga maluwag na contact. Sa sandaling ang lahat ng mga sangkap ay tipunin ang aking PCB ay ganito ang hitsura.

Maaaring napansin mo na mayroon lamang isang 7805 sa pisara na ito. Iyon ay dahil sa una ay naisip kong makakakuha ako ng malayo sa regulator lamang para sa pagpapatakbo ng parehong PIC at servo motor at kalaunan ay napagtanto kong kailangan ko ng dalawa. Kaya gumamit ako ng isang panlabas na circuit upang mapatakbo ang mga motor ng servo sa pamamagitan ng mga berdeng wires na nakikita mo rito.

Gayunpaman hindi mo kailangang mag-alala tungkol dito dahil; Ginawa ko na ang mga pagbabago sa PCB ngayon. Maaari mong magamit ang binagong PCB at maghinang ng parehong mga regulator sa board mismo.

Paggawa ng PIC Robotic Arm

Matapos ang lahat ng nakakapagod na trabaho oras na para magbayad. Solder ang lahat ng mga bahagi sa board at i-upload ang programa sa PIC controller. Ang kumpletong Code ay ibinibigay sa ibaba o maaaring ma-download mula dito. Ang konektor ng programa na ibinigay sa board ay dapat makatulong sa iyo na i-upload ang programa nang direkta gamit ang Pickit 3 nang walang gaanong abala. Kapag na-upload na ang programa dapat mong makita ang LCD na nagpapakita ng servo na kasalukuyang kinokontrol. Upang matuto nang higit pa tungkol sa pag-program ng PIC Microcontroller, sundin lamang ang nakaraang tutorial.

Mula doon maaari mo lamang buksan ang palayok at suriin kung paano tumugon ang mga servo motor sa bawat potensyomiter. Kapag naintindihan mo ang format maaari mong kontrolin ang robotic arm upang maisagawa ang anumang pagkilos na kailangan mo upang maisagawa at magsaya. Mahahanap mo ang kumpletong pagtatrabaho ng proyekto sa naka- link na video sa ibaba.

Iyon ang pag-asa ng mga lalaki na naiintindihan mo ang proyekto at may natutunan na bago mula rito. Kung mayroon kang anumang mga katanungan iwanan ang mga ito sa seksyon ng komento o gamitin ang mga forum para sa iba pang mga teknikal na talakayan.