Uglaševanje sledilnika linij GiggleBot - napredno: 7 korakov

2024 Avtor: John Day | [email protected]. Nazadnje spremenjeno: 2024-01-30 12:05

V tem zelo kratkem Instructables boste svoj GiggleBot prilagodili črni črti. V tej drugi vadnici GiggleBot Line Follower smo trdo kodirali vrednosti uglaševanja, da delujejo po tem scenariju. Morda boste želeli izboljšati obnašanje, če boste prišli do drugih koristi.

V tej vadnici vam prikazujemo 2 skripta, ki ju je mogoče naložiti na različne BBC micro: bite, tako da je eden od njiju vstavljen v GiggleBot, z drugim pa se dva gumba uporabljata za pomik po meniju in nastavitev različnih parametri. Pošiljanje teh posodobljenih parametrov poteka po radiu.

Korak: Potrebne komponente

Potrebovali boste naslednje:

1. Robot GiggleBot za micro: bit.
2. x3 AA baterije
3. x2 BBC micro: bitov - eden za GiggleBot in drugi za daljinsko upravljanje parametrov.
4. Baterija za BBC micro: bit - podobno tisti, ki je v paketu BBC micro: bit.

Tukaj dobite robota GiggleBot za BBC micro: bit

2. korak: Nastavitev skladb in okolja

Prav tako morate zgraditi svoje skladbe (prenesti, natisniti, izrezati in nalepiti ploščice) in nato nastaviti okolje (IDE in čas izvajanja).

Ker je ta vadnica zelo povezana s to drugo vadnico z naslovom GiggleBot Line Follower, pojdite tja in sledite korakom 2 in 3 in se nato vrnite sem.

Kar zadeva IDE, lahko uporabite urejevalnik Mu, za čas izvajanja pa morate prenesti GiggleBot MicroPython Runtime. Čas izvajanja lahko prenesete iz njegove dokumentacije tukaj. Pojdite na poglavje Dokumentacija za začetek in sledite tem navodilom za nastavitev okolja. Od tega trenutka se uporablja različica v0.4.0 izvajalnega okolja.

3. korak: Nastavitev GiggleBot -a

Preden utripate čas delovanja v GiggleBot, se prepričajte, da ste izbrali želeno hitrost in hitrost posodobitve za GiggleBot: privzeto je hitrost nastavljena na 100 (spremenljivka base_speed), hitrost posodobitve pa na 70 (spremenljivka update_rate).

Glede na trenutno izvedbo je najvišja stopnja posodobitve, ki jo je mogoče doseči, 70 in če je run_neopixels nastavljeno na True, je mogoče doseči le 50. Tako bi lahko na nek način rekli, da je privzeta hitrost posodabljanja ravno na robu tega, kar lahko naredi BBC micro: bit.

Samo za zapis, senzor sledilca vrstice lahko vrne posodobitve 100 -krat na sekundo.

Opomba: V tem skriptu morda manjkajo presledki, kar je verjetno posledica neke težave pri prikazovanju GitHub Gists. Kliknite na bistvo, da se pomaknete na njegovo stran GitHub, kjer lahko kopirate in prilepite kodo.

GiggleBot PID Line Follower Tuner (za nastavitev potrebuje daljinski upravljalnik) - xjfls23

iz uvoza microbit*

od gigglebot import*

iz utime uvoz sleep_ms, ticks_us

uvoz radia

uvozni ustruct

# inicializirajte radio in GB neopikslov

radio.on ()

neo = init ()

# časovni razpored

update_rate = 70

# privzetih vrednosti dobička

Kp = 0,0

Ki = 0,0

Kd = 0,0

nastavljena vrednost = 0,5

sprožilna točka = 0,0

min_hitrost_odstotka = 0,2

osnovna_hitrost = 100

last_position = nastavljena vrednost

integral = 0,0

run_neopixels = False

center_pixel = 5#, kjer je osrednja slikovna pika nasmeha na GB

# turquoise = tuple (zemljevid (lambda x: int (x / 5), (64, 224, 208))) # barvo za risanje napake z neopiksli

# turquoise = (12, 44, 41) # kar je ravno zgornja turkizna komentirana nad tem

error_width_per_pixel = 0,5/3# največja napaka, deljena s številom segmentov med vsakim neopikselom

defupper_bound_linear_speed_reducer (abs_error, trigger_point, upper_bound, najmanjša_motor_power, najvišja_motor_power):

globalna osnovna_hitrost

če abs_napaka> = sprožilna točka:

# x0 = 0,0

# y0 = 0,0

# x1 = zgornja meja - sprožilna točka

# y1 = 1,0

# x = abs_error - točka sprožilca

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

# enako kot

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

moč motorja = osnovna hitrost * (najmanjša moč motorja + (1- let) * (najvišja moč motorja - najmanjša moč motorja))

vrnitev moči motorja

drugače:

vrni osnovno hitrost * najvišjo moč motorja

run = False

prejšnja_napaka = 0

skupni_čas = 0,0

skupaj_številk = 0

medtem ko res:

# če pritisnete gumb a, začnite slediti

če je gumb_a.is_pressed ():

run = True

# če pa pritisnete gumb b, ustavite sledilnik vrstice

če je button_b.is_pressed ():

run = False

integral = 0,0

prejšnja_napaka = 0,0

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

skupni_čas = 0,0

skupaj_številk = 0

pixels_off ()

stop ()

sleep_ms (500)

če je runTrue:

# preberite linijske senzorje

start_time = ticks_us ()

# preverite, ali smo z daljinskim upravljalnikom posodobili dobičke Kp/Kd

poskusi:

Kp, Ki, Kd, sprožilna_točka, min_speed_percent = ustruct.unpack ('fffff', radio.receive_bytes ())

set_eyes ()

razenTypeError:

prehod

desno, levo = senzor za branje (LINE_SENSOR, OBA)

# vrstica je na levi, ko je položaj <0,5

# vrstica je na desni, ko je položaj> 0,5

# vrstica je na sredini, ko je položaj = 0,5

# to je utežena aritmetična sredina

poskusi:

položaj = desno /plavajoče (levo + desno)

razenZeroDivisionError:

položaj = 0,5

če je položaj == 0: položaj = 0,001

če je položaj == 1: položaj = 0,999

# uporabite krmilnik PD

napaka = položaj - nastavljena vrednost

integral += napaka

popravek = Kp * napaka + Ki * integral + Kd * (napaka - prejšnja_napaka)

previous_error = napaka

# izračunajte hitrost motorja

motor_speed = zgornja_meja_linearna_speed_reducer (abs (napaka), nastavljena vrednost * sprožilna točka, nastavljena vrednost, min_speed_percent, 1,0)

leftMotorSpeed = hitrost motorja + popravek

rightMotorSpeed = hitrost_motorja - popravek

# prižgite neopiksle, da pokažete, v katero smer mora iti GiggleBot

če je run_neopixelsTrueand 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 (napaka)> error_width_per_pixel * i:

če je napaka <0:

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

drugače:

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

drugače:

odstotek = 1- (širina_napake_za_piks * i -abs (napaka)) / širina_napake_za_piks

# osvetli trenutno slikovno piko

če je napaka <0:

# neo [center_pixel + i] = tuple (zemljevid (lambda x: int (x * odstotek), turkizna))

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

drugače:

# neo [center_pixel - i] = tuple (zemljevid (lambda x: int (x * odstotek), turkizna))

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

prekiniti

neo.show ()

poskusi:

# izrežite motorje

če je levoMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

če je desnoMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - desnoMotorSpeed +100

če je levoMotorSpeed <-100:

leftMotorSpeed = -100

če je desnoMotorSpeed <-100:

rightMotorSpeed = -100

# aktivirajte motorje

set_speed (leftMotorSpeed, rightMotorSpeed)

pogon ()

# print ((napaka, hitrost motorja))

razen:

# v primeru, da pridemo v neko težavo, ki je ni mogoče odpraviti

prehod

# in vzdržujte frekvenco zanke

end_time = ticks_us ()

delay_diff = (end_time - start_time) /1000

total_time += delay_diff

skupaj_številk += 1

if1.0/ update_rate - delay_diff> 0:

spanje (1.0/ update_rate - delay_diff)

oglejte si rawgigglebot_line_follower_tuner.py, ki ga gosti ❤ GitHub

4. korak: Nastavitev sprejemnika (daljinskega upravljalnika)

Naslednja stvar, ki jo moramo storiti, je, da bliskavico runtime + script prestavimo v 2. BBC micro: bit. Ta drugi mikro: bit bo deloval kot daljinski upravljalnik za GiggleBot, ki bo uporabljen za nastavitev naslednjih parametrov:

1. Kp = sorazmerni dobiček za PID krmilnik.
2. Ki = integralni dobiček za PID krmilnik.
3. Kd = izvedeni dobiček za PID krmilnik.
4. trigger_point = točka, izražena v odstotkih med najmanjšo in največjo hitrostjo GiggleBota, kjer se hitrost začne linearno zmanjševati, dokler ne doseže minimalne hitrosti.
5. min_speed_percent = najmanjša hitrost, izražena v odstotkih od največje hitrosti.

Drugi dve preostali spremenljivki, ki ju je mogoče nastaviti, sta neposredno kodirani v skriptu, ki sedi na GiggleBot: update_rate in base_speed, ki predstavlja največjo hitrost. Kot je opisano v dokumentaciji, je največja hitrost, ki jo je mogoče nastaviti za GiggleBot, 100, kar je tudi privzeta vrednost za naš GiggleBot.

Opomba: V tem skriptu morda manjkajo presledki, kar je verjetno posledica neke težave pri prikazovanju GitHub Gists. Kliknite na bistvo, da se pomaknete na njegovo stran GitHub, kjer lahko kopirate in prilepite kodo.

GiggleBot Remote PID Line Follower Tuner (zahteva drugi del) - xjfls23

iz uvoza microbit*

od utime import sleep_ms

uvoz radia

uvozni ustruct

# 1. element je dobiček Kp

# 2. element je dobiček Ki

# 3. element je Kd dobiček

# 4. element je točka sprožilca za motorje, ki znižujejo hitrost (0 -> 1)

# 5. element je minimalna hitrost motorjev, izražena v odstotkih (0 -> 1)

dobički = [0,0, 0,0, 0,0, 1,0, 0,0]

stepSize = 0,1

# 0 in 1 za 1. element

# 2 in 3 za 2. element

currentSetting = 0

defshowMenu ():

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

radio.on ()

showMenu ()

medtem ko res:

posodobljeno = napačno

če je gumb_a.is_pressed ():

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

posodobljeno = res

če je button_b.is_pressed ():

if currentSetting %2 == 0:

# povečanje dobička, ko je CurrentSetting 0 ali 2 ali..

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

dobički [int (currentSetting /2)] += 10* stepSize

drugače:

dobiček [int (currentSetting /2)] += stepSize

drugače:

# povečanje dobička, ko je CurrentSetting 1 ali 3 ali..

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

dobički [int (currentSetting /2)] -= 10* stepSize

drugače:

dobički [int (currentSetting /2)] -= stepSize

radio.send_bytes (ustruct.pack ('fffff', *dobiček))

posodobljeno = res

če je posodobljeno:

showMenu ()

sleep_ms (200)

oglejte si rawgigglebot_line_follower_configurator.py, ki ga gosti ❤ GitHub

5. korak: Prilagodite GiggleBot

Postavite GiggleBot na progo, ga vklopite in pustite, da deluje. Medtem ga boste morali nenehno postavljati nazaj in prilagoditi dobičke/parametre z drugim mikro -bitom BBC, ki ga držite v roki.

Če želite zagnati GiggleBot, pritisnite gumb A na BBC micro: bit GiggleBot -a in ga ustavite ter tako ponastavite stanje, pritisnite gumb B.

Na daljinskem BBC micro: bit, pritisk na gumb A vas popelje skozi vse možnosti v meniju, gumb B pa poveča/zmanjša ustrezno vrednost. To je kot nastavitev ure na armaturni plošči starega avtomobila. Možnosti so takšne:

1. Možnosti 0-1 so za dobiček Kp.
2. 2-3 možnosti so za dobiček Ki.
3. 4-5 možnosti je za Kd dobiček.
4. 6-7 možnosti je za nastavitev nastavljene vrednosti za trenutek, ko se motorji začnejo upočasnjevati.
5. 8-9 možnosti je za nastavitev najmanjše hitrosti.

Upoštevajte, da so parne številke v meniju za povečanje ustreznih vrednosti, za lihe pa je ravno nasprotno.

Ko pritisnete gumb B na BBC micro: bit GiggleBot -a, boste na zaslonu, izdelanem z Neopixel -om, videli število milisekund, ki so pretekle od zadnje ponastavitve, in število ciklov, ki jih je opravil robot - s temi 2 lahko izračunate hitrost posodabljanja robota.

Nazadnje in najpomembnejše, za GiggleBot sem pripravil 2 uglaševanja. Eden od njih je za izklop LED diod Neopixel, drugi pa za čas, ko je drugače. LED diode Neopixel se uporabljajo za prikaz, v katero smer se je napaka nakopičila.

1. niz nastavitev parametrov (z izklopljenimi LED diodami NeoPixel)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0,3 (kar je 30%)
5. min_speed_percent = 0,2 (kar je 20%)
6. base_speed = 100 (znana tudi kot največja hitrost)
7. update_rate = 70 (deluje pri 70Hz)

2. niz uravnavanja parametrov (z vklopljenimi LED diodami NeoPixel)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0,3 (kar je 30%)
5. min_speed_percent = 0,3 (kar je 30%)
6. base_speed = 70 (znana tudi kot največja hitrost)
7. update_rate = 50 (deluje pri 50Hz)
8. Tudi spremenljivko run_neopixels mora biti v skriptu, ki se naloži v BBC micro: bit GiggleBot, nastavljen na True. Zaradi tega bodo LED diode NeoPixel utripale tako, da bodo kazale, v katero smer se napaka kopiči.

6. korak: GiggleBot teče z izklopljenimi NeoPixels

To je primer izvajanja programa GiggleBot s prvimi nastavitvenimi parametri v prejšnjem koraku. V tem primeru so LED diode NeoPixel izklopljene.

7. korak: GiggleBot teče z vklopljenimi neopiksli

To je primer zagona programa GiggleBot z 2. nizom parametrov za uglaševanje, ki jih najdemo v 5. koraku. Ta primer ima vklopljene LED -diode NeoPixel.

Opazite, kako v tem primeru GiggleBot težje sledi liniji - to je zato, ker LED diode Neopixel "pojedo" čas CPU -ja BBC micro: bit. Zato smo morali zmanjšati stopnjo posodobitve s 70 na 50.