GiggleBot -linjeföljare med Python: 5 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:44

Den här gången programmerar vi i MicroPython Dexter Industries GiggleBot för att följa en svart linje med sin inbyggda linjeföljarsensor.

GiggleBot måste kopplas ihop med en BBC micro: bit för att den ska kunna styras på lämpligt sätt.

Om denna handledning är för avancerad för dig och programmering av GiggleBot är för mycket för nu kan du alltid gå igenom starthandledningen som visar hur roboten kan programmeras i MakeCode här. Den länkade självstudien leder dig genom de grundläggande grunderna.

Steg 1: Obligatoriska komponenter

Följande hårdvarukomponenter krävs:

1. x3 AA -batterier - i mitt fall använder jag laddningsbara batterier som har en lägre spänning totalt.
2. En Dexter Industries GiggleBot -robot för micro: bit.
3. En BBC micro: bit.

Naturligtvis behöver du också en mikro -USB -kabel för att programmera BBC micro: bit - den här kabeln ingår vanligtvis i BBC micro: bit -paketet eller så kan du alltid använda en som används för att ladda (Android) smartphones.

Få GiggleBot för micro: bit här

Steg 2: Konfigurera spåren

Du måste skriva ut några brickor och designa dina egna spår. Du kan använda våra egna plattor så att du är 100% säker på att du replikerar våra villkor. Eller om du känner dig äventyrlig kan du använda lite svart tejp och göra din egen. Här är PDF -filen för brickorna vi har använt.

Ovanstående spår består av följande antal olika brickor:

• 12 brickor av typ #1.
• 5 brickor av typ #2.
• 3 mallar av kakel typ #5.
• 3 mallar av kakel typ #6 - här får du en extra kakel.

Skriv sedan ut dem och klipp ut dem. Prova att placera dem som på bilden ovan och tänk på att på högra ovansidan av banan måste två brickor överlappa en med varandra - detta förväntas om du undrar om du gör något fel.

Steg 3: Konfigurera miljön

För att du ska kunna programmera BBC micro: bit i MicroPython måste du ställa in en editor för den (Mu Editor) och ställa in GiggleBot MicroPython Runtime som dess körtid. För det måste du följa instruktionerna på den här sidan. Från och med nu används version v0.4.0 av körtiden.

Steg 4: Programmering av GiggleBot

Innan GiggleBot MicroPython runtime innehåller den klassiska körtiden för BBC micro: bit och andra bibliotek för att stödja GiggleBot och andra Dexter Industries Sensors.

När du har konfigurerat det öppnar du följande skript i Mu -redigeraren och klickar på Flash. Detta kommer att blinka GiggleBot MicroPython Runtime och skriptet du just har öppnat för din BBC micro: bit. Manuset visas också nedan.

När den blinkande processen är klar, stapla BBC micro: bit in i GiggleBot med brädans neopixlar framåt, placera den på spåret och slå på den.

Lägg märke till att i skriptet är PID och andra 2 konstanter (hastighetsbörvärdet och minimihastighetskonstanterna) redan inställda.

Obs! Följande skript kan sakna blanksteg och detta verkar bero på problem med visning av GitHub -listor. Klicka på kärnan för att ta dig till dess GitHub-sida där du kan kopiera och klistra in koden.

GiggleBot PID Line Follower - Tuned w/ NeoPixels

från mikrobitimport*

från gigglebot import*

från utime import sleep_ms, ticks_us

importera struktur

# initiera GB neopixlar

neo = init ()

# timing

update_rate = 50

# förstärkning/konstant (förutsatt att batterispänningen är cirka 4,0 volt)

Kp = 25,0

Ki = 0,5

Kd = 35,0

trigger_point = 0,3

min_hastighet_procent = 0,3

bashastighet = 70

börvärde = 0,5

last_position = börvärde

integral = 0,0

run_neopixels = Sant

center_pixel = 5# där leppets mittpixel finns på GB

# turkos = tupel (karta (lambda x: int (x / 5), (64, 224, 208))) # färg att använda för att rita felet med neopixlarna

# turkos = (12, 44, 41) # vilket är exakt den ovan turkosa kommenterade ovanför detta

error_width_per_pixel = 0,5/3# max fel dividerat med antalet segment mellan varje neopixel

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

global bas_hastighet

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

# samma som

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

motor_kraft = bashastighet * (minsta_motor_kraft + (1- y) * (högsta_motor_kraft - minsta_motor_kraft))

return motor_power

annan:

returnera bashastighet * högsta_motor_kraft

kör = falskt

föregående_fel = 0

whileTrue:

# om knappen a trycks in börjar du följa

if button_a.is_pressed ():

kör = Sant

# men om knappen b trycks in, stoppa linjeföljaren

om button_b.is_pressed ():

kör = falskt

integral = 0,0

föregående_fel = 0,0

pixlar_off ()

sluta()

sleep_ms (500)

if run isTrue:

# läs linjesensorerna

start_time = ticks_us ()

höger, vänster = läs_sensor (LINE_SENSOR, BÅDE)

# rad är till vänster när position <0,5

# linje är till höger när position> 0,5

# linje är i mitten när position = 0,5

# det är ett vägat aritmetiskt medelvärde

Prova:

position = höger /flyt (vänster + höger)

utomZeroDivisionError:

position = 0,5

# intervallet måste vara (0, 1) och inte [0, 1]

om position == 0: position = 0,001

om position == 1: position = 0,999

# använd en PD -controller

fel = position - börvärde

integral += fel

korrigering = Kp * fel + Ki * integral + Kd * (fel - föregående_fel)

previous_error = fel

# beräkna motorvarvtal

motor_speed = upper_bound_linear_speed_reducer (abs (fel), börvärde * trigger_point, börvärde, min_hastighet_procent, 1.0)

leftMotorSpeed = motor_speed + korrigering

rightMotorSpeed = motor_speed - korrigering

# tänd neopixlarna enligt det angivna felet

om run_neopixels isTrueand total_counts %3 == 0:

för i inb '\ x00 / x01 / x02 / x03 / x04 / x05 / x06 / x07 / x08':

neo = (0, 0, 0)

för i inb '\ x00 / x01 / x02 / x03':

ifabs (fel)> error_width_per_pixel * i:

om fel <0:

# neo [center_pixel + i] = turkos

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

annan:

# neo [center_pixel - i] = turkos

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

annan:

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

# tända den aktuella pixeln

om fel <0:

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

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

annan:

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

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

ha sönder

neo.show ()

Prova:

# klipp motorns varvtal

om kvar MotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

om rätt MotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

if leftMotorSpeed <-100:

leftMotorSpeed = -100

om rätt MotorSpeed <-100:

rightMotorSpeed = -100

# aktivera motorerna

set_speed (leftMotorSpeed, rightMotorSpeed)

kör()

# print ((fel, motorhastighet))

bortsett från:

# om vi skulle hamna i något oföränderligt problem

passera

# och behåll loopfrekvensen

end_time = ticks_us ()

delay_diff = (end_time - start_time) /1000

if1000.0/ update_rate - delay_diff> 0:

sömn (1000,0/ update_rate - delay_diff)

visa rawgigglebot_tuned_line_follower.py värd med ❤ av GitHub

Steg 5: Låt det köra

Det finns 2 knappar på BBC micro: bit: knapp A och knapp B:

• Genom att trycka på knappen A ställs GiggleBot in för att följa linjen (om det finns en).
• Genom att trycka på knappen B stoppas GiggleBot och återställer allt så att du kan använda den igen.

Det rekommenderas starkt att inte lyfta GiggleBot medan den följer en linje och sedan sätta tillbaka den på den eftersom felet som beräknas kan ackumuleras och helt förstöra robotens väg. Om du vill lyfta den trycker du på knappen B och sedan när du sätter tillbaka den trycker du på A igen.