Rpibot - Tungkol sa Pag-aaral ng Robotics: 9 Mga Hakbang

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

Ako ay isang naka-embed na software engineer sa isang German automotive company. Sinimulan ko ang proyektong ito bilang isang platform ng pag-aaral para sa mga naka-embed na system. Ang proyekto ay nakansela ng maaga ngunit nasisiyahan ako nang labis na nagpatuloy ako sa aking libreng oras. Ito ang resulta …

Mayroon akong mga sumusunod na kinakailangan:

• Simpleng hardware (pokus ang software)
• Murang hardware (mga 100 €)
• Napapalawak (ang ilang mga pagpipilian ay bahagi na ng paglalarawan)
• Supply boltahe para sa lahat ng mga bahagi mula sa solong 5V mapagkukunan (powerbank)

Wala talagang isang layunin bukod sa pag-aaral. Ang platform ay maaaring magamit para sa pag-aaral, surveillance, robotic contests,…

Hindi ito isang tutorial ng nagsisimula. Kailangan mo ng pangunahing kaalaman tungkol sa:

• Programming (Python)
• Pangunahing electronics (upang ikonekta ang mga module na magkakasama ng tamang boltahe)
• Pangunahing teorya ng kontrol (PID)

Sa wakas marahil ay mahaharap ka sa mga problemang tulad ko. Sa ilang pag-usisa at pagtitiis, dadaan ka sa proyekto at malulutas ang mga hamon. Ang aking code ay kasing simple hangga't maaari at ang mga kritikal na linya ng code ay nagkomento upang magbigay ng mga pahiwatig.

Ang kumpletong source code at mga file ay magagamit dito:

Mga Pantustos:

Mekaniko

• 1x Plywood board (laki ng A4, 4 mm ang kapal)
• 3x M4 x 80 Screw at nut
• 2x Gear motors na may pangalawang output shaft para sa encoder. Mga gulong.
• 1x Libreng gulong

1x Pan at ikiling ang pag-mount ng camera (opsyonal)

Elektronika

• 1x Raspberry Pi Zero na may header at camera
• 1x PCA 9685 servo control
• 2x Optical encoder wheel at circuit
• 1x Mga wire ng jumper ng babae
• 1x USB powerbank
• 1x DRV8833 dual driver ng motor
• 2x Micro servos SG90 para sa camera pan at ikiling (opsyonal)
• 1x MPU9250 IMU (opsyonal)
• 1x HC-SR04 ultrasonic distansya sensor (opsyonal)
• 1x butas na board at soldering wire, header,…

Hakbang 1: Buuin ang Chassis

Hindi ako mahusay na taga-disenyo ng mekaniko. Gayundin ang layunin ng mga proyekto ay hindi gumugugol ng sobrang oras sa tsasis. Gayunpaman tinukoy ko ang mga sumusunod na kinakailangan:

• Murang mga materyales
• Mabilis na pagpupulong at pag-disassemble
• Napapalawak (hal. Puwang para sa mga idinagdag na sensor)
• Mga light material upang makatipid ng enerhiya para sa electronics

Ang isang madali at murang chassis ay maaaring gawin ng playwud. Madaling makina gamit ang isang fretsaw at isang hand drill. Maaari mong pandikit ang maliliit na mga bahagi na gawa sa kahoy upang likhain ang mga hawak para sa mga sensor at motor.

Isipin ang kapalit ng mga bahagi ng depekto o ang pag-debug ng elektrisidad. Ang mga pangunahing bahagi ay dapat na maayos ng mga turnilyo upang mapalitan. Ang isang mainit na baril na pandikit ay maaaring simple, ngunit marahil ay hindi ang pinakamahusay na paraan upang bumuo ng isang chassis … Kailangan ko ng maraming oras upang mag-isip tungkol sa isang madaling konsepto upang madaling maalis ang mga bahagi. Ang pag-print sa 3D ay isang mahusay na kahalili, ngunit maaaring maging masyadong mahal o matagal.

Ang libreng gulong sa wakas ay napakagaan at madaling mai-mount. Ang mga kahalili ay pawang mabigat o puno ng alitan (sinubukan ko ang ilan sa mga ito bago hanapin ang panghuli). Kailangan ko lang gupitin ang isang kahoy na spacer upang maitumbas ang walang gulong na gulong pagkatapos na mai-mount ang pangunahing mga gulong.

Mga katangian ng gulong (para sa mga kalkulasyon ng software)

Lupon: 21, 5 cm Mga Pulso: 20 pulso / rev. Resolusyon: 1, 075 cm (sa wakas ang 1 pulso ay tungkol sa 1cm, na madali para sa mga kalkulasyon ng software)

Hakbang 2: Elektronika at Mga Kable

Gumagamit ang proyekto ng iba't ibang mga module tulad ng ipinakita sa diagram.

Ang Raspberry Pi Zero ang pangunahing Controller. Ito ay ang pagbabasa ng mga sensor at pagkontrol sa mga motor sa pamamagitan ng isang PWM signal. Ito ay konektado sa isang remote PC sa pamamagitan ng wifi.

Ang DRV8833 ay isang dalawahang motor H-tulay. Nagbibigay ito ng sapat na kasalukuyang sa mga motor (na hindi maaaring gawin ng Raspberry Pi dahil ang mga output ay maihahatid lamang ang ilang mA).

Ang optical encoder ay nagbibigay ng isang parisukat na hugis na signal sa tuwing ang ilaw ay dumadaan sa mga gulong ng encoder. Gagamitin namin ang mga nakakagambala na HW ng Raspberry Pi upang makuha ang impormasyon sa tuwing magpapalipat-lipat ang signal.

Ang pca9695 ay isang servo control board. Ito ay nakikipag-usap sa pamamagitan ng isang serial bus na I2C. Ang board na ito ay nagbibigay ng mga signal ng PWM at supply voltage na kinokontrol ang mga servos para sa kawali at ikiling ng cam.

Ang MPU9265 ay isang 3-axis acceleration, 3-axis angular rotation speed, at 3-axis magnetic flux sensor. Gagamitin namin ito higit sa lahat upang makuha ang heading ng compass.

Ang magkakaibang mga module ay konektado nang magkasama sa pamamagitan ng jumper wire. Ang isang breadboard ay kumikilos bilang isang dispatcher at nagbibigay ng mga supply voltages (5V at 3.3V) at mga bakuran. Ang mga koneksyon ay inilarawan sa talahanayan ng koneksyon (tingnan ang kalakip). Ang pagkonekta ng 5V sa isang 3.3V input ay marahil sirain ang iyong maliit na tilad. Mag-ingat at suriin ang lahat ng iyong mga kable nang dalawang beses bago mag-supply (espesyal na dapat isaalang-alang ang encoder). Dapat mong sukatin ang pangunahing mga voltages ng supply sa dispatch board na may isang multimeter bago ikonekta ang lahat ng mga board. Ang mga module ay naayos ng mga nylon turnilyo sa tsasis. Dito din ako nasisiyahan na maayos ang mga ito ngunit naaalis din kung may mali.

Ang nag-iisa lamang na paghihinang ay ang mga motor at ang breadboard at mga header. Upang maging matapat, gusto ko ang mga jumper wires ngunit maaari silang humantong sa maluwag na koneksyon. Sa ilang mga sitwasyon, maaaring suportahan ka ng ilang pagsubaybay sa software sa pag-aralan ang mga koneksyon.

Hakbang 3: Infrastructure ng Software

Matapos makamit ang mekanika, magse-set up kami ng ilang mga imprastraktura ng software upang magkaroon ng komportableng mga kondisyon sa pag-unlad.

Git

Ito ay isang libre at bukas na sistema ng pagkontrol ng bersyon ng mapagkukunan. Ginagamit ito upang pamahalaan ang mga malalaking proyekto bilang Linux, ngunit madali ring magagamit para sa maliit na proyekto (tingnan ang Github at Bitbucket).

Ang mga pagbabago sa proyekto ay maaaring subaybayan nang lokal at maitulak din sa isang remote server upang ibahagi ang software sa komunidad.

Ang pangunahing ginagamit na mga utos ay:

git clone https://github.com/makerobotics/RPIbot.git [Kunin ang source code at git config]

git pull pinagmulan master [makuha ang pinakabagong mula sa remote na imbakan]

git katayuan [makuha ang katayuan ng lokal na lalagyan. Mayroon bang mga file na binago?] Git log [kunin ang listahan ng mga commits] git add. [idagdag ang lahat ng binago na mga file sa entablado upang maisaalang-alang para sa susunod na gumawa]

Pagtotroso

Ang Python ay nagbibigay ng ilang built in logging function. Dapat tukuyin ng istraktura ng software ang lahat ng balangkas ng pag-log bago simulan ang karagdagang pag-unlad.

Ang logger ay maaaring mai-configure upang mag-log na may isang tinukoy na format sa terminal o sa isang file ng log. Sa aming halimbawa, ang logger ay na-configure ng klase ng webserver ngunit maaari rin naming gawin ito sa aming sarili. Dito itinakda lamang namin ang antas ng pag-log sa DEBUG:

logger = logging.getLogger (_ name_)

logger.setLevel (pag-log. DEBUG)

Pagsukat at paglalagay

Upang pag-aralan ang mga signal sa paglipas ng panahon, ang pinakamaganda ay ang paglalagay ng mga ito sa isang tsart. Tulad ng ang Raspberry Pi ay mayroong isang terminal ng console lamang, susubaybayan namin ang data sa isang semicolon na pinaghiwalay na csv file at i-plot ito mula sa remote PC.

Ang pinaghiwalay na semicolon na file ng pagsubaybay ay nabuo ng aming pangunahing code ng sawa at dapat magkaroon ng mga header na tulad nito:

timestamp; yawCorr; encoderR; I_L; odoDistance; ax; encoderL; I_R; yaw; eSpeedR; eSpeedL; pwmL; speedL; CycleTimeControl; wz; pwmR; speedR; Iyaw; hdg; m_y; m_x; eYaw; cycleTimeSense;

1603466959.65;0;0;25;0.0;-0.02685546875;0;25;0;25;25;52;0.0;23;0.221252441406;16;0.0;0;252.069366413;-5.19555664062;-16.0563964844;0;6; 1603466959.71;0;0;50;0.0;0.29150390625;0;50;0;25;25;55;0.0;57;-8.53729248047;53;0.0;0;253.562118111;-5.04602050781;-17.1031494141;0;6; 1603466959.76;0;-1;75;0.0;-0.188232421875;1;75;2;25;25;57;0;52;-24.1851806641;55;0;0;251.433794171;-5.64416503906;-16.8040771484;2;7;

Ang unang haligi ay naglalaman ng timestamp. Ang mga sumusunod na haligi ay libre. Ang plotting script ay tinatawag na may isang listahan ng mga haligi na mai-plot:

remote @ pc: ~ / python rpibot_plotter -f trace.csv -p speedL, speedR, pwmL, pwmR

Magagamit ang plot script sa folder ng tool:

Gumagamit ang plotter ng mathplotlib sa Python. Dapat mong kopyahin ito sa iyong PC.

Para sa higit na kaginhawaan, ang script ng sawa ay tinawag ng isang bash script (plot.sh) na ginagamit upang kopyahin ang file ng Raspberry Pi trace sa remote PC at tawagan ang plotter na may pagpipilian ng signal. Ang bash script na "plot.sh" ay nagtanong kung ang file ay kailangang makopya. Ito ay mas maginhawa para sa akin sa halip na manu-manong pagkopya sa bawat oras. Ginagamit ang "sshpass" upang makopya ang file mula sa Raspberry Pi sa remote PC sa pamamagitan ng scp. Nagagawa nitong kopyahin ang isang file nang hindi hinihiling ang password (ipinasa ito bilang isang parameter).

Sa wakas ay bubukas ang isang window kasama ang isang lagay ng lupa tulad ng ipinakita sa larawan.

Remote na komunikasyon

Ang interface ng pag-unlad sa Raspberry Pi ay SSH. Ang mga file ay maaaring mai-edit nang direkta sa target, o makopya ng scp.

Upang makontrol ang robot, isang web server ay tumatakbo sa Pi, na nagbibigay ng kontrol sa pamamagitan ng Websockets. Ang interface na ito ay inilarawan sa susunod na hakbang.

I-setup ang Raspberry Pi

Mayroong isang file na naglalarawan sa pag-set up ng Raspberry Pi sa folder na "doc" ng source code (setup_rpi.txt). Walang maraming mga paliwanag ngunit maraming mga kapaki-pakinabang na utos at link.

Hakbang 4: Ang User Interface

Ginagamit namin ang magaan na web server ng Tornado upang ma-host ang interface ng gumagamit. Ito ay isang module ng Python na tinatawagan namin sa pagsisimula namin ng robot control software.

Arkitektura ng software

Ang interface ng gumagamit ay binuo sa pamamagitan ng mga sumusunod na file: gui.html [Inilalarawan ang mga kontrol at layout ng web page] gui.js [Naglalaman ng javascript code upang hawakan ang mga kontrol at buksan ang isang koneksyon sa websocket sa aming robot] gui.css [Naglalaman ng mga estilo ng ang mga kontrol sa html. Ang mga posisyon ng mga kontrol ay tinukoy dito]

Ang komunikasyon sa websocket

Ang interface ng gumagamit ay hindi ang pinakaastig, ngunit ginagawa nito ang trabaho. Nakatuon ako dito sa mga teknolohiya na bago sa akin tulad ng Websockets.

Ang web site ay nakikipag-usap sa robot web server sa pamamagitan ng Websockets. Ito ay isang channel ng komunikasyon na bidirectional na kung saan ay mananatiling bukas habang pinasimulan ang koneksyon. Ipinapadala namin ang mga utos ng robot sa pamamagitan ng Websocket sa Raspberry Pi at kumuha ng impormasyon (bilis, posisyon, stream ng camera) pabalik para maipakita.

Ang layout ng interface

Ang interface ng gumagamit ay may isang manu-manong pag-input para sa mga utos. Ginamit ito sa simula upang magpadala ng mga utos sa robot. Ang isang checkbox ay binubuksan at patayin ang stream ng camera. Kinokontrol ng dalawang slider ang camera pan at ikiling. Ang tuktok na kanang bahagi ng interface ng gumagamit ay kinokontrol ang paggalaw ng mga robot. Maaari mong kontrolin ang bilis at target na distansya. Ang pangunahing impormasyon sa telemetry ay ipinapakita sa pagguhit ng robot.

Hakbang 5: Programming ang Robot Platform

Ang bahaging ito ang pangunahing layunin ng proyekto. Nag-refact ako ng maraming software habang ipinakilala ko ang bagong chassis sa mga motor na DC. Ginamit ko ang Python bilang isang wika sa programa para sa iba't ibang mga kadahilanan:

• Ito ang pangunahing wika ng Raspberry Pi
• Ito ay isang mataas na antas ng wika na may maraming mga built-in na tampok at extension
• Ito ay nakatuon sa object ngunit maaari ding gamitin para sa sunud-sunod na programa
• Walang compilation o tool chain kinakailangan. I-edit ang code at patakbuhin ito.

Pangunahing arkitektura ng software

Ang software ay nakatuon sa object, nahahati sa ilang mga object. Ang aking ideya ay upang hatiin ang code sa 3 mga functional block:

Sense Think Actuate

Sense.py

Pangunahing pagkuha ng sensor at pagproseso. Ang data ay nakaimbak sa isang diksyunaryo upang magamit ng sumusunod na yugto.

Control.py

Ang isang actuation subclass ay ang pagkontrol sa mga motor at servos pagkatapos ng ilang abstraction. Ang pangunahing object ng Control ay paghawak ng mga high level command at pati na rin ang mga control algorithm (PID) para sa motor.

rpibot.py

Ang pangunahing bagay na ito ay pamamahala ng Tornado web server at pag-instay sa mga klase ng kahulugan at pagkontrol sa magkakahiwalay na mga thread.

Ang bawat module ay maaaring patakbuhin nang mag-isa o bilang bahagi ng buong proyekto. Maaari mo lamang maunawaan at mai-print ang impormasyon ng sensor upang suriin na ang mga sensor ay konektado nang tama at naghahatid ng tamang impormasyon.

Ang kontrol ng PID

Ang unang gawain ay upang malaman kung ano ang gusto nating kontrolin. Nagsimula ako sa pamamagitan ng pagsubok na kontrolin ang posisyon, na kung saan ay napaka-kumplikado at hindi masyadong tumutulong.

Sa wakas, nais naming makontrol ang bawat bilis ng gulong at din ang direksyon ng robot. Upang gawin iyon kailangan nating mag-cascade ng dalawang control logics.

Upang madagdagan ang pagiging kumplikado nang sunud-sunod, dapat kontrolin ang robot:

buksan ang loop (na may pare-pareho na lakas)

pwm = K

pagkatapos ay idagdag ang malapit na loop algorithm

pwm = Kp.speedError + Ki. Integration (speedError)

at sa wakas ay idagdag ang kontrol sa direksyon bilang isang huling hakbang.

Para sa control ng bilis gumamit ako ng isang "PI" control at "P" para lamang sa paghikab. Manwal kong itinakda ang mga parameter sa pamamagitan ng pag-eksperimento. Marahil ay mas mahusay na mga parameter ang maaaring magamit dito. Ang aking target ay isang tuwid lamang na linya at muntik ko itong makuha. Lumikha ako ng isang interface sa software upang magsulat ng ilang mga variable ng interface ng gumagamit. Ang pagtatakda ng parameter Kp sa 1.0 ay nangangailangan ng sumusunod na utos sa interface ng gumagamit:

Itakda; Kp; 1.0

Maaari kong itakda ang parameter ng P sapat na mababa lamang upang maiwasan ang anumang overshot. Ang natitirang error ay naitama ng parameter ng I (isinamang error)

Ito ay mahirap para sa akin upang malaman kung paano i-cascade ang parehong mga kontrol. Ang solusyon ay simple, ngunit sinubukan ko ang maraming iba pang mga paraan bago … Kaya sa wakas, binago ko ang target na bilis ng mga gulong upang lumiko sa isa o sa iba pang direksyon. Ang pagbabago ng direktang output ng control control ay isang error dahil sinusubukan ng speed control na alisin ang pagkakagambala na ito.

Ang ginamit na diagram ng kontrol ay nakakabit. Ipinapakita lamang nito ang kaliwang bahagi ng kontrol ng robot.

Hakbang 6: Ang Mga Pag-calibrate ng Sensor

Ang unang bagay na isasaalang-alang ay ang buong IMU na kailangang gumana nang maayos. Nag-order ako ng 3 bahagi at ibinalik ang mga ito hanggang sa magkaroon ako ng buong gumaganang sensor. Ang bawat nakaraang sensor ay may ilang mga bahagi ng sensor na hindi gumagana nang maayos o hindi man. Gumamit ako ng ilang mga halimbawa ng script upang subukan ang mga pangunahing kaalaman bago i-mount ito sa robot.

Ang mga signal ng IMU sensor ay kailangang i-calibrate bago gamitin ito. Ang ilang mga signal ng sensor ay nakasalalay sa tumataas na anggulo at posisyon.

Ang mga calibration ng bilis ng bilis at pag-ikot

Ang pinakamadaling pagkakalibrate ay para sa paayon na pagpapabilis (A_x). Sa pagtigil ay dapat na humigit-kumulang sa 0 m / s². Kung paikutin mo nang maayos ang sensor, maaari mong sukatin ang gravity (sa paligid ng 9, 8 m / s²). Upang i-calibrate ang a_x, kailangan mo lamang itong mai-mount nang maayos at pagkatapos ay tukuyin ang offset upang makakuha ng 0 m / s² sa pagtigil. Ngayon ang A_x ay naka-calibrate. Maaari kang makakuha ng mga offset para sa mga bilis ng pag-ikot sa isang katulad na paraan sa pag-upo.

Ang pagkakalibrate ng magnetometer para sa compass

Ang isang mas kumplikadong pagkakalibrate ay kinakailangan para sa mga magnetic field sensor. Gagamitin namin ang m_x at m_y upang makuha ang magnetic field sa pahalang na antas. Ang pagkakaroon ng m_x at m_y ay magbibigay sa amin ng pagkakataong makalkula ang isang heading sa compass.

Para sa aming simpleng layunin ay i-calibrate lang namin ang matapang na paglihis ng bakal. Dapat itong gumanap habang ang sensor ay nasa pangwakas na posisyon dahil nakasalalay ito sa mga pagkagambala ng magnetic field.

Itinatala namin ang m_x at m_y habang pinapaliko namin ang robot sa z-axis. Inilalagay namin ang m_x vs m_y sa isang tsart na XY. Ang resulta sa isang ellipsis tulad ng ipinakita sa larawan. Ang ellipsis ay dapat na nakasentro sa pinagmulan. Isinasaalang-alang namin dito ang maximum at minimum na mga halaga ng m_x at m_y upang makuha ang mga offset sa parehong direksyon. Panghuli suriin namin ang pagkakalibrate at makita na ang ellipsis ay nakasentro ngayon.

Ang pag-calibrate ng malambot na bakal ay nangangahulugang binabago namin ang larawan mula sa isang ellipsis patungo sa isang bilog. Maaari itong gawin sa pamamagitan ng pagdaragdag ng isang kadahilanan sa bawat halaga ng senor.

Ang isang gawain sa pagsubok ay maaari na ngayong mai-code upang muling mai-calibrate o hindi bababa upang suriin na ang mga sensor ay naka-calibrate pa rin.

Ang heading ng compass

Gagamitin ang data ng magnetometer upang makalkula ang heading ng compass. Para sa mga ito, kailangan naming i-convert ang m_x at m_y signal sa isang anggulo. Ang Python ay direktang nagbibigay ng pagpapaandar ng matematika.atan2 na mayroong hangarin na ito. Ang kumpletong pagkalkula ay tinukoy sa mpu9250_i2c.py file ("calcHeading (mx, my, mz)").

Hakbang 7: Mga Alternatibong Disenyo

Ang proyekto ay tumagal ng maraming oras dahil ang disenyo ay ganap na bukas. Para sa bawat bahagi gumawa ako ng ilang pagpapatupad ng prototype at naranasan ang mga limitasyon ng system.

Ang pinaka-kumplikadong paksa ay ang encoder ng gulong. Sinubukan ko ang 3 magkakaibang mga pagpipilian bago hanapin ang kasalukuyang ginagamit na optical encoder. Sa palagay ko ang mga napalaglag na solusyon ay napakahusay din sa naturang proyekto. Ito ay patungkol sa mga bahagi kung saan ko natutunan ang higit.

Patuloy na pag-ikot ng servo na konektado sa pca 9695

Upang maiwasan ang isang karagdagang H-tulay para sa isang motor na DC, una akong nagsimula sa tuluy-tuloy na servos ng pag-ikot. Ang mga ito ay hinihimok ng mayroon nang kasalukuyang driver ng servo ng pca 9695. Ang lahat ng mekanismo ng propulsyon at ang mga electronics ng sulat ay mas simple. Ang disenyo na ito ay may dalawang mga drawbacks:

• Ang mahinang saklaw ng kontrol ng mga servos.
• Ang nawawalang encoder na lokasyon na humahawak

Ang servos ay nagsisimulang gumalaw ng 50% pwm at may buong bilis na halos 55%. Ito ay isang napakahirap na saklaw ng kontrol.

Nang walang hawak na encoder, napaka-difficut nito upang makahanap ng handa nang pumunta sa encoder. Sinubukan ko ang 3 magkakaibang pagsasalamin encoder na naka-mount sa tsasis. Nag-tape ako ng isang self-encoder wheel sa labas ng gulong na may mga itim at puting seksyon. Ginamit ko ang mga sensor ng QTR-1RC na nangangailangan ng maraming pagpoproseso ng signal upang makuha ang tamang signal. Ang Raspberry Pi ay hindi nakagawa ng ganoong klaseng pagproseso ng real time. Kaya't nagpasya akong magdagdag ng isang NodeMCU D1 mini bilang isang real time controller sa robot. Nakakonekta ito sa raspberry Pi ng serial UART upang maihatid ang naprosesong data ng sensor. Pinangangasiwaan din ng NodeMCU ang sensor ng HC-SR04. Mahirap ang mekaniko at hindi masyadong matatag, ang linya ng serial ay nakakakuha ng ingay mula sa linya ng I2C at mga motor, kaya't sa wakas ay itinayo ko ang pangalawang bersyon ng chassis na may simpleng gear DC motor na hinimok ng isang H-tulay. Ang mga motor na ito ay may pangalawang output shaft upang maglagay ng isang optikong encoder.

Hakbang 8: Pagpoproseso ng Larawan

Upang mapabuti ang autonomous na pagmamaneho, makakagawa kami ng ilang pagproseso ng imahe.

Ang opencv library ay isang sanggunian para doon. Maaari itong magamit ng Python upang mabilis na magpatupad ng pagtuklas ng balakid.

Kumuha kami ng isang imahe at naglalapat ng ilang mga gawain sa pagproseso ng imahe:

Ang mga unang pagsubok ay ginawa kasama ang mga pagbabago sa Canny at Sobel. Si Canny ay maaaring maging isang mahusay na kandidato ngunit hindi sapat na matino. Sobel ay masyadong matino (masyadong maraming mga bagay na napansin).

Sa wakas gumawa ako ng aking sariling filter upang ihalo ang lahat ng mga pahalang at patayong mga gradient (tuklasin ang mga kasangkapan):

• Ibahin ang imahe ng kulay sa isang kulay-abo na imahe sa antas
• Palabuin ang imahe upang alisin ang maliit na ingay
• Threshold ang imahe sa isang itim at puting imahe
• Ngayon nakita namin ang pahalang at patayong mga gradient upang makita ang mga bagay bilang mga dingding at kasangkapan
• Ang mga natitirang contour lamang ang aming sinasala (tingnan ang mga may kulay na contour sa larawan)

Maaari na naming magamit ang bagong impormasyon na ito upang matukoy ang mga hadlang …

Hakbang 9: Mga Susunod na Hakbang …

Ngayon, mayroon kaming isang simpleng platform ng robot na may mga sensor, actuator at camera. Ang layunin ko ay lumipat nang autonomiya at bumalik sa istasyon nang hindi nagdaragdag ng anumang karagdagang mga sensor. Para dito kakailanganin ko ang mga sumusunod na hakbang:

• Pagsasama ng sensor ng yaw at mga signal ng heading ng magnetiko
• Pagproseso ng imahe ng camera (mababang CPU lamang ang magagamit para doon)
• Pagtuklas ng banggaan (distansya ng ultrasonic at camera)
• Pagbuo o oryentasyon ng mapa

Pumunta ngayon at lumikha ng iyong sariling mga hamon o target …