- Pagpili ng Mga Bahagi para sa Sarili na Balancing Robot
- Pagpi-print at Pag-iipon ng 3D ng aming Sarili na Balancing Robot
- Diagram ng Circuit
- Self Balancing Robot Code
- Paggawa ng Arduino Self Balancing Robot
Matapos ma-inspire ng mga RYNO motor at iba pang mga scooter sa sarili na pagbabalanse mula sa Segway, palagi kong nais na bumuo ng isang bagay na aking sariling Arduino Segway Robot. Nag-iisip nang sandali, nagpasya akong bumuo ng isang Self Balancing Robot gamit ang Arduino. Sa ganitong paraan maaunawaan ko ang pinagbabatayan na konsepto sa likod ng lahat ng mga scooter na ito at alamin din kung paano gumagana ang PID algorithm.
Kapag nagsimula na akong magtayo, napagtanto ko na ang bot na ito ay medyo isang hamon na buuin. Maraming mga pagpipilian upang pumili mula sa at samakatuwid ang mga pagkalito ay nagsisimula tamang form ng pagpili ng mga motor at mananatili hanggang sa pag-tune ng mga halaga ng PID. At maraming bagay na isasaalang-alang tulad ng uri ng baterya, posisyon ng baterya, mahigpit na pagkakahawak ng gulong, uri ng driver ng motor, pinapanatili ang CoG (Center of gravity) at marami pa.
Ngunit hayaan mo akong sirain ito sa iyo, sa sandaling maitayo mo ito sasang-ayon ka na hindi ito gaano kahirap sa pakinggan nito. Kaya't harapin natin ito, sa tutorial na ito ay idodokumento ko ang aking karanasan sa pagbuo ng self balancing robot. Maaari kang maging isang ganap na nagsisimula na nagsisimula pa lamang o maaaring nakarating dito pagkatapos ng mahabang pagkabigo na hindi gumana ang iyong bot. Nilalayon ng lugar na ito na maging iyong huling patutunguhan. Magsimula na tayo……
Pagpili ng Mga Bahagi para sa Sarili na Balancing Robot
Bago ko sabihin sa iyo ang lahat ng mga pagpipilian para sa pagbuo ng bot hayaan mo akong ilista ang mga item na ginamit ko sa mismong proyekto sa pagbalanse ng robot
- Arduino UNO
- Geared DC motors (Dilaw na kulay) - 2No
- L298N Motor Driver Module
- MPU6050
- Isang pares ng gulong
- 7.4V Li-ion Battery
- Mga kumokonekta na mga wire
- 3D na Naka-print na Katawan
Maaari mong ihalo at pumili para sa anuman sa mga sangkap sa itaas batay sa kakayahang magamit upang makagawa ng iyong sariling self balancing robot kit, siguraduhin lamang na umaangkop ang mga sangkap sa mga sumusunod na pamantayan.
Controller: Ang controller na ginamit ko dito ay Arduino UNO, bakit dahil madaling gamitin ito. Maaari mo ring gamitin ang isang Arduino Nano o Arduino mini ngunit inirerekumenda ko sa iyo na manatili sa UNO dahil maaari naming mai-program ito nang direkta nang walang anumang panlabas na hardware.
Mga Motors: Ang pinakamahusay na pagpipilian ng motor na maaari mong gamitin para sa isang self balancing robot, nang walang pag-aalinlangan ay magiging Stepper motor. Ngunit upang mapanatili ang mga bagay na simple Gumamit ako ng DC gear motor. Oo hindi ipinag-uutos na magkaroon ng isang stepper; ang bot ay gumagana ng maayos sa mga murang karaniwang magagamit na dilaw na kulay DC gear motor na rin.
Motor Driver: Kung napili mo ang DC gear motor tulad ng sa akin maaari mong gamitin ang module na driver ng L298N tulad ko, o kahit na ang L293D ay dapat na gumana nang maayos. Matuto nang higit pa tungkol sa pagkontrol sa DC motor gamit ang L293D at Arduino.
Mga gulong: Huwag tantyahin ang mga taong ito; Nagkaroon ako ng isang matigas na oras sa pag-alam na ang problema ay sa aking mga gulong. Kaya siguraduhin na ang iyong mga gulong ay may mahusay na mahigpit na pagkakahawak sa sahig na iyong ginagamit. Panoorin nang mabuti, ang iyong mahigpit na pagkakahawak ay hindi dapat pahintulutan ang iyong mga gulong na dumulas sa sahig.
Accelerometer at Gyroscope: Ang pinakamahusay na pagpipilian ng Accelerometer at Gyroscope para sa iyong bot ay ang MPU6050. Kaya huwag subukang bumuo ng isa sa isang normal na Accelerometer tulad ng ADXL345 o isang bagay na tulad nito, hindi ito gagana. Malalaman mo kung bakit sa pagtatapos ng artikulong ito. Maaari mo ring suriin ang aming nakatuon na artikulo sa paggamit ng MPU6050 sa Arduino.
Baterya: Kailangan namin ng isang baterya na kasing magaan hangga't maaari at ang boltahe ng operating ay dapat na higit sa 5V upang maaari naming direktang mapalakas ang aming Arduino nang walang isang boost module. Kaya ang perpektong pagpipilian ay isang 7.4V Li-polymer na baterya. Dito, dahil mayroon akong isang madaling magamit na baterya ng Li-ion na 7.4V Ginamit ko ito. Ngunit tandaan na ang isang Li-po ay mas nakabubuti kaysa sa Li-ion.
Chassis: Ang isa pang lugar kung saan hindi ka dapat ikompromiso ay ang iyong mga chassis ng bot. Maaari kang gumamit ng karton, kahoy, plastik ng anupaman na mahusay ka. Ngunit, siguraduhin lamang na ang chassis ay matibay at hindi dapat kumalinga kapag ang bot ay sumusubok na balansehin. Dinisenyo ko sa pamamagitan ng sariling chassis sa Solidworks na nag-iimpormasyon mula sa iba pang mga bot at naka-print ito ng 3D. Kung mayroon kang isang printer pagkatapos ay maaari mo ring mai-print ang disenyo, ang mga file ng disenyo ay ikakabit sa paparating na heading.
Pagpi-print at Pag-iipon ng 3D ng aming Sarili na Balancing Robot
Kung nagpasya kang i-print ng 3D ang parehong chassis na ginagamit ko upang mabuo ang aking bot, kung gayon ang mga file na STL ay maaaring ma-download mula sa thingiverse. Nagdagdag din ako ng mga file ng disenyo kasama nito upang maaari mo ring baguhin ito ayon sa kagustuhan ng iyong tauhan.
Ang mga bahagi ay walang mga overhanging na istraktura upang madali mong mai-print ang mga ito nang walang anumang mga suporta at isang infill na 25% ay gagana nang maayos. Ang mga disenyo ay medyo payak at ang anumang pangunahing printer ay dapat na hawakan ito nang madali. Ginamit ko ang Cura software upang hatiin ang modelo at naka-print gamit ang aking Tevo Tarantula, ang setting ay ipinapakita sa ibaba.
Kailangan mong i-print ang bahagi ng katawan pati na rin ang apat na mga bahagi ng pag-mount ng motor. Ang assembling ay medyo tuwid pasulong; gumamit ng 3mm nut at bolts upang ma-secure ang motor at board sa lugar. Pagkatapos ng pag-iipon dapat magmukhang ganito ang ipinakita sa larawan sa ibaba.
Ang aktwal na disenyo ay pinlano kasama ang module ng drive ng L298N sa ibabang rak ng Arduino at baterya sa itaas nito tulad ng ipinakita sa itaas. Kung sumusunod ka sa parehong pagkakasunud-sunod maaari mong direktang i-tornilyo ang board sa mga butas na ibinigay at gumamit ng isang wire tag para sa baterya ng Li-po. Ang pag-aayos na ito ay dapat ding gumana, maliban sa sobrang payak na gulong na kailangan kong baguhin sa paglaon.
Sa aking bot ay ipinagpalit ko ang posisyon ng baterya at Arduino UNO board para sa kadalian ng programa at kailangan ding magpakilala ng isang perf board para sa pagkumpleto ng mga koneksyon. Kaya't ang aking bot ay hindi tumingin tulad ng plano ko sa paunang yugto. Matapos makumpleto ang pagsubok sa mga kable ng programa at lahat, ang aking dalawang gulong robot sa wakas ay ganito ang hitsura
Diagram ng Circuit
Ang paggawa ng mga koneksyon para sa Arduino based na Self balancing Robot ay medyo simple. Ito ay isang robot sa sarili na pagbabalanse gamit ang Arduino at MPU6050 kaya kinuha namin upang i-interface ang MPU6050 sa Arduino at ikonekta ang mga motor kahit na ang module ng Motor driver. Ang buong set-up ay pinalakas ng 7.4V li-ion na baterya. Ang circuit diagram para sa pareho ay ipinapakita sa ibaba.
Ang Arduino at ang L298N Motor driver module ay direktang pinalakas sa pamamagitan ng Vin pin at 12V terminal ayon sa pagkakabanggit. Ang on-board regulator sa Arduino board ay babaguhin ang input na 7.4V sa 5V at ang ATmega IC at MPU6050 ay papalakasin nito. Ang DC motors ay maaaring tumakbo mula sa boltahe 5V hanggang 12V. Ngunit ikonekta namin ang 7.4V positibong kawad mula sa baterya patungo sa 12V input terminal ng motor driver module. Gagawin nito ang mga motor na gumana nang 7.4V. Ang sumusunod na talahanayan ay maglilista kung paano ang module ng driver ng motor ng MPU6050 at L298N ay konektado sa Arduino.
|
Component Pin |
Arduino Pin |
|
MPU6050 |
|
|
Vcc |
+ 5V |
|
Lupa |
Gnd |
|
SCL |
A5 |
|
SDA |
A4 |
|
INT |
D2 |
|
L298N |
|
|
IN1 |
D6 |
|
IN2 |
D9 |
|
IN3 |
D10 |
|
IN4 |
D11 |
Nakikipag-usap ang MPU6050 sa Arduino sa pamamagitan ng interface ng I2C, kaya ginagamit namin ang mga SPI pin A4 at A5 ng Arduino. Ang DC motors ay konektado sa PWM pin D6, D9 D10 at D11 ayon sa pagkakabanggit. Kailangan naming ikonekta ang mga ito sa mga pin ng PWM sapagkat makokontrol namin ang bilis ng motor na DC sa pamamagitan ng pag-iiba sa cycle ng tungkulin ng mga signal ng PWM. Kung hindi ka pamilyar sa dalawang sangkap na ito ay inirerekumenda na basahin sa pamamagitan ng tutorial ng driver ng MPU6050 at L298N Motor.
Self Balancing Robot Code
Ngayon kailangan naming i-program ang aming Arduino UNO board upang balansehin ang robot. Dito nagaganap ang lahat ng mahika; ang konsepto sa likod nito ay simple. Kailangan nating suriin kung ang bot ay nakahilig patungo sa harap o patungo sa likuran gamit ang MPU6050 at pagkatapos kung nakahilig ito sa harap kailangan nating paikutin ang mga gulong sa pasulong na direksyon at kung nakahilig ito sa likuran kailangan nating paikutin ang mga gulong sa baligtad na direksyon.
Sa parehong oras kailangan din nating kontrolin ang bilis kung saan ang mga gulong ay umiikot, kung ang bot ay bahagyang disorientado mula sa posisyon ng gitna ang mga gulong ay mabagal na umiikot at ang pagtaas ng bilis dahil nakakakuha ito ng mas malayo sa posisyon ng gitna. Upang makamit ang lohika na ito ginagamit namin ang PID algorithm, na may gitnang posisyon bilang set-point at ang antas ng disorientation bilang output.
Upang malaman ang kasalukuyang posisyon ng bot na ginagamit namin ang MPU6050, na isang 6-axis accelerometer at gyroscope sensor na pinagsama. Upang makakuha ng isang maaasahang halaga ng posisyon mula sa sensor kailangan nating gamitin ang halaga ng parehong accelerometer at gyroscope, dahil ang mga halaga mula sa accelerometer ay may mga problema sa ingay at ang mga halaga mula sa gyroscope ay may posibilidad na naaanod sa oras. Kaya kailangan nating pagsamahin ang pareho at makuha ang halaga ng yaw pitch at roll ng aming robot, kung saan gagamitin lamang namin ang halaga ng yaw.
Tunog kagat ng ulo gumagala diba? Ngunit huwag mag-alala, salamat sa pamayanan ng Arduino madali naming magagamit ang mga aklatan na maaaring maisagawa ang pagkalkula ng PID at makuha din ang halaga ng paghikab mula sa MPU6050. Ang silid-aklatan ay binuo ni br3ttb at jrowberg ayon sa pagkakabanggit. Bago magpatuloy i-download ang kanilang mga silid aklatan form ang sumusunod na link at idagdag ang mga ito sa iyong Arduino lib direktoryo.
github.com/br3ttb/Arduino-PID-Library/blob/master/PID_v1.h
github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050
Ngayon, na mayroon kaming mga library na idinagdag sa aming Arduino IDE. Magsimula na tayo sa pagprograma para sa ating Self balancing Robot. Tulad ng palaging ang kumpletong code para sa MPU6050 balancing robot ay ibinibigay sa dulo ng pahinang ito, narito ko lamang ipinapaliwanag ang pinakamahalagang mga snippet sa code. Sinabi nang mas maaga ang code ay bumuo sa tuktok ng halimbawang MPU6050 na halimbawa ay i-optimize lamang namin ang code para sa aming layunin at idagdag ang PID at pamamaraan ng kontrol para sa aming sariling balancing robot.
Isinasama muna namin ang mga aklatan na kinakailangan upang gumana ang program na ito. Isinasama nila ang built-in na I2C library, PID Library at MPU6050 Library na na-download lamang namin.
# isama ang "I2Cdev.h" # isama
Pagkatapos ay ipinahayag namin ang mga variable na kinakailangan upang makuha ang data mula sa sensor ng MPU6050. Basahin namin ang parehong mga gravity vector at quaternion na halaga at pagkatapos ay kalkulahin ang yaw pitch at roll halaga ng bot. Ang float array ypr ay magtataglay ng pangwakas na resulta.
// MPU control / status vars bool dmpReady = false; // set true kung matagumpay ang DMP init uint8_t mpuIntStatus; // humahawak ng aktwal na byte ng pagkaantala ng katayuan mula sa MPU uint8_t devStatus; // status ng pagbabalik pagkatapos ng bawat pagpapatakbo ng aparato (0 = tagumpay ,! 0 = error) uint16_t packetSize; // inaasahang laki ng packet ng DMP (ang default ay 42 bytes) uint16_t fifoCount; // count ng lahat ng byte na kasalukuyang nasa FIFO uint8_t fifoBuffer; // FIFO storage buffer // orientation / motion vars Quaternion q; // container quaternion VectorFloat gravity; // gravity vector float ypr; // yaw / pitch / roll container at gravity vector
Susunod na dumating ang napakahalagang segment ng code, at dito mo gugugol ng mahabang panahon sa pag- tune para sa tamang hanay ng mga halaga. Kung ang robot ay itinayo na may napakahusay na sentro ng gravity at ang mga bahagi ay simetriko na nakaayos (na sa karamihan ng mga kaso ay hindi) kung gayon ang halaga ng iyong set-point ay 180. Kung hindi man ikonekta ang iyong bot sa serial monitor ng Arduino at ikiling ito hanggang nakakahanap ka ng magandang posisyon sa pagbabalanse, basahin ang halagang ipinakita sa serial monitor at ito ang iyong itinakdang halaga ng point. Ang halaga ng Kp, Kd at Ki ay kailangang iakma ayon sa iyong bot. Walang dalawang magkatulad na bot na magkakaroon ng parehong halaga ng Kp, Kd at Ki kaya walang makatakas mula dito. Panoorin ang video sa dulo ng pahinang ito upang makakuha ng ideya kung paano ayusin ang mga halagang ito.
/ ********* Tonoin ang 4 na halagang ito para sa iyong BOT ********* / dobleng setpoint = 176; // itakda ang halaga kapag ang bot ay patayo sa ground gamit ang serial monitor. // Basahin ang dokumentasyon ng proyekto sa circuitdigest.com upang malaman kung paano itakda ang mga halagang ito ng doble Kp = 21; // Itakda ang unang dobleng Kd = 0.8; // Itakda ang secound na dobleng Ki = 140; // Sa wakas itakda ito / *** Pagtatapos ng setting ng mga halaga ********* /
Sa susunod na linya ay pinasimulan namin ang PID algorithm sa pamamagitan ng pagpasa ng mga input ng variable na input, output, set point, Kp, Ki at Kd. Mula sa mga ito naitakda na namin ang mga halaga ng set-point Kp, Ki at Kd sa itaas na snippet ng code. Ang halaga ng pag-input ay magiging kasalukuyang halaga ng yaw na nabasa mula sa sensor ng MPU6050 at ang halaga ng output ay ang halagang kinakalkula ng PID algorithm. Kaya karaniwang ang PID algorithm ay magbibigay sa amin ng isang halaga ng output na dapat gamitin upang iwasto ang halaga ng Input na malapit ito sa itinakdang puntong.
PID pid (& input, & output, & setpoint, Kp, Ki, Kd, DIRECT);
Sa loob ng walang bisa na pag- andar ng pag- setup pinasimuno namin ang MPU6050 sa pamamagitan ng pag-configure ng DMP (Digital Motion Processor). Tutulungan kami nito sa pagsasama ng data ng Accelerometer sa data ng Gyroscope at magbigay ng maaasahang halaga ng Yaw, Pitch at Roll. Hindi namin malalim ang lalagyan dito dahil malayo ito sa paksa. Anuman ang isang segment ng code na kailangan mong hanapin sa pag-andar ng pag-setup ay ang mga halaga ng gyro offset. Ang bawat sensor ng MPU6050 ay may sariling mga halaga ng mga offset na maaari mong gamitin ang Arduino sketch na ito upang makalkula ang offset na halaga ng iyong sensor at i-update ang mga sumusunod na linya nang naaayon sa iyong programa.
// supply your own gyro offset here, scaled for min sensitivity mpu.setXGyroOffset (220); mpu.setYGyroOffset (76); mpu.setZGyroOffset (-85); mpu.setZAccelOffset (1688);
Kailangan din nating simulan ang mga Digital PWM na pin na ginagamit namin upang ikonekta ang aming mga motor. Sa aming kaso ito ay D6, D9, D10 at D11. Kaya pinasimulan namin ang mga pin na ito bilang mga output pin na gagawin silang mababa sa pamamagitan ng default.
// Initialise ang Motor outpu pin pinMode (6, OUTPUT); pinMode (9, OUTPUT); pinMode (10, OUTPUT); pinMode (11, OUTPUT); // Sa pamamagitan ng default patayin ang parehong mga motors analogWrite (6, LOW); analogWrite (9, LOW); analogWrite (10, LOW); analogWrite (11, LOW);
Sa loob ng pangunahing pag- andar ng loop sinusuri namin kung ang data mula sa MPU6050 ay handa nang mabasa. Kung oo pagkatapos ay ginagamit namin ito upang makalkula ang halaga ng PID at pagkatapos ay ipakita ang input at output na halaga ng PID sa serial monitor upang masuri lamang kung paano tumutugon ang PID. Pagkatapos batay sa halaga ng output nagpasya kami kung ang bot ay kailangang sumulong o paatras o tumayo pa rin.
Dahil ipinapalagay namin na ang MPU6050 ay magbabalik ng 180 kapag ang bot ay patayo. Makakakuha kami ng positibong mga halaga sa pagwawasto kapag ang bot ay nahuhulog sa harap at makakakuha kami ng mga halaga sa negatibo kung ang bot ay nahuhulog sa likuran. Kaya't suriin namin ang kundisyong ito at tawagan ang mga naaangkop na pagpapaandar upang ilipat ang bot sa pasulong o back ward.
habang (! mpuInterrupt && fifoCount <packetSize) { // walang data ng mpu - gumaganap ng mga kalkulasyon at output ng PID sa mga motor pid.Compute (); // I-print ang halaga ng Input at Output sa serial monitor upang suriin kung paano ito gumagana. Serial.print (input); Serial.print ("=>"); Serial.println (output); kung (input> 150 && input <200) {// Kung ang Bot ay nahuhulog kung (output> 0) // Bumagsak patungo sa harap Na Pasulong (); // Paikutin ang mga gulong pasulong pa kung (output <0) // Bumagsak patungo sa likod Reverse (); // Paikutin ang mga gulong paatras } iba // Kung ang Bot ay hindi nahuhulog Itigil (); // Hawakan mo pa rin ang mga gulong }
Ang PID output variable din nagpapasya kung gaano kabilis ang motor ay dapat maipihit. Kung ang bot ay malapit nang mahulog pagkatapos ay gumawa kami ng menor de edad na pagwawasto sa pamamagitan ng pag-ikot ng gulong nang dahan-dahan. Kung ang mga menor de edad na pagwawasto ay hindi gumana at kung ang bot ay bumabagsak ay pinapataas namin ang bilis ng motor. Ang halaga ng kung gaano kabilis umikot ang mga gulong ay mapagpasyahan ng PI algorithm. Tandaan na para sa Reverse function na pinarami namin ang halaga ng output na may -1 upang mai-convert namin ang negatibong halaga sa positibo.
void Forward () // Code upang paikutin ang gulong pasulong { analogWrite (6, output); analogWrite (9,0); analogWrite (10, output); analogWrite (11,0); Serial.print ("F"); // Impormasyon sa pag-debug } walang bisa Reverse () // Code upang paikutin ang gulong Paatras { analogWrite (6,0); analogWrite (9, output * -1); analogWrite (10,0); analogWrite (11, output * -1); Serial.print ("R"); } walang bisa Itigil () // Code upang ihinto ang parehong mga gulong { analogWrite (6,0); analogWrite (9,0); analogWrite (10,0); analogWrite (11,0); Serial.print ("S"); }
Paggawa ng Arduino Self Balancing Robot
Kapag handa ka na sa hardware, maaari mong i-upload ang code sa iyong Arduino board. Siguraduhin na ang mga koneksyon ay tama dahil gumagamit kami ng isang Li-ion baterya matinding pag-iingat ay kinakailangan. Kaya't i-double check ang mga maikling circuit at tiyaking hindi makikipag-ugnay ang mga terminal kahit na nakakaranas ang iyong bot ng ilang maliliit na epekto. Palakasin ang iyong module at buksan ang iyong serial monitor, kung ang iyong Arduino ay maaaring makipag-usap sa MPU6050 matagumpay at kung gumagana ang lahat tulad ng inaasahan dapat mong makita ang sumusunod na screen.
Makikita natin dito ang mga halaga ng pag-input at output ng PID algorithm sa format input => output . Kung ang bot ay perpektong balansehin ang halaga ng output ay magiging 0. Ang halaga ng pag-input ay ang kasalukuyang halaga mula sa MPU6050 sensor. Ang alpabetong "F" ay kumakatawan sa bot na gumagalaw pasulong at ang "R" ay kumakatawan na ang bot sa kabaligtaran.
Sa mga paunang yugto ng PID inirerekumenda kong iwanan ang iyong Arduino cable na konektado sa bot upang madali mong masubaybayan ang mga halaga ng pag-input at output at madali din itong iwasto at mai-upload ang iyong programa para sa mga halagang Kp, Ki at Kd. Ipinapakita ng video sa ibaba ang kumpletong pagtatrabaho ng bot at ipinapakita rin kung paano maitama ang iyong mga halagang PID.
Inaasahan kong makakatulong ito upang makabuo ng iyong sariling robot sa pagbabalanse ng sarili kung mayroon kang anumang problema sa paggana nito, pagkatapos ay iwanan ang iyong mga katanungan sa seksyon ng komento sa ibaba o gamitin ang mga forum para sa higit pang mga teknikal na katanungan. Kung nais mo ng mas masaya maaari mo ring gamitin ang parehong lohika upang bumuo ng isang ball balancing robot.