Robo-Technician: 8 Mga Hakbang

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

Magisip ng isang segundo na ikaw ay isa sa mga astronaut na dumarating sa Mars. Mayroon kang isang milyong bagay na dapat gawin, mga sample na kukuha, mga eksperimento upang patakbuhin, data upang kolektahin, ngunit isang beses o dalawang beses sa isang araw kailangan mong patakbuhin ang tirahan at / o mga module ng pagsasaliksik na iyong tinitirhan at pinagtatrabahuhan upang siyasatin ang mga ito. Kailangan nito, dapat tiyakin ng isang tao na ang bagay ay nasa maayos na kalagayan, na ang lahat ng libu-libong mga piraso at bahagi ay gumagana at nasa lugar. Ngunit paano kung mayroong isang awtomatikong tumutulong upang mapawi ka sa ilan sa mga tungkulin na iyon. Paano kung mayroong isang maliit na robot na maaaring lumipat sa loob ng mga module upang matiyak na ang lahat ay nasa lugar, gumagana, at ligtas.

Robo-Technician upang iligtas.

Mahalaga, kinokontrol ng code na ito ang Robo-Technician dahil sumusunod ito sa isang ilaw na may kulay na landas sa lupa. Susundan nito ang landas na ito hanggang sa makahanap ito ng isang kantong sa landas o isang pagliko, na kung saan ay hihikayatin ang isang larawan na kuha para sa pagproseso ng imahe upang payagan ang Robo-Technician na magpasya kung saan susunod na pupunta. Gumagana ang mga light bump at bump sensor upang maprotektahan ang Robo-Technician mula sa pinsala, at makokontrol ang mga sensor ng paga kapag kinuha ang isang diagnostic na larawan. Sama-sama, ang Robo-Technician ay idinisenyo upang mag-zoom sa mga modyul ni Mar, pinapalaya ang oras ng mga astronaut habang ginagawa ang pangunahing gawain ng inspeksyon, tumatawag lamang para sa pag-input ng tao kapag nakakita ito ng mali.

Muli bilang isang babala, ito ay isang isinasagawa. Ang code, tulad ng mayroon ito, gumagana ngunit mayroon itong mga hiccup, lalo na't maraming, kasagsamang mga programa na kasangkot. Gayundin, upang gumana ang proyektong ito sa isang aktwal na misyon sa Mars, isang robot ang kailangang itayo para sa tukoy na hangarin na iyon, kaya muli hulaan ko ito ay isang "patunay ng konsepto" na pagbuo.

Mayroong ilang mga bagay na kakailanganin mo upang maiayos ito. Kakailanganin mo ng isang mamahaling programa, suportang mga pakete para sa program na iyon, at isang maliit na background sa pag-coding. Bilang isang mag-aaral ako, at ang ilan sa mga ground-floor code ay ibinigay (para sa raspberry pi), hindi ko partikular na pag-uusapan ang tungkol sa pag-set up. Mahahanap mo ang lahat ng mga link para sa batayang code sa ibaba. Dumating tayo sa listahan ng mga materyales.

Hardware

• Raspberry Pi (gumamit kami ng isang bersyon 3)
• iRobot ®
• ilang uri ng aparato na humahawak upang mapanatili ang Raspberry Pi na nakakabit sa Robo-Technician
• Raspberry Pi camera (hindi mahalaga kung anong uri, basta may mahusay na auto focus at paglutas ng imahe)
• ilang uri ng paninindigan o holster upang mapanatili ang camera na nakaharap sa Robo-Technician
• isang materyal na gagamitin bilang isang guhit, puti (o napaka-ilaw na kulay), na gaganapin sa sahig nang ligtas. Kailangan itong bahagyang mas malawak kaysa sa puwang sa pagitan ng harap ng dalawang mga sensor ng bangin.
• 4 na palatandaan na may napakalaking teksto (na may naka-print na mga salitang IMAGE, RIGHT, BACK, at LEFT)
• Mga sheet ng kulay na papel (hindi bababa sa tatlo at mas mabuti ang pula, berde, at asul)

Software

• Ang Matlab (2018a at 2017b ay parehong ginamit at tila may kaunting pagkakaiba)
• Suportang package ng Raspberry Pi para sa Matlab
• Raspberry Pi code para sa koneksyon sa Matlab (link sa ibinigay na source code sa ibaba)
• Image Processing Toolbox para sa Matlab (halos hindi mo magagawa ang proyektong ito nang wala ang toolbox)
• OPSYONAL: Naka-install ang Matlab Mobile sa iyong telepono, na ipapaliwanag ko sa paglaon

Hakbang 1: Pag-set up ng Hardware

ef.engr.utk.edu/ef230-2018-08/projects/roo…

Ito ang link para sa base code upang matiyak na ang iRobot® ay maaaring makipag-usap sa Matlab, kasama ang isang pangunahing tutorial. Tulad ng sinabi ko dati, hindi ko sasakupin ang tukoy na bahaging ito dahil ang tutorial ay napakahusay na inilatag na. Babanggitin ko na kapag nasunod mo ang mga hakbang sa link, maaari mong gamitin ang "doc" na utos ni Matlab upang tingnan ang kasama na impormasyon. Partikular:

doc roomba

At isa pang napakahalagang punto.

Kapag na-download mo ang mga file mula sa link sa itaas, Ilagay SILA SA FOLDER NA Inilarawan Ko sa Itaas, dahil hinihiling ng Matlab na nabuo ang mga file ng gumagamit na nasa kasalukuyang gumaganang folder.

Sa labas ng paraan, lumipat tayo sa code.

Hakbang 2: Paghahanap ng Lahat ng Mga Sensor

Tumagal ng isang segundo at bigyan ang iRobot® ng isang inspeksyon. Magandang malaman kung nasaan ang mga ito upang magkaroon ka ng ideya ng mga input na tinatanggap ng Robo-Technician, at malalaman mo kung bakit umiikot ang bagay sa halip na sundin ang landas na iyong i-set up (baka o maaaring hindi nangyari). Malinaw na makikita mo ang malaking pisikal na sensor ng bukol sa harap. Ang mga sensor ng bangin ay medyo mahirap makita, kakailanganin mong i-flip ito at hanapin ang apat, malinaw na mga plastik na bintana malapit sa harap na gilid. Ang mga light bump sensor ay mas nakatago, ngunit sa ngayon ay sapat na upang masabi ang live sa makintab na itim na banda na tumatakbo sa paligid ng harap ng iRobot®, na nasa harap ng pisikal na bar ng sensor ng paga.

Mayroong mga wheel drop sensor, ngunit ang mga ito ay hindi ginagamit sa proyektong ito, kaya't lilipat kami sa pagsubok ng mga sensor.

Hakbang 3: Pagsubok upang Itakda ang Mga Parameter

Bago namin mapadala ang Robo-Technician upang gawin ito ay trabaho, kailangan nating malaman ang mga tukoy na quirks at saklaw ng sensor. Dahil ang bawat iRobot® ay medyo magkakaiba at nagbabago sa buhay ng robot, kailangan nating malaman kung paano binasa ng mga sensor ang mga lugar kung saan ito gagana. Ang pinakamadaling paraan upang magawa ito ay upang mai-set up ka ng ilaw na may kulay na landas (Gumamit ako ng mga piraso ng puting papel ng printer ngunit ang anumang may kulay na kulay ay gagawin) sa ibabaw na tatakbo ng Robo-Technician.

Simulan ang Matlab at magbukas ng isang bagong script. I-save ang script SA PAREHONG FOLDER NA NAKLAKAD KO NG EARLIER at pangalanan ito kahit anong gusto mo (subukang panatilihing maikli ito, dahil ang pangalan ng file na ito ang magiging pangalan ng pag-andar). I-on ang robot at gamitin ang pag-setup ng variable ng roomba mula sa tutorial, i-type ang mga utos sa window ng utos.

Tiyaking naka-plug ang Raspberry Pi sa iRobot® at nakakonekta ka sa computer sa parehong koneksyon sa internet. Magugugol ka ng mas kaunting oras sa paghugot ng iyong buhok na sinusubukan upang malaman kung bakit hindi makakonekta ang Matlab

r = roomba (numero na iyong na-set up)

Ang variable na "r" sa pangyayaring ito ay hindi kinakailangan, maaari mo itong tawagan kahit anong gusto mo, ngunit ginagawang mas madali ang buhay na gumamit ng isang solong variable ng liham.

Kapag ang landas ay naka-set up, at ang roomba ay matagumpay na nakakonekta, ilagay ang hinaharap na Robo-Technician kung saan ang isa o dalawa sa mga cliff sensor ay nasa itaas ng landas. Malinaw na nangangahulugang ang iba pang dalawa o tatlo ay nasa tuktok ng ibabaw na iyong pinili.

Ngayon simulan ang mga sensor ng pagsubok gamit ang utos:

r.testSensors

Tandaan na ang "r." Ay ang variable na tinukoy mo nang mas maaga, kaya kung hindi 'r' palitan ang 'r.' sa kung ano man ang napagpasyahan mo. Dadalhin nito ang screen ng sensor ng pagsubok na may isang toneladang impormasyon.

Para sa proyektong ito tumuon sa mga seksyon ng lightBumpers, bumper, at cliff. Ilipat ang Robo-Technician sa paligid ng pagtiyak na panoorin kung paano nagbabago ang mga sensor sa iba't ibang mga ibabaw, o kung gaano kalapit ang isang bagay para mabago ang mga halaga ng ligthBumper, atbp. Isaisip ang mga numerong ito (o isulat ang mga ito) dahil makikita mo kailangan mo sila upang itakda ang mga parameter mo sa isang segundo.

Hakbang 4: Pagsisimula ng Code

Una ay nagtatayo ka ng isang pagpapaandar. Tinawag ko itong "landas" ngunit muli, ang pangalan ay hindi kinakailangan, ngunit tatanggalin ko ito bilang "landas" mula ngayon.

Ang nangungunang bahagi ng code ay nagse-set up ng ilang mga pagpipilian sa pag-input ng gumagamit. Bumubuo ito ng ilang mga listahan na gagamitin sa nasa listdlg at pagkatapos ay magdadala ng isang kahon ng dayalogo sa listahan. Pinapayagan nito ang gumagamit na pumili kung aling kulay ng path ang nais nilang sundin, na maglaro sa paglaon.

list = {'Pula', 'Blue', 'Green'}

problist = {'Kaswalidad, I-save ang Imahe', 'Bahagi ng Wala sa Lugar, I-save ang Larawan', 'Inaasahan, Magpatuloy'} pathcolor = listdlg ('PromptString', 'Pumili ng Kulay ng Path',… 'SelectionMode', 'solong', 'ListString', listahan) prob = 0; driv = ;

Ang mga "prob" at "driv" na variable ay kailangang ideklara dito dahil gagamitin ito sa loob ng pangunahing function habang loop, ngunit muli, kung nais mong palitan ang pangalan ng alinman sa mga variable na ito o baguhin ang mga pagpipilian sa listahan, ayos lang hangga't pare-pareho ka sa natitirang code.

Hakbang 5: Itaas ng Habang Loop: Mga Physical Bump Sensor

Ang tuktok ng habang loop ay naglalaman ng pisikal na lohika sensor sensor. Talaga, kapag ang Robo-Technician ay tumatakbo sa isang bagay na tumitigil ito (o para sa front sensor ng paga-back up ito ay 0.1 metro), pagkatapos ay iposisyon ang sarili upang kumuha ng litrato. Hinahayaan muna nating saklawin ang tulin ng tulin at tulin ng posisyon.

Kung nasubukan mo ang lahat ng mga sensor sa Robo-Technician sa mga nakaraang hakbang, malalaman mo na ang mga sensor ng paga ay may halaga sa lohika (0 o 1) na may zero na kumakatawan sa normal, hindi pinindot na posisyon ng sensor. Isaisip iyon para sa code.

habang totoo% pangunahing habang loop% makakatanggap ng impormasyon ng bumper S = r.getBumpers kung S. kaliwa ~ = 0 r.stop iba pa S. kanan ~ = 0 r.stop elseif S.front ~ = 0 r.stop end

Ito ang pangunahing "kung may pinindot ito, itigil" na bahagi. Kung ang mga sensor ay nakakakita ng isang banggaan, pagkatapos ay lumilipat ito sa susunod na bahagi ng code, na inaayos ang posisyon ng Robo-Technician upang makakuha ng isang larawan.

kung S. kaliwa ~ = 0% kung kukuha ng loop ang impormasyon ng bumper at ihanay ang camera para sa larawan r.turnAngle (5) i-pause (0.5) img = r.getImage% ay kumukuha ng larawan at ipinapakita ang imahe (img)% dialog box prob = listdlg (' PromptString ',' Nakahanap ng isang Hindi Inaasahang Sagabal, Mangyaring Kilalanin '…,' SelectionMode ',' solong ',' ListString ', problist) iba pa S. Right ~ = 0 r.turnAngle (-5) pause (0.5) img = r. getImage image (img) prob = listdlg ('PromptString', 'Nakahanap ng isang Hindi Inaasahang Sagabal, Mangyaring Kilalanin' …, 'SelectionMode', 'solong', 'ListString', problist) iba pa S.front ~ = 0 r.moveDistance (- 0.1) i-pause (0.5) img = r.getImage image (img) prob = listdlg ('PromptString', 'Nakahanap ng isang Hindi Inaasahang Sagabal, Mangyaring Kilalanin' …, 'SelectionMode', 'solong', 'ListString', problist) na nagtatapos

Talaga, kapag ang imahe ay nakuha ng isa pang kahon ng dayalogo ay lilitaw na may tatlong mga pagpipilian. Ang unang dalawang pagpipilian ay nai-save ang larawan sa isang tinukoy na folder, na tatakpan ko sa paglaon, habang ang pangatlong pagpipilian ay isinasara lamang ang kahon ng diyalogo at magpapatuloy sa pamamagitan ng loop. Kung hindi mo matandaan ang mga pagpipilian, tingnan ang nakaraang hakbang.

Ngayon ay ipinasok ko ang isang seksyon ng code sa pagitan ng bahagi ng sensor ng bukol at ang bahagi ng pag-save ng larawan. Tumatagal ito ng mga halaga ng lightBumper at itinatakda ang bilis ng pagmamaneho sa 0.025 metro / segundo (napakabagal), na hindi talaga kinakailangan ngunit binabawasan nito ang Robo-Technician na bumubulusok sa mga bagay at sa kalaunan ay nasusuot na ang mga pisikal na sensor ng paga.

L = r.getLightBumpers kung L. Kaliwa> 100 || L.leftFront> 100 || L. RightFront> 100 || L. kanan> 100 driv = 0.025 r.setDriveVelocity (0.025) iba pa driv = 0.1 end

Ito ang magiging bahagi kung saan napatupad ang mga halagang napansin mo (at sana ay nagsulat)

Ang "L. (gilid at direksyon ng sensor)> 100" ay batay sa mga halagang napagmasdan ko, kaya kung magkakaiba ang iyong mga obserbasyon, baguhin ang mga numerong ito. Ang ideya ay na kung ang Robo-Technician ay may pandama sa isang bagay ng ilang sentimetro sa harap nito, ito ay babagal, anumang higit pa sa iyon ay hindi kinakailangan.

Ang susunod na bahagi ay kung saan nai-save ang mga larawan para sa ibang pagkakataon.

% kung una o pangalawang pagpipilian ay napili sa prob dialog, makatipid ng imahe kung prob == 1% kung ang loop ay nagtatayo ng impormasyon ng file para sa larawan, nagsusulat gamit ang timestamp t = orasan; basename = sprintf ('\ img_% d_% d_% d_% d_% d.png', t (1), t (2), t (3), t (4), t (5)); folder = 'E: / UTK / Classes / fall 18 / ef230 / irobot / imahe'; fullFileName = fullfile (folder, basename); imwrite (img, fullFileName) isara ang Larawan 1 pause (2) kung hindi man == 2 t = orasan; basename = sprintf ('\ img_% d_% d_% d_% d_% d.png', t (1), t (2), t (3), t (4), t (5)); folder = 'E: / UTK / Classes / fall 18 / ef230 / irobot / imahe'; fullFileName = fullfile (folder, basename); imwrite (img, fullFileName) isara ang Figure 1 pause (2) pagtatapos

Ang lahat ng mga filename at lokasyon kung saan nai-save ang mga larawan ay opsyonal. Pinili ko ang isang folder na nakapugad sa loob ng folder ng roomba na nilikha ko sa hakbang ng pagpapakilala, ngunit maaari itong maging saan man mo mapili. Gayundin, ang mga larawan ay nai-save gamit ang timestamp, ngunit hindi iyon lalo na kinakailangan (kahit na ito ay magiging kapaki-pakinabang sa para sa isang misyon sa Mars).

Sa takip ng mga pisikal na sensor ng bunggo, maaari kaming lumipat sa mga bangin na sensor at sumusunod na landas.

Hakbang 6: Sumusunod sa Landas

Ang code para sa mga cliff sensor ay naka-set up upang ihambing ang mga halaga ng dalawang harap at dalawang halaga ng sensor ng gilid. Kakailanganin mong baguhin ang mga halagang ito (marahil) batay sa iyong naobserbahang mga halaga. Marahil ay kakailanganin mong i-edit ang mga halagang ito pagkatapos ng ilang mga pagpapatakbo ng pagsubok at palitan ang mga ito batay sa ilaw ng paligid, oras ng araw (depende sa kung gaano naiilawan ang lugar ng pagsubok) o kung marumi ang mga sensor ng bintana.

Bago kami makarating sa cliff sensor code gayunpaman, mayroong isang maikling segment ng code na ipinasok ko upang mapula ang ilan sa hindi kinakailangang data mula sa Matlab. Ang bahaging ito ay hindi kinakailangan, ngunit ginamit ko ito upang mabawasan ang imbakan na kinakailangan upang patakbuhin ang programa.

malinaw na img limasin t i-clear ang basename i-clear ang buongFileName malinaw na folder

Ang susunod na segment ng code ay ang karne ng proyekto. Pinapayagan nitong sundin ng Robo-Technician ang ilaw na may kulay na landas na inilagay sa sahig. Sa madaling sabi, sinusubukan nitong patnubayan ang sarili nito kaya ang harapan ng dalawang cliff sensor ay nasa itaas ng threshold, batay sa iyong mga naobserbahang halaga, at pinapayagan ang programa na simulan ang mga hakbang sa pagproseso ng imahe nang kaunti pa mamaya.

C = r.getCliffSensors% kung ang loop ay sumusunod sa isang kulay na banda (puti) kung C. leftFront> 2000 && C. rightFront> 2000% deretso na patnubay sa daanan r.setDriveVelocity (driv) kung hindi pa C. kaliwa ng Pauna 2000% lumiliko pakanan kung ang robot ay napakalayo kaliwa r.turnAngle (-2.5) kung hindi C. leftFront> 2000 && C. RightFront <2000% lumiliko sa kaliwa kung ang robot ay napakalayo sa kanan r.turnAngle (2.5) kung hindi C.leftFront <2000 && C. RightFront 100 || L.leftFront> 100 || L. RightFront> 100 || L. kanan> 100 img = r.getImage end% mga tseke upang makita kung mayroong isang liko sa landas kung C. Kaliwa> 2800 && C. kanan <2800 r.turnAngle (2.5) kung hindi man C. kaliwa 2800 r.turnAngle (- 2.5) may-hawak ng end% na lugar para sa disp ng pagkilala sa imahe ng path ('GETTING IMAGE') end end end

Tandaan na ang mga pangalan ng variable na pinili ko ay opsyonal, ngunit sa palagay ko ginagawang mas madali ang buhay na gumamit ng mga solong variable ng liham kung posible

Upang ipaliwanag ang gitnang seksyon ng code, kapag ang dalawang front sensor ay tumakbo sa gilid ng landas (pagdating sa isang intersection o kapag umabot ito sa dulo ng landas) tumingin ito upang makita kung may isang bagay sa harap nito. Kakailanganin mong ilagay ang isang bagay sa lupa sa dulo ng daanan o sa anumang mga interseksyon upang gumana ito.

Kapag nakuha ang larawan ay gumagamit ito ng pagkilala sa imahe upang malaman kung ano ang dapat gawin. Mayroong may hawak ng lugar sa seksyong ito ng code din:

% may-ari ng lugar para sa pagkilala ng imahe sa path ('GETTING IMAGE')

Ginamit ko ito para sa sandaling ito dahil nais kong pag-usapan ng partikular ang tungkol sa pagproseso ng teksto at kulay na nangyayari, na nasa susunod na hakbang.

Hakbang 7: Pagpoproseso ng Larawan

Mayroong dalawang bahagi sa pagproseso ng imahe. Una ay ang pagkilala sa kulay, na kinakalkula ang intensity ng kulay sa larawan upang magpasya kung magpapatuloy o hindi sa pagkilala sa teksto. Ang mga kalkulasyon ng kulay ay batay sa kung anong pagpipilian ang ginawa sa pinakaunang kahon ng pag-uusap sa simula (Gumamit ako ng pula, asul, berde ngunit maaari kang pumili ng anumang mga kulay na gusto mo, hangga't ang mga mean na halaga para sa intensity ng kulay ay maaaring makilala ng Raspberry Pi camera).

img = r.getImage img = imcrop (img, [0 30 512 354]) imgb = imcrop (img, [0 30 512 354]) imgt = imcrop (img, [0 30 512 354]) red = mean (mean (imgb (:,:, 1))); g = ibig sabihin (ibig sabihin (imgb (:,:, 2))); b = ibig sabihin (ibig sabihin (imgb (:,:, 3)));

Ito ang intensity check. Gagamitin ito sa susunod na segment upang magpasya kung ano ang nais nitong gawin.

kung pula> g && pula> b kung pathcolor == 1 imgc = imcrop (img, [0 30 512 354]) R = ocr (img) kung R. Words {1} == IMAGE || R. Mga Salitang {2} == IMAGE || R. Words {3} == IMAGE t = orasan; basename = sprintf ('\ img_% d_% d_% d_% d_% d.png', t (1), t (2), t (3), t (4), t (5)); folder = 'E: / UTK / Classes / fall 18 / ef230 / irobot / imahe'; fullFileName = fullfile (folder, basename); imwrite (img, fullFileName) i-pause (2) kung iba pa ang R. Mga salita {1} == KARAPATAN || R. Mga Salitang {2} == TAMA || R. Mga Salitang {3} == KANAN r.turnAngle (-75) iba pa kung R. Mga Salita {1} == KALIWA || R. Mga Salita {2} == KALIWA || R. Mga Salitang {3} == KALIWA r.turnAngle (75) iba pa kung R. Mga Salita {1} == BALIK || R. Mga Salitang {2} == BACK || R. Mga salita {3} == BACK r.turnAngle (110) magtapos pa r.turnAngle (110) end end

Nagpapasya ang segment na ito kung ang kulay na napili sa unang dialog box ay tumutugma sa kulay na nakikita ng camera. Kung ito ay nagpapatakbo ng pagkilala sa teksto. Tinitingnan nito upang makita kung aling salita (IMAGE, BACK, RIGHT o LEFT) ang lilitaw at pagkatapos ay alinman sa pagliko (para sa kanan at kaliwa), paikot (para sa likod) o kumukuha ng larawan at nai-save ito sa parehong paraan tulad ng mas maaga.

Nagbigay lamang ako ng isang solong seksyon ng code para sa iba't ibang mga kulay

Upang payagan ang code na makilala ang asul at berde, kopyahin lamang ang code at palitan ang tseke ng lohika sa tuktok ng segment at itakda ang "pathcolor == (numero)" upang tumutugma sa mga pagpipilian ng kulay mula sa tuktok na kahon ng dayalogo (para sa code habang ipinapakita, ang asul ay magiging 2 at ang berde ay magiging 3).

Hakbang 8: Ang Tapos na Produkto

Ngayon ang Robo-Technician ay dapat mag-zoom sa paligid ng mga module ng misyon ng Mars at mag-ulat pabalik sa mga astronaut kapag ang anumang wala sa lugar.

Tandaan, ang lahat ng mga sensor ng cliff at mga halaga ng lightBumper ay kailangang mabago sa kung ano ang iyong mga naobserbahang halaga. Gayundin, mula sa karanasan nahanap kong mas mahusay na subukan ang proyektong ito sa isang madilim na kulay na sahig at mas mabuti pa kung ang sahig na iyon ay hindi nasasalamin. Nakukuha nito ang kaibahan upang madagdagan ang pagitan ng landas at ng sahig na ginagawang mas malamang na sundin ito ng tama ng Robo-Technician.

Inaasahan kong nasiyahan ka sa pagse-set up ng isang maliit na katulong para sa misyon ng Mars, at masaya ang pagbuo.