Daftar Isi:
- Langkah 1: Komponen yang Diperlukan
- Langkah 2: Siapkan Trek
- Langkah 3: Menyiapkan Lingkungan
- Langkah 4: Memprogram GiggleBot
- Langkah 5: Membiarkannya Berjalan
Video: GiggleBot Line Follower Menggunakan Python: 5 Langkah
2024 Pengarang: John Day | [email protected]. Terakhir diubah: 2024-01-30 09:55
Kali ini, kami memprogram di MicroPython the Dexter Industries GiggleBot untuk mengikuti garis hitam menggunakan sensor pengikut garis bawaannya.
GiggleBot harus dipasangkan dengan mikro:bit BBC agar dapat dikontrol dengan tepat.
Jika tutorial ini terlalu canggih untuk Anda dan memprogram GiggleBot terlalu banyak untuk saat ini, Anda selalu dapat mengikuti tutorial awal yang menunjukkan bagaimana robot dapat diprogram di MakeCode di sini. Tutorial tertaut akan memandu Anda melalui dasar-dasarnya.
Langkah 1: Komponen yang Diperlukan
Komponen perangkat keras berikut diperlukan:
- baterai AA x3 - dalam kasus saya, saya menggunakan baterai isi ulang yang memiliki tegangan lebih rendah secara keseluruhan.
- Robot GiggleBot Dexter Industries untuk mikro:bit.
- Mikro BBC: bit.
Tentu saja, Anda juga memerlukan kabel micro USB untuk memprogram BBC micro:bit - kabel ini biasanya disertakan dalam paket BBC micro:bit atau Anda selalu dapat menggunakan kabel yang digunakan untuk mengisi daya (Android) smartphone.
Dapatkan GiggleBot untuk mikro:bit di sini
Langkah 2: Siapkan Trek
Anda harus melalui pencetakan beberapa ubin dan merancang trek Anda sendiri. Anda dapat menggunakan ubin kami sendiri sehingga Anda 100% yakin bahwa Anda mereplikasi kondisi kami. Atau jika Anda merasa ingin bertualang, Anda dapat menggunakan selotip hitam dan membuatnya sendiri. Berikut PDF untuk ubin yang telah kami gunakan.
Trek di atas terdiri dari sejumlah ubin berbeda berikut:
- 12 ubin tipe #1.
- 5 ubin tipe #2.
- 3 templat tipe ubin #5.
- 3 templat tipe ubin #6 - di sini, Anda akan mendapatkan satu ubin tambahan.
Selanjutnya, cetak dan potong. Coba tempatkan seperti pada foto di atas dan ingatlah bahwa di sisi kanan atas trek, 2 ubin harus tumpang tindih satu sama lain - ini diharapkan jika Anda bertanya-tanya apakah Anda melakukan sesuatu yang salah.
Langkah 3: Menyiapkan Lingkungan
Agar Anda dapat memprogram BBC micro:bit di MicroPython, Anda harus menyiapkan editor untuknya (Mu Editor) dan mengatur GiggleBot MicroPython Runtime sebagai runtime-nya. Untuk itu, Anda harus mengikuti petunjuk di halaman ini. Pada saat ini, runtime versi v0.4.0 digunakan.
Langkah 4: Memprogram GiggleBot
Sebelum turun ke sana, runtime GiggleBot MicroPython berisi runtime klasik untuk micro:bit BBC dan perpustakaan lain untuk mendukung GiggleBot dan Sensor Industri Dexter lainnya.
Setelah mengaturnya, buka skrip berikut di editor Mu dan klik Flash. Ini akan mem-flash GiggleBot MicroPython Runtime dan skrip yang baru saja Anda buka ke mikro:bit BBC Anda. Script juga ditampilkan di bawah.
Setelah proses flashing selesai, susun micro:bit BBC ke dalam GiggleBot dengan neopiksel papan menghadap ke depan, letakkan di trek dan nyalakan.
Perhatikan bahwa dalam skrip, PID dan 2 konstanta lainnya (setpoint kecepatan dan konstanta kecepatan minimum) sudah disetel.
Catatan: Skrip berikut mungkin memiliki spasi putih yang hilang dan ini tampaknya disebabkan oleh beberapa masalah dalam menampilkan GitHub Gists. Klik pada intinya untuk membawa Anda ke halaman GitHub di mana Anda dapat menyalin-tempel kode.
GiggleBot PID Line Follower - Disetel dengan NeoPixels
dari impor mikrobit* |
dari impor cekikikan* |
dari utime impor sleep_ms, ticks_us |
impor ustruk |
# inisialisasi GB neopiksel |
neo = init() |
# waktu |
update_rate = 50 |
# gain/konstanta (dengan asumsi tegangan baterai sekitar 4,0 volt) |
Kp = 25,0 |
Ki = 0,5 |
Kd =35.0 |
trigger_point = 0.3 |
min_speed_percent = 0,3 |
kecepatan_dasar = 70 |
titik setel = 0,5 |
posisi_terakhir = setpoint |
integral = 0,0 |
run_neopixels =Benar |
center_pixel =5# di mana piksel tengah senyum berada di GB |
# turquoise = tuple(map(lambda x: int(x / 5), (64, 224, 208))) # warna yang digunakan untuk menggambar kesalahan dengan neopiksel |
# pirus = (12, 44, 41) # persis pirus di atas yang dikomentari di atas ini |
error_width_per_pixel =0,5/3# kesalahan maks dibagi dengan jumlah segmen di antara setiap neopiksel |
defupper_bound_linear_speed_reducer(abs_error, trigger_point, upper_bound, terkecil_motor_power, tertinggi_motor_power): |
kecepatan_basis global |
jika abs_error >= trigger_point: |
# x0 = 0,0 |
# y0 = 0,0 |
# x1 = upper_bound - trigger_point |
# y1 = 1,0 |
# x = abs_error - trigger_point |
# y = y0 + (x - x0) * (y1 - y0) / (x1 - x0) |
# sama dengan |
y = (abs_error - trigger_point) / (batas_atas - trigger_point) |
motor_power = base_speed * (daya_motor_terkecil + (1- y) * (daya_motor_tertinggi - daya_motor_terkecil)) |
kembali motor_power |
lain: |
kembalikan base_speed * tertinggi_motor_power |
lari = Salah |
kesalahan_sebelumnya =0 |
sementara Benar: |
# jika tombol a ditekan maka mulailah mengikuti |
jika button_a.is_pressed(): |
lari = Benar |
# tetapi jika tombol b ditekan, hentikan pengikut garis |
jika button_b.is_pressed(): |
lari = Salah |
integral = 0,0 |
kesalahan_sebelumnya =0.0 |
piksel_mati() |
berhenti() |
tidur_ms(500) |
jika menjalankan isTrue: |
# membaca sensor garis |
start_time = ticks_us() |
kanan, kiri = read_sensor(LINE_SENSOR, BOTH) |
# garis ada di sebelah kiri saat posisinya < 0,5 |
# garis ada di sebelah kanan saat posisi > 0.5 |
# garis berada di tengah saat posisi = 0,5 |
# itu adalah rata-rata aritmatika berbobot |
mencoba: |
posisi = kanan / mengambang (kiri + kanan) |
kecualiZeroDivisionError: |
posisi = 0,5 |
# rentangnya harus (0, 1) dan bukan [0, 1] |
jika posisi ==0: posisi =0,001 |
jika posisi ==1: posisi =0,999 |
# gunakan pengontrol PD |
kesalahan = posisi - setpoint |
integral += kesalahan |
koreksi = Kp * error + Ki * integral + Kd * (error - sebelumnya_error) |
sebelumnya_kesalahan = kesalahan |
# hitung kecepatan motor |
motor_speed = upper_bound_linear_speed_reducer(abs(error), setpoint * trigger_point, setpoint, min_speed_percent, 1.0) |
leftMotorSpeed = motor_speed + koreksi |
rightMotorSpeed = motor_speed - koreksi |
# nyalakan neopiksel sesuai dengan kesalahan yang diberikan |
jika run_neopixels benar dan total_counts %3==0: |
untuk saya masuk'\x00\x01\x02\x03\x04\x05\x06\x07\x08': |
neo = (0, 0, 0) |
untuk saya masuk'\x00\x01\x02\x03': |
ifabs(error) > error_width_per_pixel * i: |
jika kesalahan <0: |
# neo[center_pixel + i] = pirus |
neo[center_pixel + i] = (12, 44, 41) |
lain: |
# neo[center_pixel - i] = pirus |
neo[center_pixel + i] = (12, 44, 41) |
lain: |
persen =1- (error_width_per_pixel * i -abs(error)) / error_width_per_pixel |
# nyalakan piksel saat ini |
jika kesalahan <0: |
# neo[center_pixel + i] = tuple(peta(lambda x: int(x * persentase), pirus)) |
neo[center_pixel + i] = (int(64* persen /5), int(224* persen /5), int(208* persen /5)) |
lain: |
# neo[center_pixel - i] = tuple(peta(lambda x: int(x * persentase), pirus)) |
neo[center_pixel - i] = (int(64* persen/5), int(224* persen/5), int(208* persen /5)) |
merusak |
neo.show() |
mencoba: |
# klip kecepatan motor |
jika dibiarkanMotorSpeed >100: |
kiriMotorSpeed = 100 |
rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100 |
jika benarMotorSpeed >100: |
kananMotorSpeed = 100 |
leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100 |
jika dibiarkanMotorSpeed <-100: |
kiriMotorSpeed =-100 |
jika rightMotorSpeed <-100: |
kananMotorSpeed =-100 |
# aktifkan motor |
set_speed (kecepatan motor kiri, kecepatan motor kanan) |
menyetir() |
# print((kesalahan, kecepatan_motor)) |
kecuali: |
# jika kita mengalami masalah yang tidak dapat diperbaiki |
lulus |
# dan pertahankan frekuensi loop |
akhir_waktu = ticks_us() |
delay_diff = (waktu_akhir - waktu_mulai) /1000 |
if1000.0/ update_rate - delay_diff >0: |
tidur(1000.0/ update_rate - delay_diff) |
lihat rawgigglebot_tuned_line_follower.py dihosting dengan ❤ oleh GitHub
Langkah 5: Membiarkannya Berjalan
Ada 2 tombol di BBC micro:bit: tombol A dan tombol B:
- Menekan tombol A akan membuat GiggleBot mengikuti garis (jika ada).
- Menekan tombol B menghentikan GiggleBot dan mengatur ulang semuanya sehingga Anda dapat menggunakannya lagi.
Sangat disarankan untuk tidak mengangkat GiggleBot saat mengikuti garis lalu memasangnya kembali karena kesalahan penghitungan dapat menumpuk dan mengacaukan rute robot. Jika Anda ingin mengangkatnya, tekan tombol B dan ketika Anda meletakkannya kembali tekan A lagi.
Direkomendasikan:
Robot Line Follower Menggunakan Arduino Uno dan L298N: 5 Langkah
Robot Pengikut Garis Menggunakan Arduino Uno dan L298N: Bunga Garis adalah robot yang sangat sederhana yang ideal untuk elektronik pemula
CARA MEMBUAT ROBOT LINE FOLLOWER Arduino (ADJUSTABLE SPEED): 5 Langkah
CARA MEMBUAT ROBOT LINE FOLLOWER Arduino (ADJUSTABLE SPEED): jadi dalam tutorial ini saya akan menunjukkan cara membuat robot line follower dengan kecepatan yang dapat disesuaikan
Cara Membuat Robot Line Follower Tanpa Menggunakan Arduino (Mikrokontroler): 5 Langkah
Cara Membuat Robot Line Follower Tanpa Menggunakan Arduino (Mikrokontroler): Dalam instruksi ini, saya akan mengajari Anda cara membuat robot pengikut garis tanpa menggunakan Arduino. Saya akan menggunakan langkah-langkah yang sangat mudah untuk menjelaskannya. Robot ini akan menggunakan Sensor Kedekatan IR untuk ikuti alurnya. Anda tidak memerlukan pengalaman pemrograman apa pun untuk
Papan Tulis Kelas Arduino Line Follower Wallrides: 8 Langkah (dengan Gambar)
Papan Tulis Kelas Wallrides Pengikut Garis Arduino: Mengikuti garis di tanah terlalu membosankan! Kami telah mencoba untuk melihat dari sudut pandang yang berbeda pada pengikut garis dan membawa mereka ke pesawat lain - ke papan tulis sekolah. Lihat apa yang terjadi
Cara Membuat Line Follower Menggunakan Arduino: 8 Langkah (dengan Gambar)
Cara Membuat Line Follower Menggunakan Arduino: Jika Anda memulai dengan robotika, salah satu proyek pertama yang pemula buat termasuk line follower. Ini adalah mobil mainan khusus dengan properti untuk berjalan di sepanjang garis yang biasanya berwarna hitam dan kontras dengan latar belakang. Mari kita dapatkan bintang