GiggleBot Line -følger med Python: 5 trinn

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

Denne gangen programmerer vi i MicroPython Dexter Industries GiggleBot for å følge en svart linje ved hjelp av den innebygde linjefølgersensoren.

GiggleBot må kobles til en BBC micro: bit for at den skal kunne kontrolleres på riktig måte.

Hvis denne opplæringen er for avansert for deg og programmering av GiggleBot er for mye for nå, kan du alltid gå gjennom startopplæringen som viser deg hvordan roboten kan programmeres i MakeCode her. Den koblede opplæringen vil lede deg gjennom det grunnleggende.

Trinn 1: Nødvendige komponenter

Følgende maskinvarekomponenter kreves:

1. x3 AA -batterier - i mitt tilfelle bruker jeg oppladbare batterier som har en lavere spenning totalt.
2. En Dexter Industries GiggleBot -robot for micro: bit.
3. En BBC micro: bit.

Selvfølgelig trenger du også en mikro -USB -kabel for å programmere BBC micro: bit - denne kabelen kommer vanligvis i pakken til BBC micro: bit, eller du kan alltid bruke en som brukes til lading av (Android) smarttelefoner.

Få GiggleBot for micro: bit her

Trinn 2: Sett opp sporene

Du må gå gjennom å skrive ut noen fliser og designe dine egne spor. Du kan bruke våre egne fliser slik at du er 100% sikker på at du replikerer betingelsene våre. Eller hvis du føler deg eventyrlysten, kan du bruke litt svart tape og lage din egen. Her er PDF -filen for flisene vi har brukt.

Sporet ovenfor består av følgende antall forskjellige fliser:

• 12 fliser av type #1.
• 5 fliser av type #2.
• 3 maler av flis type #5.
• 3 maler av flisetype #6 - her vil du ende opp med en ekstra flis.

Deretter skriver du ut dem og klipper dem. Prøv å plassere dem som på bildet ovenfor, og husk at på høyre overside av sporet må to fliser overlappe hverandre med hverandre - dette forventes hvis du lurer på om du gjør noe galt.

Trinn 3: Sette opp miljøet

For at du skal kunne programmere BBC micro: bit i MicroPython, må du sette opp en editor for den (Mu Editor) og angi GiggleBot MicroPython Runtime som kjøretid. For det må du følge instruksjonene på denne siden. Fra nå av brukes versjon v0.4.0 av kjøretiden.

Trinn 4: Programmering av GiggleBot

Før du går i gang, inneholder GiggleBot MicroPython -kjøretiden den klassiske kjøretiden for BBC micro: bit og andre biblioteker for å støtte GiggleBot og andre Dexter Industries Sensors.

Etter at du har konfigurert det, åpner du følgende skript i Mu -editoren og klikker på Flash. Dette vil blinke GiggleBot MicroPython Runtime og skriptet du nettopp har åpnet for BBC micro: bit. Manuset er også vist nedenfor.

Når den blinkende prosessen er ferdig, stabler du BBC micro: bit inn i GiggleBot med brettets neopiksler vendt fremover, plasserer den på sporet og slår den på.

Legg merke til at i skriptet er PID og andre 2 konstanter (hastighetssettpunktet og minimumshastighetskonstantene) allerede angitt.

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 - Tunet m/ NeoPixels

fra mikrobitimport*

fra gigglebot import*

fra utime import sleep_ms, ticks_us

import ustruct

# initialiser GB neopiksler

neo = init ()

# timing

update_rate = 50

# gevinster/konstanter (forutsatt at batterispenningen er rundt 4,0 volt)

Kp = 25,0

Ki = 0,5

Kd = 35,0

trigger_point = 0,3

min_hastighet_prosent = 0,3

base_speed = 70

settpunkt = 0,5

siste_posisjon = settpunkt

integrert = 0,0

run_neopixels = Sant

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

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

pixels_off ()

Stoppe()

sleep_ms (500)

if run isTrue:

# les linjesensorene

start_time = ticks_us ()

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

# området må være (0, 1) og ikke [0, 1]

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 i henhold til den angitte feilen

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] = turkis

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

ellers:

# neo [center_pixel - i] = turkis

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

ellers:

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

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

gå i stykker

neo.show ()

prøve:

# klipp motorhastighetene

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

if1000.0/ update_rate - delay_diff> 0:

sove (1000.0/ oppdateringshastighet - forsinkelses_differanse)

vis rawgigglebot_tuned_line_follower.py hostet av ❤ av GitHub

Trinn 5: La det kjøre

Det er 2 knapper på BBC micro: bit: knapp A og knapp B:

• Hvis du trykker på knappen A, settes GiggleBot til å følge linjen (hvis det er en).
• Ved å trykke på knapp B stopper GiggleBot og tilbakestiller alt slik at du kan bruke den igjen.

Det anbefales på det sterkeste å ikke løfte GiggleBot mens den følger en linje og deretter sette den tilbake på den fordi feilen som beregner kan akkumulere og ødelegge robotens rute totalt. Hvis du vil løfte den, trykker du på knapp B og deretter når du setter den tilbake, trykker du på A igjen.