GiggleBot Line Follower Brug af Python: 5 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:27

Denne gang programmerer vi i MicroPython Dexter Industries GiggleBot til at følge en sort linje ved hjælp af sin indbyggede line follower sensor.

GiggleBot skal parres med en BBC micro: bit for at den kan kontrolleres korrekt.

Hvis denne vejledning er for avanceret til dig, og programmering af GiggleBot er for meget for nu, kan du altid gennemgå startstudiet, der viser dig, hvordan robotten kan programmeres i MakeCode her. Den sammenkædede vejledning vil guide dig gennem det grundlæggende.

Trin 1: Påkrævede komponenter

Følgende hardwarekomponenter er påkrævet:

1. x3 AA -batterier - i mit tilfælde bruger jeg genopladelige batterier, der generelt har en lavere spænding.
2. En Dexter Industries GiggleBot -robot til micro: bit.
3. En BBC micro: bit.

Selvfølgelig har du også brug for et mikro -USB -kabel til at programmere BBC micro: bit - dette kabel kommer generelt inden for BBC micro: bit's pakke, eller du kan altid bruge et, der bruges til opladning (Android) smartphones.

Få GiggleBot til micro: bit her

Trin 2: Konfigurer sporene

Du bliver nødt til at gå igennem at udskrive nogle fliser og designe dine egne spor. Du kan bruge vores egne fliser, så du er 100% sikker på, at du replikerer vores betingelser. Eller hvis du føler dig eventyrlysten, kan du bruge lidt sort tape og lave din egen. Her er PDF'en for de fliser, vi har brugt.

Ovenstående spor består af følgende antal forskellige fliser:

• 12 fliser af type #1.
• 5 fliser af type #2.
• 3 skabeloner af flisetype #5.
• 3 skabeloner af flisetype #6 - her ender du med en ekstra flise.

Derefter skal du udskrive dem og klippe dem. Prøv at placere dem som på ovenstående foto, og husk på, at på den øverste højre side af sporet skal 2 fliser overlappe den ene med den anden - dette forventes, hvis du undrer dig over, om du gør noget forkert.

Trin 3: Opsætning af miljøet

For at du skal kunne programmere BBC micro: bit i MicroPython, skal du oprette en editor til den (Mu Editor) og indstille GiggleBot MicroPython Runtime som dens runtime. Til det skal du følge instruktionerne på denne side. Fra dette øjeblik bruges version v0.4.0 af runtime.

Trin 4: Programmering af GiggleBot

Inden GiggleBot MicroPython -runtime indeholder den klassiske runtime for BBC micro: bit og andre biblioteker til understøttelse af GiggleBot og andre Dexter Industries Sensors.

Når du har konfigureret det, skal du åbne følgende script i Mu -editoren og klikke på Flash. Dette vil blinke GiggleBot MicroPython Runtime og det script, du lige har åbnet for din BBC micro: bit. Scriptet er også vist herunder.

Når den blinkende proces er udført, skal du stable BBC micro: bit i GiggleBot med brættets neopixel fremad, placere den på banen og tænde den.

Bemærk, at i scriptet er PID og andre 2 konstanter (hastighedsindstillingsværdien og minimumshastighedskonstanterne) allerede indstillet.

Bemærk: Følgende script mangler muligvis mellemrum, og det ser ud til at skyldes et problem med visning af GitHub Gists. Klik på kernen for at tage dig til dens GitHub-side, hvor du kan kopiere og indsætte koden.

GiggleBot PID Line Follower - Tunet m/ NeoPixels

fra mikrobitimport*

fra gigglebot import*

fra utime import sleep_ms, ticks_us

import ustruct

# initialiser GB neopixels

neo = init ()

# timing

opdateringsrate = 50

# gevinster/konstanter (forudsat at batterispændingen er omkring 4,0 volt)

Kp = 25,0

Ki = 0,5

Kd = 35,0

trigger_point = 0,3

min_hastighed_procent = 0,3

base_hastighed = 70

setpunkt = 0,5

sidste_position = setpunkt

integral = 0,0

run_neopixels = Sandt

center_pixel = 5#, hvor smilets midterpixel er placeret på GB

# turkis = tupel (kort (lambda x: int (x / 5), (64, 224, 208))) # farve, der skal bruges til at tegne fejlen med neopixel

# turkis = (12, 44, 41) # hvilket er præcis ovenstående turkis kommenteret over dette

error_width_per_pixel = 0,5/3# max fejl divideret med antallet af segmenter mellem hver neopixel

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

global base_hastighed

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 = basis_hastighed * (mindste_motor_power + (1- y) * (højeste_motor_power - mindste_motor_power))

return motor_power

andet:

returner base_hastighed * højeste_motor_kraft

løb = Falsk

foregående_fejl = 0

whileTrue:

# hvis der trykkes på knappen a, skal du begynde at følge

hvis button_a.is_pressed ():

run = True

# men hvis der trykkes på knap b, stop linjefølgeren

hvis button_b.is_pressed ():

løb = Falsk

integral = 0,0

foregående_fejl = 0.0

pixels_off ()

hold op()

sleep_ms (500)

hvis kørsel er sandt:

# læs linjesensorerne

start_time = ticks_us ()

højre, venstre = læs_sensor (LINE_SENSOR, BÅDE)

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

# linje er til højre, når position> 0,5

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

# det er et vægtet aritmetisk middel

prøve:

position = højre /flyde (venstre + højre)

undtagenZeroDivisionError:

position = 0,5

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

hvis position == 0: position = 0,001

hvis position == 1: position = 0,999

# brug en PD -controller

fejl = position - setpunkt

integral += fejl

korrektion = Kp * fejl + Ki * integral + Kd * (fejl - foregående_fejl)

previous_error = fejl

# beregne motorhastigheder

motor_speed = upper_bound_linear_speed_reducer (abs (fejl), setpunkt * trigger_point, setpunkt, min_hastighed_procent, 1,0)

leftMotorSpeed = motor_speed + korrektion

rightMotorSpeed = motor_speed - korrektion

# tænde neopixel i henhold til den givne fejl

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 (fejl)> error_width_per_pixel * i:

hvis fejl <0:

# neo [center_pixel + i] = turkis

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

andet:

# neo [center_pixel - i] = turkis

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

andet:

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

# tænde den aktuelle pixel

hvis fejl <0:

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

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

andet:

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

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

pause

neo.show ()

prøve:

# klip motorhastighederne

hvis venstreMotorSpeed> 100:

leftMotorSpeed = 100

højreMotorSpeed = højreMotorSpeed - venstreMotorSpeed +100

hvis rightMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = venstreMotorSpeed - højreMotorSpeed +100

hvis venstreMotorSpeed <-100:

leftMotorSpeed = -100

hvis rightMotorSpeed <-100:

rightMotorSpeed = -100

# aktiver motorerne

set_speed (venstreMotorSpeed, højreMotorSpeed)

køre()

# print ((fejl, motorhastighed))

undtagen:

# i tilfælde af at vi kommer ind i et uopretteligt problem

passere

# og opretholde sløjfrekvensen

end_time = ticks_us ()

delay_diff = (end_time - start_time) /1000

if1000.0/ update_rate - delay_diff> 0:

sleep (1000.0/ update_rate - delay_diff)

se rawgigglebot_tuned_line_follower.py hostet af ❤ af GitHub

Trin 5: Lad det køre

Der er 2 knapper på BBC micro: bit: knap A og knap B:

• Ved at trykke på knappen A indstilles GiggleBot til at følge linjen (hvis der er en).
• Ved at trykke på knappen B stopper GiggleBot og nulstiller alt, så du kan bruge det igen.

Det anbefales stærkt ikke at løfte GiggleBot, mens den følger en linje og derefter sætte den tilbage på den, fordi den fejl, der beregnes, kan akkumulere og totalt ødelægge robotens rute. Hvis du vil løfte den, skal du trykke på knappen B og derefter trykke på A igen, når du sætter den tilbage.