Tuning des GiggleBot Line Follower - Fortgeschritten - Gunook

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

In diesem sehr kurzen Instructables werden Sie Ihren eigenen GiggleBot so einstellen, dass er einer schwarzen Linie folgt. In diesem anderen Tutorial GiggleBot Line Follower haben wir die Tuning-Werte fest codiert, um gemäß diesem Szenario zu funktionieren. Vielleicht möchten Sie, dass es sich besser verhält, indem Sie sich andere Vorteile einfallen lassen.

In diesem Tutorial zeigen wir Ihnen 2 Skripte, die beide auf verschiedene BBC micro:bits geladen werden können, so dass eines davon in den GiggleBot gelegt wird und mit dem anderen die 2 Tasten verwendet werden, um durch ein Menü zu gehen und anders zu stimmen Parameter. Das Senden dieser aktualisierten Parameter erfolgt über das Funkgerät.

Schritt 1: Erforderliche Komponenten

Sie benötigen Folgendes:

1. Ein GiggleBot-Roboter für das micro:bit.
2. x3 AA-Batterien
3. x2 BBC micro:bits - eines für den GiggleBot und das andere als Fernbedienung zum Einstellen von Parametern.
4. Eine Batterie für ein BBC micro:bit - wie die, die im BBC micro:bit-Paket enthalten ist.

Holen Sie sich hier den GiggleBot-Roboter für das BBC micro:bit

Schritt 2: Einrichten der Spuren und Umgebung

Sie müssen auch Ihre Tracks erstellen (Kacheln herunterladen, drucken, ausschneiden und aufzeichnen) und dann die Umgebung (die IDE und die Laufzeit) einrichten.

Da dieses Tutorial sehr verwandt mit diesem anderen Tutorial mit dem Titel GiggleBot Line Follower ist, gehen Sie einfach dorthin und folgen Sie den Schritten 2 und 3 und kommen Sie dann hierher zurück.

Für die IDE können Sie den Mu-Editor verwenden und für die Laufzeit müssen Sie die GiggleBot MicroPython-Laufzeit herunterladen. Die Runtime kann hier aus ihrer Dokumentation heruntergeladen werden. Gehen Sie zum Kapitel Erste Schritte der Dokumentation und befolgen Sie diese Anweisungen zum Einrichten der Umgebung. Ab diesem Zeitpunkt wird die Version v0.4.0 der Runtime verwendet.

Schritt 3: Einrichten des GiggleBot

Bevor Sie die Laufzeit auf den GiggleBot flashen, stellen Sie sicher, dass Sie Ihre gewünschte Geschwindigkeit und Aktualisierungsrate für den GiggleBot ausgewählt haben: Standardmäßig ist die Geschwindigkeit auf 100 (base_speed-Variable) und die Aktualisierungsrate auf 70 (update_rate-Variable) eingestellt.

Bei der aktuellen Implementierung beträgt die höchste erreichbare Aktualisierungsrate 70, und wenn run_neopixels auf True gesetzt ist, sind nur 50 erreichbar. In gewisser Weise könnte man also sagen, dass die Standardaktualisierungsrate am Rande dessen liegt, was das BBC micro:bit kann.

Nur fürs Protokoll kann der Linienfolgersensor 100 Mal pro Sekunde Updates zurückgeben.

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 Tuner (erfordert eine Fernbedienung zum Abstimmen) - xjfls23

aus Microbit-Import*

aus dem Gigglebot-Import*

aus utime importieren sleep_ms, ticks_us

Radio importieren

ustruct importieren

# Radio und GB Neopixel initialisieren

radio.on()

neo = init()

# zeitliche Koordinierung

update_rate =70

# Standardverstärkungswerte

Kp = 0,0

Ki = 0,0

Kd = 0,0

Sollwert = 0,5

trigger_point =0.0

min_speed_percent =0,2

base_speed =100

last_position = Sollwert

integral =0.0

run_neopixels =Falsch

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

total_time =0.0

total_counts =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

display.scroll('{} - {}'.format(total_time, total_counts), delay=100, wait=False)

total_time =0.0

total_counts =0

Pixel_off()

halt()

sleep_ms(500)

wenn run istTrue:

# die Zeilensensoren lesen

start_time = ticks_us()

# Überprüfen Sie, ob wir die Kp/Kd-Gewinne mit einer Fernbedienung aktualisiert haben

Versuchen:

Kp, Ki, Kd, trigger_point, min_speed_percent = ustruct.unpack('fffff', radio.receive_bytes())

set_eyes()

außerTypeError:

passieren

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

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

# Beleuchten Sie die Neopixel, um zu zeigen, in welche Richtung der GiggleBot gehen muss

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] = (12, 44, 41)

anders:

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(12* Prozent), int(44* Prozent), int(41* Prozent))

anders:

# neo[center_pixel - i] = tuple(map(lambda x: int(x * Prozent), türkis))

neo[center_pixel - i] = (int(12* Prozent), int(44* Prozent), int(41* Prozent))

brechen

neo.show()

Versuchen:

# Motoren klemmen

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

total_time += delay_diff

total_counts +=1

if1.0/ update_rate - delay_diff >0:

sleep(1.0/ update_rate - delay_diff)

rawgigglebot_line_follower_tuner.py anzeigen, gehostet mit ❤ von GitHub

Schritt 4: Einrichten des Tuners (Fernbedienung)

Als nächstes müssen wir das Runtime + Skript auf das 2. BBC micro:bit flashen. Dieses zweite micro:bit fungiert als Fernbedienung für den GiggleBot, mit dem die folgenden Parameter eingestellt werden:

1. Kp = Proportionalverstärkung für den PID-Regler.
2. Ki = Integralverstärkung für den PID-Regler.
3. Kd = Differentialverstärkung für den PID-Regler.
4. trigger_point = der in Prozent ausgedrückte Punkt zwischen der minimalen und maximalen Geschwindigkeit des GiggleBot, an dem die Geschwindigkeit linear reduziert wird, bis sie die minimale Geschwindigkeit erreicht.
5. min_speed_percent = die minimale Geschwindigkeit, ausgedrückt in Prozent der maximalen Geschwindigkeit.

Die anderen 2 verbleibenden Variablen, die eingestellt werden können, sind direkt in dem Skript, das auf dem GiggleBot sitzt, fest codiert: die update_rate und base_speed, die die maximale Geschwindigkeit darstellen. Wie in der Dokumentation beschrieben, beträgt die maximal einstellbare Geschwindigkeit für den GiggleBot 100, was auch der Standardwert für unseren GiggleBot ist.

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 Remote PID Line Follower Tuner (erfordert den anderen Teil) - xjfls23

aus Microbit-Import*

aus utime import sleep_ms

Radio importieren

ustruct importieren

# 1. Element ist die Kp-Verstärkung

# 2. Element ist der Ki-Gewinn

# 3. Element ist der Kd-Gewinn

# 4. Element ist der Triggerpunkt für Motoren, um die Geschwindigkeit zu verringern (0 -> 1)

# 5. Element ist die Mindestdrehzahl für Motoren, ausgedrückt in Prozent (0 -> 1)

Gewinne = [0.0, 0.0, 0.0, 1.0, 0.0]

Schrittgröße =0,1

# 0 und 1 für 1. Element

# 2 und 3 für 2. Element

aktuelle Einstellung =0

defshowMenu():

display.scroll('{} - {}'.format(currentSetting, gains[int(currentSetting /2)]), delay=100, wait=False)

radio.on()

zeige das Menü()

whileTrue:

aktualisiert =Falsch

if button_a.is_pressed():

aktuelle Einstellung = (aktuelle Einstellung +1) % (2*5)

aktualisiert = wahr

if button_b.is_pressed():

if currentSetting %2==0:

# Verstärkung erhöhen, wenn currentSetting 0 oder 2 ist oder..

ifint(currentSetting /2) in [0, 2]:

Gains[int(currentSetting /2)] +=10* stepSize

anders:

Gains[int(currentSetting /2)] += stepSize

anders:

# Verstärkung erhöhen, wenn currentSetting 1 oder 3 ist oder..

ifint(currentSetting /2) in [0, 2]:

Gains[int(currentSetting /2)] -=10* stepSize

anders:

Gains[int(currentSetting /2)] -= stepSize

radio.send_bytes(ustruct.pack('fffff', *gains))

aktualisiert = wahr

falls aktualisiert:

zeige das Menü()

sleep_ms(200)

rawgigglebot_line_follower_configurator.py anzeigen, gehostet mit ❤ von GitHub

Schritt 5: Tunen des GiggleBot

Platzieren Sie den GiggleBot auf der Schiene, schalten Sie ihn ein und lassen Sie ihn laufen. In der Zwischenzeit müssen Sie es ständig wieder auf den Track legen und die Verstärkungen / Parameter mit dem anderen BBC micro:bit, das Sie in der Hand halten, einstellen.

Um den GiggleBot zu starten, drücken Sie Knopf A auf dem BBC micro:bit des GiggleBot und um ihn zu stoppen und damit seinen Zustand zurückzusetzen, drücken Sie auf Knopf B.

Auf der Fernbedienung BBC micro:bit werden Sie durch Drücken von Taste A durch alle Optionen in seinem Menü geführt und Taste B erhöht/verringert den entsprechenden Wert. Es ist, als würde man die Uhr auf dem Armaturenbrett eines alten Autos stellen. Die Optionen sind wie folgt:

1. 0-1 Optionen sind für die Kp-Verstärkung.
2. 2-3 Optionen sind für den Ki-Gewinn.
3. 4-5 Optionen sind für die Kd-Verstärkung.
4. 6-7 Optionen dienen zum Einstellen des Sollwerts für den Moment, in dem die Motoren langsamer werden.
5. 8-9 Optionen dienen zum Einstellen der Mindestgeschwindigkeit.

Beachten Sie, dass gerade Zahlen im Menü dazu dienen, die entsprechenden Werte zu erhöhen, und bei ungeraden ist es genau umgekehrt.

Wenn Sie die Taste B auf dem BBC micro:bit des GiggleBot drücken, sehen Sie auf dem Neopixel-Bildschirm die Anzahl der seit dem letzten Zurücksetzen verstrichenen Millisekunden und die Anzahl der Zyklen, die der Roboter durchlaufen hat - mit diesen 2 können Sie berechnen die Aktualisierungsrate des Roboters.

Zuletzt und am wichtigsten habe ich mir 2 Tunings für den GiggleBot einfallen lassen. Eine davon ist, wenn die Neopixel-LEDs ausgeschaltet sind und die andere, wenn es anders ist. Die Neopixel-LEDs werden verwendet, um anzuzeigen, in welche Richtung sich der Fehler angesammelt hat.

1. Einstellung der Parameter (mit ausgeschalteten NeoPixel-LEDs)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0,3 (das sind 30%)
5. min_speed_percent = 0,2 (das sind 20%)
6. base_speed = 100 (auch bekannt als maximale Geschwindigkeit)
7. update_rate = 70 (läuft bei 70 Hz)

2. Einstellung der Parameter (mit den NeoPixel-LEDs an)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0,3 (das sind 30%)
5. min_speed_percent = 0,3 (das sind 30%)
6. base_speed = 70 (auch bekannt als maximale Geschwindigkeit)
7. update_rate = 50 (läuft bei 50 Hz)
8. Außerdem muss die Variable run_neopixels im Skript, das auf das BBC micro:bit des GiggleBot geladen wird, auf True gesetzt werden. Dadurch blinken die NeoPixel-LEDs so, dass sie anzeigen, in welche Richtung sich der Fehler akkumuliert.

Schritt 6: GiggleBot läuft mit ausgeschalteten NeoPixels

Dies ist ein Beispiel für die Ausführung des GiggleBot mit den ersten Tuning-Parametern, die im vorherigen Schritt gefunden wurden. In diesem Beispiel sind die NeoPixel-LEDs ausgeschaltet.

Schritt 7: GiggleBot läuft mit eingeschalteten Neopixeln

Dies ist ein Beispiel für die Ausführung des GiggleBot mit dem zweiten Satz von Tuning-Parametern aus Schritt 5. In diesem Beispiel sind die NeoPixel-LEDs eingeschaltet.

Beachten Sie, dass es dem GiggleBot in diesem Beispiel schwerer fällt, der Zeile zu folgen - das liegt daran, dass die Neopixel-LEDs die CPU-Zeit des BBC micro:bit "fressen". Deshalb mussten wir die Update-Rate von 70 auf 50 reduzieren.