Magmaneho ng isang Stepper Motor Na May isang AVR Microprocessor: 8 Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:15

Nakakuha ba ng ilang na-scaven na stepper motor mula sa mga printer / disk drive / atbp na nakahiga?

Ang ilang mga pagsisiyasat sa isang ohmeter, na sinusundan ng ilang simpleng driver code sa iyong microprocessor at ikaw ay hakbang sa istilo.

Hakbang 1: Kilalanin ang Mga Stepper

Talaga, kakailanganin mong alamin kung saan pupunta ang lahat ng mga maliit na wires.

Ang unang hakbang ay upang malaman kung ito ay isang unipolar o bipolar motor. Tingnan ang Jones on Steppers para sa ilang mas malalim na background, pagkatapos sa Ian Harries 'Site para sa isang simpleng pamamaraan upang malaman ang isang hindi kilalang motor. Magbasa nang kaunti, pagkatapos ay sumali sa akin sa isang walkthrough ng motor na ito na nakuha ko para sa murang. (Nabebenta ang mga ito sa halagang $ 0.99 ngayon. Maliit sila, medyo magaan, ngunit walang gaanong metalikang kuwintas. Hindi mo alam kung ano ang makakabuti nito.)

Hakbang 2: Maghanap ng Karaniwang Lupa

Kaya mayroon kang limang (o apat, o anim) na mga wire. Ang iyong motor ay magkakaroon ng dalawang halves, at maaari mo ring masabi sa pamamagitan lamang ng pagtingin sa aling panig ang pag-aari ng bawat kawad.

Kung ang pagtingin mo lamang sa apat na mga wire, swerte ka - ito ay isang bipolar motor. Ang kailangan mo lang gawin ay alamin kung aling dalawang pares ng mga wires ang magkakasama. Kung mayroon kang isang unipolar motor, o higit sa 4 na mga wire, kakailanganin mong masira ang iyong ohmeter. Ang hinahanap mo ay ang karaniwang (ground) wire para sa bawat kalahati. Maaari mong sabihin kung alin ang ground sa isang bipolar motor dahil mayroon itong kalahati ng paglaban sa alinman sa mga poste kaysa sa mga poste sa kanilang sarili. Ang larawan ay ang aking mga tala mula sa pag-hook ng mga wire sa mga wire at pagpuna sa paglaban (o kung konektado man sila). Maaari mong makita na ang White ay ang lupa para sa ilalim ng trio b / c mayroon itong kalahati ng paglaban sa Red o Blue na mayroon sila sa bawat isa. (Kakaiba ang motor na ito at walang gitnang tapik sa tuktok na magnet coil. Para itong half-bipolar, half-unipolar. Marahil ay maaari mo itong magamit upang makaramdam ng pag-ikot sa Red-White-Blue coil kapag ang Black-Yellow ang coil ay hinihimok.)

Hakbang 3: Alamin ang Hakbang sa Hakbang

Dadalhin ko ang motor na ito bilang isang bipolar, kaya hindi ko pinapansin ang White ground wire. Mayroon lamang akong apat na wires upang magalala.

Maaaring gusto mong patakbuhin ang iyong unipolar motor bilang bipolar pa rin, dahil ginagamit nito ang buong likaw sa parehong mga phase sa halip na magpalitan-lipat sa pagitan ng dalawang halves ng bawat likaw. Higit pang coil = mas maraming metalikang kuwintas. Patakbuhin ang kasalukuyang sa pamamagitan ng isang pares (pagpuna sa polarity na iyong pinili) at pagkatapos ay patakbuhin ang kasalukuyang sa pamamagitan ng iba pang pares nang sabay. Kapag na-hook mo ang ikalawang pares, panoorin kung aling paraan ang motor ay lumiliko. Isulat ito Ngayon baligtarin ang polarity sa unang pares na iyong pinili. Pagkatapos ay i-hook muli ang pangalawang pares sa kanilang polarity na baligtad din. Tandaan ang direksyon. Mula dito dapat mong malaman ang pagkakasunud-sunod para sa pag-ikot ng motor sa alinmang direksyon. Sa aking halimbawa, kapwa nagtapos sa pagliko ng pakaliwa, kaya ang pagtahak sa pagkakasunud-sunod sa parehong paraan na pinili ko ay tatahakin ang motor CCW.

Hakbang 4: Pagkuha ng Motor para sa isang Test Drive

Kung hindi ka pa nakakasangkapan para sa microprocessor programming, maaari kang gumawa ng mas masahol kaysa sa Ghetto Development Kit o alinman sa iba't ibang mga programmer ng PIC. I-hook up ang mga wire nang direkta hanggang sa iyong microproc at sunugin ito sa sumusunod na code:

/ * Nagpe-play sa pagkuha ng maliit na stepper motor na hinimok. * /

/ * Isama ang pagpapaandar na pagkaantala * / # tukuyin ang F_CPU 1000000UL # isama / * I-pin ang mga def para sa ATTiny2313 * / / * Clockwise order * / #define BLUE _BV (PB0) #define BLACK _BV (PB1) #define RED _BV (PB2) #define YELLOW _BV (PB3) # tukuyin ang PAG-ADLAY ng 200 / * milliseconds sa pagitan ng mga hakbang * / int main (walang bisa) {DDRB = 0xff; / * Paganahin ang output sa lahat ng mga B pin * / PORTB = 0x00; / * Itakda silang lahat sa 0v * / habang (1) {/ * pangunahing loop dito * / PORTB = BLUE; _delay_ms (TANGGULIN); PORTB = BLACK; _delay_ms (TANGGULIN); PORTB = PULA; _delay_ms (TANGGULIN); PORTB = DILAW; _delay_ms (TANGGULIN); }} Gaano kadali ang code na iyon? Talagang simple. Ang ginagawa lamang nito ay ang paggawa ng ilang magagandang kahulugan upang maaari akong mag-refer sa mga wire sa pamamagitan ng kulay kaysa sa kanilang mga pin-name, at pagkatapos ay i-onggle ang mga ito sa pagkakasunud-sunod na may isang madaling iakma na pagkaantala sa pagitan. Para sa mga nagsisimula, pumili ako ng kalahating segundong pagkaantala sa pagitan ng mga hakbang. Tingnan ang maikling video para sa mga resulta. Kung talagang nasa laro ka, bilangin ang bilang ng mga hakbang bawat pag-ikot upang malaman ang solong-hakbang na resolusyon ng angular na motor. (Oh yeah. PS. Nagmamaneho na walang pag-load nang 3.6v madali. Tingnan ang baterya sa video.)

Hakbang 5: Pag-ugoy Ito Balik-Balik

Kaya't nakuha mo itong tumatakbo nang pakanan. May mas nakakainteres pa ba? Isang maliit na paglilinis ng code, at maaari nating itong patakbuhin pabalik-balik. Inilagay ko ang sunud-sunod na pagkakasunud-sunod sa isang array upang maaari mong hakbang sa pamamagitan ng mga phase na may isang simpleng para sa loop. Ngayon ay maaari mong patakbuhin ang loop pataas o pababa upang pumunta sa pakanan o pakaliwa.

int main (walang bisa) {const uint8_t pagkaantala = 50; const uint8_t pakaliwa = {BLUE, BLACK, RED, YELLOW}; uint8_t i; DDRB = 0xff; / * Paganahin ang output sa lahat ng mga B pin * / PORTB = 0x00; / * Itakda ang lahat sa 0v * / habang (1) {/ * pangunahing loop dito * / para sa (i = 0; i <= 3; i ++) {/ * hakbangin ang mga kulay na pakaliwa * / PORTB = pakanan ; _delay_ms (pagkaantala); } para sa (i = 3; i> = 0; i -) {/ * hakbangin ang mga kulay na ccw * / PORTB = pakanan ; _delay_ms (pagkaantala); }}} Tingnan ang racy na video para sa back-and-forthing.

Hakbang 6: Hindi Ako Half-step, Dahil Hindi Ako Half-stepper…

Tumabi sa liriko ng paghahanap, kalahating hakbang ng iyong motor ay naroroon. Nakakakuha ka ng mas kasalukuyang rurok, mas madalian na metalikang kuwintas, at dalawang beses ang angular na resolusyon. Half-stepping in a nutshell: Sa halip na Blue, Black, Red, Yellow, hinihimok mo ang motor na may Blue, Blue + Black, Black, Black + Red, Red, Red + Yellow, Yellow, Yellow + Blue. Ang upshot ay iyon sa kalahati ng oras na umaakit ka ng parehong mga magnet nang sabay-sabay. At sa mga oras na ang parehong mga set ay nakikibahagi, ang motor point sa pagitan ng dalawa, pinaliit ang anggulo sa pagitan ng "mga hakbang" at ginagawang mas maayos ang pag-on ng motor. Maaari mo bang sabihin mula sa video? Hindi ako sigurado … Ngayon ang bahagi ng code na ginagawa ang kalahating hakbang na ganito:

walang bisa ang HalfStepping (uint16_t pagkaantala, uint8_t direksyon ) {uint8_t i; para sa (i = 0; i <= 3; i ++) {PORTB = direksyon ; / * single-coil part * / _delay_ms (pagkaantala); PORTB | = direksyon [i + 1]; / * idagdag sa kalahating hakbang * / _delay_ms (antala); }} Ang unang utos ng PORTB ay nagtatakda ng isang solong poste sa positibo at lahat ng iba ay negatibo. Tapos naghihintay ito. Pagkatapos ang pangalawang utos ng PORTB ay nagtatakda ng isang pangalawang poste (sa kabilang paikot-ikot) sa positibo, umaakit sa parehong paikot-ikot para sa 1.4x na metalikang kuwintas (at 2x ang kasalukuyang). Ang isang buong listahan ng programa ay nakakabit sa ibaba. Ang dalawang mga pag-array ay tinukoy na ngayon (pakaliwa, pakaliwa) at parehong may 5 mga elemento bawat isa upang payagan ang i + 1 na entry sa halfStepping function.

Hakbang 7: Magdagdag ng isang Motor Driver

Sa ngayon napakahusay.

Ang problema lamang ay ang motor ay tila walang lahat ng labis na metalikang kuwintas, na maaaring sanhi ng ang katunayan na ang microprocessor ay ilalagay lamang ~ 50mA bawat pin. Ang halata na susunod na hakbang ay ang mai-hook ito sa isang driver ng motor upang maihatid ito ng mas maraming katas. Ngunit pagkatapos ay isang maliit na pag-iisip ': Nagmamaneho lamang ako ng 5v, at ang paglaban ng coil-winding ay ~ 125 ohms. Na nangangahulugang ang pagguhit lamang ng motor na 40mA bawat pin, at dapat itong hinimok na mabuti lamang sa (masigla!) AVR chip. Kaya upang makakuha ng mas maraming boltahe sa pagmamaneho ng motor, isinabit ko ito sa isang SN754410 H-bridge chip. Ang circuit ay medyo simple. Ang bawat pin mula sa AVR ay papunta sa isang input, at ang mga kaukulang output pin ay pupunta sa motor. Ang maliit na tilad ay nangangailangan ng 5v para sa seksyon ng lohika, at maaaring tumagal ng mas maraming boltahe sa seksyon ng motor. Ang pagpapatakbo nito sa 11.25v (tatlong 3.6v na baterya) ay nakatulong nang kaunti. Kapansin-pansin na mas maraming metalikang kuwintas sa aking daliri, ngunit hindi pa rin ito isang powerhouse. Hindi masama para sa isang motor na mas maliit kaysa sa isang nikelado, bagaman. At ngayon ang circuit ay naging isang pangkalahatang-layunin bipolar stepper motor driver. Idinagdag Nov 29: Patakbuhin ang motor kagabi sa 12v para sa isang sandali at nagsimula itong maging mainit. Hindi ako sigurado kung ito ay isang resonant na problema sa dalas o kung ito ay simpleng labis na kasalukuyang para sa mga paikot-ikot. Alinmang paraan, maging medyo maingat kung nagmamaneho ka ng maliit na motor na ito na may mas malalaking boltahe.

Hakbang 8: Ang Wakas

Kaya ano ang natutunan ko? Ang pagmamaneho ng isang stepper motor na may isang AVR (at isang H-bridge chip) ay medyo madali, kahit na sa "magarbong" kalahating hakbang na mode.

Hindi sigurado kung ano ang gagawin ko sa mga maliit na stepper motor ngayon, bagaman. May mga mungkahi ba?