- Memilih Bagian untuk Self Balancing Robot
- 3D Printing dan Merakit Robot Self Balancing kami
- Diagram Sirkuit
- Kode Robot Penyeimbang Diri
- Pengerjaan Robot Self Balancing Arduino
Setelah terinspirasi oleh motor RYNO dan skuter penyeimbang diri lainnya dari Segway, saya selalu ingin membuat Robot Segway Arduino saya sendiri. Berpikir sejenak, saya memutuskan untuk membangun Robot Self Balancing menggunakan Arduino. Dengan cara ini saya akan dapat memahami konsep yang mendasari di balik semua skuter ini dan juga mempelajari cara kerja algoritma PID.
Begitu saya mulai membangun, saya menyadari bahwa bot ini agak sulit untuk dibuat. Ada begitu banyak pilihan untuk dipilih dan karena itu kebingungan mulai dari memilih motor dan tetap sampai nilai PID disetel. Dan ada banyak hal yang perlu diperhatikan seperti jenis aki, posisi aki, pegangan roda, tipe pengendara motor, perawatan CoG (Center of Gravity) dan masih banyak lagi.
Tapi izinkan saya menjelaskannya kepada Anda, setelah Anda membangunnya, Anda akan setuju bahwa itu tidak sesulit kedengarannya. Jadi mari kita hadapi itu, dalam tutorial ini saya akan mendokumentasikan pengalaman saya dalam membangun robot self balancing. Anda mungkin seorang pemula absolut yang baru saja memulai atau mungkin sudah mendarat di sini setelah frustrasi lama karena bot Anda tidak berfungsi. Tempat ini bertujuan untuk menjadi tujuan akhir Anda. Jadi mari kita mulai……
Memilih Bagian untuk Self Balancing Robot
Sebelum saya memberi tahu Anda semua opsi untuk membangun bot, izinkan saya mencantumkan item yang telah saya gunakan dalam proyek robot penyeimbang diri ini
- Arduino UNO
- Motor DC yang diarahkan (berwarna kuning) - 2Nos
- Modul Driver Motor L298N
- MPU6050
- Sepasang roda
- Baterai Li-ion 7.4V
- Menghubungkan kabel
- Tubuh Cetak 3D
Anda dapat mencampur dan memilih salah satu komponen di atas berdasarkan ketersediaan untuk membuat kit robot penyeimbang diri Anda sendiri, cukup pastikan bahwa komponen tersebut sesuai dengan kriteria berikut.
Pengontrol: Pengontrol yang saya gunakan di sini adalah Arduino UNO, mengapa karena mudah digunakan. Anda juga dapat menggunakan Arduino Nano atau Arduino mini tetapi saya akan merekomendasikan Anda untuk tetap menggunakan UNO karena kami dapat memprogramnya secara langsung tanpa perangkat keras eksternal.
Motor: Pilihan motor terbaik yang dapat Anda gunakan untuk robot penyeimbang diri, tidak diragukan lagi adalah motor Stepper. Tetapi untuk menjaga hal-hal sederhana saya telah menggunakan motor roda gigi DC. Ya, tidak wajib memiliki anak tiri; bot ini bekerja dengan baik dengan motor roda gigi DC berwarna kuning murah yang umumnya tersedia juga.
Pengemudi Motor: Jika Anda telah memilih motor roda gigi DC seperti milik saya maka Anda dapat menggunakan modul driver L298N seperti saya, atau bahkan L293D seharusnya berfungsi dengan baik. Pelajari lebih lanjut tentang mengendalikan motor DC menggunakan L293D dan Arduino.
Roda: Jangan remehkan orang-orang ini; Saya mengalami kesulitan untuk mengetahui bahwa masalahnya ada pada roda saya. Jadi pastikan roda Anda memiliki pegangan yang baik di atas lantai yang Anda gunakan. Perhatikan baik-baik, pegangan Anda tidak boleh membiarkan roda meluncur di lantai.
Akselerometer dan Giroskop: Pilihan terbaik Akselerometer dan Giroskop untuk bot Anda adalah MPU6050. Jadi jangan mencoba untuk membuatnya dengan Accelerometer normal seperti ADXL345 atau semacamnya, itu tidak akan berhasil. Anda akan mengetahui alasannya di akhir artikel ini. Anda juga dapat memeriksa artikel khusus kami tentang penggunaan MPU6050 dengan Arduino.
Baterai: Kami membutuhkan baterai yang seringan mungkin dan tegangan operasi harus lebih dari 5V sehingga kami dapat memberi daya Arduino kami secara langsung tanpa modul boost. Jadi pilihan ideal adalah baterai Li-polimer 7.4V. Di sini, karena saya memiliki baterai Li-ion 7.4V yang tersedia, saya telah menggunakannya. Tapi ingat Li-po lebih menguntungkan daripada Li-ion.
Sasis: Tempat lain di mana Anda tidak boleh berkompromi adalah dengan sasis bot Anda. Anda bisa menggunakan karton, kayu, plastik apapun yang Anda suka. Tapi, pastikan saja sasisnya kokoh dan tidak boleh bergoyang saat bot mencoba menyeimbangkan. Saya telah merancang dengan sasis sendiri di Solidworks menyimpulkan dari bot lain dan 3D mencetaknya. Jika Anda memiliki printer, Anda juga dapat mencetak desain, file desain akan dilampirkan di judul yang akan datang.
3D Printing dan Merakit Robot Self Balancing kami
Jika Anda telah memutuskan untuk mencetak sasis 3D yang sama dengan yang saya gunakan untuk membuat bot saya, maka file STL dapat diunduh dari thingiverse. Saya juga menambahkan file desain bersamanya sehingga Anda juga dapat memodifikasinya sesuai preferensi personel Anda.
Suku cadang tidak memiliki struktur yang menjorok sehingga Anda dapat dengan mudah mencetaknya tanpa penyangga apa pun dan pengisian 25% akan berfungsi dengan baik. Desainnya cukup polos dan semua printer dasar harus dapat menanganinya dengan mudah. Saya menggunakan perangkat lunak Cura untuk memotong model dan mencetak menggunakan Tevo Tarantula saya, pengaturannya ditunjukkan di bawah ini.
Anda harus mencetak bagian bodi serta empat bagian pemasangan motor. Pemasangannya cukup mudah; gunakan mur dan baut 3mm untuk mengamankan motor dan papan pada tempatnya. Setelah dirakit akan terlihat seperti ini yang ditunjukkan pada gambar di bawah ini.
Desain sebenarnya direncanakan dengan modul penggerak L298N di rak bawah Arduino dan baterai di atasnya seperti yang ditunjukkan di atas. Jika Anda mengikuti urutan yang sama, Anda dapat langsung mengencangkan papan melalui lubang yang disediakan dan menggunakan tag kawat untuk baterai Li-po. Pengaturan ini seharusnya juga berfungsi, kecuali untuk roda super polos yang harus saya ubah nanti.
Di bot saya, saya telah menukar posisi baterai dan papan Arduino UNO untuk kemudahan pemrograman dan juga harus memperkenalkan papan kinerja untuk menyelesaikan koneksi. Jadi bot saya tidak terlihat seperti yang saya rencanakan pada tahap awal. Setelah menyelesaikan pengujian pemrograman kabel dan semuanya, robot roda dua saya akhirnya terlihat seperti ini
Diagram Sirkuit
Membuat koneksi untuk Self Balancing Robot berbasis Arduino ini cukup sederhana. Ini adalah robot self balancing menggunakan Arduino dan MPU6050 jadi kami harus menghubungkan MPU6050 dengan Arduino dan menghubungkan motor melalui modul driver Motor. Seluruh pengaturan didukung oleh baterai li-ion 7.4V. Diagram sirkuit untuk hal yang sama ditunjukkan di bawah ini.
Arduino dan modul driver Motor L298N diberi daya secara langsung melalui pin Vin dan terminal 12V. Regulator on-board pada papan Arduino akan mengubah input 7.4V menjadi 5V dan IC ATmega dan MPU6050 akan didukung olehnya. Motor DC dapat berjalan dari tegangan 5V hingga 12V. Tetapi kami akan menghubungkan kabel positif 7.4V dari baterai ke terminal input 12V modul driver motor. Ini akan membuat motor beroperasi dengan 7.4V. Tabel berikut akan mencantumkan bagaimana modul driver motor MPU6050 dan L298N terhubung dengan Arduino.
|
Komponen Pin |
Pin Arduino |
|
MPU6050 |
|
|
Vcc |
+ 5V |
|
Tanah |
Gnd |
|
SCL |
A5 |
|
SDA |
A4 |
|
INT |
D2 |
|
L298N |
|
|
IN1 |
D6 |
|
IN2 |
D9 |
|
IN3 |
D10 |
|
IN4 |
D11 |
MPU6050 berkomunikasi dengan Arduino melalui antarmuka I2C, jadi kami menggunakan pin SPI A4 dan A5 dari Arduino. Motor DC masing-masing terhubung ke pin PWM D6, D9 D10 dan D11. Kita perlu menghubungkannya ke pin PWM karena kita akan mengontrol kecepatan motor DC dengan memvariasikan siklus kerja sinyal PWM. Jika Anda tidak familiar dengan kedua komponen ini, maka disarankan untuk membaca tutorial driver Motor MPU6050 Interfacing dan L298N.
Kode Robot Penyeimbang Diri
Sekarang kita harus memprogram papan Arduino UNO kita untuk menyeimbangkan robot. Di sinilah semua keajaiban terjadi; konsep di baliknya sederhana. Kami harus memeriksa apakah bot condong ke depan atau ke belakang menggunakan MPU6050 dan kemudian jika condong ke depan kami harus memutar roda ke arah depan dan jika condong ke belakang kami harus memutar roda ke arah sebaliknya.
Pada saat yang sama kita juga harus mengontrol kecepatan saat roda berputar, jika bot sedikit mengalami disorientasi dari posisi tengah, roda berputar perlahan dan kecepatan bertambah karena semakin menjauh dari posisi tengah. Untuk mencapai logika ini kita menggunakan algoritma PID, yang memiliki posisi tengah sebagai set-point dan tingkat disorientasi sebagai keluaran.
Untuk mengetahui posisi bot saat ini kita menggunakan MPU6050 yang merupakan gabungan sensor akselerometer 6 sumbu dan sensor giroskop. Untuk mendapatkan nilai posisi yang dapat diandalkan dari sensor tersebut kita perlu menggunakan nilai akselerometer dan giroskop, karena nilai dari akselerometer memiliki masalah noise dan nilai dari giroskop cenderung melayang seiring waktu. Jadi kita harus menggabungkan keduanya dan mendapatkan nilai yaw pitch and roll robot kita, yang mana kita hanya akan menggunakan nilai yaw.
Kedengarannya agak pusing bukan? Tapi jangan khawatir, terima kasih kepada komunitas Arduino kami telah memiliki pustaka yang tersedia yang dapat melakukan penghitungan PID dan juga mendapatkan nilai yaw dari MPU6050. Perpustakaan dikembangkan oleh br3ttb dan jrowberg. Sebelum melanjutkan, unduh pustaka mereka dari tautan berikut dan tambahkan ke direktori lib Arduino Anda.
github.com/br3ttb/Arduino-PID-Library/blob/master/PID_v1.h
github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050
Sekarang, kami memiliki perpustakaan yang ditambahkan ke Arduino IDE kami. Mari mulai membuat program untuk Self Balancing Robot kita. Seperti biasanya kode lengkap untuk robot balancing MPU6050 diberikan di akhir halaman ini, di sini saya hanya menjelaskan cuplikan terpenting dalam kode tersebut. A diberitahu sebelumnya kode dibangun di atas kode contoh MPU6050 kita hanya akan mengoptimalkan kode untuk tujuan kita dan menambahkan PID dan teknik kontrol untuk robot self balancing kita.
Pertama kami menyertakan perpustakaan yang diperlukan agar program ini berfungsi. Mereka termasuk perpustakaan I2C built-in, Perpustakaan PID dan Perpustakaan MPU6050 yang baru saja kita unduh.
#include "I2Cdev.h" #include
Kemudian kami mendeklarasikan variabel yang dibutuhkan untuk mendapatkan data dari sensor MPU6050. Kita membaca nilai vektor gravitasi dan angka empat lalu menghitung nilai yaw pitch and roll dari bot. The mengapung Array YPR akan mengadakan hasil akhir.
// Kontrol MPU / status vars bool dmpReady = false; // set true jika DMP init berhasil uint8_t mpuIntStatus; // memegang byte status interupsi aktual dari MPU uint8_t devStatus; // kembalikan status setelah setiap operasi perangkat (0 = sukses ,! 0 = error) uint16_t packetSize; // ukuran paket DMP yang diharapkan (standarnya adalah 42 byte) uint16_t fifoCount; // hitung semua byte yang saat ini ada di FIFO uint8_t fifoBuffer; // Buffer penyimpanan FIFO // orientasi / motion vars Quaternion q; // quaternion container VectorFloat gravitasi; // float vektor gravitasi ypr; // wadah yaw / pitch / roll dan vektor gravitasi
Berikutnya adalah segmen kode yang sangat penting, dan di sinilah Anda akan menghabiskan waktu lama untuk menyetel set nilai yang tepat. Jika robot Anda dibangun dengan pusat gravitasi yang sangat baik dan komponennya diatur secara simetris (yang dalam banyak kasus tidak) maka nilai set-point Anda adalah 180. Jika tidak, hubungkan bot Anda ke monitor serial Arduino dan miringkan hingga Anda menemukan posisi balancing yang baik, baca nilai yang ditampilkan pada monitor serial dan ini adalah nilai set point Anda. Nilai Kp, Kd dan Ki harus disetel sesuai bot Anda. Tidak ada dua bot identik yang memiliki nilai Kp, Kd dan Ki yang sama sehingga tidak ada jalan keluar darinya. Tonton video di akhir halaman ini untuk mendapatkan gambaran tentang cara menyesuaikan nilai-nilai ini.
/ ********* Sesuaikan 4 nilai ini untuk BOT Anda ********* / setpoint ganda = 176; // setel nilai saat bot tegak lurus dengan tanah menggunakan monitor serial. // Baca dokumentasi proyek di circuitdigest.com untuk mempelajari cara menyetel nilai-nilai ini double Kp = 21; // Setel ganda pertama ini Kd = 0.8; // Set ini secound ganda Ki = 140; // Terakhir setel ini / ****** Pengaturan akhir nilai ********* /
Pada baris selanjutnya kita menginisialisasi algoritma PID dengan melewatkan input variabel input, output, set point, Kp, Ki dan Kd. Dari ini kita telah menetapkan nilai set-point Kp, Ki dan Kd dalam potongan kode di atas. Nilai input akan menjadi nilai arus yaw yang dibaca dari sensor MPU6050 dan nilai output akan menjadi nilai yang dihitung dengan algoritma PID. Jadi pada dasarnya algoritma PID akan memberi kita nilai output yang harus digunakan untuk mengoreksi nilai Input agar mendekati set point.
PID pid (& masukan, & keluaran, & setpoint, Kp, Ki, Kd, LANGSUNG);
Di dalam fungsi pengaturan kosong kami menginisialisasi MPU6050 dengan mengkonfigurasi DMP (Digital Motion Processor). Ini akan membantu kami dalam menggabungkan data Akselerometer dengan data Giroskop dan memberikan nilai Yaw, Pitch and Roll yang andal. Kami tidak akan membahas lebih dalam karena ini akan jauh di luar topik. Bagaimanapun satu segmen kode yang harus Anda cari dalam fungsi pengaturan adalah nilai offset gyro. Setiap sensor MPU6050 memiliki nilai offsetnya sendiri, Anda dapat menggunakan sketsa Arduino ini untuk menghitung nilai offset sensor Anda dan memperbarui baris berikut sesuai dalam program Anda.
// sediakan gyro offset Anda sendiri di sini, diskalakan untuk sensitivitas min mpu.setXGyroOffset (220); mpu.setYGyroOffset (76); mpu.setZGyroOffset (-85); mpu.setZAccelOffset (1688);
Kami juga harus menginisialisasi pin PWM Digital yang kami gunakan untuk menghubungkan motor kami. Dalam kasus kami adalah D6, D9, D10 dan D11. Jadi kami menginisialisasi pin ini karena pin keluaran membuatnya RENDAH secara default.
// Menginisialisasinya Motor outpu pin pinMode (6, OUTPUT); pinMode (9, OUTPUT); pinMode (10, OUTPUT); pinMode (11, OUTPUT); // Secara default matikan kedua motor analogWrite (6, LOW); analogWrite (9, LOW); analogWrite (10, LOW); analogWrite (11, LOW);
Di dalam fungsi loop utama kami memeriksa apakah data dari MPU6050 siap untuk dibaca . Jika ya, kami menggunakannya untuk menghitung nilai PID dan kemudian menampilkan nilai input dan output PID pada monitor serial hanya untuk memeriksa bagaimana PID merespons. Kemudian berdasarkan nilai keluaran kami memutuskan apakah bot harus bergerak maju atau mundur atau diam.
Karena kami berasumsi bahwa MPU6050 akan mengembalikan 180 saat bot tegak. Kita akan mendapatkan nilai koreksi positif ketika bot jatuh ke depan dan kita akan mendapatkan nilai negatif jika bot jatuh ke belakang. Jadi kami memeriksa kondisi ini dan memanggil fungsi yang sesuai untuk menggerakkan bot maju atau mundur.
while (! mpuInterrupt && fifoCount <packetSize) { // tidak ada data mpu - melakukan kalkulasi PID dan keluaran ke motor pid.Compute (); // Cetak nilai Input dan Output pada monitor serial untuk memeriksa cara kerjanya. Serial.print (masukan); Serial.print ("=>"); Serial.println (keluaran); if (input> 150 && input <200) {// Jika Bot jatuh if (output> 0) // Jatuh ke arah depan Forward (); // Putar roda ke depan jika (keluaran <0) // Jatuh ke belakang Reverse (); // Putar roda ke belakang } else // Jika Bot tidak jatuh Stop (); // Tahan roda dengan tenang }
The PID variabel output juga memutuskan seberapa cepat motor harus diputar. Jika bot hampir jatuh maka kami melakukan koreksi kecil dengan memutar roda secara perlahan. Jika koreksi kecil ini tidak berhasil dan masih jika bot jatuh, kami meningkatkan kecepatan motor. Nilai seberapa cepat roda berputar akan ditentukan oleh algoritma PI. Perhatikan bahwa untuk fungsi Reverse kita telah mengalikan nilai output dengan -1 sehingga kita dapat mengubah nilai negatif menjadi positif.
void Forward () // Kode untuk memutar roda ke depan { analogWrite (6, output); analogWrite (9,0); analogWrite (10, keluaran); analogWrite (11,0); Serial.print ("F"); // Informasi debug } void Reverse () // Kode untuk memutar roda Mundur { analogWrite (6,0); analogWrite (9, keluaran * -1); analogWrite (10,0); analogWrite (11, keluaran * -1); Serial.print ("R"); } void Stop () // Kode untuk menghentikan kedua roda { analogWrite (6,0); analogWrite (9,0); analogWrite (10,0); analogWrite (11,0); Serial.print ("S"); }
Pengerjaan Robot Self Balancing Arduino
Setelah Anda siap dengan perangkat kerasnya, Anda dapat mengunggah kode ke papan Arduino Anda. Pastikan koneksi sudah benar karena kami menggunakan baterai Li-ion sangat hati-hati. Jadi periksa kembali korsleting dan pastikan terminal tidak akan bersentuhan bahkan jika bot Anda mengalami beberapa benturan kecil. Nyalakan modul Anda dan buka monitor serial Anda, jika Arduino Anda dapat berkomunikasi dengan MPU6050 dengan sukses dan jika semuanya berfungsi seperti yang diharapkan, Anda akan melihat layar berikut.
Di sini kita melihat nilai input dan output dari algoritma PID dalam format input => output . Jika bot seimbang sempurna, nilai output akan menjadi 0. Nilai input adalah nilai arus dari sensor MPU6050. Alfabet "F" menunjukkan bahwa bot bergerak maju dan "R" menunjukkan bahwa bot bergerak mundur.
Selama tahap awal PID, saya sarankan untuk membiarkan kabel Arduino Anda terhubung ke bot sehingga Anda dapat dengan mudah memantau nilai input dan output dan juga akan mudah untuk memperbaiki dan mengunggah program Anda untuk nilai Kp, Ki dan Kd. The video di bawah ini menunjukkan kerja lengkap bot dan juga menunjukkan bagaimana untuk memperbaiki nilai-nilai PID Anda.
Semoga ini bisa membantu membangun robot self balancing Anda sendiri jika Anda memiliki masalah dalam membuatnya berfungsi, maka tinggalkan pertanyaan Anda di bagian komentar di bawah atau gunakan forum untuk pertanyaan yang lebih teknis. Jika ingin lebih menyenangkan Anda juga bisa menggunakan logika yang sama untuk membangun robot penyeimbang bola.