Ladenie nasledovníka linky GiggleBot - pokročilé: 7 krokov

2024 Autor: John Day | [email protected]. Naposledy zmenené: 2024-01-30 11:58

V tomto veľmi krátkom návode sa naladíte na svoj vlastný GiggleBot tak, aby nasledoval čiernu čiaru. V tomto inom tutoriále GiggleBot Line Follower sme naprogramovali hodnoty ladenia tak, aby fungovali podľa tohto scenára. Možno budete chcieť, aby sa správalo lepšie tým, že prídete s inými ziskami.

V tomto návode vám ukazujeme 2 skripty, ktoré je možné načítať na rôzne BBC micro: bity, takže jeden z nich je vložený do GiggleBot a pomocou druhého sa dve tlačidlá používajú na prechádzanie ponuky a ladenie rôznych parametre. Odoslanie týchto aktualizovaných parametrov sa vykonáva prostredníctvom rádia.

Krok 1: Požadované komponenty

Budete potrebovať nasledujúce:

1. GiggleBot robot pre micro: bit.
2. x3 AA batérie
3. x2 BBC micro: bits - jeden pre GiggleBot a druhý slúžiaci ako diaľkový ovládač pre ladenie parametrov.
4. Batéria pre BBC micro: bit - podobná tej, ktorá je súčasťou balíka BBC micro: bit.

Získajte GiggleBot Robot pre BBC micro: bit tu

Krok 2: Nastavenie stôp a prostredia

Musíte tiež skutočne vytvoriť stopy (sťahovať, tlačiť, vystrihovať a lepiť pásky) a potom nastaviť prostredie (IDE a runtime).

Pretože tento návod veľmi súvisí s týmto ďalším tutoriálom s názvom GiggleBot Line Follower, choďte tam a postupujte podľa krokov 2 a 3 a potom sa vráťte sem.

Pokiaľ ide o IDE, môžete použiť editor Mu a na spustenie si musíte stiahnuť GiggleBot MicroPython Runtime. Runtime je možné stiahnuť z jeho dokumentácie tu. Prejdite do kapitoly Začíname s dokumentáciou a postupujte podľa pokynov na nastavenie prostredia. Od tohto momentu sa používa verzia v0.4.0 runtime.

Krok 3: Nastavenie GiggleBot

Pred spustením doby chodu na GiggleBot sa uistite, že ste vybrali požadovanú rýchlosť a rýchlosť aktualizácie pre GiggleBot: v predvolenom nastavení je rýchlosť nastavená na 100 (premenná base_speed) a rýchlosť aktualizácie na 70 (premenná update_rate).

Vzhľadom na súčasnú implementáciu je najvyššia rýchlosť aktualizácií, ktorú je možné dosiahnuť, 70 a ak je parameter run_neopixels nastavený na hodnotu True, potom je možné dosiahnuť iba 50. Svojím spôsobom by ste mohli povedať, že predvolená rýchlosť aktualizácií je na okraji toho, čo dokáže BBC micro: bit.

Len pre zaujímavosť, senzor sledovača linky môže vrátiť aktualizácie 100 krát za sekundu.

Poznámka: Nasledujúci skript môže mať prázdne medzery, a zdá sa, že je to kvôli nejakému problému so zobrazovaním GitHub Gists. Kliknutím na podstatu sa dostanete na stránku GitHub, kde môžete skopírovať a prilepiť kód.

Tuner sledovača linky GiggleBot PID (na jeho naladenie je potrebný diaľkový ovládač) - xjfls23

z importu mikrobitov*

z importu gigglebot*

z utime importu sleep_ms, ticks_us

dovozné rádio

dovozná štruktúra

# inicializujte rádiové a GB neopixely

radio.on ()

neo = init ()

# načasovanie

update_rate = 70

# predvolené hodnoty zisku

Kp = 0,0

Ki = 0,0

Kd = 0,0

požadovaná hodnota = 0,5

trigger_point = 0,0

min_speed_percent = 0,2

základná rýchlosť = 100

last_position = požadovaná hodnota

integrál = 0,0

run_neopixels = Nepravda

center_pixel = 5#, kde je stredový pixel úsmevu umiestnený v GB

# tyrkysová = tuple (mapa (lambda x: int (x / 5), (64, 224, 208))) # farba, ktorá sa použije na vykreslenie chyby s neopixelmi

# turquoise = (12, 44, 41) # čo je presne vyššie uvedená tyrkysová, komentovaná nad týmto

error_width_per_pixel = 0,5/3# maximálna chyba delená počtom segmentov medzi každým neopixelom

defupper_bound_linear_speed_reducer (abs_error, trigger_point, upper_bound, smaller_motor_power, najvyššia_motor_power):

globálna základná rýchlosť

if 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)

# rovnaké ako

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

motor_power = základná rýchlosť * (najmenšia_motorová sila + (1- r) * (najvyššia_motorová sila - najmenšia_motorová sila))

vrátiť motor_power

inak:

vrátiť základnú rýchlosť * najvyššia_motorová sila

beh = nepravda

previous_error = 0

total_time = 0,0

total_counts = 0

whileTrue:

# ak stlačíte tlačidlo a, začnite sledovať

ak button_a.is_pressed ():

beh = Pravda

#, ale ak stlačíte tlačidlo b, zastavte sledovanie čiar

ak button_b.is_pressed ():

beh = nepravda

integrál = 0,0

previous_error = 0,0

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

total_time = 0,0

total_counts = 0

pixely_vypnute ()

zastaviť ()

sleep_ms (500)

ak je beh pravdivý:

# prečítajte riadkové snímače

start_time = ticks_us ()

# skontrolujte, či sme aktualizovali zisky Kp/Kd pomocou diaľkového ovládača

skús:

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

set_eyes ()

kroměTypeError:

prejsť

vpravo, vľavo = snímač_ čítania (LINE_SENSOR, OBOJ)

# riadok je vľavo, keď je pozícia <0,5

# riadok je vpravo, keď je pozícia> 0,5

# riadok je v strede, keď je poloha = 0,5

# je to vážený aritmetický priemer

skús:

poloha = vpravo /plávajúca (vľavo + vpravo)

okremZeroDivisionError:

poloha = 0,5

ak pozícia == 0: poloha = 0,001

ak pozícia == 1: poloha = 0,999

# používajte PD ovládač

chyba = poloha - požadovaná hodnota

integrál += chyba

oprava = Kp * chyba + Ki * integrál + Kd * (chyba - predchádzajúca chyba)

previous_error = chyba

# vypočítajte otáčky motora

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

leftMotorSpeed = motor_speed + korekcia

rightMotorSpeed = motor_speed - oprava

# rozsvieťte neopixely, aby ste ukázali, akým smerom sa musí GiggleBot uberať

ak je run_neopixels True a total_counts %3 == 0:

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

neo = (0, 0, 0)

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

ifabs (chyba)> error_width_per_pixel * i:

ak chyba <0:

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

inak:

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

inak:

percento = 1- (error_width_per_pixel * i -abs (chyba)) / error_width_per_pixel

# rozsvieti aktuálny pixel

ak chyba <0:

# neo [center_pixel + i] = tuple (mapa (lambda x: int (x * percent), tyrkysová))

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

inak:

# neo [center_pixel - i] = tuple (mapa (lambda x: int (x * percent), tyrkysová))

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

prestávka

neo.show ()

skús:

# spusťte motory

ak je ponechaná MotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

ak je správne MotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

ak je ponechaný MotorSpeed <-100:

leftMotorSpeed = -100

ak vpravoMotorSpeed <-100:

rightMotorSpeed = -100

# aktivujte motory

set_speed (leftMotorSpeed, rightMotorSpeed)

riadiť ()

# print ((chyba, rýchlosť motora))

okrem:

# v prípade, že sa dostaneme do nejakého neopraviteľného problému

prejsť

# a udržiavať frekvenciu slučky

end_time = ticks_us ()

delay_diff = (end_time - start_time) /1000

total_time += rozdiel_ oneskorenia

total_counts += 1

if1.0/ update_rate - delay_diff> 0:

spánok (1,0/ aktualizácia_rýchlosť - rozdiel oneskorenia)

zobraziť rawgigglebot_line_follower_tuner.py hostené s ❤ od GitHub

Krok 4: Nastavenie tunera (diaľkové ovládanie)

Ďalšia vec, ktorú musíme urobiť, je zaslať skript runtime + na 2. BBC micro: bit. Tento druhý mikro: bit bude fungovať ako diaľkový ovládač k GiggleBot, ktorý bude použitý na vyladenie nasledujúcich parametrov:

1. Kp = proporcionálne zosilnenie pre PID regulátor.
2. Ki = integrálny zisk pre PID regulátor.
3. Kd = derivačný zisk pre PID regulátor.
4. trigger_point = bod vyjadrený v percentách medzi minimálnymi a maximálnymi rýchlosťami GiggleBot, kde sa rýchlosť začína lineárne znižovať, až kým nedosiahne minimálnu rýchlosť.
5. min_speed_percent = minimálna rýchlosť vyjadrená v percentách z maximálnej rýchlosti.

Ostatné 2 zostávajúce premenné, ktoré je možné ladiť, sú priamo naprogramované v skripte, ktorý sedí na GiggleBot: update_rate a base_speed, čo predstavuje maximálnu rýchlosť. Ako je popísané v dokumentácii, maximálna rýchlosť, ktorú je možné nastaviť pre GiggleBot, je 100, čo je tiež predvolená hodnota pre náš GiggleBot.

Poznámka: Nasledujúci skript môže mať prázdne medzery, a zdá sa, že je to kvôli nejakému problému so zobrazovaním GitHub Gists. Kliknutím na podstatu sa dostanete na stránku GitHub, kde môžete skopírovať a prilepiť kód.

GiggleBot Remote PID Line Follower Tuner (vyžaduje druhú časť) - xjfls23

z importu mikrobitov*

od utime import sleep_ms

dovozné rádio

dovozná štruktúra

# 1. prvok je zisk Kp

# 2. prvok je zisk Ki

# 3. prvok je zisk Kd

# 4. prvok je spúšťací bod pre motory, ktoré znižujú rýchlosť (0 -> 1)

# Piaty prvok je minimálna rýchlosť pre motory vyjadrená v percentách (0 -> 1)

zisky = [0,0, 0,0, 0,0, 1,0, 0,0]

stepSize = 0,1

# 0 a 1 pre 1. prvok

# 2 a 3 pre 2. prvok

currentSetting = 0

defshowMenu ():

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

radio.on ()

showMenu ()

whileTrue:

aktualizované = nepravdivé

ak button_a.is_pressed ():

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

aktualizované = Pravda

ak button_b.is_pressed ():

if currentSetting %2 == 0:

# zvýšiť zisk, ak je aktuálneNastavenie 0 alebo 2 alebo..

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

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

inak:

zisky [int (currentSetting /2)] += veľkosť kroku

inak:

# zvýšiť zisk, keď je aktuálneNastavenie 1 alebo 3 alebo..

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

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

inak:

zisky [int (currentSetting /2)] -= veľkosť kroku

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

aktualizované = Pravda

ak je aktualizovaný:

showMenu ()

sleep_ms (200)

zobraziť rawgigglebot_line_follower_configurator.py hostené s ❤ od GitHub

Krok 5: Ladenie GiggleBot

Umiestnite GiggleBot na dráhu, zapnite ho a nechajte bežať. Medzitým ho budete musieť neustále vracať na trať a ladiť zisky/parametre pomocou druhého micro: bitu BBC, ktorý držíte v ruke.

GiggleBot spustíte stlačením tlačidla A na BBC micro: bite GiggleBot a zastavíte ho, čím resetujete jeho stav, stlačte tlačidlo B.

Na diaľkovom ovládači BBC micro: bit stlačením tlačidla A prejdete všetkými možnosťami v jeho ponuke a tlačidlom B zvýšite/znížite zodpovedajúcu hodnotu. Je to ako nastaviť hodiny na palubnej doske starého auta. Možnosti sú tieto:

1. Možnosti 0-1 sú pre zisk Kp.
2. 2-3 možnosti sú pre zisk Ki.
3. Na zisk Kd je 4-5 možností.
4. 6-7 možností je na nastavenie žiadanej hodnoty v okamihu, keď sa motory začnú spomaľovať.
5. 8-9 možností je na nastavenie minimálnej rýchlosti.

Majte na pamäti, že párne čísla v ponuke slúžia na zvýšenie zodpovedajúcich hodnôt a pri nepárnych je to presne naopak.

Tiež keď stlačíte tlačidlo B na mikrogitovom BBC GiggleBot, na jeho obrazovke vyrobenej z Neopixelu uvidíte počet uplynulých milisekúnd od posledného vynulovania a počet cyklov, ktorými robot prešiel - pomocou týchto 2 môžete vypočítať rýchlosť aktualizácie robota.

Nakoniec, a čo je najdôležitejšie, vymyslel som 2 ladenia pre GiggleBot. Jeden z nich je určený pre prípady, keď sú diódy LED Neopixel vypnuté, a druhý, keď je to inak. Neopixelové diódy LED slúžia na zobrazenie, v akom smere sa chyba nahromadila.

1. sada ladenia parametrov (s vypnutými LED diódami NeoPixel)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0,3 (čo je 30%)
5. min_speed_percent = 0,2 (čo je 20%)
6. base_speed = 100 (alias maximálna rýchlosť)
7. update_rate = 70 (beží pri 70 Hz)

2. sada ladenia parametrov (so zapnutými LED diódami NeoPixel)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0,3 (čo je 30%)
5. min_speed_percent = 0,3 (čo je 30%)
6. base_speed = 70 (alias maximálna rýchlosť)
7. update_rate = 50 (beží pri 50 Hz)
8. Tiež premenná run_neopixels musí byť nastavená na True v skripte, ktorý sa načítava na GiggleBot BBC micro: bit. Vďaka tomu budú LED diódy NeoPixel blikať takým spôsobom, že indikujú, v ktorom smere sa chyba nahromadí.

Krok 6: GiggleBot beží s vypnutými NeoPixelmi

Toto je príklad spustenia GiggleBotu s 1. parametrami ladenia, ktoré boli nájdené v predchádzajúcom kroku. V tomto prípade sú LED diódy NeoPixel vypnuté.

Krok 7: GiggleBot beží so zapnutými neopixelmi

Je to príklad spustenia GiggleBot s druhou sadou parametrov ladenia, ktoré nájdete v kroku 5. Tento príklad má zapnuté LED diódy NeoPixel.

Všimnite si, ako v tomto prípade GiggleBot ťažšie sleduje líniu - je to preto, že LED diódy Neopixel „žerú“čas CPU mikro: bitu BBC. Preto sme museli znížiť rýchlosť aktualizácií zo 70 na 50.