Nasledovník linky GiggleBot pomocou Pythonu: 5 krokov

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

Tentoraz programujeme v MicroPythone Dexter Industries GiggleBot, aby sledoval čiernu čiaru pomocou vstavaného senzora sledovača riadkov.

Aby bolo možné GiggleBot vhodne ovládať, musí byť spárované s BBC micro: bitom.

Ak je tento tutoriál pre vás príliš pokročilý a programovanie GiggleBotu je zatiaľ príliš veľa, môžete si vždy prejsť návod pre začiatočníkov, ktorý vám ukáže, ako sa dá robot naprogramovať v programe MakeCode tu. Prepojený tutoriál vás prevedie úplnými základmi.

Krok 1: Požadované komponenty

Vyžadujú sa nasledujúce hardvérové komponenty:

1. x3 AA batérie - v mojom prípade používam nabíjateľné batérie, ktoré majú celkovo nižšie napätie.
2. Robot Dexter Industries GiggleBot pre mikro: bit.
3. Micro BBC: bit.

Na naprogramovanie BBC micro: bit samozrejme potrebujete aj kábel micro USB - tento kábel sa spravidla dodáva v balení BBC micro: bit alebo ho môžete vždy použiť na nabíjanie smartfónov (Android).

Získajte GiggleBot za micro: bit tu

Krok 2: Nastavte stopy

Budete musieť prejsť vytlačením niektorých dlaždíc a navrhnutím vlastných skladieb. Môžete použiť naše vlastné dlaždice, aby ste si boli 100% istí, že replikujete naše podmienky. Alebo ak sa cítite dobrodružne, môžete použiť čiernu pásku a vyrobiť si vlastnú. Tu je PDF pre dlaždice, ktoré sme použili.

Vyššie uvedená stopa pozostáva z nasledujúceho počtu rôznych dlaždíc:

• 12 dlaždíc typu #1.
• 5 dlaždíc typu #2.
• 3 šablóny typu dlaždice č. 5.
• 3 šablóny typu dlaždice č. 6 - tu skončíte s jednou dlaždicou navyše.

Ďalej ich vytlačte a odstrihnite. Skúste ich umiestniť ako na vyššie uvedenej fotografii a majte na pamäti, že na pravej hornej strane trate sa 2 dlaždice musia navzájom prekrývať - to sa očakáva v prípade, že vás zaujíma, či robíte niečo zle.

Krok 3: Nastavenie prostredia

Aby ste mohli programovať micro: bit BBC v MicroPythone, musíte preň nastaviť editor (Mu Editor) a nastaviť jeho runtime ako GiggleBot MicroPython Runtime. Na to musíte postupovať podľa pokynov na tejto stránke. Od tohto momentu sa používa verzia v0.4.0 runtime.

Krok 4: Programovanie GiggleBot

Než sa pustíte do toho, runtime GiggleBot MicroPython obsahuje klasický runtime pre BBC micro: bit a ďalšie knižnice na podporu GiggleBot a ďalších senzorov Dexter Industries.

Po nastavení otvorte v editore Mu nasledujúci skript a kliknite na Flash. To bude blikať GiggleBot MicroPython Runtime a skript, ktorý ste práve otvorili pre váš BBC micro: bit. Skript je tiež zobrazený nižšie.

Akonáhle je proces blikania hotový, naskladajte BBC micro: bit do GiggleBotu neopixelmi dosky smerom dopredu, umiestnite ho na dráhu a zapnite.

Všimnite si, že v skripte sú PID a ďalšie 2 konštanty (požadovaná hodnota rýchlosti a konštanty minimálnej rýchlosti) už nastavené.

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.

Nasledovník linky GiggleBot PID - vyladený s NeoPixels

z importu mikrobitov*

z importu gigglebot*

z utime importu sleep_ms, ticks_us

dovozná štruktúra

# inicializujte GB neopixely

neo = init ()

# načasovanie

update_rate = 50

# zisky/konštanty (za predpokladu, že napätie batérie je okolo 4,0 voltov)

Kp = 25,0

Ki = 0,5

Kd = 35,0

trigger_point = 0,3

min_speed_percent = 0,3

základná rýchlosť = 70

požadovaná hodnota = 0,5

last_position = požadovaná hodnota

integrál = 0,0

run_neopixels = Pravda

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

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

pixely_vypnute ()

zastaviť ()

sleep_ms (500)

ak je beh pravdivý:

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

start_time = ticks_us ()

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

# rozsah musí byť (0, 1) a nie [0, 1]

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

# rozsviette neopixely podľa danej chyby

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

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

inak:

# neo [center_pixel - i] = tyrkysová

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

inak:

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

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

prestávka

neo.show ()

skús:

# orežte otáčky motora

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

if1000.0/ update_rate - delay_diff> 0:

spánok (1 000,0/ aktualizačný_rýchlosť - rozdiel pri oneskorení)

zobraziť rawgigglebot_tuned_line_follower.py hostené s ❤ od GitHub

Krok 5: Nechajte to bežať

Na BBC micro: bit: tlačidlo A a tlačidlo B sú dve tlačidlá:

• Stlačením tlačidla A nastavíte GiggleBot tak, aby sledoval čiaru (ak existuje).
• Stlačením tlačidla B sa GiggleBot zastaví a všetko sa resetuje, aby ste ho mohli znova použiť.

Dôrazne sa odporúča, aby ste GiggleBot nezdvíhali, keď sleduje čiaru, a potom ho na ňu nevrátili, pretože chyba, ktorá sa počíta, by sa mohla nahromadiť a úplne narušiť trasu robota. Ak ho chcete zdvihnúť, stlačte tlačidlo B a potom, keď ho vrátite späť, znova stlačte A.