Inhoudsopgave:
2025 Auteur: John Day | [email protected]. Laatst gewijzigd: 2025-01-13 06:57
Deze keer programmeren we in MicroPython de Dexter Industries GiggleBot om een zwarte lijn te volgen met behulp van de ingebouwde lijnvolgersensor.
De GiggleBot moet worden gekoppeld aan een BBC micro:bit om op de juiste manier te kunnen worden bestuurd.
Als deze tutorial te geavanceerd voor je is en het programmeren van de GiggleBot voor nu te veel is, kun je altijd de starterstutorial doorlopen die je laat zien hoe de robot kan worden geprogrammeerd in MakeCode hier. De gekoppelde zelfstudie leidt u door de basisprincipes.
Stap 1: Vereiste componenten
De volgende hardwarecomponenten zijn vereist:
- x3 AA-batterijen - in mijn geval gebruik ik oplaadbare batterijen die over het algemeen een lagere spanning hebben.
- Een Dexter Industries GiggleBot-robot voor de micro:bit.
- Een BBC-micro:bit.
Natuurlijk heb je ook een micro-USB-kabel nodig om de BBC micro:bit te programmeren - deze kabel zit meestal in het BBC micro:bit-pakket of je kunt er altijd een gebruiken die wordt gebruikt voor het opladen van (Android-)smartphones.
Download hier de GiggleBot voor de micro:bit
Stap 2: Stel de sporen in
Je zult een aantal tegels moeten printen en je eigen tracks moeten ontwerpen. U kunt onze eigen tegels gebruiken, zodat u 100% zeker weet dat u onze voorwaarden repliceert. Of als je avontuurlijk bent, kun je wat zwarte tape gebruiken en er zelf een maken. Hier is de PDF voor de tegels die we hebben gebruikt.
Het bovenstaande spoor bestaat uit het volgende aantal verschillende tegels:
- 12 tegels van het type #1.
- 5 tegels van het type #2.
- 3 sjablonen van tegeltype #5.
- 3 sjablonen van tegeltype #6 - hier krijg je een extra tegel.
Druk ze vervolgens af en knip ze uit. Probeer ze te plaatsen zoals op de bovenstaande foto en houd er rekening mee dat aan de rechterbovenkant van de baan 2 tegels elkaar moeten overlappen - dit wordt verwacht voor het geval je je afvraagt of je iets verkeerd doet.
Stap 3: De omgeving instellen
Om de BBC micro:bit in MicroPython te kunnen programmeren, moet je er een editor voor instellen (de Mu Editor) en de GiggleBot MicroPython Runtime als runtime instellen. Daarvoor moet je de instructies op deze pagina volgen. Vanaf dit moment wordt versie v0.4.0 van de runtime gebruikt.
Stap 4: De GiggleBot programmeren
Voordat we ermee aan de slag gaan, bevat de GiggleBot MicroPython-runtime de klassieke runtime voor de BBC micro:bit en andere bibliotheken om de GiggleBot en andere Dexter Industries-sensoren te ondersteunen.
Nadat je het hebt ingesteld, open je het volgende script in de Mu-editor en klik je op Flash. Hiermee flitst de GiggleBot MicroPython Runtime en het script dat je zojuist hebt geopend voor je BBC micro:bit. Het script wordt ook hieronder weergegeven.
Zodra het knipperen is voltooid, stapelt u de BBC micro:bit in de GiggleBot met de neopixels van het bord naar voren gericht, plaatst u deze op de baan en schakelt u hem in.
Merk op dat in het script de PID en andere 2 constanten (het toerentalsetpoint en minimum toerentalconstanten) al zijn ingesteld.
Opmerking: het volgende script bevat mogelijk ontbrekende spaties en dit lijkt te wijten te zijn aan een probleem bij het weergeven van GitHub Gists. Klik op de kern om naar de GitHub-pagina te gaan waar u de code kunt kopiëren en plakken.
GiggleBot PID-lijnvolger - afgestemd met NeoPixels
| van microbit-import* |
| van gigglebot-import* |
| van utime import sleep_ms, ticks_us |
| import ustruct |
| # initialiseer GB neopixels |
| neo = init() |
| # timing |
| update_rate = 50 |
| # versterkingen/constanten (ervan uitgaande dat de batterijspanning ongeveer 4,0 volt is) |
| Kp = 25.0 |
| Ki = 0,5 |
| Kd = 35.0 |
| trigger_point =0.3 |
| min_speed_percent =0.3 |
| basissnelheid = 70 |
| instelpunt =0.5 |
| last_position = instelpunt |
| integraal =0.0 |
| run_neopixels =True |
| center_pixel =5# waar de middelste pixel van de glimlach zich op de GB bevindt |
| # turkoois = tuple(map(lambda x: int(x / 5), (64, 224, 208))) # kleur die moet worden gebruikt om de fout met de neopixels te tekenen |
| # turkoois = (12, 44, 41) # wat precies de bovenstaande turkoois is die hierboven is becommentarieerd |
| error_width_per_pixel =0.5/3# max fout gedeeld door het aantal segmenten tussen elke neopixel |
| defupper_bound_linear_speed_reducer (abs_error, trigger_point, upper_bound, kleinste_motor_power, hoogste_motor_power): |
| globale basissnelheid |
| if 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) |
| # hetzelfde als |
| y = (abs_error - trigger_point) / (upper_bound - trigger_point) |
| motor_power = basis_snelheid * (kleinste_motor_power + (1- y) * (hoogste_motor_power - kleinste_motor_power)) |
| retour motor_power |
| anders: |
| return base_speed * hoogste_motor_power |
| uitvoeren =False |
| previous_error = 0 |
| whileTrue: |
| # als knop a wordt ingedrukt, begin dan met volgen |
| if button_a.is_pressed(): |
| rennen = True |
| # maar als knop b wordt ingedrukt, stop de lijnvolger |
| if button_b.is_pressed(): |
| uitvoeren =False |
| integraal =0.0 |
| vorige_fout =0.0 |
| pixels_off() |
| stop() |
| sleep_ms(500) |
| als uitvoeren waar is: |
| # lees de lijnsensoren |
| start_time = ticks_us() |
| rechts, links = read_sensor (LINE_SENSOR, BEIDE) |
| # lijn is aan de linkerkant wanneer positie < 0,5 |
| # lijn is aan de rechterkant wanneer positie > 0,5 |
| # lijn is in het midden wanneer positie = 0,5 |
| # het is een gewogen rekenkundig gemiddelde |
| proberen: |
| positie = rechts / zwevend (links + rechts) |
| behalveZeroDivisionError: |
| positie =0.5 |
| # het bereik moet (0, 1) zijn en niet [0, 1] |
| als positie ==0: positie =0.001 |
| als positie ==1: positie =0.999 |
| # gebruik een PD-controller |
| fout = positie - instelpunt |
| integraal += fout |
| correctie = Kp * fout + Ki * integraal + Kd * (fout - vorige_fout) |
| previous_error = fout |
| # bereken motorsnelheden |
| motor_speed = upper_bound_linear_speed_reducer(abs(error), setpoint * trigger_point, setpoint, min_speed_percent, 1.0) |
| leftMotorSpeed = motor_speed + correctie |
| rightMotorSpeed = motor_speed - correctie |
| # verlicht de neopixels volgens de gegeven fout |
| if run_neopixels isTrueand total_counts %3==0: |
| voor i inb'\x00\x01\x02\x03\x04\x05\x06\x07\x08': |
| neo = (0, 0, 0) |
| voor i inb'\x00\x01\x02\x03': |
| ifabs(fout) > error_width_per_pixel * i: |
| als fout <0: |
| # neo[center_pixel + i] = turkoois |
| neo[center_pixel + i] = (12, 44, 41) |
| anders: |
| # neo[center_pixel - i] = turkoois |
| neo[center_pixel + i] = (12, 44, 41) |
| anders: |
| procent = 1- (error_width_per_pixel * i -abs(error)) / error_width_per_pixel |
| # verlicht de huidige pixel |
| als fout <0: |
| # neo[center_pixel + i] = tuple(map(lambda x: int(x * percentage), turquoise)) |
| neo[center_pixel + i] = (int(64* procent /5), int(224* procent /5), int(208* procent /5)) |
| anders: |
| # neo[center_pixel - i] = tuple(map(lambda x: int(x * percentage), turquoise)) |
| neo[center_pixel - i] = (int(64* procent /5), int(224* procent /5), int(208* procent /5)) |
| pauze |
| neo.show() |
| proberen: |
| # clip de motorsnelheden |
| indien linksMotortoerental >100: |
| linkerMotorSnelheid = 100 |
| rechtsMotorSnelheid = rechtsMotorSnelheid - linksMotorSnelheid +100 |
| indien juistMotortoerental >100: |
| rechts MotorSnelheid = 100 |
| leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100 |
| indien linksMotorsnelheid <-100: |
| linkerMotorSnelheid =-100 |
| indien rechtsMotorsnelheid <-100: |
| rechtsMotorSnelheid =-100 |
| # activeer de motoren |
| set_speed (linksMotorSpeed, rechtsMotorSpeed) |
| rit() |
| # print((fout, motor_snelheid)) |
| behalve: |
| # voor het geval we in een onoplosbaar probleem komen |
| doorgang |
| # en behoud de lusfrequentie |
| end_time = ticks_us() |
| delay_diff = (eindtijd - begintijd) /1000 |
| if1000.0/ update_rate - delay_diff >0: |
| slaap (100.0/update_rate - delay_diff) |
bekijk rawgigglebot_tuned_line_follower.py gehost met ❤ door GitHub
Stap 5: Het laten lopen
Er zijn 2 knoppen op de BBC micro:bit: knop A en knop B:
- Door op knop A te drukken, laat de GiggleBot de lijn volgen (als die er is).
- Door op knop B te drukken stopt de GiggleBot en reset alles zodat je hem weer kunt gebruiken.
Het wordt ten zeerste aangeraden om de GiggleBot niet op te tillen terwijl hij een lijn volgt en hem er dan weer op te plaatsen, omdat de fout die wordt berekend zich kan ophopen en de route van de robot volledig kan verstoren. Als u hem wilt optillen, drukt u op knop B en als u hem weer terugplaatst, drukt u nogmaals op A.