Daftar Isi:

GiggleBot Line Follower Menggunakan Python: 5 Langkah
GiggleBot Line Follower Menggunakan Python: 5 Langkah

Video: GiggleBot Line Follower Menggunakan Python: 5 Langkah

Video: GiggleBot Line Follower Menggunakan Python: 5 Langkah
Video: GiggleBot Line Follower — запрограммируйте робота micro:bit с помощью Line Follower. 2024, November
Anonim
Pengikut Garis GiggleBot Menggunakan Python
Pengikut Garis GiggleBot Menggunakan Python
Pengikut Garis GiggleBot Menggunakan Python
Pengikut Garis GiggleBot Menggunakan Python
Pengikut Garis GiggleBot Menggunakan Python
Pengikut Garis GiggleBot Menggunakan Python

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 yang Diperlukan
Komponen yang Diperlukan

Komponen perangkat keras berikut diperlukan:

  1. baterai AA x3 - dalam kasus saya, saya menggunakan baterai isi ulang yang memiliki tegangan lebih rendah secara keseluruhan.
  2. Robot GiggleBot Dexter Industries untuk mikro:bit.
  3. 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

Siapkan Trek
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

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