Wallace - „Pasidaryk pats“autonominis robotas - 5 dalis - pridėkite IMU: 9 žingsniai

2024 Autorius: John Day | [email protected]. Paskutinį kartą keistas: 2024-01-30 10:48

Mes einame kartu su Wallace. Pavadinimas „Wallace“kilo iš „Wall-E“mišinio ir ankstesnio projekto (balso atpažinimo), o naudojant „espeak“įrankį jis skambėjo šiek tiek britiškai. Ir kaip patarnautojas ar liokajus. Ir tai yra galutinis tikslas: kad šis projektas taptų kažkuo naudingu. Taigi „Wallace“.

Wallace'as gali judėti, jis gali išvengti kliūčių naudodamas IR atstumo jutiklius (neseniai jie kažkaip apkepė (?)) laikas, kartu su MCP23017 plėtikliu) ir galiausiai gali aptikti variklio srovės pokyčius, kad žinotų, kada jis atsitrenkia į kažką.

Be jutiklių, Wallace „prisimena“100 judesių ir atlieka tam tikrą elementarią analizę, naudodama judesių istoriją.

Iki šiol Wallace'o tikslas yra tiesiog stengtis judėti į priekį ir žinoti, kada jis įstrigo pasikartojančiame šablone (pvz., Kampe) ir tikrai neina į priekį.

Aš perėjau keletą judėjimo ir navigacijos kartojimų, o sukimosi metu nuolat skaudėjo galvą.

Kadangi Wallace'as yra sekamas robotas, ir aš norėjau, kad viskas būtų paprasčiau programinėje įrangoje (vėlesniam laikui), kad galėčiau pasukti, aš tiesiog turiu jį pasukti/pasukti. Taigi varikliams taikykite vienodą, bet priešingą galios / darbo ciklą.

Problema kilo dėl roboto platformos „Agent 390“dizaino. Vikšro diržai linkę trintis į šonus. Ir dar blogiau, viena pusė tai daro daugiau nei kita.

Dėl grindų ir einant tiesiai, tai nebuvo problema. Tai pasirodo ant kilimų. Aš nusprendžiau neleisti Wallace'ui kilimėlio, kai jo takeliai pasidarė niūrūs (jie labai lengvai surenka nešvarumus).

Tikroji problema yra sukant grindis.

Jei turiu programinę įrangą taikyti aukšto lygio darbo ciklą, tada ji daugmaž nuosekliai sukasi. Tačiau mažo darbo ciklo metu jis gali apsisukti arba ne. Arba jis gali šiek tiek pasisukti, o tada sulėtėti. Atrodo, kad sukamasis veiksmas yra nekontroliuojamas naudojant programinę įrangą arba geriausiu atveju labai sunkus.

Problema atsiranda navigacijos metu ir judant aplink kliūtis ar toliau nuo jų. Jis gali arba per daug atsitrenkti, arba gali užstrigti bandydamas atlikti labai trumpus poslinkius, net nejudėdamas.

Taigi aukščiau pateiktas paaiškinimas paskatino šį „Instructable“.

Iš pradžių norėjau atsisakyti judesio jutimo įrenginio (IMU) arba jį atidėti, nes jie A) sudėtingi, B) triukšmingi, C) laikui bėgant gali atsirasti klaidų ir pan. mums pavyko labai gerai pereiti prie skrydžio laiko IR lazerinių jutiklių. Ir mes galėtume - naudodami lazerius galėtume sužinoti, ar robotas sukasi, ar ne, stebėdami atstumo pokyčius.

Tiesą sakant, mes taip pat (savotiškai) galėtume tai padaryti dabar su akustiniais jutikliais.

Tačiau visa tai yra labai netiesioginis, sudėtingas būdas atsakyti į vieną paprastą klausimą: „ar sukomės, ar ne?“.

Man atrodė, kad šokinėjimas naudoti ToF lazerinius jutiklius pakels į kitą programinės įrangos lygį; būtent SLAM (sinchroninis lokalizavimas ir kartografavimas). Aš dar nesiruošiau ten vykti.

Geras dalykas yra atlikti roboto projektą sluoksniais, kai pirmasis (apatinis) sluoksnis yra paprastesnis, o antrasis (viršutinis) sluoksnis yra abstraktesnis ir sprendžia sunkesnes problemas.

Apie sluoksnius galima galvoti taip:

1. roboto fizinis rėmas / mechaninis konstrukcinis pagrindas
2. elementari pavaros sistema („Raspberry“, „Roboclaw“, varikliai, kabeliai ir kt., pagrindinė programinė įranga, valdoma klaviatūra)
3. esminė grandinė jutikliams palaikyti (dvikryptis įtampos perjungiklis, prievado plėtiklis, „E-Stop“, maitinimo paskirstymas ir kt.)
4. kliūčių vengimo jutikliai (akustiniai, IR)
5. esminis, pagrindinis padėties nustatymas ir judesio aptikimas (akselerometras, giroskopas, magnetometras, variklio koduotuvai, ratų kodavimo įrenginiai)

Galite sugalvoti savo sąrašą. Šio sąrašo esmė yra ta, kad jūs tikriausiai turėtumėte tai padaryti daugiau ar mažiau tokia tvarka, taip pat, jei praleidžiate šiek tiek laiko kiekviename sluoksnyje, kad kiekvienas iš jų pasiektų gerą darbo būseną, tai jums turėtų padėti vėliau, kai viskas tampa sudėtingesnė.

Aukščiau pateiktas sąrašas gali būti daugiau ar mažiau susietas su šiais koncepciniais programinės įrangos sluoksniais.

• SLAM (sinchroninis lokalizavimas ir kartografavimas)
• Judėjimo kontrolė ir suvokimas, rotacija
• Pagrindinis kliūčių vengimas
• Jutiklių duomenų valdymas ir aptikimas
• Esminis judėjimas pirmyn, atgal, kairėn ir dešinėn, greitis, lėtėjimas, sustojimas

Kaip matote, šiame sąraše pirmieji elementai būtų viršutiniai, sudėtingesni sluoksniai, kuriuose sprendžiami abstraktesni klausimai ir klausimai, pvz., „Kur aš esu“ir „kur aš einu“, o pastarieji elementai būtų apatinius programinės įrangos sluoksnius, kurie tvarko „kaip kalbėti/klausytis jutiklio A“arba „kaip perkelti šį ratą“.

Dabar aš nesakau, kad kai pradėsite nuo sluoksnio, jį baigsite, o tada jis bus kitame sluoksnyje, niekada negrįšite prie ankstesnio. Roboto projektas gali būti labai panašus į šiuolaikinius, pasikartojančius programinės įrangos kūrimo metodus (judrus, SCRUM ir kt.).

Aš tik sakau, kad kiekvienam reikia skirti laiko. Turėsite subalansuoti, kiek nuveikti kiekviename, ir nuspręsti, ką bandote tam tikru sluoksniu, verta laiko ir rūpesčių.

Tarp dviejų konkuruojančių idėjų ar krypčių yra tam tikras „konfliktas“arba „įtampa“.

Viena yra tai, ką aš pavadinčiau „plug-n-play“, kad išspręstume A problemą.

Kitas yra „pasidaryk pats“(daryk pats). Ir tai gali būti net ne geriausia šios kitos idėjos etiketė.

Štai kiekvieno pavyzdys, tikiuosi, kad pamatysite įtampą ar konfliktą tarp dviejų pasirinkimų.

Pavyzdžiui, SLAM, kliūčių vengimo ir esminio pagrindinio judėjimo vienkartinė problema yra viena problema, kurią reikia išspręsti vienu metu.

1. Jei nuspręsime eiti „plug-n-play“keliu, nedelsdami (priklausomai nuo biudžeto) pereiname prie tokių dalykų, kaip tie viršuje sumontuoti besisukantys lazeriai, lauko gylio kamera arba ToF lazeriai ir IMU (šios temos tema) Pamokoma).
2. Kita vertus, jei norime eiti antruoju keliu, galime pabandyti išgauti visą įmanomą informacijos dalį iš kai kurių akustinių jutiklių ar IR jutiklių arba jų visai nėra - mes tiesiog naudojame variklio srovės stebėjimą (smūgį)

Ką galima pasakyti apie #1 vs #2? Vienas dalykas būtų tai, kad atlikę antrąjį žingsnį mes išmoktume daug daugiau. Vien tik akustinių jutiklių veikimo apribojimai verčia mus galvoti apie daug daugiau problemų.

Kita vertus, jei per daug susikoncentruojame į tai, ką darome per antrąjį numerį, galime gaišti laiką, nes prašome iš akustinių jutiklių daugiau nei turėtume.

Dar viena koncepcija ar idėja, kurią reikia pagalvoti: koks techninės ir programinės įrangos mišinys geriausiai atsako į klausimus „kaip“, o koks programinės įrangos (ir aparatūros?) Mišinys - į klausimą „kas“, „kada“, „kur“. Kadangi „kaip“paprastai yra žemesnio lygio klausimas, nuo kurio priklauso „kas“, „kada“ir „kur“, kad gautumėte atsakymą.

Šiaip ar taip, visa tai buvo tik apie ką pagalvoti.

Mano atveju, po daugybės pastangų ir nuolatinio erzinančio kelio trinties klausimo ir nesugebėjimo nuosekliai valdyti ir judėti, laikas daryti ką nors kita.

Taigi šis Instructable - IMU.

Tikslas yra tas, kad jei IMU sako, kad robotas nesisuka, mes padidiname darbo ciklą. Jei pasukame per greitai, sutrumpiname darbo ciklą.

1 žingsnis: IMU jutiklis

Kitas mūsų jutiklis, kurį reikia pridėti prie Wallace, yra IMU. Po tam tikrų tyrimų nusprendžiau naudoti MPU6050. Bet tada šiuo metu MPU9050 (o dar neseniai - MPU9250) atrodė dar geresnė idėja.

Mano šaltinis buvo „Amazon“(JAV). Taigi aš užsisakiau du iš jų.

Iš tikrųjų aš gavau (atrodo, kad to nekontroliuoju; štai kas man nepatinka „Amazon“) buvo du MPU92/65. Šiek tiek įdomu dėl žymėjimo. Pažvelkite į paveikslėlius; atrodo, kad tai yra „šeimos“pavadinimas. Bet kokiu atveju, tai ir esu įstrigęs.

Pridėti labai paprasta -gaukite protinę plokštę su jungiamosiomis trasomis, lituokite jutiklį prie plokštės, pridėkite 10 kontaktų varžto gnybtų bloką (aš jį gavau iš „Pololu“).

Siekdamas sumažinti bet kokius trukdžius, bandžiau šiuos jutiklius pastatyti atokiau nuo visų kitų dalykų.

Tai taip pat reiškė kai kurių nailoninių varžtų/veržlių naudojimą.

Aš naudoju I2C protokolą. Tikimės, kad bendras laido ilgis nebus labai blogas.

Kitur yra daug informacijos apie pagrindines jungtis ir įtampos lygius ir pan., Todėl to čia nekartosiu.

2 žingsnis: ne visada viskas paprasta ir paprasta

Šiuo raštu neatrodo, kad internete yra daug šio konkretaus MPU-92/65. Tai, kas yra prieinama, kaip ir dauguma jutiklių, atrodo, yra pavyzdžiai naudojant „Arduino“.

Aš stengiuosi padaryti šias instrukcijas šiek tiek kitokias, pateikdamas ne tokį švarų procesą, nes viskas ne visada veikia iš karto.

Manau, kad šie nurodymai labiau panašūs į tinklaraštį nei tiesūs A-B-C, 1-2-3 „štai kaip tai darote“.

3 žingsnis: pradinis testas

Iš ankstesnio veiksmo vaizdų raudoni ir juodi laidai, einantys į jutiklius, žinoma, yra VCC (5V) ir GND. Žalia ir geltona laidai yra I2C jungtys.

Jei atlikote kitus I2C projektus arba sekėte kartu su šiomis serijomis, tuomet jūs jau žinote apie „i2cdetect“ir tai yra pirmasis žingsnis norint sužinoti, ar „Raspberry“gali pamatyti naują jutiklį.

Kaip matote iš šio žingsnio vaizdų, pirmasis mūsų bandymas buvo nesėkmingas. IMU nerodomas (turėtų būti įrenginio ID 0x68).

Tačiau gera žinia ta, kad I2C autobusas veikia. Mes matome vieną įrenginį 0x20 ir tai yra MCP23017 prievado plėtiklis (šiuo metu atsakingas už akustinius jutiklius HCSR04).

Tai nėra lengva pamatyti paveikslėlyje, bet aš prijungiau tuos pačius spalvotus žalius ir geltonus laidus iš IMU prie MCP23017 (žr. Apatinį kairįjį paveikslėlį)

Turėsime atlikti kai kuriuos trikčių šalinimo veiksmus.

4 žingsnis: trikčių šalinimas

Naudodamas voltmetro (tono aukšto tono) tęstinumo nustatymą, išbandžiau VCC (5V), GND, SDA ir SCL jungtis. Tie buvo geri.

Kitas bandymas buvo atjungti MCP23017 nuo I2C magistralės, paliekant tik MPU-92/65 magistralėje. Tai pasirodė neveiksminga - „i2cdetect“tada nerodė jokių įrenginių.

Taigi, aš atjungiau jutiklį nuo totemo poliaus ir vėl prijungiau jį prie 5V-3V dvikryptės magistralės; y., tiesiai į Avietę. (trumpesni laidai?).

Ir voila. Šį kartą sėkmė. Matome, kad 0x68 rodomas naudojant „i2cdetect“.

Bet mes dar nežinome, kodėl šį kartą tai pavyko. Ar tai gali būti laidų ilgis? Ankstesnė vieta?

Pastaba: nebuvo jokio skirtumo, ar ADO buvo įžemintas, ar ne. Gali būti, kad laive yra traukimo ir ištraukimo rezistoriai. Tas pats gali būti ir su FSYNC.

Tada iš naujo prijungiau MCP23017. Taigi dabar mes turime du įrenginius I2C magistralėje. (žr. paveikslėlį). Sėkmės, dabar matome 0x20 ir 0x68 su „i2cdetect“.

Vaizdo įrašuose pateikiama šiek tiek daugiau informacijos apie tai, kas įvyko trikčių šalinimo metu.

5 žingsnis: Jutiklio duomenų skaitymas

Įvairūs požiūriai

Aš nusprendžiau naudoti kelis būdus, kaip gauti naudingos informacijos iš jutiklio. Štai jie, bet kokia tvarka:

1. išbandykite pagrindinį programavimą
2. Peržiūrėkite internetinius registrų dokumentus
3. pažvelkite į kitų pavyzdžius ir (arba) kodą

Kodėl šie požiūriai? Kodėl gi ne tiesiog ieškoti kokios nors esamos bibliotekos ar kodo?

Eksperimentuodami ir išbandydami kai kurias idėjas, mes galime geriau įsisavinti tam tikras žinias ne tik apie šį konkretų jutiklį, bet ir įgyti tam tikros technikos, įgūdžių ir mąstymo būdų, kaip spręsti ką nors naujo, o tai, ko gali neturėti daug dokumentų; kažkas, kas gali turėti daug nežinomų dalykų.

Be to, kai pažaidėme ir išbandėme kai kurias savo idėjas ir įgijome tam tikrų įžvalgų, galime geriau įvertinti kažkieno kodą ar biblioteką.

Pavyzdžiui, pažiūrėjęs į „Github“MPU9250 C ++ kodą, supratau, kad tai verčia mane naudoti pertraukas, ko dar nenoriu daryti.

Be to, jis ateina su papildomais dalykais, tokiais kaip kalibravimas; vėl kažkas, kas man neįdomu.

Gali būti, kad tai, ką turiu padaryti, kad atsakyčiau į paprastą klausimą „ar robotas sukasi taip ar ne“, būtų galima atsakyti labai paprastai, tiesiog perskaičius kai kuriuos registrus.

Registrai

Šiuo metu atrodo, kad šiame jutiklyje nėra daug galimybių. Tiesą sakant, jei pažvelgsite į vaizdus, pateiktus kartu su šia „Instructable“, ir atidžiai pažvelgsite į užrašus ant tikrųjų mikroschemų, man kyla klausimas, ar tai nėra smūgis. Aš nesieju to, ką matau, su niekuo iš „Invense“. Nepaisant to, nusprendžiau pažvelgti į rastų modelių registro informaciją: MPU-6050 ir MPU-9250.

Abiem atvejais toliau pateikiamas tas pats abiem atvejais. Pradedantiesiems darome prielaidą, kad taip pat bus ir su šiuo MPU-92/65.

59–64 - akselerometro matavimai

65, 66 - temperatūros matavimai nuo 67 iki 72 - giroskopo matavimai nuo 73 iki 96 - išorinių jutiklių duomenys

Pastaba: atrodo, kad MPU-6050 neturi magnetometro, o MPU-9250 (ir mes manome, kad ir šis) turi.

Iš registro dokumento surinkta dar įdomi, tikiuosi naudinga informacija:

Informacija apie magnetometrą:

magnetometro ID: 0x48 registruoja 00–09 H 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 HYHZZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ ST2 0 0 0 BITM HOFL 0 0 0 suskirstymas, ką reiškia kiekvienas registras: HXL [7: 0]: X ašies matavimo duomenys žemesni 8 bitų HXH [15: 8]: X ašies matavimo duomenys didesni 8 bitų HYL [7: 0]: Y ašies matavimo duomenys žemesni 8 bitų HYH [15: 8]: Y ašies matavimo duomenys didesni 8 bitų HZL [7: 0]: mažesni Z ašies matavimo duomenys 8 bitų HZH [15: 8]: didesni Z ašies matavimo duomenys 8 bitų

Programavimas

Kita informacija iš registro dokumentų yra ta, kad atrodė, kad yra tik apie 100 registrų. Taigi viena taktika galėtų būti parašyti paprastą programą, kuri pasiekia įrenginį (0x68) ir bando nuosekliai skaityti registrų seriją, neatsižvelgdama į jų reikšmę, kad tik pamatytų, kokius duomenis galima pamatyti.

Tada atlikite nuoseklius leidimus, naudodami tą patį kodą, ir palyginkite vieno leidimo duomenis su kitu.

Idėja yra ta, kad tikriausiai galėtume pašalinti visus registrus, kuriuose, atrodo, nėra duomenų (nulių ar FF?) Arba kurie niekada nesikeičia, taip pat galėtume sutelkti dėmesį į tuos, kurie keičiasi.

Tada mes žiūrime tik į tuos, kurie keičiasi, pridėkite vidurkio nustatymo funkciją, kuri apskaičiuoja paskutinius to registro N rodmenis, kad pamatytume, ar iš tikrųjų yra tam tikra to registro vertė. Tai darytų prielaidą, kad jutiklį laikome labai nejudantį ir toje pačioje vietoje.

Galiausiai, mes galėtume švelniai išbandyti dalykus su jutikliu, pavyzdžiui, pastumti jį (pagreičio matuoklis, giroskopas), pūsti ant jo (temperatūra) arba pasukti (du ankstesni plius magnetometrai) ir pamatyti, kokį poveikį tai turi reikšmėms.

Man patinka kuo daugiau naudotis „wiringPi“biblioteka. Jis palaiko I2C.

Pirmasis bėgimas:

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

* sukurti: gcc first.test.mpu9265.c -o first.test.mpu9265 -lwiringPi * * paleisti: sudo./first.test.mpu9265 * * ši programa tik išleidžia (galimų) registrų diapazoną iš MCP23017, * ir tada iš MPU9265 (ar bet kurio kito MPU tuo 0x68 adresu). ************************************************* ****************************/ #include #include #include #include #include int main (int argc, char ** argv) {put ("Pažiūrėkime, ką turi pasakyti MCP23017 @ 0x20:"); klaida = 0; int deviceId1 = 0x20; int fd1 = wiringPiI2CSetup (deviceId1); if (-1 == fd1) {fprintf (stderr, "Negaliu atidaryti wiringPi I2C įrenginio: %s / n", strerror (klaida)); grąžinimas 1; } for (int reg = 0; reg <300; reg ++) {fprintf (stderr, "%d", wiringPiI2CReadReg8 (fd1, reg))); fflush (stderr); vėlavimas (10); } uždeda (""); pateikia ("Pažiūrėkime, ką turi pasakyti MPU9265 @ 0x20:"); klaida = 0; int deviceId2 = 0x68; int fd2 = wiringPiI2CSetup (deviceId2); if (-1 == fd2) {fprintf (stderr, "Negaliu atidaryti wiringPi I2C įrenginio: %s / n", strerror (klaida)); grąžinimas 1; } for (int reg = 0; reg <300; reg ++) {fprintf (stderr, "%d", wiringPiI2CReadReg8 (fd2, reg)); fflush (stderr); vėlavimas (10); } uždeda (""); grįžti 0; }

Antras važiavimas:

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

* kurti: gcc second.test.mpu9265.c -o second.test.mpu9265 -lwiringPi * * paleisti: sudo./second.test.mpu9265 * * Ši programa pateikia registro numerį kartu su nuskaityta verte. * * Dėl to naudinga išvestį perkelti (nukreipti) į failą, o tada * galima atlikti kelis palyginimus. Tai gali suteikti informacijos apie tai, * koks registras yra svarbus ir kaip duomenys gali elgtis. ************************************************* ****************************/ #include #include #include #include #include #include int main (int argc, char ** argv) {int prietaisoId = -1; if (0) {} else if (! strncmp (argv [1], "0x20", strlen ("0x20"))) {deviceId = 0x20; } else if (! strncmp (argv [1], "0x68", strlen ("0x68")))) {deviceId = 0x68; } else if (! strncmp (argv [1], "0x69", strlen ("0x69"))) {deviceId = 0x69; } pateikia ("Pažiūrėkime, ką turi pasakyti MPU9265 @ 0x20:"); klaida = 0; int fd = wiringPiI2CSetup (deviceId); if (-1 == fd) {fprintf (stderr, "Negaliu atidaryti wiringPi I2C įrenginio: %s / n", strerror (klaida)); grąžinimas 1; } for (int reg = 0; reg <300; reg ++) {fprintf (stderr, "%d:%d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); vėlavimas (10); } grįžti 0; }

Trečias važiavimas:

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

* sukurti: gcc third.test.mpu9265.c -o third.test.mpu9265 -lwiringPi * * paleisti: sudo./third.test.mpu9265 * * Ši programa yra antrojo rezultatas. Jis skaitomas tik iš * registrų, nurodžiusių skirtumą tarp vieno ir kito paleidimo.************************************************* ****************************/ #include #include #include #include #include #include int main (int argc, char ** argv) {int prietaisoId = -1; if (0) {} else if (! strncmp (argv [1], "0x68", strlen ("0x68"))) {deviceId = 0x68; } else if (! strncmp (argv [1], "0x69", strlen ("0x69"))) {deviceId = 0x69; } pateikia ("Pažiūrėkime, ką turi pasakyti MPU9265 @ 0x20:"); klaida = 0; int fd = wiringPiI2CSetup (deviceId); if (-1 == fd) {fprintf (stderr, "Negaliu atidaryti wiringPi I2C įrenginio: %s / n", strerror (klaida)); grąžinimas 1; } for (int reg = 61; reg <= 73; reg ++) {fprintf (stderr, "%d:%d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); vėlavimas (10); } for (int reg = 111; reg <= 112; reg ++) {fprintf (stderr, "%d:%d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); vėlavimas (10); } for (int reg = 189; reg <= 201; reg ++) {fprintf (stderr, "%d:%d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); vėlavimas (10); } for (int reg = 239; reg <= 240; reg ++) {fprintf (stderr, "%d:%d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); vėlavimas (10); } grįžti 0; }

Taigi, ko mes išmokome iki šiol? Lentelės vaizdas su spalvotomis paryškintomis sritimis rodo, kad išvestis, atrodo, atitinka pirmuosius registrų rinkinius.

Iki šiol gauti rezultatai gali sukelti naujų klausimų.

Klausimas: kodėl „išorinei“grupei yra tik vienas registro rezultatas?

Klausimas: kas yra visi tie nežinomi registrai "??????"

Klausimas: kadangi programa nėra pertraukiama, ar ji paprašė duomenų per lėtai? per greitai?

Klausimas: ar galime paveikti rezultatus, išbandydami dalykus su pačiu jutikliu, kai jis veikia?

6 žingsnis: įsigilinkime į rodmenis / duomenis

Manau, kad kitas žingsnis prieš ką nors kitą yra patobulinti programą taip:

• būti lanksčiam, kiek ciklo uždelsimo (ms)
• būti lankstus, kiek rodmenų pateikti einamąjį registro vidurkį

(Turėjau pridėti programą kaip failą. Atrodė, kad problema įterpiant ją čia. "4th.test.mpu9265.c")

Štai paleidimas, naudojant vidutiniškai paskutinius 10 rodmenų, esant 10 ms ciklui:

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

Pirmasis kairysis stulpelis yra registro numeris. Tada ateina paskutiniai 10 šio registro rodmenų. Galiausiai paskutinis stulpelis yra kiekvienos eilutės vidurkis.

Atrodo, kad registrai 61, 69, 71, 189, 197 ir 199 yra tik dvejetainiai, arba paruošti / nepasiruošę, arba jie yra didelis 16 bitų vertės baitas (neigiamas?).

Kiti įdomūs pastebėjimai:

• registrai 65, 193 - labai pastovi ir ta pati vertė
• registras 63, 191 - labai pastovi ir ta pati vertė
• registrai 73, 112, 195, 201, 240 - visi nulis

Susiekime šiuos pastebėjimus su daugiaspalviu, paryškintu lentelės vaizdu iš ankstesnio.

Registruotis 65 - temperatūra

Registruotis 193 - ??????

Registras 63 - akselerometras

Registruotis 191 - ??????

Registras 73 - išorinis

Registruokitės 112 ir toliau - ??????

Na, mes vis dar turime nežinomų dalykų, tačiau sužinojome kažką naudingo.

65 registras (temperatūra) ir 63 registras (akselerometras) buvo labai pastovūs. To mes tikėjomės. Aš nepaliečiau jutiklio; jis nejuda, išskyrus atsitiktines vibracijas, nes robotas guli ant to paties stalo kaip ir mano kompiuteris.

Yra vienas įdomus testas, kurį galime atlikti kiekvienam iš šių temperatūros/akselerometro registrų. Tam bandymui mums reikia dar vienos programos versijos.

7 žingsnis: mes galime paveikti temperatūrą ir pagreitį

Ankstesniuose žingsniuose mes susiaurinome bent vieną temperatūros registrą ir vieną pagreitį.

Naudodami šią kitą programos versiją ("4th.test.mpu9265.c"), iš tikrųjų galime matyti, kad pasikeičia abu registrai. Prašome žiūrėti vaizdo įrašus.

Daugiau kasimo

Jei grįšime atgal ir pažiūrėsime į registro informaciją, pamatysime, kad yra:

• trys 16 bitų išėjimai giroskopui
• trys 16 bitų išėjimai akselerometrui
• trys 16 bitų išėjimai magnetometrui
• vienas 16 bitų išėjimas temperatūrai

Tačiau mūsų paprastų testavimo programų rezultatai buvo pavieniai 8 bitų išėjimai. (pavieniai registrai).

Taigi pabandykime daugiau to paties požiūrio, tačiau šį kartą skaitykite 16 bitų, o ne 8.

Tikriausiai turėsime padaryti kažką panašaus į žemiau pateiktą. Kaip pavyzdį naudokime temperatūrą, nes tai tik vienas 16 bitų išėjimas.

// gauti failo deskriptorių fd …

int tempRegHi = 65; int tempRegLo = 66; int hiByte = wiringPiI2CReadReg8 (fd, tempRegHi); int loByte = wiringPiI2CReadReg8 (fd, tempRegLo); int rezultatas = hiByte << 8; // įdėkite 8 bitų eilės į 16 bitų vertės viršutinę dalį | = loByte; // dabar į eilę pridėkite 8 bitus, gaudami pilną 16 bitų skaičių // atspausdinkite tą skaičių arba naudokite ekrano horizontalios grafikos funkciją anksčiau

Iš ankstesnių veiksmų matėme, kad 65 registras yra gana stabilus, o 66 registras yra labai triukšmingas. Kadangi 65 yra aukšto eilės baitas, o 66 - žemos eilės baitas, tai yra prasminga.

Skaitymui galime priimti 65 registro duomenis tokius, kokie jie yra, tačiau vidutiniškai galime įvertinti 66 registro vertes.

Arba galime tiesiog įvertinti viso rezultato vidurkį.

Pažvelkite į paskutinį šios dalies vaizdo įrašą; tai rodo visos 16 bitų temperatūros vertės nuskaitymą. Kodas yra „sixth.test.mpu9265.c“

8 žingsnis: pagreičio matuoklis ir giroskopas

Šio skyriaus vaizdo įrašuose pateikiama akcelerometro ir giroskopo išvestis, naudojant bandymo programą „septintoji.testas.mpu9265.c“. Šis kodas gali nuskaityti 1, 2 ar 3 iš eilės baitų poras (hi ir lo baitus) ir konvertuoja reikšmes į vieną 16 bitų vertę. Taigi, mes galime perskaityti bet kurią ašį arba dvi iš jų kartu (ir tai apibendrina pokyčius), arba galime perskaityti visas tris (ir tai apibendrina pokyčius).

Norėdami pakartoti, šiam etapui, šiam „Instructable“, aš tik noriu atsakyti į paprastą klausimą: „ar robotas sukasi/sukasi?“. Aš neieškau jokios tikslios vertės, pavyzdžiui, ar ji pasuko 90 laipsnių. Tai įvyks vėliau, kai pradėsime daryti SLAM, tačiau tai nėra būtina paprastam kliūčių vengimui ir atsitiktiniam judėjimui.

9 žingsnis: (Vykdomas darbas) Magnetometras

naudojant „i2cdetect“įrankį, MPU9265 lentelėje rodomas kaip 0x68:

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: -- -- -- -- -- -- -- --

Norint perskaityti IMU magnetometro dalį, reikia atlikti papildomus veiksmus.

Iš „Invesense“registrų PDF dokumento:

REGISTRACIJOS 37 - 39 - I2C SLAVE 0 CONTROL

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