GiggleBot Line Follower mit Python - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:18

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:

1. x3 AA-Batterien - in meinem Fall verwende ich wiederaufladbare Batterien, die insgesamt eine niedrigere Spannung haben.
2. Ein GiggleBot-Roboter von Dexter Industries für das micro:bit.
3. 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.