Innholdsfortegnelse:
2025 Forfatter: John Day | [email protected]. Sist endret: 2025-01-13 06:58
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:
- x3 AA -batterier - i mitt tilfelle bruker jeg oppladbare batterier som har en lavere spenning totalt.
- En Dexter Industries GiggleBot -robot for micro: bit.
- 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.