Menala Pengikut Garis GiggleBot - Lanjutan: 7 Langkah

2024 Pengarang: John Day | [email protected]. Diubah suai terakhir: 2024-01-30 11:09

Dalam Instructables yang sangat pendek ini, anda akan menyesuaikan GiggleBot anda sendiri untuk mengikuti garis hitam. Dalam tutorial lain GiggleBot Line Follower ini, kami mengekodkan nilai-nilai penalaan untuk berfungsi sesuai dengan senario itu. Anda mungkin mahu menjadikannya berperilaku lebih baik dengan memperoleh keuntungan lain.

Dalam tutorial ini, kami menunjukkan kepada anda 2 skrip yang keduanya dapat dimuat pada mikro BBC yang berlainan: satu daripadanya dimasukkan ke dalam GiggleBot dan dengan yang lain, 2 butang digunakan untuk menelusuri menu dan menyesuaikan lagu yang berbeza parameter. Penghantaran parameter yang dikemas kini ini dilakukan melalui radio.

Langkah 1: Komponen yang Diperlukan

Anda memerlukan perkara berikut:

1. Robot GiggleBot untuk mikro: bit.
2. x3 Bateri AA
3. x2 Mikro BBC: bit - satu untuk GiggleBot dan satu lagi berfungsi sebagai alat kawalan jauh untuk parameter penalaan.
4. Bateri untuk mikro BBC: bit - seperti yang terdapat dalam pakej mikro: bit BBC.

Dapatkan Robot GiggleBot untuk mikro BBC: bit di sini

Langkah 2: Menyiapkan Lintasan & Persekitaran

Anda juga harus benar-benar membina trek anda (muat turun, cetak, potong dan jubin pita) dan kemudian siapkan persekitarannya (IDE dan masa berjalan).

Oleh kerana tutorial ini sangat berkaitan dengan tutorial lain yang berjudul GiggleBot Line Follower, pergi ke sana dan ikuti langkah 2 dan 3 dan kemudian kembali ke sini.

Bagi IDE, anda boleh menggunakan editor Mu dan untuk jangka masa, anda perlu memuat turun GiggleBot MicroPython Runtime. Masa berjalan boleh dimuat turun dari dokumentasinya di sini. Pergi ke bab Memulakan dokumentasi dan ikuti arahan tersebut untuk mengatur persekitaran. Pada masa ini, versi v0.4.0 runtime digunakan.

Langkah 3: Menyiapkan GiggleBot

Sebelum memancarkan masa berjalan ke GiggleBot, pastikan anda telah memilih kadar kelajuan dan kemas kini yang anda inginkan untuk GiggleBot: secara lalai, kelajuan ditetapkan ke 100 (pemboleh ubah dasar_kelajuan) dan kadar kemas kini ditetapkan ke 70 (pemboleh ubah kadar_kemas kini).

Memandangkan pelaksanaannya sekarang, kadar kemas kini tertinggi yang dapat dicapai adalah 70 dan jika run_neopixels ditetapkan ke True, maka hanya 50 yang dapat dicapai. Oleh itu, anda boleh mengatakan bahawa kadar kemas kini lalai tepat di pinggir apa yang boleh dilakukan oleh mikro BBC: bit.

Hanya untuk rekod, sensor pengikut baris dapat mengembalikan kemas kini 100 kali sesaat.

Catatan: Skrip berikut mungkin tidak mempunyai ruang kosong dan ini mungkin disebabkan oleh beberapa masalah dalam menampilkan GitHub Gists. Klik pada inti untuk membawa anda ke halaman GitHubnya di mana anda boleh menyalin-menampal kodnya.

GiggleBot PID Line Follower Tuner (memerlukan alat kawalan jauh untuk menyesuaikannya) - xjfls23

dari import mikrob *

dari import gigglebot *

dari utime import sleep_ms, ticks_us

mengimport radio

import ustruct

# memulakan radio dan GB neopixel

radio.on ()

neo = init ()

# masa

kemas kini_kadar = 70

# nilai keuntungan lalai

Kp = 0.0

Ki = 0.0

Kd = 0.0

setpoint = 0.5

trigger_point = 0.0

min_speed_percent = 0.2

asas_kecepatan = 100

last_position = setpoint

kamiran = 0.0

run_neopixels = Salah

center_pixel = 5 # di mana piksel tengah senyuman terletak pada GB

# turquoise = tuple (peta (lambda x: int (x / 5), (64, 224, 208))) # warna untuk digunakan untuk menarik ralat dengan neopixel

# turquoise = (12, 44, 41) # yang betul-betul turquoise di atas memberikan komen di atas ini

error_width_per_pixel = 0.5 / 3 # ralat maksimum dibahagi dengan bilangan segmen antara setiap neopixel

defupper_bound_linear_speed_reducer (abs_error, trigger_point, upper_bound, terkecil_motor_power, tertinggi_motor_power):

asas_kelajuan global

jika abs_error> = trigger_point:

# x0 = 0.0

# y0 = 0.0

# x1 = atas_batas - titik pemicu

# y1 = 1.0

# x = abs_error - trigger_point

# y = y0 + (x - x0) * (y1 - y0) / (x1 - x0)

# sama seperti

y = (abs_error - trigger_point) / (upper_bound - trigger_point)

motor_power = base_speed * (terkecil_motor_power + (1- y) * (tertinggi_motor_power - terkecil_motor_power))

mengembalikan motor_power

lain:

return base_speed * tertinggi_motor_power

lari = Salah

sebelumnya_kesalahan = 0

total_time = 0.0

jumlah_kira = 0

sementara benar:

# jika butang a ditekan maka mulailah mengikuti

jika button_a.is_pressed ():

lari = Betul

# tetapi jika butang b ditekan hentikan pengikut garis

jika button_b.is_pressed ():

lari = Salah

kamiran = 0.0

error_ sebelumnya = 0.0

display.scroll ('{} - {}'. format (total_time, total_counts), kelewatan = 100, tunggu = Salah)

total_time = 0.0

jumlah_kira = 0

piksel_off ()

berhenti ()

tidur_ms (500)

jika dijalankan isTrue:

# baca sensor baris

start_time = ticks_us ()

# periksa sama ada kita telah mengemas kini keuntungan Kp / Kd dengan alat kawalan jauh

cuba:

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

set_eyes ()

kecuali TypeError:

lulus

kanan, kiri = read_sensor (LINE_SENSOR, KEDUA)

# garisan berada di sebelah kiri ketika kedudukan <0.5

# garis berada di sebelah kanan ketika kedudukan> 0.5

# garisan berada di tengah ketika kedudukan = 0.5

# itu adalah aritmetik berwajaran

cuba:

kedudukan = kanan / terapung (kiri + kanan)

kecuali ZeroDivisionError:

kedudukan = 0.5

jika kedudukan == 0: kedudukan = 0.001

jika kedudukan == 1: kedudukan = 0.999

# gunakan alat kawalan PD

ralat = kedudukan - setpoint

kamiran + = ralat

pembetulan = Kp * ralat + Ki * integral + Kd * (ralat - ralat sebelumnya)

kesalahan_ sebelumnya = ralat

# hitung kelajuan motor

motor_speed = upper_bound_linear_speed_reducer (abs (ralat), setpoint * trigger_point, setpoint, min_speed_percent, 1.0)

leftMotorSpeed = kelajuan motor + pembetulan

rightMotorSpeed = motor_speed - pembetulan

# nyalakan neopixel untuk menunjukkan ke arah mana GiggleBot harus pergi

jika run_neopixels isTrueand total_counts% 3 == 0:

untuk i in '\ x00 / x01 / x02 / x03 / x04 / x05 / x06 / x07 / x08':

neo = (0, 0, 0)

untuk i inb '\ x00 / x01 / x02 / x03':

ifabs (error)> error_width_per_pixel * i:

jika ralat <0:

neo [center_pixel + i] = (12, 44, 41)

lain:

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

lain:

peratus = 1- (error_width_per_pixel * i -abs (ralat)) / error_width_per_pixel

# nyalakan piksel semasa

jika ralat <0:

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

neo [center_pixel + i] = (int (12 * peratus), int (44 * peratus), int (41 * peratus))

lain:

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

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

rehat

neo.show ()

cuba:

# klip motor

jika dibiarkanMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

jika betulMotorSpeed> 100:

betulMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - kananMotorSpeed +100

jika dibiarkanMotorSpeed <-100:

leftMotorSpeed = -100

jika betulMotorSpeed <-100:

betulMotorSpeed = -100

# aktifkan motor

set_speed (leftMotorSpeed, rightMotorSpeed)

memandu ()

# cetak ((ralat, kelajuan motor))

kecuali:

# sekiranya kita menghadapi masalah yang tidak dapat diperbaiki

lulus

# dan mengekalkan frekuensi gelung

end_time = ticks_us ()

delay_diff = (end_time - start_time) / 1000

total_time + = delay_diff

jumlah_kira + = 1

if1.0 / update_rate - delay_diff> 0:

tidur (kadar 1.0 / kemas kini - kelewatan_diff)

lihat rawgigglebot_line_follower_tuner.py dihoskan dengan ❤ oleh GitHub

Langkah 4: Menyiapkan Penala (Jauh)

Perkara seterusnya yang harus kita lakukan ialah memancarkan skrip runtime + ke mikro BBC ke-2. Mikro kedua: bit ini akan berfungsi sebagai alat kawalan jauh ke GiggleBot, yang akan digunakan untuk menyesuaikan parameter berikut:

1. Kp = keuntungan berkadar untuk pengawal PID.
2. Ki = keuntungan integral untuk pengawal PID.
3. Kd = keuntungan terbitan untuk pengawal PID.
4. trigger_point = titik dinyatakan dalam peratusan antara kelajuan minimum dan maksimum GiggleBot di mana kelajuan mulai berkurang secara linear sehingga mencapai kelajuan minimum.
5. min_speed_percent = kelajuan minimum dinyatakan dalam peratusan kelajuan maksimum.

2 pemboleh ubah lain yang dapat diselaraskan secara langsung dikodkan keras dalam skrip yang berada di GiggleBot: kadar_kemas kini dan kecepatan_ yang mewakili kelajuan maksimum. Seperti yang dijelaskan dalam dokumentasi, kecepatan maksimum yang dapat ditetapkan untuk GiggleBot adalah 100, yang juga merupakan nilai lalai untuk GiggleBot kami.

Catatan: Skrip berikut mungkin tidak mempunyai ruang kosong dan ini mungkin disebabkan oleh beberapa masalah dalam menampilkan GitHub Gists. Klik pada inti untuk membawa anda ke halaman GitHubnya di mana anda boleh menyalin-menampal kodnya.

GiggleBot Remote PID Line Follower Tuner (memerlukan bahagian lain) - xjfls23

dari import mikrob *

dari utime import sleep_ms

mengimport radio

import ustruct

Unsur # 1 adalah keuntungan Kp

# Unsur ke-2 adalah keuntungan Ki

# Unsur ke-3 ialah keuntungan Kd

Elemen ke-4 adalah titik pemicu bagi motor menurunkan kelajuan (0 -> 1)

Unsur ke-5 adalah kelajuan min untuk motor seperti dinyatakan dalam peratusan (0 -> 1)

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

stepSize = 0.1

# 0 dan 1 untuk elemen 1

# 2 dan 3 untuk elemen ke-2

currentSetting = 0

defshowMenu ():

display.scroll ('{} - {}'. format (currentSetting, keuntungan [int (currentSetting / 2)]), kelewatan = 100, tunggu = Salah)

radio.on ()

persembahanMenu ()

sementara benar:

dikemas kini = Salah

jika button_a.is_pressed ():

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

dikemas kini = Benar

jika button_b.is_pressed ():

jika semasaSetting% 2 == 0:

# tingkatkan kenaikan semasa CurrentSetting adalah 0 atau 2 atau..

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

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

lain:

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

lain:

# tingkatkan kenaikan semasa CurrentSetting adalah 1 atau 3 atau..

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

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

lain:

keuntungan [int (currentSetting / 2)] - = stepSize

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

dikemas kini = Benar

jika dikemas kini:

persembahanMenu ()

tidur_ms (200)

lihat rawgigglebot_line_follower_configurator.py dihoskan dengan ❤ oleh GitHub

Langkah 5: Menala GiggleBot

Letakkan GiggleBot di trek, hidupkan dan biarkan ia berjalan. Sementara itu, anda mesti terus meletakkannya kembali di trek dan menyesuaikan keuntungan / parameter dengan mikro BBC lain: sedikit yang anda pegang di tangan anda.

Untuk memulakan GiggleBot, tekan butang A pada mikro BBC GiggleBot: bit dan untuk menghentikannya dan dengan itu tetapkan semula keadaannya tekan butang B.

Pada mikro BBC jarak jauh: bit, menekan butang A akan membawa anda melalui setiap pilihan dalam menu dan butang B menambah / menurunkan nilai yang sesuai. Ia seperti meletakkan jam di papan pemuka kereta lama. Pilihannya seperti ini:

1. Pilihan 0-1 adalah untuk keuntungan Kp.
2. 2-3 pilihan adalah untuk keuntungan Ki.
3. 4-5 pilihan adalah untuk keuntungan Kd.
4. 6-7 pilihan adalah untuk menetapkan titik tolak untuk saat motor mula perlahan.
5. 8-9 pilihan adalah untuk menetapkan kelajuan minimum.

Perlu diingat bahawa nombor genap dalam menu adalah untuk meningkatkan nilai yang sepadan dan untuk yang ganjil adalah sebaliknya.

Juga, semasa menekan butang B pada mikro BBC GiggleBot: bit, anda akan melihat pada skrin buatan Neopixel jumlah milisaat yang telah berlalu sejak tetapan semula terakhir dan jumlah kitaran yang telah dilalui oleh robot - dengan 2 ini, anda dapat mengira kadar kemas kini robot.

Terakhir dan yang paling penting, saya telah membuat 2 penalaan untuk GiggleBot. Salah satunya adalah ketika LED Neopixel dimatikan dan yang lain adalah ketika LED sebaliknya. LED Neopixel digunakan untuk menunjukkan ke arah mana kesalahan telah terkumpul.

Set pertama parameter penalaan (dengan LED NeoPixel mati)

1. Kp = 32.0
2. Ki = 0.5
3. Kd = 80.0
4. trigger_setpoint = 0.3 (iaitu 30%)
5. min_speed_percent = 0.2 (iaitu 20%)
6. base_speed = 100 (alias kelajuan maksimum)
7. update_rate = 70 (berjalan @ 70Hz)

Set kedua parameter penalaan (dengan LED NeoPixel menyala)

1. Kp = 25.0
2. Ki = 0.5
3. Kd = 35.0
4. trigger_setpoint = 0.3 (iaitu 30%)
5. min_speed_percent = 0.3 (iaitu 30%)
6. base_speed = 70 (aka kelajuan maksimum)
7. update_rate = 50 (berjalan @ 50Hz)
8. Juga, variabel run_neopixels harus ditetapkan ke True dalam skrip yang dimuat pada mikro: bit GiggleBot BBC. Ini akan menjadikan LED NeoPixel berkelip sedemikian rupa sehingga menunjukkan arah ke mana kesalahan terkumpul.

Langkah 6: GiggleBot Berjalan Dengan Matikan NeoPixels

Ini adalah contoh menjalankan GiggleBot dengan parameter penalaan pertama yang terdapat pada langkah sebelumnya. Contoh ini telah mematikan LED NeoPixel.

Langkah 7: GiggleBot Berjalan Dengan Neopixels Dihidupkan

Ini adalah contoh menjalankan GiggleBot dengan set parameter penalaan ke-2 yang terdapat pada langkah 5. Contoh ini telah menghidupkan LED NeoPixel.

Perhatikan bagaimana dalam contoh ini, GiggleBot mempunyai masa yang lebih sukar mengikuti garis - itu kerana LED Neopixel "memakan" masa CPU mikro BBC: bit. Itulah sebabnya kami terpaksa mengurangkan kadar kemas kini dari 70 ke 50.