Itinulak ang Menu ng Pagkontrol ng Bilis ng Stepper para sa Arduino: 6 na Hakbang

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

Ang aklatan ng SpeedStepper na ito ay isang muling pagsulat ng aklatan ng AccelStepper upang payagan ang kontrol ng bilis ng stepper motor. Hinahayaan ka ng library ng SpeedStepper na baguhin ang itinakdang bilis ng motor at pagkatapos ay mapabilis / mabagal sa bagong hanay ng bilis gamit ang parehong algorithm bilang aklatan ng AccelStepper. Pinapayagan ka rin ng aklatan ng SpeedStepper na magtakda ng plus at minus na limitasyon at isang posisyon na 'bahay'. Mayroong isang utos ng goHome na bumalik sa posisyon ng bahay.

Mga Limitasyon: Ang library ng SpeedStepper ay naghahimok lamang ng direksyon at mga hakbang na output at sa gayon ay kailangang ma-konektado sa isang driver ng motor, tulad ng Easy Driver, upang aktwal na himukin ang stepper motor. Nagbibigay ang aklatan ng AccelStepper ng higit pang mga pagpipilian sa pagmamaneho na maaaring makopya sa aklatan na ito kung kinakailangan.

Ang tatlong mga halimbawa ng sketch ay ibinigay, ang bawat isa ay maaaring patakbuhin nang walang motor o driver ng motor. Nag-isyu ang speedStepperPlot sketch ng halimbawa ng mga utos ng bilis at ang goHome na utos at bumubuo ng isang balangkas ng nagresultang bilis at posisyon. Ang speedStepperSetup sketch ay nagbibigay ng isang menu na hinimok ng setup upang maitakda ang bahay ng motor at limitasyon at pagkatapos ay patakbuhin ang motor at ayusin ang bilis pataas at pababa at goHome upang matapos. Ang speedStepperProfile sketch ay nagpapakita ng isang halimbawa ng pagse-set up at pagpapatupad ng isang profile ng bilis.

Habang ang aklatan ng AccelStepper ay nagbibigay ng mahusay na kontrol sa posisyon, kinakailangan ang kontrol sa bilis para sa Prototype Ice-Melting Probe para sa Pagkolekta ng Mga Sampol na Biyolohikal sa Europa. Narito ang isang video ng isang naunang bersyon ng prototype, na gumamit ng timbang sa halip na isang motor. Nagdagdag ang rebisyon ng 1.1 ng mga profile ng bilis matapos ang isang gumagamit na humiling ng isang paraan para sa pagkontrol sa profile ng bilis ng isang bomba.

Ang library na ito ay tumatakbo sa Arduino Uno at Mega2560, ngunit para sa prototype isang mas malaking memorya / mas mabilis na processor na SparkFun Redboard Turbo ang ginamit.

Ang itinuturo na ito ay magagamit din online sa Stepper Speed Control Library para sa Arduino

Mga gamit

Upang patakbuhin ang halimbawa ng mga sketch lamang ng isang Arduino UNO o Mega2560 at kailangan ng mga library ng software

Para sa pagsubok sa bench ng silid-aklatan isang SparkFun Redboard Turbo ang ginamit sa isang Easy Driver, isang 200 hakbang / rev, 12V 350mA stepper motor at isang 12 DC supply 2A o mas malaki, hal. https://www.sparkfun.com/products/14934. USB A hanggang Micro cableUSB sa TTL Serial CableArduino IDE V1.8.9 at isang computer upang patakbuhin ito. SpeedStepper librarypfodParser library para sa nonBlockingInput at pfodBufferedStream na klase millisDelay library para sa mga hindi pagka-block na pagkaantala

Hakbang 1: Mga Pag-andar sa Library

Pinapatakbo ng library ng SpeedStepper ang stepper motor na limitado sa pamamagitan ng mga hangganan na itinakda ng library. Tingnan ang SpeedStepper.h file para sa iba't ibang mga pamamaraan ng library na magagamit. Narito ang isang balangkas ng lohika sa likod nila.

Ang posisyon ng stepper ay sinusubaybayan sa pamamagitan ng pagbibilang ng bilang ng mga hakbang (pulso). Nililimitahan ng library ang posisyon na nasa pagitan ng mga posisyon ng setPlusLimit (int32_t) at setMinusLimit (int32_t). Ang plus limit ay palaging> = 0 at ang minus limit ay palaging <= 0. Sa pagsisimula ang posisyon ng motor ay 0 (home) at ang mga limitasyon ay nakatakda sa napakalaking mga numero +/- (mga +/- 1e9 na mga hakbang). itinakda ng setAcceleration (float) kung gaano kabilis ang motor ay magbabago ng bilis alinman pataas o pababa. Habang papalapit ang motor sa plus o minus na limitasyon ay magpapabagal sa rate na ito hanggang sa huminto sa limitasyon. Sa pagsisimula up ang pagpabilis ay nakatakda sa 1.0 mga hakbang / sec / sec. Ang setting ng pagpabilis ay palaging isang numero ng + ve. Ang tanda ng setting ng setSpeed (float) ay nagtatakda ng direksyon na lilipat ng motor.

Ang setSpeed (float) ay nagtatakda ng bilis upang mapabilis / mabawasan ang motor, mula sa kasalukuyang bilis. Ang bilis na maitatakda sa pamamagitan ng setSpeed (float) ay limitado, sa ganap na halaga, sa pamamagitan ng mga setting, setMaxSpeed (float), default na 1000 mga hakbang / sec at setMinSpeed (float), default na 0.003 na mga hakbang / sec. Ang mga default na ito ay din ang absolute hard coded speed limit na tatanggapin ng library para sa setMaxSpeed () at setMinSpeed (). Kung nais mong magtakda ng isang max bilis> 1000 mga hakbang / sec kailangan mong i-edit ang unang linya sa SpeedStepper.cpp file upang baguhin ang maxMaxSpeed (1000) sa max na bilis na gusto mo. Sa pagsasanay ang maximum na bilis ay limitado rin sa pamamagitan ng oras sa pagitan ng mga tawag sa run () na pamamaraan ng library. Para sa 1000 mga hakbang / sec ang run () na pamamaraan ay dapat tawaging hindi bababa sa bawat 1mS. Tingnan ang seksyon ng Latency sa ibaba.

Ang pagsubok na magtakda ng isang bilis na mas mababa sa min bilis ay magiging sanhi ng paghinto ng motor. Ang bawat isa sa mga setting na ito ay may kaukulang getter, tingnan ang SpeedStepper.h file. Para sa bilis, ibabalik ng getSetSpeed () ang bilis na itinakda mo sa pamamagitan ng setSpeed (), habang ang getSpeed () ay nagbabalik ng kasalukuyang bilis ng motor na nag-iiba habang pinapabilis nito / nababawasan ang itinakda mong bilis. Kung ang motor ay hindi papunta sa direksyon na naisip mo ng isang ve maaari kang tumawag sa invertDirectionLogic () upang ipagpalit ang direksyon na gumagalaw ang motor para sa mga bilis ng.

getCurrentPosition () ay nagbabalik ng kasalukuyang posisyon ng motor kumpara sa 'home' (0). Maaari mong i-override ang kasalukuyang setting ng posisyon ng motor saCurrentPosition (int32_t). Ang bagong posisyon ay limitado sa loob ng itinakdang mga limitasyong plus / minus.

Pauna ang motor ay tumigil sa posisyon 0. Ang pagtawag sa setSpeed (50.0) ay magiging sanhi nito upang simulan ang pagbilis sa direksyon ng + ve sa isang maximum na bilis ng 50 mga hakbang / min. Ang pagtawag sa hardStop () ay agad na titigil sa motor kung nasaan ito. Sa kabilang banda ang pagtawag sa stop () na pamamaraan ay magtatakda ng bilis sa zero at magpapabilis ng motor sa isang hintuan. Ang pagtawag sa stopAndSetHome () ay hihinto kaagad ang motor at itatakda ang posisyon nito sa 0. Ang mga halaga ng plus / minus na limitasyon ay hindi binago ngunit ngayon ay tinutukoy sa bagong posisyon na 0 (tahanan) na ito. Ang pagtawag sa goHome () ay ibabalik ang stepper sa posisyon na 0 (home) na ito at titigil. Ang pagtawag sa setSpeed () ay makakansela sa pag-uwi.

Nagbibigay din ang library ng SpeedStepper ng kontrol sa bilis ng profile sa pamamagitan ng mga pamamaraan na setProfile (SpeedProfileSonstr * profileArray, size_t arrayLen), startProfile (), stopProfile (), upang makagambala sa isang tumatakbo na profile, at isProfileRunning (). Tingnan ang speedStepperProfile halimbawa ng sketch.

Hakbang 2: Pagpapatakbo ng Halimbawa ng SpeedStepperPlot Nang Walang Motor

I-install ang Arduino IDE V1.8.9I-download at i-install ang SpeedStepper library I-save ang SpeedStepper.zip at pagkatapos ay gamitin ang item ng menu ng Arduino IDE na Sketch → Isama ang Library → Idagdag. Library ng ZIP upang mai-import ang library I-download at i-install din ang millisDelay library

Buksan ang Mga Halimbawa → SpeedStepper → speedStepperPlot halimbawa ng sketch (I-restart ang IDE kung kinakailangan). Ang sketch na ito ay na-configure upang gumana sa Serial, hal. UNO at Mega atbp Para sa pagtakbo sa SparkFun Redboard Turbo tingnan sa ibaba.

Walang driver board o stepper motor ang kailangang magpatakbo ng halimbawang ito. Ang mga halimbawang ito ay gumagamit ng D6 at D7 bilang mga output. Maaari mong baguhin ang mga output pin sa anumang digital na output sa pamamagitan ng pagbabago ng mga setting ng STEP_PIN at DIR_PIN na malapit sa tuktok ng sketch.

I-upload ang sketch upang sumakay at pagkatapos ay buksan ang Tools → Serial Plotter sa 115200 baud upang ipakita ang balangkas ng bilis (RED) at posisyon (BLUE) Ang plus limit ay nakatakda sa 360 na sanhi ng bilis ng rampa sa zero mula sa halos 100 point sa x-axis. Ang limitasyong minus ay -510. Humihinto ang posisyon sa ~ -390 sapagkat ang bilis ay hiniling sa 0.0. Ang sa 380 point sa x-axis, ang goHome cmd ay inisyu na nagbabalik sa stepper sa posisyon na zero.

Ang sketch ng speedStepperPlot na ito ay gumagamit ng millisDelays sa paglipat ng oras sa pagitan ng iba't ibang mga bilis at acceleration. Sa maraming mga kaso ng paggamit ng isang SpeedStepperProfile, tulad ng sa susunod na halimbawa, ay mas simple.

Hakbang 3: Pagpapatakbo ng Halimbawa ng SpeedStepperProfile Nang Walang Motor

Buksan ang Mga Halimbawa → SpeedStepper → speedStepperPlot halimbawa ng sketch, ang sketch na ito ay gumagawa ng balangkas sa itaas gamit ang Arduino Serial Plotter at isang halimbawa ng pagpapatakbo ng isang iniresetang profile ng bilis halimbawa kung nagpapatakbo ng isang bomba.

Ang Stepper Speed Profiles ay binubuo ng isang hanay ng SpeedProfileSonstr, na tinukoy sa file ng SpeedStepper.h.

struct SpeedProfileSonstr {

bilis ng float; // ang bilis ng target sa pagtatapos ng hakbang na ito na hindi naka-sign ng mahabang deltaTms; // ang oras upang mapabilis mula sa kasalukuyang bilis (sa simula ng hakbang na ito) hanggang sa target na bilis};

Tukuyin ang isang hanay ng SpeedProfileStrip na naglalaman ng bilis ng target para sa bawat hakbang at oras, ang deltaTms, sa mS, upang maabot ang bilis ng target mula sa nakaraang bilis ng target. Kung ang deltaTms ay zero o napakaliit, kung gayon ang bilis ay tatalon kaagad sa bagong bilis ng target. Kung hindi man, ang kinakailangang pagpabilis ay makakalkula sa setAcceleration () ay tatawag na susundan ng isang tawag sa setSpeed () para sa bagong bilis ng target. Sa lahat ng mga kaso ang profile ay malilimitahan ng umiiral na mga limitasyon sa plus at minus na posisyon at mga setting ng bilis ng max / min. Kung nais mong hawakan ang isang bilis, ulitin lamang ang dating bilis sa oras na nais mong gaganapin. Dahil ang bagong bilis ng target ay kapareho ng kasalukuyang bilis, ang kinakalkula na pagpabilis ay magiging zero at, walang pagbabago ay nangyayari ang bilis.

Ang array na ito ng SpeedProfileSonstr ay gumawa ng balangkas sa itaas

const SpeedProfileSonstr profile = {{0, 0}, // huminto kaagad kung hindi pa tumitigil sa {0, 1000}, // hold zero for 1sec {-50, 0}, // jump to -50 {-200, 2000}, // ramp to -200 {-200, 6000}, // hold at -200 for 6sec {-50, 2000}, // ramp down to -50 {0, 0}, // // immeadiately stop {0, 1500}, // hold zero for 1.5sec {50, 0}, // jump to 50 {200, 2000}, // ramp to 200 {200, 6000}, // hold 200 for 6 sec {50, 2000}, // ramp hanggang 50 {0, 0}, // // immeadiately ihinto {0, 1000} // hold zero // para sa plotting output}; const size_t PROFILE_LEN = sizeof (profile) / sizeof (SpeedProfileSonstr); // kalkulahin ang laki ng array ng profile

Ang profile ay itinakda sa pamamagitan ng pagtawag sa setProfile (SpeedProfileSonstr * profileArray, size_t arrayLen) hal. stepper.setProfile (profile, PROFILE_LEN);

Kapag na-set ang profile, tawagan ang startProfile () upang simulang patakbuhin ito mula sa kasalukuyang bilis ng motor (karaniwang magsisimula ka mula sa pagtigil). Sa pagtatapos ng profile, ang motor ay magpapatuloy lamang sa pagpapatakbo sa huling bilis ng target. Ang pamamaraan ng isProfileRunning () ay maaaring tawagan upang makita kung tumatakbo pa rin ang profile. Kung nais mong ihinto ang profile nang maaga maaari kang tumawag sa stopProfile () na iiwan ang profile at ihinto ang motor.

Hakbang 4: Pagpapatakbo ng Halimbawa ng SpeedStepperSetup Nang Walang Motor

Ang halimbawa ng sketch ay idinisenyo sa isang mga base para sa iyong sariling application ng stepper motor. Nagbibigay ito ng isang interface na hinimok ng menu na nagbibigay-daan sa iyo upang lumipat sa motor sa posisyon ng bahay nito, kung wala pa doon at pagkatapos ay opsyonal na i-reset ang mga limitasyon ng plus at minus at pagkatapos ay patakbuhin ang motor sa loob ng saklaw na iyon. Pinapayagan ka ng menu na 'run' na dagdagan at bawasan ang bilis, mag-freeze sa kasalukuyang bilis, huminto at bumalik din sa bahay.

Ang sketch na ito ay naglalarawan ng isang bilang ng mga tampok sa software na panatilihin ang loop () na tumutugon sa gayon maaari mong idagdag ang iyong sariling mga input ng sensor upang makontrol ang stepper. Tumatagal ng kirot upang maiwasan ang mga pagkaantala na makagambala sa kontrol ng bilis. (Tingnan ang Mga pagkaantala ay Masama)

I-install ang mga library na ginamit para sa pagpapatakbo ng SpeedStepperPlot, sa itaas, at pagkatapos ay i-install din ang pfodParser library. Ang library ng pfodParser ay nagbibigay ng mga klase sa NonBlockingInput at pfodBufferedStream na ginagamit upang hawakan ang input ng user at output ng menu na may pag-block sa loop () mula sa pagtakbo.

Buksan ang Mga Halimbawa → SpeedStepper → halimbawa ng speedSpeedSetup. Ang sketch na ito ay na-configure upang gumana sa Serial, hal. UNO at Mega atbp Para sa pagtakbo sa SparkFun Redboard Turbo tingnan sa ibaba.

Walang driver board o stepper motor ang kailangang magpatakbo ng halimbawang ito. Ang mga halimbawang ito ay gumagamit ng D6 at D7 bilang mga output. Maaari mong baguhin ang mga output pin sa anumang digital na output sa pamamagitan ng pagbabago ng mga setting ng STEP_PIN at DIR_PIN na malapit sa tuktok ng sketch. I-upload ang sketch sa board at pagkatapos buksan ang Tools → Serial Monitor sa 115200 upang makita ang menu ng SETUP.

SETUP pos: 0 sp: 0.00 + Lim: 500000 -Lim: -500 LATENCY: stepper: 492uS loop: 0uS p - set Home l - set limit h - goHome r - run>

Kapag ang sketch ay nagpapatakbo ng kasalukuyang posisyon ng stepper ay kinuha bilang 'home' (0) na posisyon. Kung kailangan mong muling iposisyon ang stepper sa totoong posisyon na 'home' nito, ipasok ang p command upang maipakita ang SET HOME menu

SET HOME pos: 0 sp: 0.00 + Lim: 1073741808 -Lim: -1073741808 LATENCY: stepper: 752uS loop: 3852uS x - setHome here and exit + - Forward - - Reverse s - swap Forward / Reverse - hardStop >

Tulad ng nakikita mo ang mga limitasyong naka-code sa sketch ay tinanggal upang maaari mong muling iposisyon ang stepper kahit saan. Kailangan mong mag-ingat hindi mo ito ihahatid sa mga limitasyong pisikal o baka masira mo ang isang bagay.

Gamitin ang + cmd upang simulang ilipat ang stepper pasulong, kung nakita mo itong gumagalaw sa maling direksyon ipasok ang isang hindi utos o isang walang laman na linya lamang upang ihinto ito at pagkatapos ay gamitin ang scommand upang ipagpalit ang direksyon ng Ipasa. Dapat mong i-update ang sketch upang isama ang isang tawag sa invertDirectionLogic () sa pag-setup upang ayusin ito para sa susunod na pagtakbo.

Gamitin ang + / - cmds upang iposisyon ang stepper sa tamang zero na posisyon. Ang motor ay nagsisimula nang mabagal at pagkatapos ay bumubuo ng bilis habang nagpapatuloy, gamitin lamang at walang laman na linya upang ihinto ito. Ang maximum na bilis para dito at ang menu ng mga limitasyon ay itinatakda ng MAX_SETUP_SPEED sa tuktok ng setupMenus.cpp.

Kapag ang motor ay nakaposisyon sa posisyon na 'home', gamitin ang x cmd upang muling itakda ang kasalukuyang posisyon bilang 0 at bumalik sa menu ng SETUP.

Kung kailangan mong itakda ang mga limitasyon, karaniwang ang sa paunang pag-setup lamang, gamitin ang l cmd upang ipasok ang menu na SET LIMITS

SET LIMITS pos: 0 sp: 0.00 + Lim: 1073741808 -Lim: -1073741808 LATENCY: stepper: 944uS loop: 5796uS l - setLimit here + - Forward - - Reverse h - goHome x - exit - hardStop>

Gamitin ang + cmd upang higit na pasulong sa plus limit at pagkatapos ay gamitin ang l cmd upang maitakda ito bilang plus limit. Ang h command ay maaaring magamit upang bumalik sa 0 at ang - cmd gamitin upang ilipat kung igalang sa posisyon ang motor sa minus limit. Muli gamitin ang l cmd upang maitakda ang minus limit. Tandaan ang mga posisyon ng mga limitasyon ng plus at minus at i-update ang setPlusLimit na paraan ng pag-set up () at setMinusLimit na pahayag sa mga halagang ito.

Kapag itinakda ang mga limitasyon gamitin ang x cmd upang bumalik sa menu ng SETUP at pagkatapos ay maaari mong gamitin ang r cmd upang buksan ang RUN menu

RUN MENU pos: 0 sp: 3.31 + Lim: 500000 -Lim: -500 LATENCY: stepper: 944uS loop: 5796uS + - Speed up - - Speed down h - goHome. - hardStop - Freeze Speed> + pos: 4 sp: 9.49 + Lim: 500000 -Lim: -500 LATENCY: stepper: 792uS loop: 5664uS pos: 42 sp: 29.15 + Lim: 500000 -Lim: -500 LATENCY: stepper: 792uS loop: 5664uS pos: 120 sp: 49.09 + Lim: 500000 -Lim: -500 LATENCY: stepper: 792uS loop: 5664uS pos: 238 sp: 69.06 + Lim: 500000 -Lim: -500 LATENCY: stepper: 792uS loop: 5664uS

Ang + cmd ay nagsisimulang bumilis sa pasulong na direksyon at i-print ang posisyon at bilis bawat 2 segundo. Kapag naabot ng motor ang bilis na nais mo maaari mong ihinto ang bilis ng anumang iba pang key (o isang walang laman na input). Maaari mong bawasan ang bilis gamit ang - cmd pababa upang tumigil. Kung itinigil ang - cmd ay magpapabilis sa kabaligtaran.

Nagbibigay ang RUN menu na ito ng manu-manong kontrol sa iyong proyekto. Para sa awtomatikong kontrol kakailanganin mong magdagdag ng ilang iba pang mga sensor.

Hakbang 5: Latency

Ang kontrol ng stepper motor ay nakasalalay sa software na namumuno sa bawat hakbang. Upang mapanatili ang itinakdang bilis, kailangang tawagan ng iyong sketch ang hakbang na stepper.run () na madalas na sapat upang maputok ang susunod na hakbang sa tamang oras para sa kasalukuyang bilis. Para sa kontrol sa pamamagitan ng mga sensor kailangan mong agad na maproseso ang mga bagong sukat. Ang posisyon / bilis ng pag-print ay may kasamang dalawang mga sukat ng LATENCY upang hayaan kang suriin ang iyong sketch ay sapat na mabilis.

Stepper Latency (pfodBufferedStream)

Sinusukat ng latency ng stepper ang maximum na pagkaantala sa pagitan ng sunud-sunod na mga tawag sa stepper.run () na pamamaraan. Upang patakbuhin ang stepper motor sa 1000 mga hakbang bawat sec, ang stepper latency ay kailangang mas mababa pagkatapos ng 1000uS (1mS). Ang unang bersyon ng sketch na ito ay may latency ng maraming milliseconds. Upang mapagtagumpayan ang labis na mga tawag sa runStepper () na pamamaraan (na tumatawag sa stepper.run ()) kung saan idinagdag sa pamamagitan ng code. Hindi nito kumpletong nalutas ang problema dahil ang menu at mga output ng pahayag na naka-block ang sketch kapag ang maliit na buffer ng Serial Tx ay puno na. Upang maiwasan ang pagharang na ito, ginamit ang pfodBufferedStream mula sa pfodParser library upang magdagdag ng isang 360 byte output print buffer na maaaring mabilis na isulat ng mga pahayag sa pag-print. Pagkatapos pfodBufferedStream ay naglalabas ng mga byte sa rate ng baud na tinukoy na 115200 sa kasong ito. Ang pfodBufferedStream ay may pagpipilian na mag-block kung ang buffer ay puno o i-drop lamang ang mga overflow chars. Dito nakatakda upang i-drop ang anumang labis na mga char kapag ang buffer ay puno na upang ang sketch ay hindi naka-block na naghihintay para sa Serial na magpadala ng mga chars.

Latency ng Loop (NonBlockingInput)

Sinusukat ng latency ng loop ang maximum na pagkaantala sa pagitan ng sunud-sunod na mga tawag sa loop () na pamamaraan. Itinakda nito kung gaano mo kabilis maproseso ang mga bagong sukat ng sensor at ayusin ang bilis ng hanay ng motor. Kung gaano kabilis kailangan maging depende sa kung ano ang sinusubukan mong kontrolin.

Ang mga pagkaantala dahil sa mga pahayag sa pag-print ay tinanggal sa pamamagitan ng paggamit ng pfodBufferedStream sa itaas, ngunit upang maproseso ang pag-input ng gumagamit kailangan mong kunin ang unang char lang ng input at huwag pansinin ang natitirang linya. Ang klase ng NonBlockingInput sa pfodParer library ay ginagamit upang ibalik ang isang non-zero char kapag may input, gamit ang readInput (), at upang i-clear at itapon ang mga sumusunod na character, gamit ang clearInput (), hanggang sa walang mga natanggap na chars para sa 10mS nang hindi hinaharangan ang loop ()

Siyempre ang latency ng loop ay tataas ng sobrang code na idinagdag mo upang mabasa ang mga sensor at kalkulahin ang bagong bilis ng itinakda. Maraming mga library ng sensor ang gumawa ng uri ng hiwa ng paggamit lamang ng pagkaantala (..) sa pagitan ng pagsisimula ng pagsukat at pagkuha ng resulta. Kakailanganin mong muling isulat ang mga aklatan na ito upang magamit sa halip ang millisDelay, upang kunin ang pagsukat pagkatapos ng angkop na pagkaantala na hindi nag-block.

Hakbang 6: Pagpapatakbo ng SpeedStepperSetup Gamit ang isang Stepper Motor at SparkFun Redboard Turbo

Upang patakbuhin ang SpeedStepperSetup sketch para sa totoong kakailanganin mo ng isang stepper motor, driver at supply ng kuryente at sa halimbawang ito SparkFun Redboard Turbo.

Ang diagram ng mga kable sa itaas (bersyon ng pdf) ay nagpapakita ng mga koneksyon. Sa SpeedStepperSetup sketch baguhin ang SERIAL na tukuyin sa # tukuyin ang SERIAL Serial1

Stepper Motor, Power Supply, Driver at Proteksyon

Mayroong maraming mga uri at sukat ng mga stepper motor. Narito ang isang dalawang likaw na 12V 350mA stepper motor ay ginagamit para sa pagsubok. Upang mapagana ang stepper na ito kailangan mo ng suplay ng kuryente na 12V o higit pa at higit sa 350mA.

Nagbibigay lamang ang library na ito ng isang direksyon at hakbang na output kaya kailangan mo ng isang driver upang mag-interface gamit ang stepper motor. Kinokontrol ng Easy Driver at Big Easy Driver ang kasalukuyang sa mga coil ng motor upang magamit mo ang isang power supply ng isang mas mataas na boltahe nang ligtas, halimbawa gamit ang 6V supply para sa isang 3.3V motor. Ang Madaling Driver ay maaaring mag-supply sa pagitan ng 150mA / coil at 700mA / coil. Para sa mas mataas na alon, ang Big Easy Driver ay maaaring magbigay ng hanggang sa 2A bawat coil. Basahin ang mga FAQ sa ilalim ng pahina ng Easy Drive.

Ang mga halimbawang ito ay gumagamit ng D6 at D7 bilang mga hakbang ng Hakbang at Direksyon. Maaari mong baguhin ang mga output pin sa anumang digital na output sa pamamagitan ng pagbabago ng mga setting ng STEP_PIN at DIR_PIN na malapit sa tuktok ng sketch.

Programming ang Sparkfun Redboard Turbo

May problema ang Programming ng Redboard Turbo. Kung nabigo itong mag-program, pindutin muna ang i-reset ang pushbutton nang isang beses at muling piliin ang COM port sa Arduino Tools menu at subukang muli. Kung hindi iyon gumana, doble pindutin ang pindutang reset push at subukang muli.

Pag-kable ng Easy Driver

Ang dalawang coil stepper motor ay mayroong 4 na mga wire. Gumamit ng isang multimeter upang hanapin ang mga pares na kumonekta sa bawat likaw at pagkatapos ay i-wire ang isang likaw sa Easy Driver A terminal at ang iba pang coil sa B terminal. Hindi mahalaga kung aling paraan ang pag-ikot mo sa kanila dahil maaari mong gamitin ang s cmd sa menu ng pag-setup upang mapalitan ang direksyon ng paggalaw.

Ang suplay ng kuryente ng motor ay naka-wire sa M + at GNDSet ang antas ng lohika ng board na may 3 / 5V na link. Maikli ang link nang magkakasama para sa mga output ng 3.3V microprocessor, tulad ng SparkFun Redboard Turbo (kung iniiwan mong bukas ito ay angkop sa mga digital signal na 5V, hal. UNO, Mega) Ikonekta ang GND, STEP, DIR pin sa microprocessor GND at ang hakbang at dir output pin. Walang ibang mga koneksyon ay kinakailangan upang himukin ang motor.

USB sa TTL Serial Cable

Kapag inililipat ang SpeedStepperSetup sketch mula sa Uno / Mega sa Redboard Turbo maaari mong mapalitan na palitan lamang ang #define SERIAL Serial ng #define SERIAL SerialUSB upang umangkop sa koneksyon sa serial na usb ng Redboard Turbo, subalit malalaman mo na ang nagreresultang stepper latency ay halos 10mS. Iyon ay 10x mas mabagal pagkatapos para sa UNO. Dahil ito sa kung paano hawakan ng Redboard cpu ang koneksyon sa USB. Sa paglipas nito, kumonekta sa isang USB sa TTL Serial Cable sa D0 / D1 at itakda ang # tukuyin ang SERIAL Serial1 upang magamit ang serial serial na koneksyon upang makontrol ang stepper motor. Ang paggamit ng Serial1 ay nagbibigay sa LATENCY: stepper: 345uS loop: 2016uS na 3 oras na mas mabilis pagkatapos ng UNO para sa stepper at loop latency

Terminal Program

Ang Arduino Serial Monitor ay medyo mahirap gamitin upang makontrol ang stepper motor dahil kailangan mong ipasok ang char sa linya ng cmd at pagkatapos ay pindutin ang Enter upang ipadala ito. Ang isang mas mabilis na mas madaling paraan na tumutugon ay upang buksan ang isang window ng terminal, TeraTerm para sa PC (o CoolTerm Mac), na konektado sa USB sa TTL cable COM port. Pagkatapos sa window na iyon ang pagpindot sa isang cmd key ay ipinapadala ito kaagad. Ang pagpindot sa Enter magpadala lamang ng isang walang laman na linya.

Itinatakda ang saklaw ng bilis ng motor

Tulad ng naka-wire sa itaas, ang Easy Drive ay naka-configure para sa 1 / 8th na mga hakbang, kaya 1000 hakbang / sec ay magpapasara sa motor sa 1000/8/200 hakbang / rebolusyon = 0.625 revs bawat sec o 37.5 rpm na maximum. Sa pamamagitan ng pagbabago ng mga input sa MS1 / MS2 maaari kang lumipat sa pagitan ng 1/8, ¼, ½ at buong mga hakbang. Para sa buong hakbang na ikonekta ang parehong MS1 at MS2 sa GND. Papayagan nito ang mga bilis ng hanggang sa 300 rpm. Ang pagpili ng naaangkop na mga setting ng MS1 / MS2 ay nagbibigay-daan sa iyo upang ayusin ang naka-install na ratio ng gear sa pagitan ng motor at ng hinihimok na bahagi.

Proteksyon sa Hardware

Habang pinapayagan ka ng aklatan ng SpeedStepper na magtakda ng mga limitasyon sa posisyon sa paggalaw ng motor, ang paglalagay ng posisyon ay ginagawa sa pamamagitan ng pagbibilang ng mga hakbang na output ng software. Kung ang mga stall ng motor, ibig sabihin, ang metalikang kuwintas ay hindi sapat upang himukin ang motor sa susunod na hakbang pagkatapos ang posisyon ng software ay hindi mai-sync sa posisyon ng motor. Pagkatapos kapag ginamit mo ang 'goHome' na utos ang motor ay mag-overshoot sa posisyon ng bahay. Upang maiwasan ang pinsala sa hardware dapat mong magkasya ang mga switch ng limitasyon sa mga matitigas na limitasyon upang idiskonekta ang suplay ng kuryente ng motor

Ang pagtatakda ng kasalukuyang limitasyon ng motor

Una, itakda ito sa pinakamababang setting ng potensyomiter. ibig sabihin, ang boltahe sa TP1 ay minimum. Ang potensyomiter ay maselan, kaya huwag pilitin ang potentiometro na lampas sa mga hinto ng mekanikal. Itakda ang pagmamaneho ng motor sa isang mabagal na matatag na bilis ng mabagal, pagkatapos ay dahan-dahang i-on ang potensyomiter hanggang sa ang motor ay hindi lumaktaw o mabulingan sa pagitan ng mga hakbang.

Konklusyon

Ipinapakita ng proyektong ito kung paano gamitin ang aklatan ng SpeedStepper sa isang praktikal na aplikasyon. Habang ang aklatan ng AccelStepper ay nagbibigay ng mahusay na kontrol sa posisyon, kinakailangan ang kontrol sa bilis para sa Prototype Ice-Melting Probe para sa Pagkolekta ng Mga Sampol na Biolohikal sa Europa kaya ang aklatan ng AccelStepper ay muling isinulat upang magbigay ng kontrol sa bilis na may mga limitasyon sa pagtatapos at isang pag-andar ng goHome.