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:

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

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.