Ugađanje GiggleBot sljedbenika linije - napredno: 7 koraka

2024 Autor: John Day | [email protected]. Zadnja izmjena: 2024-01-30 08:07

U ovom vrlo kratkom Instructablesu namjestit ćete svoj GiggleBot da slijedi crnu liniju. U ovom drugom vodiču GiggleBot Line Follower, mi smo teško kodirali vrijednosti ugađanja za rad prema tom scenariju. Možda ćete htjeti poboljšati ponašanje tako što ćete doći do drugih dobitaka.

U ovom tutorijalu pokazujemo vam 2 skripte koje se mogu učitati na različite BBC micro: bitove tako da se jedna od njih stavi u GiggleBot, a s drugom, 2 tipke se koriste za prolazak kroz izbornik i podešavanje različitih parametri. Slanje ovih ažuriranih parametara vrši se putem radija.

Korak 1: Potrebne komponente

Trebat će vam sljedeće:

1. GiggleBot robot za micro: bit.
2. x3 AA baterije
3. x2 BBC micro: bitovi - jedan za GiggleBot, a drugi za daljinsko podešavanje parametara.
4. Baterija za BBC micro: bit - poput one koja se nalazi u BBC micro: bit paketu.

Ovdje nabavite GiggleBot robota za BBC micro: bit

Korak 2: Postavljanje zapisa i okruženja

Morate i sami izgraditi svoje zapise (preuzeti, ispisati, izrezati i zalijepiti pločice), a zatim postaviti okruženje (IDE i vrijeme izvođenja).

Budući da je ovaj vodič vrlo povezan s drugim vodičem pod nazivom GiggleBot Line Follower, samo idite tamo i slijedite korake 2 i 3, a zatim se vratite ovdje.

Što se tiče IDE -a, možete koristiti Mu uređivač, a za vrijeme izvođenja morate preuzeti GiggleBot MicroPython Runtime. Runtime se može preuzeti iz njegove dokumentacije ovdje. Idite na poglavlje Dokumentacija za početak rada i slijedite ta uputstva o postavljanju okruženja. Od ovog trenutka koristi se verzija v0.4.0 vremena izvođenja.

Korak 3: Postavljanje GiggleBot -a

Prije prebacivanja vremena izvođenja na GiggleBot, provjerite jeste li odabrali željenu brzinu i brzinu ažuriranja za GiggleBot: prema zadanim postavkama brzina je postavljena na 100 (varijabla base_speed), a brzina ažuriranja na 70 (varijabla update_rate).

S obzirom na trenutnu implementaciju, najveća brzina ažuriranja koja se može postići je 70, a ako je run_neopixels postavljeno na True, tada je moguće postići samo 50. Tako biste na neki način mogli reći da je zadana brzina ažuriranja upravo na rubu onoga što BBC micro: bit može učiniti.

Samo za zapis, senzor pratioca linije može vratiti ažuriranja 100 puta u sekundi.

Napomena: Sljedećoj skripti možda nedostaju razmaci, a čini se da je to zbog nekog problema u prikazivanju GitHub gista. Kliknite na suštinu da biste se prebacili na njenu stranicu GitHub gdje možete kopirati i zalijepiti kôd.

GiggleBot PID Line Follower Tuner (potreban je daljinski upravljač za podešavanje) - xjfls23

iz microbit uvoza*

iz gigglebot uvoza*

from utime import sleep_ms, ticks_us

uvoz radio

import ustruct

# inicijalizira radio i GB neopiksele

radio.on ()

neo = init ()

# tajming

update_rate = 70

# zadane vrijednosti pojačanja

Kp = 0,0

Ki = 0,0

Kd = 0,0

zadana vrijednost = 0,5

trigger_point = 0.0

min_speed_percent = 0.2

osnovna_brzina = 100

last_position = zadata vrijednost

integral = 0,0

run_neopixels = Netačno

center_pixel = 5# gdje se središnji piksel osmijeha nalazi na GB

# tirkizna = tuple (mapa (lambda x: int (x / 5), (64, 224, 208))) # boja koju ćete koristiti za iscrtavanje greške s neopikselima

# tirkizna = (12, 44, 41) # što je upravo gornja tirkizna komentirana iznad ovoga

error_width_per_pixel = 0.5/3# max greška podijeljena s brojem segmenata između svakog neopiksela

defupper_bound_linear_speed_reducer (aps_pogreška, okidač_točka, gornja granica, najmanja_motorna_ snaga, najveća_motorna_moć):

globalna osnovna_brzina

ako je aps_pogreška> = okidač_točka:

# x0 = 0,0

# y0 = 0,0

# x1 = gornja granica - tačka okidača

# y1 = 1.0

# x = aps_pogreška - okidač_točka

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

# isto kao

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

snaga motora = osnovna brzina * (najmanja snaga motora + (1- godina) * (najveća snaga motora - najmanja snaga motora))

povratak snage motora

drugo:

povratna osnovna brzina * najveća_motorna snaga

run = False

prethodna_pogreška = 0

ukupno_vreme = 0,0

ukupni_brojevi = 0

whileTrue:

# ako pritisnete dugme a, počnite da pratite

ako je button_a.is_pressed ():

run = True

# ali ako je pritisnuto dugme b, zaustavite pratioce linija

if button_b.is_pressed ():

run = False

integral = 0,0

prethodna_pogreška = 0.0

display.scroll ('{} - {}'. format (ukupno_vreme, ukupni_brojevi), kašnjenje = 100, čekanje = Netačno)

ukupno_vreme = 0,0

ukupni_brojevi = 0

pixels_off ()

stop ()

sleep_ms (500)

ako je run isTrue:

# pročitajte linijske senzore

start_time = ticks_us ()

# provjerite da li smo Kp/Kd dobitke ažurirali daljinskim upravljačem

probaj:

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

set_eyes ()

osimTypeError:

pass

desno, lijevo = senzor za čitanje (LINE_SENSOR, OBA)

# linija je s lijeve strane kada je pozicija <0,5

# linija je s desne strane kada je položaj> 0,5

# linija je u sredini kada je pozicija = 0,5

# to je ponderisana aritmetička sredina

probaj:

položaj = desno /lebdi (lijevo + desno)

osimZeroDivisionError:

položaj = 0,5

ako je pozicija == 0: pozicija = 0,001

ako je pozicija == 1: pozicija = 0.999

# koristite PD kontroler

greška = položaj - zadata vrijednost

integral += greška

ispravak = Kp * greška + Ki * integral + Kd * (greška - prethodna_pogreška)

prethodna_pogreška = greška

# izračunajte brzine motora

motor_brzina = gornja_graničena_linearna_brzina_reducer (abs (greška), zadana vrijednost * okidač_točka, zadana vrijednost, min_brzina_procent, 1,0)

leftMotorSpeed = brzina_motora + korekcija

rightMotorSpeed = brzina_motora - ispravka

# upalite neopiksele da pokažete u kom smeru GiggleBot mora da ide

ako je run_neopixels isTrueand total_counts %3 == 0:

za i inb '\ x00 / x01 / x02 / x03 / x04 / x05 / x06 / x07 / x08':

neo = (0, 0, 0)

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

ifabs (greška)> error_width_per_pixel * i:

ako je greška <0:

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

drugo:

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

drugo:

postotak = 1- (greška_širina_po_pikselu * i -abs (greška)) / greška_širine_po_pikselu

# osvetljava trenutni piksel

ako je greška <0:

# neo [center_pixel + i] = tuple (mapa (lambda x: int (x * postotak), tirkizna))

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

drugo:

# neo [center_pixel - i] = tuple (mapa (lambda x: int (x * postotak), tirkizna))

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

break

neo.show ()

probaj:

# isecite motore

ako je ostavljenoMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

ako je rightMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

ako je ostavljenoMotorSpeed <-100:

leftMotorSpeed = -100

ako je rightMotorSpeed <-100:

rightMotorSpeed = -100

# aktivirajte motore

set_speed (leftMotorSpeed, rightMotorSpeed)

drive ()

# print ((greška, brzina_motora))

osim:

# u slučaju da upadnemo u neki problem koji nije moguće riješiti

pass

# i održavati frekvenciju petlje

end_time = ticks_us ()

delay_diff = (end_time - start_time) /1000

ukupno_vreme += kašnjenje_razlika

ukupni_brojevi += 1

if1.0/ update_rate - delay_diff> 0:

spavanje (1.0/ update_rate - delay_diff)

pogledajte rawgigglebot_line_follower_tuner.py hostirano sa ❤ na GitHub -u

Korak 4: Postavljanje tunera (daljinskog upravljača)

Sljedeća stvar koju moramo učiniti je prenijeti runtime + skriptu na 2. BBC micro: bit. Ovaj drugi micro: bit će djelovati kao daljinski upravljač za GiggleBot, koji će se koristiti za podešavanje sljedećih parametara:

1. Kp = proporcionalni dobitak za PID regulator.
2. Ki = integralni dobitak za PID regulator.
3. Kd = derivacijski dobitak za PID regulator.
4. trigger_point = točka izražena u postocima između minimalne i maksimalne brzine GiggleBota gdje se brzina počinje linearno smanjivati sve dok ne dosegne minimalnu brzinu.
5. min_speed_percent = minimalna brzina izražena u procentima od maksimalne brzine.

Ostale 2 preostale varijable koje se mogu podesiti izravno su kodirane u skripti koja se nalazi na GiggleBot -u: update_rate i base_speed koja predstavlja maksimalnu brzinu. Kao što je opisano u dokumentaciji, maksimalna brzina koja se može postaviti za GiggleBot je 100, što je ujedno i zadana vrijednost za naš GiggleBot.

Napomena: Sljedećoj skripti možda nedostaju razmaci, a čini se da je to zbog nekog problema u prikazivanju GitHub gista. Kliknite na suštinu da biste se prebacili na njenu stranicu GitHub gdje možete kopirati i zalijepiti kôd.

GiggleBot Remote PID Line Follower Tuner (potreban je drugi dio) - xjfls23

iz microbit uvoza*

from utime import sleep_ms

uvoz radio

import ustruct

# Prvi element je Kp dobitak

# 2. element je Ki dobitak

# 3. element je Kd pojačanje

# 4. element je točka okidača za motore za smanjenje brzine (0 -> 1)

# 5. element je minimalna brzina za motore izražena u postocima (0 -> 1)

dobici = [0,0, 0,0, 0,0, 1,0, 0,0]

stepSize = 0,1

# 0 i 1 za prvi element

# 2 i 3 za 2. element

currentSetting = 0

defshowMenu ():

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

radio.on ()

showMenu ()

whileTrue:

ažurirano = Netačno

ako je button_a.is_pressed ():

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

ažurirano = Tačno

if button_b.is_pressed ():

if currentSetting %2 == 0:

# povećati dobitak kada je CurrentSetting 0 ili 2 ili..

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

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

drugo:

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

drugo:

# povećati dobitak kada je CurrentSetting 1 ili 3 ili..

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

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

drugo:

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

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

ažurirano = Tačno

ako se ažurira:

showMenu ()

sleep_ms (200)

pogledajte rawgigglebot_line_follower_configurator.py hostirano sa ❤ od GitHub -a

Korak 5: Podešavanje GiggleBot -a

Postavite GiggleBot na stazu, uključite ga i pustite da radi. U međuvremenu ćete ga stalno morati vraćati na pravi put i usklađivati dobitke/parametre s drugim BBC micro: bitom koji držite u ruci.

Da biste pokrenuli GiggleBot, pritisnite dugme A na BBC mikro: bitu GiggleBot -a i da biste ga zaustavili i tako resetovali njegovo stanje, pritisnite dugme B.

Na udaljenom BBC micro: bit -u pritiskom na dugme A proći ćete kroz svaku opciju u svom meniju, a dugme B povećava/smanjuje odgovarajuću vrijednost. To je kao postavljanje sata na nadzornu ploču starog automobila. Opcije su ovakve:

1. 0-1 opcije su za Kp dobitak.
2. 2-3 opcije su za Ki dobitak.
3. 4-5 opcija je za Kd pojačanje.
4. 6-7 opcija služi za postavljanje zadane vrijednosti u trenutku kada motori počnu usporavati.
5. 8-9 opcija je za postavljanje minimalne brzine.

Imajte na umu da su parni brojevi u izborniku za povećanje odgovarajućih vrijednosti, a za neparne je upravo suprotno.

Također, pritiskom na tipku B na BBC micro: bitu GiggleBot -a, na ekranu napravljenom od Neopixela vidjet ćete broj proteklih milisekundi od zadnjeg resetiranja i broj ciklusa koje je robot prošao - sa ova 2 možete izračunati brzina ažuriranja robota.

Na kraju i najvažnije, smislio sam 2 podešavanja za GiggleBot. Jedan od njih služi za isključenje Neopixel LED dioda, a drugi za slučaj kada je drugačije. Neopixel LED diode se koriste za pokazivanje u kojem smjeru se greška nakupila.

1. skup podešavanja parametara (sa isključenim NeoPixel LED diodama)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0,3 (što je 30%)
5. min_speed_percent = 0,2 (što je 20%)
6. osnovna_brzina = 100 (poznata i kao maksimalna brzina)
7. update_rate = 70 (radi na 70Hz)

2. skup podešavanja parametara (sa uključenim NeoPixel LED diodama)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0,3 (što je 30%)
5. min_speed_percent = 0,3 (što je 30%)
6. osnovna brzina = 70 (poznata i kao maksimalna brzina)
7. update_rate = 50 (radi na 50Hz)
8. Takođe, varijabla run_neopixels mora biti postavljena na True u skripti koja se učitava na GiggleBot -ov BBC micro: bit. Zbog toga će NeoPixel LED diode zasvijetliti na takav način da pokazuju u kojem smjeru se greška akumulira.

Korak 6: GiggleBot radi s isključenim NeoPixels -om

Ovo je primjer izvođenja GiggleBot -a sa prvim parametrima ugađanja koji su pronađeni u prethodnom koraku. U ovom primjeru NeoPixel LED diode su isključene.

Korak 7: GiggleBot radi s uključenim neopikselima

Ovo je primjer pokretanja GiggleBot -a sa 2. skupom parametara za podešavanje koji se nalazi u koraku 5. Ovaj primjer ima uključene NeoPixel LED diode.

Primijetite kako u ovom primjeru GiggleBot teže prati liniju - to je zato što LED diode Neopixel "jedu" vrijeme procesora BBC micro: bita. Zato smo morali smanjiti stopu ažuriranja sa 70 na 50.