Innehållsförteckning:
2025 Författare: John Day | [email protected]. Senast ändrad: 2025-01-13 06:58
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:
- x3 AA -batterier - i mitt fall använder jag laddningsbara batterier som har en lägre spänning totalt.
- En Dexter Industries GiggleBot -robot för micro: bit.
- 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.