Ugađanje sljedbenika linije GiggleBot - napredno: 7 koraka

2024 Autor: John Day | [email protected]. Zadnja promjena: 2024-01-30 09:35

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 biste htjeli učiniti da se bolje ponaša tako što ćete doći do drugih dobitaka.

U ovom vodiču 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 gumba koriste se 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 robota GiggleBot za BBC micro: bit

Korak 2: Postavljanje zapisa i okoliša

Također morate 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 uređivač Mu, a za vrijeme izvođenja morate preuzeti GiggleBot MicroPython Runtime. Vrijeme izvođenja može se preuzeti iz njegove dokumentacije ovdje. Idite na poglavlje dokumentacije Početak rada i slijedite te upute 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 točno na rubu onoga što BBC micro: bit može učiniti.

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

Napomena: Sljedećoj skripti možda nedostaju razmaci, a čini se da je to zbog problema u prikazivanju GitHub gista. Pritisnite suštinu da biste se prebacili na njegovu 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

uvozni ustrukt

# inicijalizirati radio i GB neopiksele

radio.on ()

neo = init ()

# vrijeme

brzina ažuriranja = 70

# zadane vrijednosti pojačanja

Kp = 0,0

Ki = 0,0

Kd = 0,0

zadana vrijednost = 0,5

okidačka_točka = 0,0

postotak min_brzine = 0,2

osnovna_brzina = 100

last_position = zadana vrijednost

integral = 0,0

run_neopixels = Netačno

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

# tirkizna = tuple (karta (lambda x: int (x / 5), (64, 224, 208))) # boja za crtanje pogreške s neopikselima

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

error_width_per_pixel = 0.5/3# max pogreš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 snaga):

globalna osnovna_brzina

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

# x0 = 0,0

# y0 = 0,0

# x1 = gornja granica - toč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))

povratna snaga 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 gumb a, počnite slijediti

ako je button_a.is_pressed ():

run = True

# ali ako je pritisnut gumb b, zaustavite sljedbenik linije

ako je 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 runTrue:

# pročitajte linijske senzore

start_time = ticks_us ()

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

probati:

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

set_eyes ()

osimTypeError:

proći

desno, lijevo = osjetnik_čitanja (LINE_SENSOR, OBA)

# redak je s lijeve strane kada je položaj <0,5

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

# linija je u sredini kada je položaj = 0,5

# to je ponderirana aritmetička sredina

probati:

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

osimZeroDivisionError:

položaj = 0,5

ako je položaj == 0: položaj = 0,001

ako je položaj == 1: položaj = 0,999

# koristite PD kontroler

pogreška = položaj - zadana vrijednost

integral += pogreška

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

prethodna_pogreška = pogreška

# izračunajte brzine motora

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

leftMotorSpeed = brzina_motora + ispravak

rightMotorSpeed = brzina_motora - ispravak

# osvijetlite neopiksele kako biste pokazali u kojem smjeru GiggleBot mora ići

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 (pogreška)> error_width_per_pixel * i:

ako je pogreška <0:

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

drugo:

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

drugo:

postotak = 1- (širina_greške_po_pikselu * i -abs (pogreška)) / greška_širine_po_pikselu

# osvjetljava trenutni piksel

ako je pogreška <0:

# neo [center_pixel + i] = tuple (karta (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 (karta (lambda x: int (x * postotak), tirkizna))

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

pauza

neo.show ()

probati:

# isjecite 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)

voziti()

# ispis ((pogreška, brzina_motora))

osim:

# u slučaju da dođemo u neki problem koji se ne može riješiti

proći

# i održavati frekvenciju petlje

end_time = ticks_us ()

delay_diff = (end_time - start_time) /1000

ukupno_ vrijeme += 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 GitHubu

Korak 4: Postavljanje tunera (daljinski)

Sljedeće što 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 postocima od maksimalne brzine.

Ostale 2 preostale varijable koje se mogu podesiti izravno su kodirane u skripti koja se nalazi na GiggleBotu: update_rate i base_speed koja predstavlja najveću brzinu. Kao što je opisano u dokumentaciji, najveća brzina koja se može postaviti za GiggleBot je 100, što je također zadana vrijednost za naš GiggleBot.

Napomena: Sljedećoj skripti možda nedostaju razmaci, a čini se da je to zbog problema u prikazivanju GitHub gista. Pritisnite suštinu da biste se prebacili na njegovu 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

uvozni ustrukt

# Prvi element je dobitak Kp

# 2. element je Ki dobitak

# 3. element je Kd dobitak

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

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

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

stepSize = 0,1

# 0 i 1 za 1. 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 = Istina

ako je button_b.is_pressed ():

ako je trenutna postavka %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 = Istina

ako se ažurira:

showMenu ()

spavanje_ms (200)

pogledaj rawgigglebot_line_follower_configurator.py hostirano sa ❤ na GitHubu

Korak 5: Ugađanje GiggleBot -a

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

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

Na daljinskom BBC micro: bitu, pritiskom na tipku A proći ćete kroz svaku opciju u svom izborniku, a tipka B povećava/smanjuje odgovarajuću vrijednost. To je kao postavljanje sata na nadzornu ploču starog automobila. Opcije su ovakve:

1. Opcije 0-1 služe za dobitak Kp.
2. 2-3 mogućnosti su za Ki dobitak.
3. 4-5 opcija je za Kd dobitak.
4. 6-7 opcija služi za postavljanje zadane vrijednosti u trenutku kada motori počnu usporavati.
5. 8-9 opcija služi 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, kada pritisnete gumb B na BBC micro: bit GiggleBot -a, vidjet ćete na ekranu napravljenom od Neopixela broj proteklih milisekundi od zadnjeg resetiranja i broj ciklusa koje je robot prošao - s 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čivanje Neopixel LED dioda, a drugi za slučaj kada je drugačije. Neopixel LED diode služe za pokazivanje u kojem smjeru se greška nakupila.

1. skup podešavanja parametara (s 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_brzina_procent = 0,2 (što je 20%)
6. osnovna_brzina = 100 (poznata i kao najveća brzina)
7. update_rate = 70 (radi na 70Hz)

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

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0,3 (što je 30%)
5. min_brzina_procent = 0,3 (što je 30%)
6. osnovna_brzina = 70 (poznata i kao najveća brzina)
7. update_rate = 50 (radi na 50Hz)
8. Također, varijabla run_neopixels mora biti postavljena na True u skripti koja se učitava na GiggleBot -ov BBC micro: bit. Time ć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 s prvim parametrima ugađanja koji su pronađeni u prethodnom koraku. U ovom primjeru LED diode NeoPixel isključene.

Korak 7: GiggleBot radi s uključenim neopikselima

Ovo je primjer izvođenja GiggleBot -a s drugim skupom parametara za ugađanje koji se nalazi u koraku 5. Ovaj primjer ima uključene LED diode NeoPixel.

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.