Wallace - Robot Autonomi DIY - Bahagian 5 - Tambahkan IMU: 9 Langkah

2025 Pengarang: John Day | [email protected]. Diubah suai terakhir: 2025-01-23 15:01

Kami meneruskan perjalanan bersama Wallace. Nama Wallace berasal dari gabungan "Wall-E", dan dari projek sebelumnya (pengecaman suara), dan ketika menggunakan utiliti "espeak", kedengarannya agak british. Dan seperti valet atau butler. Dan itulah tujuan akhirnya: agar projek ini berubah menjadi sesuatu yang berguna. Oleh itu "Wallace".

Wallace dapat bergerak, dia dapat mengelakkan halangan menggunakan sensor jarak IR (baru-baru ini, entah bagaimana mereka menggoreng (?) (Harus melihatnya ketika saya berpeluang), juga memiliki beberapa sensor jarak akustik (tiga di antaranya menjadi buruk sekaligus masa, bersama dengan pengembang MCP23017), dan akhirnya, dapat mengesan perubahan arus motor untuk mengetahui kapan ia menabrak sesuatu.

Selain sensor, Wallace "mengingat" 100 gerakan itu, dan memiliki beberapa analisis dasar menggunakan sejarah pergerakan.

Matlamat sejauh ini untuk Wallace adalah hanya berusaha untuk terus maju, dan untuk mengetahui kapan ia terjebak dalam beberapa corak berulang (seperti di sudut) dan tidak benar-benar bergerak ke depan.

Saya telah melalui beberapa lelaran untuk pergerakan dan navigasi, dan sakit kepala yang konsisten telah berlaku semasa bergilir.

Oleh kerana Wallace adalah robot yang dilacak, dan saya ingin membuat perkara lebih mudah dalam perisian (untuk kemudian), untuk mengubahnya saya hanya meminta dia berpusing / berputar di tempat. Oleh itu, gunakan kitar daya / tugas yang sama tetapi bertentangan pada motor.

Masalah yang dihadapi adalah kerana reka bentuk platform robot Ejen 390. Tali pinggang trek cenderung digosok ke sisi. Dan lebih buruk lagi, satu pihak melakukannya lebih banyak daripada yang lain.

Di lantai dan lurus, itu tidak menjadi masalah. Ia muncul di permaidani. Saya memilih untuk menjauhkan Wallace dari permaidani setelah trek menjadi suram (mereka mengambil kotoran sangat mudah).

Masalah sebenarnya adalah ketika berpusing di lantai.

Sekiranya saya mempunyai perisian menggunakan kitaran tugas tahap tinggi, maka ia akan berubah secara konsisten. Walau bagaimanapun, semasa kitaran tugas rendah, ia mungkin atau tidak benar-benar berubah. Atau mungkin berubah sebentar dan kemudian perlahan. Tindakan berpusing nampaknya tidak terkawal melalui perisian, atau paling sukar sekali.

Masalahnya muncul semasa navigasi dan bergerak di sekitar atau jauh dari rintangan. Ia boleh berayun terlalu liar, atau tersekat ketika berusaha melakukan pergeseran sangat cepat, tanpa bergerak.

Oleh itu penjelasan di atas mendorong Instruktif ini.

Pada mulanya, saya ingin melepaskan, atau menunda memperkenalkan unit pengesan gerakan (IMU), kerana kesalahan A) rumit, B) bising, C) dapat diperkenalkan dari masa ke masa, dan lain-lain, dll. Fikiran saya mempunyai kita boleh melakukannya dengan baik dengan menggunakan sensor laser IR masa penerbangan. Dan kita dapat - dengan menggunakan laser kita dapat mengetahui apakah robot berputar atau tidak, dengan mengesan perubahan jarak.

Sebenarnya, kita juga boleh (semacam) melakukannya sekarang, dengan sensor akustik.

Namun, semua itu adalah cara yang sangat tidak langsung dan rumit untuk menjawab satu soalan mudah: "adakah kita telah berpusing atau tidak?"

Saya nampaknya melompat menggunakan sensor laser ToF akan membawa saya ke tahap perisian seterusnya; iaitu, SLAM (Penyetempatan dan Pemetaan Serentak). Saya belum bersedia ke sana.

Adalah baik untuk membuat projek robot secara berlapis, dengan lapisan pertama (bawah) lebih sederhana, dan lapisan terakhir (atas) lebih abstrak dan menangani masalah yang lebih sukar.

Lapisan boleh difikirkan seperti ini:

1. rangka fizikal robotik / struktur mekanikal
2. sistem pemacu asas (Raspberry, Roboclaw, motor, kabel, dll., perisian asas, didorong oleh papan kekunci)
3. litar penting untuk menyokong sensor (pemindah voltan dua arah, pengembang port, E-Stop, pengagihan kuasa, dll)
4. sensor penghindaran halangan (akustik, IR)
5. penting, kedudukan dan pergerakan asas - pengesanan (akselerometer, giro, magnetometer, pengekod motor, pengekod roda)

Anda boleh membuat senarai sendiri. Perkara-perkara mengenai senarai ini adalah bahawa anda mungkin harus melakukan ini lebih kurang mengikut urutan itu, dan juga bahawa jika anda meluangkan masa di setiap lapisan untuk mendapatkan masing-masing keadaan yang baik, itu akan membantu anda kemudian kerana keadaan menjadi lebih rumit.

Senarai di atas dapat dipetakan lebih kurang pada lapisan konseptual ini dalam perisian.

• SLAM (Penyetempatan dan Pemetaan Serentak)
• Kawalan dan Kesedaran Pergerakan, Putaran
• Penghindaran Halangan Asas
• Kawalan dan Pengesanan Data Sensor
• Pergerakan Penting Ke Depan, Ke Belakang, Kiri dan Kanan, Kelajuan, Perlahan, Berhenti

Seperti yang anda lihat, untuk senarai ini, item pertama adalah lapisan atas dan lebih rumit yang menangani masalah dan persoalan yang lebih abstrak, seperti "di mana saya" dan "ke mana saya akan pergi", sementara item terakhir adalah lapisan perisian yang lebih rendah yang mengendalikan "cara bercakap / mendengar sensor A" atau "cara menggerakkan roda ini".

Sekarang, saya tidak mengatakan bahawa apabila anda memulakan lapisan, anda akan menyelesaikannya dan kemudian berada di lapisan seterusnya, tidak akan pernah kembali ke lapisan sebelumnya. Projek robot boleh seperti kaedah pembangunan perisian yang berulang dan moden (tangkas, SCRUM, dll).

Saya hanya mengatakan untuk meluangkan masa masing-masing. Anda harus mengimbangkan berapa banyak yang harus dilakukan pada setiap satu, dan memutuskan apa yang anda cuba pada lapisan tertentu yang bernilai masa dan masalah.

Terdapat "konflik" atau "ketegangan" tertentu antara dua idea atau arah yang bersaing.

Salah satunya adalah apa yang saya panggil "plug-n-play" untuk menyelesaikan masalah A.

Yang lain adalah DIY (buat sendiri). Itu mungkin bukan label terbaik untuk idea lain ini.

Berikut adalah contoh masing-masing, semoga anda dapat melihat ketegangan atau konflik antara kedua-dua pilihan.

Untuk contoh ini, mari kita lumpuhkan SLAM, penghindaran halangan, dan pergerakan asas yang penting sebagai satu masalah untuk diselesaikan pada masa yang sama.

1. Sekiranya kami memutuskan untuk menggunakan laluan plug-n-play, kami segera melompat (bergantung pada anggaran) ke perkara-perkara seperti laser berputar yang dipasang di atas, atau kamera kedalaman lapangan, atau laser ToF, dan IMU (topik ini Boleh diajar).
2. Sekiranya kita, sebaliknya, ingin menempuh laluan kedua, kita mungkin akan berusaha mengekstrak sedikit maklumat dari beberapa sensor akustik atau sensor IR, atau tidak ada sensor sama sekali - kita hanya menggunakan pemantauan arus motor (bump)

Apa yang boleh dikatakan mengenai # 1 vs # 2? Satu perkara ialah kita akan belajar lebih banyak lagi dengan melakukan # 2. Keterbatasan untuk mempunyai sensor akustik sahaja, memaksa kita untuk memikirkan lebih banyak masalah.

Sebaliknya, jika kita terlalu fokus melakukan sesuatu melalui # 2, kita mungkin membuang masa, kerana kita meminta lebih banyak daripada yang seharusnya dari sensor akustik.

Satu lagi konsep atau idea yang perlu difikirkan: Campuran perkakasan dan perisian apa yang paling baik menjawab soalan "bagaimana", dan campuran perisian (dan perkakasan?) Yang menjawab persoalan "apa", "kapan", "di mana". Kerana "bagaimana" biasanya merupakan pertanyaan tingkat bawah yang bergantung pada "apa", "kapan", dan "di mana" untuk mendapatkan jawapan.

Bagaimanapun, semua perkara di atas hanyalah sesuatu yang perlu difikirkan.

Dalam kes saya, setelah banyak usaha dan mengalami masalah gangguan geseran yang konsisten dan tidak dapat mendapatkan kawalan dan pergerakan yang konsisten, inilah masanya untuk melakukan sesuatu yang lain.

Oleh itu ini boleh diarahkan - IMU.

Tujuannya adalah jika IMU mengatakan bahawa robot TIDAK berputar, kita meningkatkan kitaran tugas. Sekiranya kita berpusing terlalu cepat, kita mengurangkan kitaran tugas.

Langkah 1: Sensor IMU

Oleh itu, sensor kami yang seterusnya untuk ditambahkan ke Wallace adalah IMU. Selepas beberapa kajian, saya mendapat MPU6050. Tetapi pada masa ini, MPU9050 (dan baru-baru ini, MPU9250) kelihatan seperti idea yang lebih baik.

Sumber masuk saya adalah Amazon (di A. S.). Oleh itu, saya memesan dua daripadanya.

Apa yang saya dapat sebenarnya (nampaknya tidak ada kawalan terhadap ini; itulah yang saya tidak suka mengenai Amazon) adalah dua MPU92 / 65. Saya tertanya-tanya sedikit mengenai sebutan. Lihat gambarnya; yang nampaknya sebutan "keluarga". Walau apa pun, itulah yang saya hadapi.

Menambahnya sangat mudah - dapatkan papan proto dengan trek penghubung, solder sensor ke papan, tambahkan blok terminal skru 10-pin (saya mendapat tambang dari Pololu).

Untuk mengurangkan gangguan, saya cuba meletakkan sensor ini dari semua perkara lain.

Itu juga bermaksud menggunakan beberapa baut / mur nilon.

Saya akan menggunakan protokol I2C. Semoga panjang wayar tidak terlalu teruk.

Terdapat banyak maklumat di tempat lain mengenai sambungan asas dan tahap voltan, dan sebagainya, jadi saya tidak akan mengulanginya di sini.

Langkah 2: Perkara Tidak Selalu Bersih, Mudah

Pada penulisan ini, nampaknya tidak ada banyak talian untuk MPU-92/65 ini. Apa yang ada, seperti kebanyakan sensor, nampaknya menjadi contoh menggunakan Arduino.

Saya cuba menjadikan Instructables ini sedikit berbeza dengan membentangkan proses yang tidak begitu bersih, kerana perkara tidak selalu berfungsi dengan segera.

Saya rasa Instructables ini lebih mirip dengan blog daripada straight A-B-C, 1-2-3 "ini adalah bagaimana anda melakukannya".

Langkah 3: Ujian Permulaan

Dari gambar pada langkah sebelumnya, wayar merah dan hitam yang menuju ke sensor tentu saja VCC (5V) dan GND. Wayar hijau dan kuning adalah sambungan I2C.

Sekiranya anda telah melakukan projek I2C lain, atau mengikuti siri ini, maka anda sudah mengetahui mengenai "i2cdetect", dan itulah langkah pertama untuk mengetahui apakah Raspberry dapat melihat sensor baru.

Seperti yang anda lihat dari gambar dalam langkah ini, percubaan pertama kami tidak berjaya. IMU tidak muncul (mestilah id peranti 0x68).

Namun, berita baiknya ialah bas I2C beroperasi. Kami melihat satu peranti 0x20 dan ia adalah pengembang port MCP23017 (kini bertanggungjawab untuk sensor akustik HCSR04).

Tidak mudah dilihat dalam gambar, tetapi saya menyambungkan wayar berwarna hijau dan kuning yang sama dari IMU ke MCP23017 (lihat kiri bawah gambar)

Kita perlu melakukan beberapa penyelesaian masalah.

Langkah 4: Penyelesaian masalah

Menggunakan tetapan kesinambungan pada voltmeter (yang dengan nada bernada tinggi), saya menguji sambungan VCC (5V), GND, SDA, dan SCL. Itu bagus.

Percubaan seterusnya adalah memutuskan sambungan MCP23017 dari bas I2C, dengan hanya meninggalkan MPU-92/65 di dalam bas. Itu terbukti tidak berbuah - "i2cdetect" kemudian tidak menunjukkan peranti.

Jadi, seterusnya, saya melepaskan sensor dari tiang totem, dan menyambungkannya semula terus ke bas dua arah 5V-ke-3V; iaitu terus ke Raspberry. (wayar lebih pendek?).

Dan voila. Kali ini ada kejayaan. Kami melihat 0x68 muncul menggunakan "i2cdetect".

Tetapi kita belum tahu mengapa ia berfungsi pada masa ini. Mungkinkah panjang wayar? Lokasi sebelumnya?

Catatan: Tidak ada perbezaan sama ada ADO dibumikan atau tidak. Mungkin ada resistor pull-down dan pull-down di atas kapal. Perkara yang sama mungkin berlaku untuk FSYNC.

Seterusnya, saya menyambung semula MCP23017. Jadi sekarang kita mempunyai dua peranti di bas I2C. (lihat gambar). Berjaya, sekarang kita melihat 0x20 dan 0x68 dengan i2cdetect.

Video menerangkan lebih banyak perkara yang berlaku semasa menyelesaikan masalah.

Langkah 5: Membaca Data Sensor

Pelbagai Pendekatan

Saya memutuskan untuk mengambil pelbagai pendekatan untuk mendapatkan maklumat berguna dari sensor. Inilah mereka, tidak mengikut urutan apa pun:

1. cuba beberapa pengaturcaraan asas
2. lihatlah beberapa dokumentasi dalam talian mengenai daftar
3. lihat contoh dan / atau kod orang lain

Mengapa pendekatan ini? Mengapa tidak hanya mencari beberapa pustaka atau kod yang ada?

Dengan bereksperimen dan mencuba beberapa idea, kita dapat dengan lebih baik menyerap pengetahuan tentang bukan hanya sensor tertentu ini, tetapi juga memperoleh beberapa teknik, kemahiran, dan cara berfikir untuk mengatasi sesuatu yang baru, dan sesuatu yang mungkin tidak mempunyai banyak dokumentasi; sesuatu yang mungkin mempunyai banyak perkara yang tidak diketahui.

Juga, setelah kita bermain dan mencuba beberapa idea kita sendiri dan memperoleh pandangan, kita berada dalam kedudukan yang lebih baik untuk menilai kod atau perpustakaan orang lain.

Sebagai contoh, setelah melihat beberapa kod C ++ untuk MPU9250 di github, saya menyedari bahawa ia memaksa saya untuk menggunakan gangguan, yang belum saya mahu lakukan.

Ia juga dilengkapi dengan perkara tambahan seperti penentukuran; sekali lagi, sesuatu yang belum saya minati.

Mungkin yang perlu saya lakukan untuk menjawab soalan mudah "ialah robot berputar ya atau tidak" dapat dijawab dengan sangat sederhana dengan hanya membaca beberapa daftar.

Daftar

Pada penulisan ini, nampaknya tidak banyak yang terdapat pada sensor ini. Sebenarnya, jika anda melihat gambar yang disertakan dengan Instructable ini, dan melihat prasasti pada cip sebenar, itu membuat saya tertanya-tanya apakah ini bukan tiruan. Saya tidak mengaitkan apa yang saya lihat dengan apa-apa dari Invense. Walau apa pun, saya memilih untuk melihat maklumat daftar untuk model yang saya dapati: MPU-6050, dan MPU-9250.

Dalam kedua kes, perkara berikut adalah sama untuk kedua-duanya. Sebagai permulaan, kami menganggap ia juga akan sama untuk MPU-92/65 ini.

59 hingga 64 - pengukuran pecutan

65, 66 - pengukuran suhu 67 hingga 72 - pengukuran giroskop 73 hingga 96 - data sensor luaran

Item nota: MPU-6050 nampaknya TIDAK memiliki magnetometer, sedangkan MPU-9250 (dan kami menganggap ini juga) mempunyai satu.

Beberapa maklumat yang lebih menarik dan mudah-mudahan berguna yang diperoleh daripada dokumen daftar:

Maklumat Magnetometer:

magnetometer id: 0x48 register 00 hingga 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 HX6 HX5 HX4 HX3 HX2 HX1 HX0 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 07H HZL HZ7 HZ7 Hz7 HZ7 Hz7 HZ7 ST2 0 0 0 BITM HOFL 0 0 0 pecahan maksud setiap daftar: HXL [7: 0]: Data pengukuran paksi-X lebih rendah 8bit HXH [15: 8]: Data pengukuran paksi-X lebih tinggi 8bit HYL [7: 0]: Data pengukuran paksi-Y lebih rendah 8bit HYH [15: 8]: Data pengukuran paksi-Y lebih tinggi 8bit HZL [7: 0]: Data pengukuran paksi-Z lebih rendah 8bit HZH [15: 8]: Data pengukuran paksi-Z lebih tinggi 8bit

Pengaturcaraan

Satu maklumat lain dari dokumen daftar adalah bahawa terdapat hanya kira-kira 100 atau lebih daftar. Jadi salah satu taktiknya ialah menulis program sederhana yang mengakses peranti (0x68) dan berusaha membaca serangkaian daftar secara berurutan, tanpa memperhatikan maknanya, hanya untuk melihat data apa yang dapat dilihat.

Kemudian, lakukan hantaran berturut-turut, menggunakan kod yang sama, dan bandingkan data dari satu lulus berbanding yang berikutnya.

Idenya adalah bahawa kita mungkin dapat menghilangkan daftar yang sepertinya tidak memiliki data (nol atau FF?) Atau yang sama sekali tidak pernah berubah, dan kita juga dapat memusatkan perhatian pada yang mengubahnya.

Kemudian, kita hanya melihat yang berubah, tambahkan fungsi rata-rata yang rata-rata membaca N terkini dari daftar itu, untuk melihat apakah sebenarnya ada nilai mantap tertentu untuk daftar itu. Ini akan mengandaikan bahawa kita menyimpan sensor dengan tenang, dan di lokasi yang sama.

Akhirnya, kita kemudian dapat dengan lembut mencuba sesuatu dengan sensor, seperti mendorongnya (akselerometer, giro), atau meniupnya (suhu), atau memutarnya (magnetometer dua tambah sebelumnya) dan melihat apa kesannya terhadap nilai-nilai tersebut.

Saya suka menggunakan perpustakaan wiringPi sebanyak mungkin. Ia mempunyai sokongan untuk I2C.

Larian pertama:

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

* untuk membina: gcc first.test.mpu9265.c -o first.test.mpu9265 -lwiringPi * * untuk menjalankan: sudo./first.test.mpu9265 * * program ini hanya mengeluarkan pelbagai (mungkin) daftar dari MCP23017, * dan kemudian dari MPU9265 (atau MPU lain di alamat 0x68 itu) * * Saya menggunakannya untuk mengesahkan jika saya dapat membaca dari sensor, kerana saya sudah * yakin pada MCP23017. * ************************************************* **************************** / #include #include #include #include #include int main (int argc, char ** argv) {let ("Mari kita lihat apa yang dinyatakan oleh MCP23017 @ 0x20:"); errno = 0; int deviceId1 = 0x20; int fd1 = pendawaianPiI2CSetup (deviceId1); if (-1 == fd1) {fprintf (stderr, "Tidak dapat membuka peranti pendawaianPi I2C:% s / n", strerror (errno)); pulangan 1; } untuk (int reg = 0; reg <300; reg ++) {fprintf (stderr, "% d", wiringPiI2CReadReg8 (fd1, reg)); fflush (stderr); kelewatan (10); } meletakkan (""); meletakkan ("Mari kita lihat apa yang dikatakan oleh MPU9265 @ 0x20:"); errno = 0; int deviceId2 = 0x68; int fd2 = pendawaianPiI2CSetup (deviceId2); if (-1 == fd2) {fprintf (stderr, "Tidak dapat membuka peranti pendawaianPi I2C:% s / n", strerror (errno)); pulangan 1; } untuk (int reg = 0; reg <300; reg ++) {fprintf (stderr, "% d", wiringPiI2CReadReg8 (fd2, reg)); fflush (stderr); kelewatan (10); } meletakkan (""); pulangan 0; }

Larian kedua:

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

* untuk membina: gcc second.test.mpu9265.c -o second.test.mpu9265 -lwiringPi * * untuk menjalankan: sudo./second.test.mpu9265 * * Program ini mengeluarkan nombor pendaftaran di samping nilai yang dibaca. * * Ini berguna untuk menyalurkan (mengarahkan) output ke file, dan kemudian * beberapa jalan dapat dilakukan, untuk membandingkan. Ini mungkin memberi sedikit gambaran tentang * daftar apa yang penting, dan bagaimana data tersebut berkelakuan. * ************************************************* **************************** / #include #include #include #include #include #include int main (int argc, char ** argv) {int deviceId = -1; if (0) {} lain jika (! strncmp (argv [1], "0x20", strlen ("0x20"))) {deviceId = 0x20; } lain jika (! strncmp (argv [1], "0x68", strlen ("0x68"))) {deviceId = 0x68; } lain jika (! strncmp (argv [1], "0x69", strlen ("0x69"))) {deviceId = 0x69; } meletakkan ("Mari kita lihat apa yang dikatakan oleh MPU9265 @ 0x20:"); errno = 0; int fd = wiringPiI2CSetup (deviceId); if (-1 == fd) {fprintf (stderr, "Tidak dapat membuka peranti wiringPi I2C:% s / n", strerror (errno)); pulangan 1; } untuk (int reg = 0; reg <300; reg ++) {fprintf (stderr, "% d:% d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); kelewatan (10); } pulangkan 0; }

Larian ketiga:

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

* untuk membina: gcc third.test.mpu9265.c -o third.test.mpu9265 -lwiringPi * * untuk menjalankan: sudo./third.test.mpu9265 * * Program ini adalah hasil dari yang kedua. Ini hanya dibaca dari daftar * yang menunjukkan perbezaan antara satu larian dan yang berikutnya.* ************************************************* **************************** / #include #include #include #include #include #include int main (int argc, char ** argv) {int deviceId = -1; if (0) {} lain jika (! strncmp (argv [1], "0x68", strlen ("0x68"))) {deviceId = 0x68; } lain jika (! strncmp (argv [1], "0x69", strlen ("0x69"))) {deviceId = 0x69; } meletakkan ("Mari kita lihat apa yang dikatakan oleh MPU9265 @ 0x20:"); errno = 0; int fd = wiringPiI2CSetup (deviceId); if (-1 == fd) {fprintf (stderr, "Tidak dapat membuka peranti wiringPi I2C:% s / n", strerror (errno)); pulangan 1; } untuk (int reg = 61; reg <= 73; reg ++) {fprintf (stderr, "% d:% d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); kelewatan (10); } untuk (int reg = 111; reg <= 112; reg ++) {fprintf (stderr, "% d:% d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); kelewatan (10); } untuk (int reg = 189; reg <= 201; reg ++) {fprintf (stderr, "% d:% d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); kelewatan (10); } untuk (int reg = 239; reg <= 240; reg ++) {fprintf (stderr, "% d:% d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); kelewatan (10); } pulangkan 0; }

Jadi apa yang kita pelajari setakat ini? Gambar jadual dengan kawasan yang diserlahkan berwarna menunjukkan bahawa output sepertinya sesuai dengan set daftar pertama.

Hasilnya setakat ini dapat menghasilkan soalan baru.

Soalan: mengapa hanya ada satu hasil pendaftaran untuk kumpulan "luaran"?

Soalan: apakah semua daftar yang tidak diketahui itu "??????"

Soalan: oleh kerana program ini tidak didorong oleh gangguan, adakah permintaan data terlalu lambat? terlalu laju?

Soalan: dapatkah kita mempengaruhi hasilnya dengan mencuba sensor itu sendiri ketika berjalan?

Langkah 6: Mari Menggali Lebih Banyak Pembacaan / Data

Saya fikir langkah seterusnya sebelum melakukan perkara lain adalah meningkatkan program untuk:

• fleksibel dalam berapa banyak kelewatan gelung (ms)
• fleksibel dalam berapa banyak bacaan untuk memberikan purata berjalan setiap daftar

(Saya terpaksa melampirkan program sebagai fail. Nampaknya ada masalah memasukkannya ke sini. "Four.test.mpu9265.c")

Berikut adalah larian menggunakan 10 bacaan terakhir secara purata, pada gelung 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

Lajur pertama, paling kiri adalah nombor daftar. Kemudian datang 10 bacaan terakhir untuk daftar itu. Akhirnya, lajur terakhir adalah purata bagi setiap baris.

Nampaknya daftar 61, 69, 71, 189, 197, dan 199 sama ada hanya binari, atau siap / tidak siap, atau bait tinggi dengan nilai 16-bit (negatif?).

Pemerhatian menarik yang lain:

• daftar 65, 193 - nilai yang sangat mantap dan sama
• daftar 63, 191 - nilai yang sangat mantap dan sama
• daftar 73, 112, 195, 201, 240 - semuanya pada sifar

Mari kita kaitkan pemerhatian ini dengan gambar meja berwarna yang diserlahkan dari sebelumnya.

Daftar 65 - suhu

Daftar 193 - ??????

Daftar 63 - pecutan

Daftar 191 - ??????

Daftar 73 - luaran

Daftar 112 dan seterusnya - ??????

Kami masih belum mengetahui, namun kami telah mempelajari sesuatu yang berguna.

Daftar 65 (suhu) dan daftar 63 (pecutan) keduanya sangat stabil. Ini adalah sesuatu yang kita harapkan. Saya belum menyentuh sensor; ia tidak bergerak, selain daripada getaran tidak sengaja, kerana robot itu terletak di atas meja yang sama dengan komputer saya.

Terdapat satu ujian menarik yang dapat kami lakukan untuk setiap daftar suhu / akselerometer ini. Untuk ujian itu, kami memerlukan versi program yang lain.

Langkah 7: Kami Mampu Mempengaruhi Suhu dan Pecutan

Pada langkah sebelumnya kami menyempitkan sekurang-kurangnya satu daftar untuk suhu, dan satu untuk pecutan.

Dengan versi program seterusnya ("second.test.mpu9265.c"), kita sebenarnya dapat melihat perubahan berlaku untuk kedua-dua daftar. Sila tonton videonya.

Lebih Menggali

Sekiranya kita kembali dan melihat maklumat daftar, kita melihat bahawa terdapat:

• tiga output 16 bit untuk giroskop
• tiga output 16 bit untuk pecutan
• tiga output 16 bit untuk magnetometer
• satu output 16 bit untuk suhu

Walau bagaimanapun, hasil yang diperoleh oleh program ujian sederhana kami adalah semua output 8 bit tunggal. (daftar tunggal).

Oleh itu, mari kita cuba lebih banyak pendekatan yang sama, tetapi kali ini membaca 16 bit dan bukannya 8 bit.

Kita mungkin akan melakukan sesuatu seperti di bawah. Mari gunakan suhu sebagai contoh, kerana ia hanya satu output 16 bit.

// dapatkan deskriptor fail fd…

int tempRegHi = 65; int tempRegLo = 66; int hiByte = pendawaianPiI2CReadReg8 (fd, tempRegHi); int loByte = pendawaianPiI2CReadReg8 (fd, tempRegLo); hasil int = hiByte << 8; // masukkan pesanan hi 8 bit ke bahagian atas hasil nilai 16 bit | = loByte; // sekarang tambahkan urutan 8 bit, menghasilkan nombor 16 bit lengkap // cetak nombor itu atau gunakan fungsi grafik mendatar paparan dari sebelumnya

Dari langkah sebelumnya kami telah melihat bahawa register 65 cukup stabil, sementara register 66 sangat bising. Oleh kerana 65 adalah bait pesanan tinggi, dan 66 bait pesanan rendah, itu masuk akal.

Untuk membaca, kita dapat mengambil data daftar 65 sebagaimana adanya, tetapi kita dapat menilai nilai 66.

Atau kita boleh menilai keseluruhan hasilnya.

Lihat video terakhir untuk bahagian ini; ia menunjukkan membaca keseluruhan nilai suhu 16 bit. Kodnya adalah "six.test.mpu9265.c"

Langkah 8: Accelerometer dan Giroskop

Video untuk bahagian ini menunjukkan output dari pecutan dan giroskop, menggunakan program ujian "seven.test.mpu9265.c". Kod itu boleh membaca 1, 2, atau 3 pasangan bait berturut-turut (hi dan lo bait) dan menukar nilainya menjadi satu nilai 16 bit. Oleh itu, kita dapat membaca mana-mana paksi tunggal, atau kita dapat membaca dua daripadanya bersama (dan ini merangkum perubahannya), atau kita dapat membaca ketiga-tiganya (dan ini merangkum perubahannya).

Untuk mengulangi, untuk fasa ini, untuk Instructable ini, saya hanya ingin menjawab soalan mudah: "adakah robot berputar / berpusing?". Saya tidak mencari nilai tepat, seperti, adakah ia berputar 90 darjah. Itu akan datang kemudian ketika kita melakukan SLAM, tetapi tidak diperlukan untuk mengelakkan halangan dan pergerakan secara rawak.

Langkah 9: (Kerja Sedang Berlangsung) Magnetometer

semasa menggunakan alat i2cdetect, MPU9265 muncul sebagai 0x68 dalam jadual:

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

Terdapat langkah tambahan yang diperlukan untuk membaca dari bahagian magnetometer IMU.

Dari dokumen PDF Invesense register:

PENDAFTARAN 37 HINGGA 39 - KAWALAN IZC SLAVE 0

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