Sledovač řádku GiggleBot pomocí Pythonu: 5 kroků

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

Tentokrát programujeme v MicroPythonu Dexter Industries GiggleBot, abychom sledovali černou čáru pomocí vestavěného senzoru sledovače čáry.

Aby bylo možné GiggleBot vhodně ovládat, musí být spárován s BBC micro: bitem.

Pokud je tento výukový program pro vás příliš pokročilý a programování GiggleBotu je prozatím příliš mnoho, můžete si vždy projít úvodní návod, který vám ukáže, jak lze robota naprogramovat v MakeCode zde. Propojený tutoriál vás provede úplnými základy.

Krok 1: Požadované součásti

Jsou vyžadovány následující hardwarové komponenty:

1. x3 AA baterie - v mém případě používám nabíjecí baterie, které mají celkově nižší napětí.
2. Robot Dexter Industries GiggleBot pro micro: bit.
3. Micro: bit BBC.

K naprogramování BBC micro: bit samozřejmě potřebujete také kabel micro USB - tento kabel se obvykle dodává v balíčku BBC micro: bit nebo můžete vždy použít ten, který se používá k nabíjení smartphonů (Android).

Získejte GiggleBot pro micro: bit zde

Krok 2: Nastavení stop

Budete muset projít tiskem některých dlaždic a navrhováním vlastních skladeb. Můžete použít naše vlastní dlaždice, abyste si byli 100% jisti, že replikujete naše podmínky. Nebo pokud se cítíte dobrodružně, můžete použít černou pásku a vytvořit si vlastní. Zde je PDF pro dlaždice, které jsme použili.

Výše uvedená stopa se skládá z následujícího počtu různých dlaždic:

• 12 dlaždic typu #1.
• 5 dlaždic typu #2.
• 3 šablony typu dlaždice #5.
• 3 šablony typu dlaždice č. 6 - zde skončíte s jednou dlaždicí navíc.

Dále je vytiskněte a ořízněte. Zkuste je umístit jako na výše uvedené fotografii a mějte na paměti, že na pravé horní straně trati se 2 dlaždice musí překrývat s ostatními - to se očekává v případě, že vás zajímá, jestli děláte něco špatně.

Krok 3: Nastavení prostředí

Abyste mohli programovat micro: bit BBC v programu MicroPython, musíte pro něj nastavit editor (editor Mu) a nastavit běhový čas GiggleBot MicroPython Runtime. Chcete -li to provést, musíte postupovat podle pokynů na této stránce. Od tohoto okamžiku se používá verze v0.4.0 modulu runtime.

Krok 4: Programování GiggleBot

Než se pustíme do toho, běhový modul GiggleBot MicroPython obsahuje klasický běhový modul pro BBC micro: bit a další knihovny na podporu GiggleBot a dalších senzorů Dexter Industries.

Po nastavení otevřete v editoru Mu následující skript a klikněte na Flash. To bude blikat GiggleBot MicroPython Runtime a skript, který jste právě otevřeli pro váš BBC micro: bit. Skript je také zobrazen níže.

Jakmile je proces blikání hotový, naskládejte BBC micro: bit do GiggleBotu neopixely desky směrem dopředu, umístěte jej na dráhu a zapněte.

Všimněte si, že ve skriptu jsou již nastaveny PID a další 2 konstanty (požadovaná hodnota rychlosti a konstanty minimální rychlosti).

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.

Sledovač linky GiggleBot PID - vyladěný s NeoPixels

z importu mikrobitů*

z importu gigglebot*

z utime import sleep_ms, ticks_us

dovozní ustruct

# inicializujte GB neopixely

neo = init ()

# načasování

update_rate = 50

# zisky/konstanty (za předpokladu, že napětí baterie je kolem 4,0 voltů)

Kp = 25,0

Ki = 0,5

Kd = 35,0

trigger_point = 0,3

min_speed_percent = 0,3

základní rychlost = 70

žádaná hodnota = 0,5

last_position = požadovaná hodnota

integrál = 0,0

run_neopixels = Pravda

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

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

pixely_vypnuto ()

stop()

sleep_ms (500)

pokud je běh True:

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

start_time = ticks_us ()

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

# rozsah musí být (0, 1) a ne [0, 1]

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 podle dané chyby

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] = tyrkysová

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

jiný:

# neo [center_pixel - i] = tyrkysová

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 (64* procent /5), int (224* procent /5), int (208* procent /5))

jiný:

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

neo [center_pixel - i] = (int (64* procent /5), int (224* procent /5), int (208* procent /5))

přestávka

neo.show ()

Snaž se:

# omezte otáčky motoru

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

if1000.0/ update_rate - delay_diff> 0:

spánek (1000.0/ update_rate - delay_diff)

zobrazit rawgigglebot_tuned_line_follower.py hostované s ❤ od GitHub

Krok 5: Nechte to běžet

Na BBC micro: bit: tlačítko A a tlačítko B jsou 2 tlačítka:

• Stisknutím tlačítka A nastavíte GiggleBot tak, aby sledoval čáru (pokud existuje).
• Stisknutím tlačítka B GiggleBot zastavíte a vše resetujete, abyste jej mohli znovu použít.

Důrazně doporučujeme nezvedat GiggleBot, když jde po čáře, a pak ho na něj vrátit, protože chyba, která se vypočítává, se může nahromadit a úplně zkazit trasu robota. Pokud ho chcete zvednout, stiskněte tlačítko B a poté, co jej vrátíte zpět, stiskněte znovu A.