Inhaltsverzeichnis:
2025 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2025-01-13 06:56
Dieses Mal programmieren wir in MicroPython den Dexter Industries GiggleBot so, dass er mit seinem eingebauten Linienfolgersensor einer schwarzen Linie folgt.
Der GiggleBot muss mit einem BBC micro:bit gepaart werden, damit er entsprechend gesteuert werden kann.
Wem dieses Tutorial zu fortgeschritten ist und das Programmieren des GiggleBot vorerst zu viel ist, kann jederzeit das Starter-Tutorial durchgehen, das Ihnen zeigt, wie der Roboter in MakeCode hier programmiert werden kann. Das verlinkte Tutorial führt Sie durch die Grundlagen.
Schritt 1: Erforderliche Komponenten
Folgende Hardwarekomponenten werden benötigt:
- x3 AA-Batterien - in meinem Fall verwende ich wiederaufladbare Batterien, die insgesamt eine niedrigere Spannung haben.
- Ein GiggleBot-Roboter von Dexter Industries für das micro:bit.
- Ein BBC micro:bit.
Natürlich benötigen Sie auch ein Micro-USB-Kabel, um das BBC micro:bit zu programmieren - dieses Kabel ist normalerweise im Lieferumfang des BBC micro:bit enthalten oder Sie können immer eines verwenden, das zum Laden von (Android-)Smartphones verwendet wird.
Holen Sie sich hier den GiggleBot für das micro:bit
Schritt 2: Einrichten der Spuren
Sie müssen einige Kacheln drucken und Ihre eigenen Spuren entwerfen. Sie können unsere eigenen Fliesen verwenden, so dass Sie 100% sicher sind, dass Sie unsere Bedingungen replizieren. Oder wenn Sie abenteuerlustig sind, können Sie ein schwarzes Klebeband verwenden und Ihr eigenes machen. Hier ist das PDF für die von uns verwendeten Kacheln.
Der obige Track besteht aus der folgenden Anzahl verschiedener Kacheln:
- 12 Kacheln vom Typ #1.
- 5 Kacheln vom Typ #2.
- 3 Vorlagen des Kacheltyps #5.
- 3 Vorlagen des Kacheltyps #6 - hier erhalten Sie eine zusätzliche Kachel.
Als nächstes drucken Sie sie aus und schneiden Sie sie aus. Versuchen Sie, sie wie auf dem obigen Foto zu platzieren, und denken Sie daran, dass sich auf der rechten oberen Seite der Schiene 2 Kacheln überlappen müssen - dies wird erwartet, falls Sie sich fragen, ob Sie etwas falsch machen.
Schritt 3: Einrichten der Umgebung
Damit Sie das BBC micro:bit in MicroPython programmieren können, müssen Sie dafür einen Editor (den Mu Editor) einrichten und als Laufzeit die GiggleBot MicroPython Runtime einstellen. Dazu müssen Sie den Anweisungen auf dieser Seite folgen. Ab diesem Zeitpunkt wird die Version v0.4.0 der Runtime verwendet.
Schritt 4: Programmierung des GiggleBot
Bevor es zur Sache geht, enthält die GiggleBot MicroPython-Laufzeit die klassische Laufzeit für das BBC micro:bit und andere Bibliotheken zur Unterstützung des GiggleBot und anderer Dexter Industries-Sensoren.
Öffnen Sie nach der Einrichtung das folgende Skript im Mu-Editor und klicken Sie auf Flash. Dadurch wird die GiggleBot MicroPython Runtime und das Skript, das Sie gerade geöffnet haben, für Ihr BBC micro:bit blinken. Das Skript wird auch unten angezeigt.
Sobald der Flash-Vorgang abgeschlossen ist, stapeln Sie das BBC micro:bit mit den Neopixeln des Boards nach vorne in den GiggleBot, legen Sie es auf die Schiene und schalten Sie es ein.
Beachten Sie, dass im Skript die PID und andere 2 Konstanten (der Drehzahlsollwert und die minimale Drehzahlkonstanten) bereits eingestellt sind.
Hinweis: Im folgenden Skript fehlen möglicherweise Leerzeichen, und dies scheint auf ein Problem bei der Anzeige von GitHub-Gists zurückzuführen zu sein. Klicken Sie auf das Wesentliche, um zur GitHub-Seite zu gelangen, auf der Sie den Code kopieren und einfügen können.
GiggleBot PID Line Follower - Abgestimmt mit NeoPixels
| aus Microbit-Import* |
| aus dem Gigglebot-Import* |
| aus utime importieren sleep_ms, ticks_us |
| ustruct importieren |
| # GB-Neopixel initialisieren |
| neo = init() |
| # zeitliche Koordinierung |
| update_rate =50 |
| # Verstärkungen/Konstanten (unter der Annahme, dass die Batteriespannung etwa 4,0 Volt beträgt) |
| Kp = 25,0 |
| Ki = 0,5 |
| Kd = 35,0 |
| trigger_point =0.3 |
| min_speed_percent =0,3 |
| base_speed =70 |
| Sollwert = 0,5 |
| last_position = Sollwert |
| integral =0.0 |
| run_neopixels = Wahr |
| center_pixel =5# wobei sich das mittlere Pixel des Lächelns auf dem GB befindet |
| # türkis = tuple(map(lambda x: int(x / 5), (64, 224, 208))) # Farbe um den Fehler mit den Neopixeln zu zeichnen |
| # türkis = (12, 44, 41) # das ist genau das obige Türkis, das darüber kommentiert wurde |
| error_width_per_pixel =0.5/3# max. Fehler geteilt durch die Anzahl der Segmente zwischen jedem Neopixel |
| defupper_bound_linear_speed_reducer(abs_error, trigger_point, upper_bound, kleinste_motor_power, höchste_motor_power): |
| globale base_speed |
| 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) |
| # gleich wie |
| y = (abs_error - trigger_point) / (upper_bound - trigger_point) |
| motor_power = base_speed * (kleinste_motor_power + (1- y) * (höchste_motor_power - kleinste_motor_power)) |
| Motorleistung zurückgeben |
| anders: |
| zurück base_speed * höchste_motor_power |
| laufen = falsch |
| vorheriger_Fehler =0 |
| whileTrue: |
| # wenn Taste a gedrückt wird, dann fang an zu folgen |
| if button_a.is_pressed(): |
| laufen = wahr |
| # aber wenn Taste b gedrückt wird, stoppen Sie den Linienfolger |
| if button_b.is_pressed(): |
| laufen = falsch |
| integral =0.0 |
| vorheriger_Fehler =0.0 |
| Pixel_off() |
| halt() |
| sleep_ms(500) |
| wenn run istTrue: |
| # die Zeilensensoren lesen |
| start_time = ticks_us() |
| rechts, links = read_sensor (LINE_SENSOR, BOTH) |
| # Zeile ist links, wenn Position < 0,5 |
| # Linie ist rechts, wenn Position > 0.5 |
| # Linie ist in der Mitte, wenn Position = 0.5 |
| # es ist ein gewichtetes arithmetisches Mittel |
| Versuchen: |
| Position = rechts / schweben (links + rechts) |
| außerZeroDivisionError: |
| Position = 0,5 |
| # der Bereich muss (0, 1) sein und nicht [0, 1] |
| wenn Position ==0: Position =0,001 |
| wenn Position ==1: Position =0,999 |
| # einen PD-Controller verwenden |
| Fehler = Position - Sollwert |
| integral += Fehler |
| Korrektur = Kp * Fehler + Ki * Integral + Kd * (Fehler - vorheriger_Fehler) |
| vorheriger_Fehler = Fehler |
| # Motordrehzahlen berechnen |
| motor_speed = upper_bound_linear_speed_reducer(abs(error), setpoint * trigger_point, setpoint, min_speed_percent, 1.0) |
| leftMotorSpeed = motor_speed + Korrektur |
| rightMotorSpeed = motor_speed - Korrektur |
| # leuchten die Neopixel entsprechend dem angegebenen Fehler |
| if run_neopixels isTrueund 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(error) > error_width_per_pixel * i: |
| wenn Fehler <0: |
| # neo[center_pixel + i] = türkis |
| neo[center_pixel + i] = (12, 44, 41) |
| anders: |
| # neo[center_pixel - i] = türkis |
| neo[center_pixel + i] = (12, 44, 41) |
| anders: |
| Prozent =1- (error_width_per_pixel * i -abs(error)) / error_width_per_pixel |
| # das aktuelle Pixel aufleuchten |
| wenn Fehler <0: |
| # neo[center_pixel + i] = tuple(map(lambda x: int(x * Prozentsatz), türkis)) |
| neo[center_pixel + i] = (int(64* Prozent /5), int(224* Prozent /5), int(208* Prozent /5)) |
| anders: |
| # neo[center_pixel - i] = tuple(map(lambda x: int(x * Prozent), türkis)) |
| neo[center_pixel - i] = (int(64* Prozent /5), int(224* Prozent /5), int(208* Prozent /5)) |
| brechen |
| neo.show() |
| Versuchen: |
| # beschneide die Motordrehzahlen |
| wenn leftMotorSpeed >100: |
| linkeMotorgeschwindigkeit =100 |
| rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100 |
| wenn rechtsMotorSpeed >100: |
| rechtsMotorSpeed =100 |
| leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100 |
| wenn leftMotorSpeed <-100: |
| leftMotorSpeed =-100 |
| wenn rechtMotorSpeed <-100: |
| rechtsMotorSpeed =-100 |
| # die Motoren ansteuern |
| set_speed(leftMotorSpeed, rightMotorSpeed) |
| Fahrt() |
| # print((Fehler, motor_speed)) |
| außer: |
| # falls wir auf ein nicht behebbares Problem stoßen |
| passieren |
| # und halten Sie die Schleifenfrequenz ein |
| 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) |
rawgigglebot_tuned_line_follower.py ansehen, gehostet mit ❤ von GitHub
Schritt 5: Lassen Sie es laufen
Es gibt 2 Tasten auf dem BBC micro:bit: Taste A und Taste B:
- Durch Drücken von Knopf A wird der GiggleBot so eingestellt, dass er der Linie folgt (sofern vorhanden).
- Ein Druck auf Taste B stoppt den GiggleBot und setzt alles zurück, damit Sie ihn wieder verwenden können.
Es wird dringend empfohlen, den GiggleBot nicht anzuheben, während er einer Linie folgt, und ihn dann wieder darauf zu setzen, da sich der berechnete Fehler ansammeln und die Route des Roboters völlig durcheinander bringen könnte. Wenn Sie es anheben möchten, drücken Sie auf Knopf B und dann, wenn Sie es zurücklegen, drücken Sie erneut A.