Wallace - DIY Autonomous Robot - Sehemu ya 5 - Ongeza IMU: Hatua 9

2024 Mwandishi: John Day | [email protected]. Mwisho uliobadilishwa: 2024-01-30 12:53

Tunaendelea pamoja na Wallace. Jina Wallace lilitokana na mchanganyiko wa "Wall-E", na kutoka kwa mradi uliopita (utambuzi wa sauti), na kwa kutumia huduma ya "espeak", ilisikika kuwa ya Uingereza. Na kama valet au mnyweshaji. Na hilo ndilo lengo la mwisho: kwa mradi huu kugeuka kuwa kitu muhimu. Kwa hivyo "Wallace".

Wallace anaweza kuzunguka, anaweza kuzuia vizuizi kwa kutumia sensorer za umbali wa IR (hivi karibuni, kwa njia fulani walikaanga (?) (Lazima angalie wakati nitapata nafasi), pia ana sensorer za umbali wa sauti (tatu kati ya hizo zilikuwa mbaya wakati huo huo wakati, pamoja na expander ya MCP23017), na mwishowe, inaweza kugundua mabadiliko katika motor-current kujua wakati imegubikwa na kitu.

Mbali na sensorer, Wallace "anakumbuka" hatua 100, na ana uchambuzi wa kawaida kutumia historia ya harakati.

Lengo hadi sasa kwa Wallace ni kujaribu tu kuendelea kusonga mbele, na kujua ni wakati gani imekwama katika muundo fulani wa kurudia (kama vile kona) na sio kusonga mbele.

Nimepitia njia kadhaa za harakati na urambazaji, na maumivu ya kichwa yanayofanana imekuwa wakati wa kuzunguka.

Kwa kuwa Wallace ni roboti inayofuatiliwa, na nilitaka kuweka vitu rahisi kwenye programu (kwa baadaye), ili kugeuza nina tu kuwa na pivot / zungusha mahali. Kwa hivyo, tumia mzunguko sawa wa nguvu / wajibu kwa motors.

Tatizo lililojitokeza ni kwa sababu ya muundo wa jukwaa la Wakala 390 la roboti. Mikanda ya kufuatilia huwa inasugua pande. Na mbaya zaidi, upande mmoja hufanya hivyo zaidi kuliko ule mwingine.

Kwenye sakafu na kwenda moja kwa moja, haikuwa shida. Inaonyesha juu ya kupaka. Nilichagua kuweka Wallace mbali na utaftaji baada ya nyimbo zake kuwa mbaya (wanachukua unyonge rahisi sana).

Shida halisi ni wakati wa kupigia sakafu.

Ikiwa nina programu inayotumia mzunguko wa ushuru wa kiwango cha juu, basi hubadilika mara kwa mara. Walakini, wakati wa mzunguko wa ushuru mdogo, inaweza kugeuka au isigeuke. Au inaweza kugeuka kwa kidogo na kisha kupunguza mwendo. Kitendo cha kupigia debe kinaonekana kuwa hakiwezi kudhibitiwa kupitia programu, au kwa ugumu sana.

Tatizo linajitokeza wakati wa urambazaji na kuzunguka au mbali na vizuizi. Inaweza kupinduka sana, au inaweza kukwama kujaribu kufanya mabadiliko ya dakika, bila hata kusonga.

Na kwa hivyo maelezo hapo juu yalimpa motisha Agizo hili.

Hapo awali, nilikuwa nikitaka kupeana, au kuchelewesha kuanzisha kitengo cha kuhisi mwendo (IMU), kwa sababu ni A) ngumu, B) kelele, C) makosa yanaweza kuletwa kwa muda, na nk, nk mawazo yangu yalikuwa imekuwa kwamba tunaweza kufanya vizuri sana kwa kuruka mbele kwa sensorer za wakati wa kukimbia-IR za laser. Na tunaweza - kutumia lasers tunaweza kujua ikiwa roboti ilizunguka au la, kwa kufuatilia mabadiliko kwa umbali.

Kwa kweli, tunaweza pia (aina ya) kufanya hivyo sasa, na sensorer za sauti.

Walakini, yote hayo ni njia isiyo ya moja kwa moja, ngumu kujibu swali moja rahisi: "tumezunguka au la?"

Ilionekana kwangu kuwa kuruka kutumia sensorer za ToF laser kuninipeleka kwenye kiwango kingine cha programu; yaani, SLAM (Ujanibishaji wa wakati mmoja na Ramani). Sikuwa tayari kwenda huko bado tu.

Ni jambo zuri kufanya mradi wa roboti kwa matabaka, na tabaka za kwanza (chini) zikiwa rahisi, na safu za mwisho (juu) zikiwa za kufikirika na kushughulikia maswala magumu zaidi.

Safu zinaweza kufikiria kitu kama hiki:

1. sura ya mwili ya roboti / msingi wa kimuundo
2. mfumo wa kuendesha gari wa kawaida (Raspberry, Roboclaw, motors, cabling, nk, programu ya msingi, inayoendeshwa na kibodi)
3. mizunguko muhimu kusaidia sensorer (shifter ya umeme-mwelekeo, uhamishaji wa bandari, E-Stop, usambazaji wa nguvu, nk)
4. sensorer za kuzuia kikwazo (acoustic, IR)
5. muhimu, nafasi ya msingi na harakati - kugundua (accelerometer, gyro, magnetometer, encoders za magari, encoders za gurudumu)

Unaweza kuja na orodha yako mwenyewe. Hoja juu ya orodha hii ni kwamba labda unapaswa kufanya zaidi au chini kwa utaratibu huo, na pia kwamba ikiwa utatumia muda kwa kila safu kupata kila moja kwa hali nzuri ya kufanya kazi, hiyo inapaswa kukusaidia baadaye wakati mambo yanakuwa magumu zaidi.

Orodha hapo juu inaweza kupangiliwa zaidi au chini kwa safu hizi za dhana katika programu.

• SLAM (Ujanibishaji wa wakati mmoja na Ramani)
• Udhibiti na Uhamasishaji wa Harakati, Mzunguko
• Kuepuka Kizuizi cha Msingi
• Udhibiti na Ugunduzi wa Takwimu za Sensorer
• Harakati Muhimu Mbele, Nyuma, Kushoto na Kulia, Harakisha, Punguza Mwendo, Simama

Kama unavyoona, kwa orodha hii, vitu vya kwanza vitakuwa safu za juu, ngumu zaidi zinazoshughulikia maswala na maswali zaidi, kama vile "niko wapi" na "ninaenda wapi", wakati vitu vya mwisho vitakuwa tabaka za chini za programu ambazo hushughulikia "jinsi ya kuongea / kusikiliza sensa A" au "jinsi ya kusonga gurudumu hili".

Sasa, sisemi kwamba unapoanza kwa safu, utakuwa umekamilisha na kisha iko kwenye safu inayofuata, kamwe usirudi kwa ile ya awali. Mradi wa roboti unaweza kuwa kama njia za kisasa, za kukuza programu (itikadi, SCRUM, nk).

Ninasema tu kuchukua muda kwa kila mmoja. Itabidi usawazishe ni kiasi gani cha kufanya katika kila moja, na uamue ni nini unajaribu kwenye safu fulani inayofaa wakati na shida.

Kuna "mzozo" fulani au "mvutano" kati ya maoni au mwelekeo mbili zinazoshindana.

Mojawapo ni ile ambayo ningeiita "plug-n-play" kutatua shida A.

Nyingine ni DIY (fanya mwenyewe). Na hiyo inaweza kuwa sio lebo bora kwa wazo hili lingine.

Hapa kuna mfano wa kila mmoja, tumaini utaona mvutano au mzozo kati ya chaguzi mbili.

Kwa mfano huu, wacha uvimbe wa SLAM, kuzuia kikwazo, na harakati muhimu za kimsingi kama shida moja ya kutatua kwa wakati mmoja.

1. Ikiwa tunaamua kwenda kwa njia ya kuziba-n-kucheza, tunaruka mara moja (kulingana na bajeti) kwa vitu kama vile lasers zinazozunguka juu, au kamera ya kina ya uwanja, au lasers za ToF, na IMU (mada ya hii Inayofundishwa).
2. Ikiwa sisi, kwa upande mwingine, tunataka kwenda njia ya pili, tunaweza kujaribu kutoa kila habari inayowezekana kutoka kwa sensorer za acoustic au sensorer za IR, au hakuna sensorer kabisa - tunatumia tu ufuatiliaji wa sasa wa motor (bump)

Ni nini kinachoweza kusema juu ya # 1 vs # 2? Jambo moja itakuwa kwamba tutakuwa tumejifunza mengi zaidi kwa kufanya # 2. Upungufu wa kuwa na sensorer za sauti tu za kufanya kazi, hutulazimisha kufikiria juu ya maswala mengi zaidi.

Kwa upande mwingine, ikiwa tunazingatia sana kufanya vitu kupitia # 2, tunaweza kuwa tunapoteza wakati, kwa sababu tunaomba zaidi ya vile tunapaswa kutoka kwa sensorer za sauti.

Dhana moja zaidi au wazo la kufikiria: Je! Ni mchanganyiko gani wa vifaa na programu hujibu maswali ya "jinsi ya", na ni mchanganyiko gani wa programu (na vifaa?) Hujibu swali la "nini", "lini", "wapi". Kwa sababu "jinsi ya" kawaida ni swali la kiwango cha chini ambalo "nini", "lini", na "wapi" hutegemea kupata jibu.

Kwa hivyo, yote hapo juu yalikuwa kitu cha kufikiria.

Kwa upande wangu, baada ya bidii nyingi na kuwa na suala linalokasirisha linalofanana la msuguano wa wimbo na hauwezi kupata udhibiti thabiti na harakati, ni wakati wa kufanya kitu kingine.

Kwa hivyo hii inaweza kufundishwa - IMU.

Lengo ni kwamba ikiwa IMU inasema kuwa roboti HAIJALI, tunaongeza mzunguko wa ushuru. Ikiwa tunatembea kwa kasi sana, tunapunguza mzunguko wa ushuru.

Hatua ya 1: Sensorer ya IMU

Na kwa hivyo sensorer yetu inayofuata ya kuongeza Wallace ni IMU. Baada ya utafiti, nilikuwa nikikaa kwenye MPU6050. Lakini wakati huu, MPU9050 (na hata hivi karibuni, MPU9250) ilionekana kama wazo bora zaidi.

Chanzo changu cha kwenda imekuwa Amazon (huko Merika). Kwa hivyo niliamuru wawili wao.

Kile nilichopata kwa kweli (inaonekana hakuna udhibiti juu ya hii; ndio sipendi kuhusu Amazon) walikuwa MPU92 / 65. Nashangaa kidogo juu ya uteuzi. Angalia picha; hiyo inaonekana kuwa jina la "familia". Kwa hali yoyote, ndivyo ninavyoshikilia.

Ukiongeza ni rahisi sana -pata bodi ya proto iliyo na nyimbo za kuunganisha, unganisha kiwambo cha kupanda, ongeza kizuizi cha pini-10 cha pini (nilipata yangu kutoka Pololu).

Ili kupunguza usumbufu wowote, nilijaribu kuweka sensorer hizi mbali na kila kitu kingine.

Hiyo ilimaanisha pia kutumia bolts / karanga za nylon.

Nitatumia itifaki ya I2C. Tunatumai kuwa urefu wa waya hautakuwa mbaya sana.

Kuna habari nyingi mahali pengine juu ya unganisho la msingi na viwango vya voltage, nk, kwa hivyo sitairudia hapa.

Hatua ya 2: Vitu Sio Safi Daima, Rahisi

Katika maandishi haya, inaonekana hakuna mengi mkondoni kwa hii MPU-92/65. Kinachopatikana, kama vile sensorer nyingi, zinaonekana kuwa mifano ya kutumia Arduino.

Ninajaribu kufanya Maagizo haya kuwa tofauti kidogo kwa kuwasilisha mchakato sio safi sana, kwa sababu mambo hayafanyi kazi kila wakati mara moja.

Nadhani Maagizo haya yanafanana zaidi na blogi kuliko moja kwa moja A-B-C, 1-2-3 "hivi ndivyo unavyofanya".

Hatua ya 3: Mtihani wa Awali

Kutoka kwa picha katika hatua ya awali, waya nyekundu na nyeusi kwenda kwa sensorer bila shaka ni VCC (5V) na GND. Waya wa kijani na manjano ni unganisho la I2C.

Ikiwa umefanya miradi mingine ya I2C, au umekuwa ukifuata pamoja na safu hizi, basi tayari unajua kuhusu "i2cdetect", na hiyo ni hatua ya kwanza kujua ikiwa Raspberry inaweza kuona sensa mpya.

Kama unavyoona kutoka kwa picha kwenye hatua hii, jaribio letu la kwanza halikufanikiwa. IMU haionekani (inapaswa kuwa id ya kifaa 0x68).

Walakini, habari njema ni kwamba basi ya I2C inafanya kazi. Tunaona kifaa kimoja 0x20 na ni bandari ya bandari ya MCP23017 (ambayo sasa inawajibika kwa sensorer za sauti za HCSR04).

Sio rahisi kuona kwenye picha, lakini niliunganisha waya zile zenye rangi ya kijani na manjano kutoka IMU hadi MCP23017 (angalia kushoto chini kwenye picha)

Tutalazimika kufanya utatuzi fulani.

Hatua ya 4: Utatuzi wa matatizo

Kutumia mpangilio wa mwendelezo kwenye voltmeter (iliyo na sauti ya juu), nilijaribu uhusiano wa VCC (5V), GND, SDA, na SCL. Hiyo ilikuwa nzuri.

Jaribio lingine lilikuwa kukatisha MCP23017 kutoka kwa basi ya I2C, ikiacha MPU-92/65 tu kwenye basi. Hiyo ilionekana kuwa haina matunda - "i2cdetect" basi haikuonyesha vifaa.

Kwa hivyo, baadaye, nilishusha kihisi kutoka pole ya totem, na nikaiweka tena waya moja kwa moja kwa basi la 5V-to-3V; yaani, moja kwa moja kwa Raspberry. (waya fupi?).

Na voila. Wakati huu kuna mafanikio. Tunaona 0x68 ikijitokeza kwa kutumia "i2cdetect".

Lakini bado hatujui kwanini ilifanya kazi wakati huu. Inaweza kuwa urefu wa waya? Eneo la awali?

Kumbuka: Haikufanya tofauti yoyote ikiwa ADO ilikuwa msingi au la. Inaweza kuwa kuna bodi za pullup na vipinga-kuvuta. Hiyo inaweza kuwa kweli kwa FSYNC.

Ifuatayo, niliunganisha tena MCP23017. Kwa hivyo sasa tuna vifaa viwili kwenye basi ya I2C. (tazama picha). Mafanikio, sasa tunaona zote 0x20 na 0x68 na i2cdetect.

Video zinaingia zaidi ya kile kilichotokea wakati wa utatuzi.

Hatua ya 5: Kusoma Takwimu za Sensorer

Mbinu Mbalimbali

Niliamua kuchukua njia nyingi za kupata habari muhimu kutoka kwa sensa. Hapa wapo, sio kwa mpangilio wowote:

1. jaribu programu ya msingi
2. angalia nyaraka zingine mkondoni kwenye madaftari
3. angalia mifano ya wengine na / au nambari

Kwa nini njia hizi? Kwa nini usitafute tu maktaba au nambari iliyopo?

Kwa kujaribu na kujaribu maoni, tunaweza kuchukua maarifa kadhaa juu ya sio tu sensor hii, lakini pia kupata mbinu, ustadi, na njia za kufikiria juu ya kushughulikia kitu kipya, na kitu ambacho hakiwezi kuwa na nyaraka nyingi; kitu ambacho kinaweza kuwa na mengi yasiyojulikana.

Pia, mara tu tumecheza na kujaribu maoni yetu wenyewe na kupata ufahamu, tuko katika nafasi nzuri ya kutathmini nambari au maktaba ya mtu mwingine.

Kwa mfano, baada ya kuangalia nambari kadhaa ya C ++ ya MPU9250 huko github, niligundua ilikuwa inanilazimisha nitumie visumbufu, ambavyo bado sitaki kufanya.

Pia, inakuja na vitu vya ziada kama hesabu; tena, kitu ambacho sijapendezwa nacho.

Inawezekana kwamba kile ninachohitaji kufanya kujibu swali rahisi "ni roboti inayozunguka ndiyo au hapana" inaweza kujibiwa kwa urahisi kwa kusoma tu rejista zingine.

Sajili

Katika maandishi haya, inaonekana hakuna inapatikana kwenye kihisi hiki. Kwa kweli, ukiangalia picha ambazo zinakuja na hii inayoweza kufundishwa, na uangalie kwa uangalifu maandishi kwenye chips halisi, inanifanya nijiulize ikiwa hii sio kubisha. Sihusishi kile ninachokiona kutoka kwa Invense. Bila kujali, nilichagua kuangalia habari ya rejista ya mifano ambayo nimepata: MPU-6050, na MPU-9250.

Katika visa vyote viwili, yafuatayo ni sawa kwa wote wawili. Na kwa mwanzo, tunadhani itakuwa sawa na hii MPU-92/65.

59 hadi 64 - vipimo vya accelerometer

65, 66 - vipimo vya joto 67 hadi 72 - vipimo vya gyroscope 73 hadi 96 - data ya sensorer ya nje

Bidhaa ya kumbuka: MPU-6050 inaonekana HAINA sumaku ya sumaku, wakati MPU-9250 (na tunachukulia hii, pia) ina moja.

Maelezo mengine ya kufurahisha zaidi, na tumaini muhimu yalikusanywa kutoka kwa hati-ya usajili:

Maelezo ya Magnetometer:

kitambulisho cha magnetometer: 0x48 madaftari 00 hadi 09: 00H WIA 0 1 0 0 1 0 0 0 01H INFO INFO7 INFO6 INFO5 INFO4 INFO3 INFO2 INFO1 INFO0 02H ST1 0 0 0 0 0 0 DOR DRDY 03H HXL HX7 HXX HX4 HX4 HX HXH HX15 HX14 HX13 HX12 HX11 HX10 HX9 HX8 05H HYL HY7 HY6 HY5 HY4 HY3 HY2 HY1 HY0 06H HYH HY15 HY14 HY13 HY12 HY11 HY10 HY9 HY8 07HZ HZZ HZZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZZ HZ ZIWE ZINAZOTUMIKA ST2 0 0 0 BITM HOFL 0 0 0 mgawanyiko wa kile kila rejista inamaanisha: HXL [7: 0]: Takwimu za kipimo cha mhimili wa X hupungua 8bit HXH [15: 8]: Takwimu za kipimo cha X-axis juu 8bit HYL [7: 0]: Y-mhimili data chini ya 8bit HYH [15: 8]: Y-axis kipimo data juu 8bit HZL [7: 0]: Z-axis kipimo data chini 8bit HZH [15: 8]: Z-mhimili data data juu 8bit

Kupanga programu

Maelezo mengine mengine kutoka kwa hati za kujiandikisha ni kwamba ilionekana kuwa na sajili karibu 100 tu. Kwa hivyo mbinu moja inaweza kuwa kuandika programu rahisi inayofikia kifaa (0x68) na kujaribu kusoma safu ya rejista mfululizo, bila kuzingatia maana yake, ili tu kuona ni data gani inaweza kuonekana.

Na kisha, fanya kupita mfululizo, ukitumia nambari ile ile, na ulinganishe data kutoka kwa kupita moja hadi inayofuata.

Wazo ni kwamba labda tunaweza kuondoa sajili zozote ambazo zinaonekana hazina data (zero au FF?) Au ambazo hazibadiliki kabisa, na tunaweza pia kuzingatia zile zinazobadilika.

Halafu, moja tunatazama tu zile zinazobadilika, ongeza katika kazi ya wastani ambayo wastani wa kusoma kwa hivi karibuni kwa N hiyo ya rejista, kuona ikiwa kwa kweli kuna thamani fulani thabiti ya rejista hiyo. Hii inaweza kudhani tunaweka sensorer bado, na katika eneo moja.

Mwishowe, tunaweza kujaribu vitu kwa upole kwa sensorer, kama kuisukuma (accelerometer, gyro), au kuipuliza (joto), au kuizungusha (magnetometer mbili zilizopita) na kuona athari hii ina maadili.

Ninapenda kutumia maktaba ya wiringPi iwezekanavyo. Ina msaada kwa I2C.

Mbio wa kwanza:

/********************************************************************************

* kujenga: gcc kwanza.test.mpu9265.c -o kwanza.test.mpu9265 -lwiringPi * * kuendesha:, * na kisha kutoka MPU9265 (au MPU nyingine yoyote kwenye anwani hiyo ya 0x68) * * Niliitumia kuthibitisha ikiwa ningeweza kusoma kutoka kwa sensa, kwani tayari * nilikuwa na imani na MCP23017. * **************************************************. {inaweka ("Wacha tuone MCP23017 @ 0x20 inasema nini:"); makosa = 0; kifaa cha intId1 = 0x20; int fd1 = wiringPiI2CSetup (kifaaId1); ikiwa (-1 == fd1) {fprintf (stderr, "Haiwezi kufungua kifaa cha wiringPi I2C:% s / n", strerror (errno)); kurudi 1; } kwa (int reg = 0; reg <300; reg ++) {fprintf (stderr, "% d", wiringPiI2CReadReg8 (fd1, reg)); fflush (stderr); kuchelewesha (10); } huweka (""); inaweka ("Wacha tuone ni nini MPU9265 @ 0x20 inasema:"); makosa = 0; kifaa cha intId2 = 0x68; int fd2 = wiringPiI2CSetup (kifaaId2); ikiwa (-1 == fd2) {fprintf (stderr, "Haiwezi kufungua kifaa cha wiringPi I2C:% s / n", strerror (errno)); kurudi 1; } kwa (int reg = 0; reg <300; reg ++) {fprintf (stderr, "% d", wiringPiI2CReadReg8 (fd2, reg)); fflush (stderr); kuchelewesha (10); } huweka (""); kurudi 0; }

Kukimbia kwa pili:

/********************************************************************************

* kujenga: gcc second.test.mpu9265.c -o pili.test.mpu9265 -lwiringPi * * kuendesha: sudo./second.test.mpu9265 * * Mpango huu hutoa idadi ya rejista pamoja na thamani iliyosomwa. * * Hii inafanya kuwa muhimu kwa bomba (kuelekeza) pato kwenye faili, na kisha * kukimbia kadhaa kunaweza kufanywa, kulinganisha. Inaweza kutoa ufahamu juu ya * rejista gani ni muhimu, na jinsi data inaweza kuishi. * ************************************************* ******************** argv) {int kifaaId = -1; ikiwa (0) {} vingine ikiwa (! strncmp (argv [1], "0x20", strlen ("0x20"))) {deviceId = 0x20; } mwingine ikiwa (! strncmp (argv [1], "0x68", strlen ("0x68"))) {deviceId = 0x68; } mwingine ikiwa (! strncmp (argv [1], "0x69", strlen ("0x69"))) {deviceId = 0x69; } inaweka ("Wacha tuone ni nini MPU9265 @ 0x20 inasema:"); makosa = 0; int fd = wiringPiI2CSetup (kifaaId); ikiwa (-1 == fd) {fprintf (stderr, "Haiwezi kufungua kifaa cha wiringPi I2C:% s / n", strerror (errno)); kurudi 1; } kwa (int reg = 0; reg <300; reg ++) {fprintf (stderr, "% d:% d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); kuchelewesha (10); } kurudi 0; }

Kukimbia kwa tatu:

/********************************************************************************

* kujenga: gcc third.test.mpu9265.c -o tatu.test.mpu9265 -lwiringPi * * kuendesha: sudo./third.test.mpu9265 * * Mpango huu ni matokeo ya ile ya pili. Inasomeka tu kutoka kwa * sajili zilizoonyesha tofauti kati ya kukimbia moja na inayofuata.* ************************************************* ******************** argv) {int kifaaId = -1; ikiwa (0) {} vingine ikiwa (! strncmp (argv [1], "0x68", strlen ("0x68"))) {deviceId = 0x68; } mwingine ikiwa (! strncmp (argv [1], "0x69", strlen ("0x69"))) {deviceId = 0x69; } inaweka ("Wacha tuone ni nini MPU9265 @ 0x20 inasema:"); makosa = 0; int fd = wiringPiI2CSetup (kifaaId); ikiwa (-1 == fd) {fprintf (stderr, "Haiwezi kufungua kifaa cha wiringPi I2C:% s / n", strerror (errno)); kurudi 1; } kwa (int reg = 61; reg <= 73; reg ++) {fprintf (stderr, "% d:% d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); kuchelewesha (10); } kwa (int reg = 111; reg <= 112; reg ++) {fprintf (stderr, "% d:% d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); kuchelewesha (10); } kwa (int reg = 189; reg <= 201; reg ++) {fprintf (stderr, "% d:% d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); kuchelewesha (10); } kwa (int reg = 239; reg <= 240; reg ++) {fprintf (stderr, "% d:% d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); kuchelewesha (10); } kurudi 0; }

Kwa hivyo tulijifunza nini hadi sasa? Picha ya jedwali iliyo na sehemu zilizoangaziwa zenye rangi inaonyesha kuwa pato linaonekana kufanana na seti za kwanza za rejista.

Matokeo hadi sasa yanaweza kutoa maswali mapya.

Swali: kwa nini kuna matokeo moja tu ya sajili ya kikundi cha "nje"?

Swali: ni nini sajili hizo zote zisizojulikana "??????"

Swali: kwa kuwa mpango hauendeshwi na usumbufu, uliuliza data polepole sana? haraka mno?

Swali: tunaweza kuathiri matokeo kwa kujaribu vitu na sensor yenyewe inapoendesha?

Hatua ya 6: Wacha Tuchimbe Zaidi Katika Usomaji / Takwimu

Nadhani hatua inayofuata kabla ya kitu kingine chochote ni kuongeza programu kwa:

• badilika kwa kuchelewesha kitanzi kiasi gani (ms)
• badilika kwa zaidi ya usomaji ngapi ili kutoa wastani wa kukimbia kwa rejista

(Ilinibidi kuambatisha mpango kama faili. Ilionekana kuwa ni suala kuu kuiingiza hapa. "Fourth.test.mpu9265.c")

Hapa kuna kukimbia ukitumia usomaji 10 wa mwisho kwa wastani, kwa kitanzi cha 10ms:

sudo./fourth.test.mpu9265 0x68 10 10

61:255 0 255 0 255 0 255 0 0 0: 102 62:204 112 140 164 148 156 188 248 88 228: 167 63:189 188 189 187 189 188 188 188 188 189: 188 64: 60 40 16 96 208 132 116 252 172 36: 112 65: 7 7 7 7 7 7 7 7 7 7: 7 66:224 224 224 240 160 208 224 208 144 96: 195 67: 0 0 0 0 0 0 0 0 0 0: 0 68:215 228 226 228 203 221 239 208 214 187: 216 69: 0 255 0 255 255 0 255 0 0 0: 102 70:242 43 253 239 239 45 206 28 247 207: 174 71: 0 255 255 0 255 255 255 255 255 255: 204 72: 51 199 19 214 11 223 21 236 193 8: 117 73: 0 0 0 0 0 0 0 0 0 0: 0 111: 46 149 91 199 215 46 142 2 233 199: 132 112: 0 0 0 0 0 0 0 0 0 0: 0 189:255 0 255 0 255 0 0 255 0 255: 127 190: 76 36 240 36 100 0 164 164 152 244: 121 191:188 188 188 188 187 188 187 189 187 189: 187 192: 8 48 48 196 96 220 144 0 76 40: 87 193: 7 7 7 7 7 8 7 7 7 7: 7 194:208 224 144 240 176 240 224 208 240 224: 212 195: 0 0 0 0 0 0 0 0 0 0: 0 196:243 184 233 200 225 192 189 242 188 203: 209 197:255 0 0 0 255 0 255 0 0 255: 102 198:223 39 247 43 245 22 255 221 0 6: 130 199: 0 255 255 255 0 255 255 255 255 0: 178 200:231 225 251 1 252 20 211 216 218 16: 164 201: 0 0 0 0 0 0 0 0 0 0: 0 239: 21 138 196 87 26 89 16 245 187 144: 114 240: 0 0 0 0 0 0 0 0 0 0: 0

Safu ya kwanza, kushoto zaidi ni nambari ya usajili. Kisha kuja masomo 10 ya mwisho kwa daftari hilo. Mwishowe, safu ya mwisho ni wastani kwa kila safu.

Inaonekana kama rejista 61, 69, 71, 189, 197, na 199 labda ni za kibinadamu tu, au ziko tayari / haziko tayari, au ni kiwango cha juu cha thamani ya 16-bit (hasi?).

Uchunguzi mwingine wa kupendeza:

• rejista 65, 193 - thabiti sana na thamani sawa
• kujiandikisha 63, 191 - thabiti sana na thamani sawa
• madaftari 73, 112, 195, 201, 240 - yote kwa sifuri

Wacha tuunganishe uchunguzi huu kwa picha ya meza iliyo na rangi nyingi, iliyoangaziwa kutoka mapema.

Sajili 65 - joto

Jisajili 193 - ??????

Sajili 63 - accelerometer

Jisajili 191 - ??????

Sajili 73 - nje

Sajili 112 na kuendelea - ??????

Kweli, bado tuna haijulikani, hata hivyo, tumejifunza kitu muhimu.

Sajili 65 (joto) na rejista 63 (accelerometer) zote zilikuwa thabiti sana. Hili ni jambo ambalo tungetarajia. Sijagusa sensa; haiendi, zaidi ya mitetemo yoyote inayotokea, kwani roboti imekaa kwenye meza moja na kompyuta yangu.

Kuna jaribio moja la kupendeza tunaweza kwa kila moja ya rejista hizi za joto / accelerometer. Kwa jaribio hilo, tunahitaji toleo jingine la programu.

Hatua ya 7: Tunaweza Kuathiri Joto na Kuongeza kasi

Katika hatua zilizopita tulipunguza angalau daftari moja la joto, na moja kwa kuongeza kasi.

Na toleo hili linalofuata la programu ("tano.test.mpu9265.c"), tunaweza kuona mabadiliko yakifanyika kwa sajili zote mbili. Tafadhali angalia video.

Kuchimba Zaidi

Ikiwa tutarudi nyuma na kuangalia habari ya sajili, tunaona kuwa kuna:

• matokeo matatu kidogo ya 16 ya gyroscope
• matokeo matatu kidogo ya 16 ya accelerometer
• matokeo matatu kidogo ya 16 ya sumaku ya umeme
• pato moja 16 kwa joto

Walakini, matokeo yaliyopatikana na programu zetu rahisi za majaribio yote yalikuwa matokeo moja ya 8. (daftari moja).

Kwa hivyo wacha tujaribu njia sawa, lakini wakati huu kusoma bits 16 badala ya 8.

Labda tutalazimika kufanya kitu kama hapa chini. Wacha tutumie joto kama mfano, kwani ni pato moja tu la 16.

// pata fasili ya faili fd…

intRegHi = 65; int tempRegLo = 66; int hiByte = wiringPiI2CReadReg8 (fd, tempRegHi); int loByte = wiringPiI2CReadReg8 (fd, tempRegLo); matokeo = hiByte << 8; // weka agizo hi bits 8 ndani ya sehemu ya juu ya matokeo ya thamani 16 kidogo | = loByte; // sasa ongeza kwa mpangilio wa bits 8, ukitoa nambari kamili ya 16 bit // chapisha nambari hiyo au utumie kazi ya kuonyesha picha ya usawa kutoka hapo awali

Kutoka kwa hatua zetu za awali tumeona kuwa rejista 65 ni nzuri mwamba thabiti, wakati rejista 66 ni kelele sana. Kwa kuwa 65 ni hi hi ya ka, na 66 mpangilio wa chini, hiyo ina maana.

Kwa kusoma, tunaweza kuchukua data ya 65 kama ilivyo, lakini tunaweza wastani kusajili maadili ya 66.

Au tunaweza wastani wa matokeo yote.

Angalia video ya mwisho ya sehemu hii; inaonyesha kusoma thamani nzima ya joto 16 kidogo. Nambari ni "six.test.mpu9265.c"

Hatua ya 8: Accelerometer na Gyroscope

Video za sehemu hii zinaonyesha pato kutoka kwa accelerometer na gyroscope, kwa kutumia programu ya majaribio "seven.test.mpu9265.c". Nambari hiyo inaweza kusoma jozi 1, 2, au 3 mfululizo (jo na lo byte) na kubadilisha maadili kuwa thamani moja 16. Kwa hivyo, tunaweza kusoma mhimili wowote, au tunaweza kusoma mbili kwa pamoja (na inahesabu mabadiliko), au tunaweza kusoma zote tatu (na inaelezea mabadiliko).

Ili kurudia, kwa awamu hii, kwa hii inayoweza kufundishwa, natafuta tu kujibu swali rahisi: "je! Roboti ilizunguka / kuzunguka?". Sitafuti thamani yoyote sahihi, kama vile, ilizunguka digrii 90. Hiyo itakuja baadaye tutakapofika kufanya SLAM, lakini haihitajiki kwa kuzuia kikwazo rahisi na harakati za nasibu.

Hatua ya 9: (fanya kazi katika Maendeleo) Magnetometer

unapotumia zana ya i2cdetect, MPU9265 inaonyesha kama 0x68 kwenye jedwali:

0 1 2 3 4 5 6 7 8 9 a b c d e f

00: -- -- -- -- -- -- -- -- -- -- -- -- -- 10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 60: -- -- -- -- -- -- -- -- 68 -- -- -- -- -- -- -- 70: -- -- -- -- -- -- -- --

Kuna hatua za ziada zinazohitajika kusoma kutoka sehemu ya magnetometer ya IMU.

Kutoka kwa hati za Invesense za hati ya PDF:

WASAJILI 37 HADI 39 - I2C MTUMWA 0 UDHIBITI

• USAJILI 37 - I2C_SLV0_ADDR
• USAJILI 38 - I2C_SLV0_REG
• USAJILI 39 - I2C_SLV0_CTRL