Tuning GiggleBot Line Follower - Advanced: 7 Steps

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:23

I denne meget korte instruksen kommer du til å stille din egen GiggleBot for å følge en svart linje. I denne andre opplæringen GiggleBot Line Follower har vi hardkodet tuningverdiene for å fungere i henhold til det scenariet. Du vil kanskje få det til å oppføre seg bedre ved å komme med andre gevinster.

I denne opplæringen viser vi deg to skript som begge kan lastes på forskjellige BBC micro: bits slik at en av dem settes inn i GiggleBot og med den andre brukes de 2 knappene til å gå gjennom en meny og stille inn forskjellige parametere. Sending av disse oppdaterte parametrene skjer via radioen.

Trinn 1: Nødvendige komponenter

Du trenger følgende:

1. En GiggleBot -robot for micro: bit.
2. x3 AA -batterier
3. x2 BBC micro: bits - en for GiggleBot og den andre fungerer som en fjernkontroll for innstilling av parametere.
4. Et batteri for en BBC micro: bit - som det som følger med BBC micro: bit -pakken.

Få GiggleBot Robot for BBC micro: bit her

Trinn 2: Sette opp spor og miljø

Du må også faktisk bygge sporene dine (laste ned, skrive ut, klippe og tape fliser) og deretter sette opp miljøet (IDE og kjøretid).

Siden denne opplæringen er veldig relatert til denne andre opplæringen med tittelen GiggleBot Line Follower, bare gå dit og følg trinn 2 og 3 og kom tilbake hit.

Når det gjelder IDE, kan du bruke Mu -editoren og for kjøretiden må du laste ned GiggleBot MicroPython Runtime. Kjøretiden kan lastes ned fra dokumentasjonen her. Gå til kapitlet Komme i gang i dokumentasjonen, og følg instruksjonene for å sette opp miljøet. Fra nå av brukes versjon v0.4.0 av kjøretiden.

Trinn 3: Konfigurere GiggleBot

Før du blinker kjøretiden til GiggleBot, må du kontrollere at du har valgt ønsket hastighet og oppdateringshastighet for GiggleBot: Som standard er hastigheten satt til 100 (base_speed -variabel) og oppdateringshastigheten er satt til 70 (update_rate -variabel).

Gitt den nåværende implementeringen er den høyeste oppdateringshastigheten som kan oppnås 70, og hvis run_neopixels er satt til True, er det bare 50 som kan oppnås. Så på en måte kan du si at standard oppdateringshastighet ligger helt på kanten av hva BBC micro: bit kan gjøre.

Bare for ordens skyld, linjefølgersensoren kan returnere oppdateringer 100 ganger i sekundet.

Merk: Følgende skript kan mangle mellomrom, og dette ser ut til å skyldes et problem med visning av GitHub Gists. Klikk på essensen for å ta deg til GitHub-siden der du kan kopiere og lime inn koden.

GiggleBot PID Line Follower Tuner (krever en fjernkontroll for å stille den) - xjfls23

fra mikrobitimport*

fra gigglebot import*

fra utime import sleep_ms, ticks_us

importere radio

import ustruct

# initialiser radio og GB neopiksler

radio.on ()

neo = init ()

# timing

update_rate = 70

# standard gevinstverdier

Kp = 0,0

Ki = 0,0

Kd = 0,0

settpunkt = 0,5

trigger_point = 0,0

min_hastighet_prosent = 0,2

base_speed = 100

siste_posisjon = settpunkt

integrert = 0,0

run_neopixels = Falsk

center_pixel = 5# hvor midtpunktet til smilet er plassert på GB

# turkis = tupel (kart (lambda x: int (x / 5), (64, 224, 208))) # farge som skal brukes for å tegne feilen med neopikslene

# turkis = (12, 44, 41) # som er akkurat den turkise ovenfor kommenterte over dette

error_width_per_pixel = 0,5/3# maks feil delt på antall segmenter mellom hver neopiksel

defupper_bound_linear_speed_reducer (abs_error, trigger_point, upper_bound, smallest_motor_power, highest_motor_power):

global base_speed

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

# samme som

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

motor_power = base_speed * (smallest_motor_power + (1- y) * (highest_motor_power - smallest_motor_power))

return motor_power

ellers:

returner base_speed * høyeste_motor_makt

run = False

forrige feil = 0

total_tid = 0,0

total_counts = 0

whileTrue:

# hvis du trykker på knapp a, begynner du å følge

hvis button_a.is_pressed ():

run = True

# men hvis du trykker på knapp b, stopp linjefølgeren

hvis button_b.is_pressed ():

run = False

integrert = 0,0

forrige feil = 0,0

display.scroll ('{} - {}'. format (total_tid, totalt_tall), forsinkelse = 100, vent = usant)

total_tid = 0,0

total_counts = 0

pixels_off ()

Stoppe()

sleep_ms (500)

if run isTrue:

# les linjesensorene

start_time = ticks_us ()

# sjekk om vi har oppdatert Kp/Kd -gevinstene med en fjernkontroll

prøve:

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

set_eyes ()

exceptTypeError:

sende

høyre, venstre = lesesensor (LINE_SENSOR, BÅDE)

# linje er til venstre når posisjon <0,5

# linje er til høyre når posisjon> 0,5

# linje er i midten når posisjon = 0,5

# det er et vektet aritmetisk gjennomsnitt

prøve:

posisjon = høyre /flyte (venstre + høyre)

unntatt ZeroDivisionError:

posisjon = 0,5

hvis posisjon == 0: posisjon = 0,001

hvis posisjon == 1: posisjon = 0,999

# bruk en PD -kontroller

feil = posisjon - settpunkt

integral += feil

korreksjon = Kp * feil + Ki * integral + Kd * (feil - forrige feil)

previous_error = feil

# beregne motorhastigheter

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

leftMotorSpeed = motor_speed + korreksjon

rightMotorSpeed = motor_speed - korreksjon

# lys opp neopikslene for å vise hvilken retning GiggleBot må gå

hvis run_neopixels isTrueand total_counts %3 == 0:

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

neo = (0, 0, 0)

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

ifabs (feil)> error_width_per_pixel * i:

hvis feil <0:

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

ellers:

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

ellers:

prosent = 1- (error_width_per_pixel * i -abs (error)) / error_width_per_pixel

# lys opp gjeldende piksel

hvis feil <0:

# neo [center_pixel + i] = tuple (kart (lambda x: int (x * prosent), turkis))

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

ellers:

# neo [center_pixel - i] = tuple (kart (lambda x: int (x * prosent), turkis))

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

gå i stykker

neo.show ()

prøve:

# klipp motorene

hvis venstreMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - venstreMotorSpeed +100

hvis rett MotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - høyreMotorSpeed +100

hvis venstreMotorSpeed <-100:

leftMotorSpeed = -100

hvis høyreMotorSpeed <-100:

rightMotorSpeed = -100

# aktiver motorene

set_speed (leftMotorSpeed, rightMotorSpeed)

kjøre()

# print ((feil, motorhastighet))

unntatt:

# i tilfelle vi kommer inn i et problem som ikke kan løses

sende

# og opprettholde sløyfefrekvensen

sluttid = ticks_us ()

delay_diff = (sluttid - starttid) /1000

total_tid += forsinkelses_forskjell

total_tall += 1

if1.0/ update_rate - delay_diff> 0:

hvilemodus (1.0/ update_rate - delay_diff)

vis rawgigglebot_line_follower_tuner.py hostet av ❤ av GitHub

Trinn 4: Sette opp tuneren (fjernkontroll)

Det neste vi må gjøre er å blinke runtime + scriptet til den andre BBC micro: bit. Denne andre mikro: bit vil fungere som en fjernkontroll til GiggleBot, som vil bli brukt til å stille inn følgende parametere:

1. Kp = proporsjonal forsterkning for PID -kontrolleren.
2. Ki = integrert forsterkning for PID -kontrolleren.
3. Kd = derivatforsterkning for PID -kontrolleren.
4. trigger_point = punktet uttrykt i prosent mellom minimum og maksimal hastighet på GiggleBot der hastigheten begynner å bli redusert lineært til den når minimumshastigheten.
5. min_speed_percent = minimumshastigheten uttrykt i prosent av maksimal hastighet.

De to andre gjenværende variablene som kan stilles inn er direkte hardkodet i skriptet som sitter på GiggleBot: oppdateringshastigheten og basishastigheten som representerer maksimal hastighet. Som beskrevet i dokumentasjonen er maksimal hastighet som kan angis for GiggleBot 100, som også er standardverdien for vår GiggleBot.

Merk: Følgende skript kan mangle mellomrom, og dette ser ut til å skyldes et problem med visning av GitHub Gists. Klikk på essensen for å ta deg til GitHub-siden der du kan kopiere og lime inn koden.

GiggleBot Remote PID Line Follower Tuner (krever den andre delen) - xjfls23

fra mikrobitimport*

fra utime import sleep_ms

importere radio

import ustruct

# 1. element er Kp -gevinsten

# 2. element er Ki -gevinsten

# 3. element er Kd -gevinsten

# 4. element er trigger_point for motorer for å senke hastigheten (0 -> 1)

# 5. element er minhastigheten for motorer uttrykt i prosent (0 -> 1)

gevinster = [0.0, 0.0, 0.0, 1.0, 0.0]

stepSize = 0,1

# 0 og 1 for første element

# 2 og 3 for 2. element

currentSetting = 0

defshowMenu ():

display.scroll ('{} - {}'. format (currentSetting, gevinster [int (currentSetting /2)]), forsinkelse = 100, vent = usant)

radio.on ()

showMenu ()

whileTrue:

oppdatert = Feil

hvis button_a.is_pressed ():

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

updated = True

hvis button_b.is_pressed ():

hvis currentSetting %2 == 0:

# øk gevinst når nåværende innstilling er 0 eller 2 eller..

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

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

ellers:

gevinster [int (currentSetting /2)] += stepSize

ellers:

# øk gevinst når nåværende innstilling er 1 eller 3 eller..

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

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

ellers:

gevinster [int (currentSetting /2)] -= stepSize

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

updated = True

hvis oppdatert:

showMenu ()

sleep_ms (200)

vis rawgigglebot_line_follower_configurator.py hostet av ❤ av GitHub

Trinn 5: Tuning GiggleBot

Plasser GiggleBot på sporet, slå den på og la den løpe. I mellomtiden må du hele tiden sette den tilbake på sporet og stille gevinster/parametere med den andre BBC micro: bit som du holder i hånden.

For å starte GiggleBot, trykk på knapp A på GiggleBots BBC micro: bit og for å stoppe den og dermed tilbakestille tilstanden, trykk på knapp B.

På den eksterne BBC micro: bit vil et trykk på knapp A ta deg gjennom alle alternativene i menyen, og knapp B øker/reduserer den tilsvarende verdien. Det er som å stille klokken på en gammel bils dashbord. Alternativene er slik:

1. 0-1 alternativer er for Kp-gevinsten.
2. 2-3 alternativer er for Ki-gevinsten.
3. 4-5 alternativer er for Kd-gevinsten.
4. 6-7 alternativer er for å stille inn settpunktet for øyeblikket når motorene begynner å bremse.
5. 8-9 alternativer er for å stille inn minimumshastigheten.

Husk at partall i menyen er for å øke de tilsvarende verdiene, og for de merkelige er det akkurat det motsatte.

Når du trykker på knapp B på GiggleBots BBC micro: bit, vil du på Neopixel -laget skjerm se antall forløpte millisekunder siden siste tilbakestilling og antall sykluser som roboten har gjennomgått - med disse 2 kan du beregne oppdateringshastigheten til roboten.

Til slutt og viktigst av alt, har jeg kommet opp med 2 tuninger for GiggleBot. En av dem er for når Neopixel -lysdiodene er slått av, og den andre er for når det er noe annet. Neopixel -lysdiodene brukes til å vise i hvilken retning feilen har samlet seg.

Første sett med innstilling av parametrene (med NeoPixel -lysdioder av)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0,3 (som er 30%)
5. min_speed_percent = 0,2 (som er 20%)
6. base_speed = 100 (aka maksimal hastighet)
7. update_rate = 70 (kjører @70Hz)

Andre sett med justering av parametrene (med NeoPixel -lysdiodene på)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0,3 (som er 30%)
5. min_speed_percent = 0,3 (som er 30%)
6. base_speed = 70 (aka maksimal hastighet)
7. update_rate = 50 (kjører @50Hz)
8. Variabel run_neopixels må også settes til True i skriptet som lastes på GiggleBots BBC micro: bit. Dette vil få NeoPixel -lysdiodene til å blinke på en slik måte at de indikerer i hvilken retning feilen akkumuleres.

Trinn 6: GiggleBot som kjører med NeoPixels slått av

Dette er et eksempel på hvordan du kjører GiggleBot med de første tuningparametrene som ble funnet i forrige trinn. I dette eksempelet er NeoPixel -lysdiodene slått av.

Trinn 7: GiggleBot som kjører med Neopixels slått på

Dette er et eksempel på hvordan du kjører GiggleBot med det andre settet med tuningparametere som ble funnet i trinn 5. Dette eksemplet har NeoPixel -lysdiodene slått på.

Legg merke til hvordan GiggleBot i dette eksemplet har det vanskeligere å følge linjen - det er fordi Neopixel -LEDene "spiser" CPU -tiden til BBC micro: bit. Derfor måtte vi redusere oppdateringshastigheten fra 70 ned til 50.