Obsah:
2025 Autor: John Day | [email protected]. Naposledy změněno: 2025-01-13 06:57
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:
- x3 AA baterie - v mém případě používám nabíjecí baterie, které mají celkově nižší napětí.
- Robot Dexter Industries GiggleBot pro micro: bit.
- 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.