Ladění sledovače linky GiggleBot - pokročilé: 7 kroků

2024 Autor: John Day | [email protected]. Naposledy změněno: 2024-01-30 08:21

V tomto velmi krátkém Instructables se chystáte vyladit svůj vlastní GiggleBot tak, aby sledoval černou čáru. V tomto dalším tutoriálu GiggleBot Line Follower jsme napevno zakódovali hodnoty ladění, aby fungovaly podle tohoto scénáře. Možná budete chtít, aby se to chovalo lépe tím, že přijdete s dalšími zisky.

V tomto tutoriálu vám ukazujeme 2 skripty, které lze oba načíst na různé BBC micro: bity, takže jeden z nich je vložen do GiggleBot a druhým, 2 tlačítka slouží k procházení nabídky a ladění různých parametry. Odeslání těchto aktualizovaných parametrů se provádí prostřednictvím rádia.

Krok 1: Požadované součásti

Budete potřebovat následující:

1. GiggleBot robot pro micro: bit.
2. x3 AA baterie
3. x2 BBC micro: bits - jeden pro GiggleBot a druhý fungující jako dálkový ovladač pro ladění parametrů.
4. Baterie pro BBC micro: bit - jako ta, která je součástí balíčku BBC micro: bit.

Pořiďte si GiggleBot Robot pro BBC micro: bit zde

Krok 2: Nastavení stop a prostředí

Musíte také skutečně vytvořit své stopy (stahovat, tisknout, vyjímat a páskovat dlaždice) a poté nastavit prostředí (IDE a runtime).

Protože tento tutoriál velmi souvisí s tímto dalším tutoriálem s názvem GiggleBot Line Follower, přejděte tam a postupujte podle kroků 2 a 3 a poté se vraťte sem.

Pokud jde o IDE, můžete použít editor Mu a za běhu si musíte stáhnout GiggleBot MicroPython Runtime. Runtime lze stáhnout z jeho dokumentace zde. Přejděte do kapitoly Začínáme s dokumentací a postupujte podle pokynů k nastavení prostředí. Od tohoto okamžiku se používá verze v0.4.0 modulu runtime.

Krok 3: Nastavení GiggleBot

Před spuštěním doby běhu na GiggleBot se ujistěte, že jste pro GiggleBot vybrali požadovanou rychlost a rychlost aktualizace: ve výchozím nastavení je rychlost nastavena na 100 (proměnná base_speed) a rychlost aktualizace na 70 (proměnná update_rate).

Vzhledem k současné implementaci je nejvyšší dosažitelná rychlost aktualizace 70 a pokud je run_neopixels nastaveno na True, pak je dosažitelné pouze 50. Svým způsobem by se dalo říci, že výchozí rychlost aktualizace je právě na hraně toho, co dokáže BBC micro: bit.

Jen pro informaci, senzor sledovače řádků může vrátit aktualizace 100krát za sekundu.

Poznámka: Následující skript může mít chybějící mezery a zdá se, že je to způsobeno nějakým problémem při zobrazování GitHub Gists. Kliknutím na podstatu se dostanete na stránku GitHub, kde můžete zkopírovat a vložit kód.

Tuner sledovače linky GiggleBot PID (k jeho vyladění vyžaduje dálkové ovládání) - xjfls23

z importu mikrobitů*

z importu gigglebot*

z utime import sleep_ms, ticks_us

importovat rádio

dovozní ustruct

# inicializujte rádio a neopixely GB

radio.on ()

neo = init ()

# načasování

update_rate = 70

# výchozí hodnoty zisku

Kp = 0,0

Ki = 0,0

Kd = 0,0

žádaná hodnota = 0,5

trigger_point = 0,0

min_speed_percent = 0,2

základní rychlost = 100

last_position = požadovaná hodnota

integrál = 0,0

run_neopixels = Nepravda

center_pixel = 5# kde je středový pixel úsměvu umístěn na GB

# turquoise = tuple (map (lambda x: int (x / 5), (64, 224, 208))) # color to use to draw the error with the neopixels

# turquoise = (12, 44, 41) # což je přesně ta výše zmíněná tyrkysová komentovaná nad tímto

error_width_per_pixel = 0,5/3# max chyba děleno počtem segmentů mezi každým neopixelem

defupper_bound_linear_speed_reducer (abs_error, trigger_point, upper_bound, smaller_motor_power, higher_motor_power):

globální základní rychlost

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

# stejný jako

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

motor_power = základní_rychlost * (nejmenší_motorová_moc + (1- r) * (nejvyšší_motorová_míra - nejmenší_motorová_moc))

vrátit motor_power

jiný:

návrat base_speed * nejvyšší_motor_power

run = False

previous_error = 0

total_time = 0,0

total_counts = 0

whileTrue:

# pokud je stisknuto tlačítko a, začněte sledovat

if button_a.is_pressed ():

run = True

#, ale pokud je stisknuto tlačítko b, zastavte sledovače řádků

pokud button_b.is_pressed ():

run = False

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_vypnuto ()

stop()

sleep_ms (500)

pokud je běh True:

# přečtěte si čidla linky

start_time = ticks_us ()

# zkontrolujte, zda jsme aktualizovali zisky Kp/Kd pomocí dálkového ovladače

Snaž se:

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

set_eyes ()

kroměTypeError:

složit

vpravo, vlevo = snímač čtení (LINE_SENSOR, BOTH)

# řádek je vlevo, když je pozice <0,5

# řádek je vpravo, když je poloha> 0,5

# řádek je uprostřed, když pozice = 0,5

# je to vážený aritmetický průměr

Snaž se:

pozice = vpravo /plovoucí (vlevo + vpravo)

kroměZeroDivisionError:

pozice = 0,5

pokud pozice == 0: pozice = 0,001

pokud pozice == 1: pozice = 0,999

# použijte PD ovladač

chyba = poloha - žádaná hodnota

integrál += chyba

oprava = Kp * chyba + Ki * integrál + Kd * (chyba - předchozí_ chyba)

previous_error = chyba

# vypočítat otáčky motoru

motor_speed = horní_bound_linear_speed_reducer (abs (chyba), setpoint * trigger_point, setpoint, min_speed_percent, 1.0)

leftMotorSpeed = motor_speed + oprava

rightMotorSpeed = motor_speed - oprava

# rozsviťte neopixely a ukažte, kterým směrem se musí GiggleBot vydat

pokud run_neopixels isTrueaand total_counts %3 == 0:

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

neo = (0, 0, 0)

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

ifabs (chyba)> error_width_per_pixel * i:

pokud chyba <0:

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

jiný:

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

jiný:

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

# rozsviťte aktuální pixel

pokud chyba <0:

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

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

jiný:

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

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

přestávka

neo.show ()

Snaž se:

# spusťte motory

je -li ponecháno MotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

pokud správně MotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

pokud je vlevo MotorSpeed <-100:

leftMotorSpeed = -100

pokud rightMotorSpeed <-100:

rightMotorSpeed = -100

# aktivujte motory

set_speed (leftMotorSpeed, rightMotorSpeed)

řídit()

# tisk ((chyba, rychlost motoru))

až na:

# v případě, že se dostaneme do nějakého neopravitelného problému

složit

# a udržujte frekvenci smyčky

end_time = ticks_us ()

delay_diff = (end_time - start_time) /1000

total_time += delay_diff

celkem_účty += 1

if1.0/ update_rate - delay_diff> 0:

spánek (1.0/ update_rate - delay_diff)

zobrazit rawgigglebot_line_follower_tuner.py hostované s ❤ od GitHub

Krok 4: Nastavení tuneru (dálkové ovládání)

Další věc, kterou musíme udělat, je flashovat runtime + skript na 2. BBC micro: bit. Tento druhý micro: bit bude fungovat jako dálkový ovladač GiggleBot, který bude použit k vyladění následujících parametrů:

1. Kp = proporcionální zisk pro PID regulátor.
2. Ki = integrální zisk pro PID regulátor.
3. Kd = derivační zisk pro PID regulátor.
4. trigger_point = bod vyjádřený v procentech mezi minimální a maximální rychlostí GiggleBot, kde se rychlost začíná lineárně snižovat, dokud nedosáhne minimální rychlosti.
5. min_speed_percent = minimální rychlost vyjádřená v procentech maximální rychlosti.

Další 2 zbývající proměnné, které lze naladit, jsou přímo pevně zakódovány ve skriptu, který sedí na GiggleBot: update_rate a base_speed, což představuje maximální rychlost. Jak je popsáno v dokumentaci, maximální rychlost, kterou lze pro GiggleBot nastavit, je 100, což je také výchozí hodnota pro náš GiggleBot.

Poznámka: Následující skript může mít chybějící mezery a zdá se, že je to způsobeno nějakým problémem při zobrazování GitHub Gists. Kliknutím na podstatu se dostanete na stránku GitHub, kde můžete zkopírovat a vložit kód.

GiggleBot Remote PID Line Follower Tuner (vyžaduje druhou část) - xjfls23

z importu mikrobitů*

z utime import sleep_ms

importovat rádio

dovozní ustruct

# 1. prvek je zisk Kp

# 2. prvek je zisk Ki

# 3. prvek je zisk Kd

# 4. prvek je trigger_point pro snížení rychlosti motoru (0 -> 1)

# 5. prvek je minimální rychlost pro motory, vyjádřená v procentech (0 -> 1)

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

stepSize = 0,1

# 0 a 1 pro 1. prvek

# 2 a 3 pro 2. prvek

currentSetting = 0

defshowMenu ():

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

radio.on ()

showMenu ()

whileTrue:

aktualizováno = False

if button_a.is_pressed ():

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

aktualizováno = Pravda

pokud button_b.is_pressed ():

if currentSetting %2 == 0:

# zvýšit zisk, když je aktuální nastavení 0 nebo 2 nebo..

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

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

jiný:

zisky [int (currentSetting /2)] += velikost kroku

jiný:

# zvýšit zisk, když je aktuální nastavení 1 nebo 3 nebo..

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

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

jiný:

zisky [int (currentSetting /2)] -= velikost kroku

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

aktualizováno = Pravda

pokud je aktualizováno:

showMenu ()

sleep_ms (200)

zobrazit rawgigglebot_line_follower_configurator.py hostované s ❤ od GitHub

Krok 5: Ladění GiggleBot

Umístěte GiggleBot na dráhu, zapněte jej a nechte běžet. Mezitím ho budete muset neustále vracet na trať a ladit zisky/parametry druhým BBC micro: bitem, který držíte v ruce.

Chcete -li GiggleBot spustit, stiskněte tlačítko A na BBC micro: bit GiggleBot a zastavte jej, a tím resetujte jeho stav, stiskněte tlačítko B.

Na dálkovém ovladači BBC micro: bit vás stisknutí tlačítka A provede všemi možnostmi v jeho nabídce a tlačítko B zvýší/sníží odpovídající hodnotu. Je to jako nastavit hodiny na palubní desce starého auta. Možnosti jsou následující:

1. Možnosti 0-1 jsou pro zisk Kp.
2. 2-3 možnosti jsou pro zisk Ki.
3. 4-5 možností je pro zisk Kd.
4. 6-7 možností je nastavení žádané hodnoty pro okamžik, kdy motory začnou zpomalovat.
5. 8-9 možností je pro nastavení minimální rychlosti.

Mějte na paměti, že sudá čísla v nabídce jsou pro zvýšení odpovídajících hodnot a u lichých je to přesně naopak.

Také když stisknete tlačítko B na BBC micro: bit GiggleBot, na jeho obrazovce vytvořené Neopixelem uvidíte počet uplynulých milisekund od posledního resetu a počet cyklů, kterými robot prošel - s těmito 2 můžete vypočítat rychlost aktualizace robota.

A konečně, a co je nejdůležitější, vymyslel jsem 2 ladění pro GiggleBot. Jeden z nich je určen pro vypnutí LED diod Neopixel a druhý pro případ, kdy je tomu jinak. LED diody Neopixel slouží k zobrazení, ve kterém směru se chyba nahromadila.

1. sada ladění parametrů (s vypnutými LED diodami NeoPixel)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0,3 (což je 30%)
5. min_speed_percent = 0,2 (což je 20%)
6. base_speed = 100 (aka maximální rychlost)
7. update_rate = 70 (běžící při 70 Hz)

2. sada ladění parametrů (se zapnutými LED diodami NeoPixel)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0,3 (což je 30%)
5. min_speed_percent = 0,3 (což je 30%)
6. base_speed = 70 (aka maximální rychlost)
7. update_rate = 50 (běžící na 50 Hz)
8. Také proměnná run_neopixels musí být ve skriptu, který se načte na micro: bit GiggleBot BBC, nastaven na True. Díky tomu budou LED diody NeoPixel blikat takovým způsobem, že indikují, kterým směrem se chyba hromadí.

Krok 6: GiggleBot běží s vypnutými NeoPixely

Toto je příklad spuštění GiggleBot s 1. parametry ladění nalezenými v předchozím kroku. V tomto příkladu jsou LED diody NeoPixel vypnuté.

Krok 7: GiggleBot běží se zapnutými Neopixely

Toto je příklad spuštění GiggleBot s 2. sadou parametrů ladění nalezenou v kroku 5. Tento příklad má zapnuté LED diody NeoPixel.

Všimněte si, že v tomto příkladu má GiggleBot těžší sledování řádku - to je proto, že LED diody Neopixel „žerou“čas CPU mikro: bit BBC. Proto jsme museli snížit rychlost aktualizace ze 70 na 50.