Menyetel Pengikut Garis GiggleBot - Tingkat Lanjut: 7 Langkah

2024 Pengarang: John Day | [email protected]. Terakhir diubah: 2024-01-30 09:56

Dalam Instruksi yang sangat singkat ini Anda akan menyetel GiggleBot Anda sendiri untuk mengikuti garis hitam. Dalam tutorial lain GiggleBot Line Follower ini, kami mengkodekan nilai penyetelan agar bekerja sesuai dengan skenario itu. Anda mungkin ingin membuatnya berperilaku lebih baik dengan menghasilkan keuntungan lain.

Dalam tutorial ini, kami menunjukkan kepada Anda 2 skrip yang keduanya dapat dimuat pada mikro BBC yang berbeda: bit sehingga salah satunya dimasukkan ke dalam GiggleBot dan yang lainnya, 2 tombol digunakan untuk menelusuri menu dan menyetel yang berbeda parameter. Pengiriman parameter yang diperbarui ini dilakukan melalui radio.

Langkah 1: Komponen yang Diperlukan

Anda akan membutuhkan yang berikut ini:

1. Robot GiggleBot untuk mikro:bit.
2. Baterai AA x3
3. x2 BBC micro:bits - satu untuk GiggleBot dan yang lainnya berfungsi sebagai remote untuk menyetel parameter.
4. Baterai untuk mikro:bit BBC - seperti yang ada dalam paket mikro:bit BBC.

Dapatkan Robot GiggleBot untuk mikro BBC: bit di sini

Langkah 2: Menyiapkan Trek & Lingkungan

Anda juga harus benar-benar membangun trek Anda (mengunduh, mencetak, memotong, dan merekam ubin) dan kemudian mengatur lingkungan (IDE dan runtime).

Karena tutorial ini sangat terkait dengan tutorial lain yang berjudul GiggleBot Line Follower, langsung saja ke sana dan ikuti langkah 2 dan 3 lalu kembali lagi ke sini.

Adapun IDE, Anda dapat menggunakan editor Mu dan untuk runtime, Anda perlu mengunduh GiggleBot MicroPython Runtime. Runtime dapat diunduh dari dokumentasinya di sini. Buka bab Memulai dokumentasi dan ikuti instruksi tersebut tentang pengaturan lingkungan. Pada saat ini, runtime versi v0.4.0 digunakan.

Langkah 3: Menyiapkan GiggleBot

Sebelum mem-flash runtime ke GiggleBot, pastikan Anda telah memilih kecepatan dan kecepatan pembaruan yang diinginkan untuk GiggleBot: secara default, kecepatan diatur ke 100 (variabel kecepatan_dasar) dan kecepatan pembaruan diatur ke 70 (variabel kecepatan_pembaruan).

Mengingat implementasi saat ini, tingkat pembaruan tertinggi yang dapat dicapai adalah 70 dan jika run_neopixels disetel ke True, maka hanya 50 yang dapat dicapai. Jadi di satu sisi, Anda dapat mengatakan bahwa kecepatan pembaruan default tepat di tepi apa yang dapat dilakukan oleh mikro: bit BBC.

Sekadar catatan, sensor pengikut garis dapat mengembalikan pembaruan 100 kali per detik.

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 Tuner (memerlukan remote untuk menyetelnya) - xjfls23

dari impor mikrobit*

dari impor cekikikan*

dari utime impor sleep_ms, ticks_us

impor radio

impor ustruk

# inisialisasi radio dan GB neopiksel

radio.on()

neo = init()

# waktu

update_rate = 70

# nilai perolehan default

Kp = 0,0

Ki = 0,0

Kd = 0,0

titik setel = 0,5

trigger_point = 0,0

min_speed_percent = 0,2

base_speed = 100

posisi_terakhir = setpoint

integral = 0,0

run_neopixels =Salah

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

total_waktu = 0,0

jumlah_total =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

display.scroll('{} - {}'.format(total_time, total_counts), delay=100, wait=False)

total_waktu = 0,0

jumlah_total =0

piksel_mati()

berhenti()

tidur_ms(500)

jika menjalankan isTrue:

# membaca sensor garis

start_time = ticks_us()

# periksa apakah kami telah memperbarui perolehan Kp/Kd dengan remote

mencoba:

Kp, Ki, Kd, trigger_point, min_speed_percent = ustruct.unpack('fffff', radio.receive_bytes())

set_mata()

exceptionTypeError:

lulus

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

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 untuk menunjukkan ke arah mana GiggleBot harus pergi

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] = (12, 44, 41)

lain:

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(12* persen), int(44* persen), int(41* persen))

lain:

# neo[center_pixel - i] = tuple(peta(lambda x: int(x * persentase), pirus))

neo[center_pixel - i] = (int(12* persen), int(44* persen), int(41* persen))

merusak

neo.show()

mencoba:

# klip 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

total_time += delay_diff

jumlah_total +=1

if1.0/ update_rate - delay_diff >0:

tidur(1.0/ update_rate - delay_diff)

lihat rawgigglebot_line_follower_tuner.py dihosting dengan ❤ oleh GitHub

Langkah 4: Menyiapkan Tuner (Jarak Jauh)

Hal berikutnya yang harus kita lakukan adalah mem-flash runtime + script ke 2nd BBC micro:bit. Mikro:bit kedua ini akan bertindak sebagai remote ke GiggleBot, yang akan digunakan untuk menyetel parameter berikut:

1. Kp = gain proporsional untuk kontroler PID.
2. Ki = penguatan integral untuk kontroler PID.
3. Kd = gain turunan untuk kontroler PID.
4. trigger_point = titik yang dinyatakan dalam persentase antara kecepatan minimum dan maksimum GiggleBot di mana kecepatan mulai berkurang secara linier hingga mencapai kecepatan minimum.
5. min_speed_percent = kecepatan minimum yang dinyatakan dalam persentase kecepatan maksimum.

2 variabel tersisa lainnya yang dapat disetel secara langsung dikodekan dalam skrip yang ada di GiggleBot: update_rate dan base_speed yang mewakili kecepatan maksimum. Seperti yang dijelaskan dalam dokumentasi, kecepatan maksimum yang dapat diatur untuk GiggleBot adalah 100, yang juga merupakan nilai default untuk GiggleBot kami.

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 Remote PID Line Follower Tuner (memerlukan bagian lain) - xjfls23

dari impor mikrobit*

dari utime impor sleep_ms

impor radio

impor ustruk

Elemen #1 adalah Kp gain

Elemen ke-2 adalah perolehan Ki

Elemen ke-3 adalah perolehan Kd

Elemen # 4 adalah trigger_point untuk motor untuk menurunkan kecepatan (0 -> 1)

Elemen # 5 adalah kecepatan minimum untuk motor yang dinyatakan dalam persentase (0 -> 1)

keuntungan = [0.0, 0.0, 0.0, 1.0, 0.0]

ukuran langkah = 0.1

# 0 dan 1 untuk elemen pertama

#2 dan 3 untuk elemen ke-2

pengaturan saat ini =0

defshowMenu():

display.scroll('{} - {}'.format(currentSetting, gain[int(currentSetting /2)]), delay=100, wait=False)

radio.on()

tampilkanMenu()

sementara Benar:

diperbarui = False

jika button_a.is_pressed():

currentSetting = (currentSetting +1) % (2*5)

diperbarui = Benar

jika button_b.is_pressed():

jika pengaturan saat ini %2==0:

# tingkatkan penguatan saat Pengaturan saat ini adalah 0 atau 2 atau..

ifint(currentSetting/2) di [0, 2]:

gain[int(currentSetting/2)] +=10* stepSize

lain:

gain[int(currentSetting/2)] += stepSize

lain:

# tingkatkan penguatan saat Pengaturan saat ini adalah 1 atau 3 atau..

ifint(currentSetting/2) di [0, 2]:

gain[int(currentSetting/2)] -=10* stepSize

lain:

gain[int(currentSetting/2)] -= ukuran langkah

radio.send_bytes(ustruct.pack('fffff', *gain))

diperbarui = Benar

jika diperbarui:

tampilkanMenu()

tidur_ms(200)

lihat rawgigglebot_line_follower_configurator.py dihosting dengan ❤ oleh GitHub

Langkah 5: Menyetel GiggleBot

Tempatkan GiggleBot di trek, nyalakan dan biarkan berjalan. Sementara itu, Anda harus terus-menerus mengembalikannya ke trek dan menyetel gain/parameter dengan mikro:bit BBC lain yang Anda pegang.

Untuk memulai GiggleBot, tekan tombol A pada mikro:bit BBC GiggleBot dan untuk menghentikannya dan dengan demikian mengatur ulang statusnya, tekan tombol B.

Pada mikro:bit BBC jarak jauh, menekan tombol A akan membawa Anda melalui setiap opsi di menunya dan tombol B menambah/mengurangi nilai yang sesuai. Ini seperti mengatur jam di dashboard mobil tua. Pilihannya seperti ini:

1. Opsi 0-1 adalah untuk keuntungan Kp.
2. 2-3 opsi adalah untuk mendapatkan Ki.
3. 4-5 opsi adalah untuk gain Kd.
4. 6-7 opsi untuk menyetel setpoint saat motor mulai melambat.
5. 8-9 opsi untuk menyetel kecepatan minimum.

Ingatlah bahwa angka genap dalam menu adalah untuk meningkatkan nilai yang sesuai dan untuk angka ganjil justru sebaliknya.

Juga, ketika menekan tombol B pada mikro:bit BBC GiggleBot, Anda akan melihat di layar buatan Neopiksel jumlah milidetik yang telah berlalu sejak reset terakhir dan jumlah siklus yang telah dilalui robot - dengan 2 ini Anda dapat menghitung kecepatan pembaruan robot.

Terakhir dan yang paling penting, saya telah menemukan 2 penyetelan untuk GiggleBot. Salah satunya adalah ketika LED Neopixel dimatikan dan yang lainnya ketika sebaliknya. LED Neopixel digunakan untuk menunjukkan ke arah mana kesalahan telah terakumulasi.

Set pertama penyetelan parameter (dengan LED NeoPixel mati)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0,3 (yaitu 30%)
5. min_speed_percent = 0,2 (yaitu 20%)
6. base_speed = 100 (alias kecepatan maksimum)
7. update_rate = 70 (berjalan @70Hz)

Set kedua penyetelan parameter (dengan LED NeoPixel menyala)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0,3 (yaitu 30%)
5. min_speed_percent = 0,3 (yaitu 30%)
6. base_speed = 70 (alias kecepatan maksimum)
7. update_rate = 50 (berjalan @50Hz)
8. Selain itu, variabel run_neopixels harus disetel ke True dalam skrip yang dimuat di mikro:bit BBC GiggleBot. Ini akan membuat LED NeoPixel berkedip sedemikian rupa sehingga menunjukkan ke arah mana kesalahan terakumulasi.

Langkah 6: GiggleBot Berjalan Dengan NeoPixels Dimatikan

Ini adalah contoh menjalankan GiggleBot dengan parameter penyetelan pertama yang ditemukan di langkah sebelumnya. Contoh ini mematikan LED NeoPixel.

Langkah 7: GiggleBot Berjalan Dengan Neopiksel Dinyalakan

Ini adalah contoh menjalankan GiggleBot dengan set parameter penyetelan ke-2 yang ditemukan di langkah 5. Contoh ini menyalakan LED NeoPixel.

Perhatikan bagaimana dalam contoh ini, GiggleBot lebih sulit mengikuti garis - itu karena LED Neopixel "memakan" waktu CPU mikro:bit BBC. Itu sebabnya kami harus mengurangi kecepatan pembaruan dari 70 menjadi 50.