Erstellen Sie einen Lidar-gesteuerten Roboter mit dem GiggleBot - Gunook

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

In diesem Tutorial bringen wir den GiggleBot dazu, die Schwierigkeiten eines Labyrinths zu bewältigen.

Wir montieren am GiggleBot ein Servo, an dem wir einen Distanzsensor anbringen. Während der Fahrt dreht sich das Servo hin und her, damit der Distanzsensor die Distanz bis zu jedem Hindernis messen kann. Dies funktioniert ähnlich wie ein LIDAR-Sensor, der normalerweise viel teurer ist.

Gleichzeitig sendet der GiggleBot diese Daten an ein entferntes BBC micro:bit, das auf seiner 5-x-5-Matrix von LEDs seine relative Position zu den Hindernissen anzeigt.

Ihre Aufgabe ist es, den GiggleBot nur zu navigieren, indem Sie sich ansehen, was auf dem anderen BBC micro:bit angezeigt wird. Um den GiggleBot zu steuern, werden die Tasten auf der Fernbedienung BBC micro:bit verwendet.

Das klingt nach Spaß! Kommen wir zur Sache, ja?

Schritt 1: Erforderliche Komponenten

Wir werden brauchen:

1. Ein GiggleBot.
2. Ein Akku für das BBC micro:bit. Es kommt zusammen mit einem BBC micro:bit in seinem Paket.
3. x3 AA-Batterien für den GiggleBot.
4. Ein Grove-Kabel zum Verbinden des Distanzsensors mit dem GiggleBot.
5. Ein Servo-Kit von DexterIndustries.
6. x3 BBC-Mikro: Bits. Einer für den GiggleBot und einer zur Steuerung des Roboters aus der Ferne.
7. Ein Distanzsensor von DexterIndustries.

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

Schritt 2: Zusammenbau des Roboters

Um den GiggleBot programmierbereit zu machen, müssen wir ihn zusammenbauen, obwohl es nicht viel zu tun gibt.

Legen Sie die 3 AA-Batterien in das Fach unter dem GiggleBot ein.

Bauen Sie das Servopaket zusammen. Verwenden Sie an seinem rotierenden Arm des Servos das letzte Loch, um das Servo an den vorderen Anschlüssen des GiggleBot zu befestigen. Sie können eine Schraube und/oder einen Draht verwenden, um es stabiler zu machen. Oder Sie können es heiß auf das Brett kleben. In meinem Fall habe ich eine Schraube und einen kurzen Draht verwendet, um den Servoarm an die GiggleBot-Platine zu binden.

Stellen Sie bei der Montage des Servoarms am Servo sicher, dass das Servo bereits auf Position 80 eingestellt ist. Dies können Sie tun, indem Sie gigglebot.set_servo(gigglebot. RIGHT, 80) aufrufen. Mehr dazu können Sie hier lesen.

Platzieren Sie anschließend den Abstandssensor auf der Vorderseite des Servopakets und befestigen Sie ihn wie im obigen Beispiel.

Schließen Sie abschließend den Distanzsensor mit einem Grove-Kabel an einen der 2 I2C-Ports und den Servomotor an den rechten Port des GiggleBot an - der richtige Port ist darauf erwähnt.

Schritt 3: Erstellen Sie Ihr eigenes Labyrinth - optional

In diesem Fall habe ich eine Reihe von Boxen verwendet, um einen Closed-Loop-Track zu erstellen, ähnlich einem NASCAR-Track.

In diesem Schritt können Sie wirklich kreativ werden und es so verdrehen, wie Sie es möchten, oder es super lang machen, weil es wirklich an Ihnen liegt.

Oder wenn Sie gar keine Spur haben möchten, können Sie den GiggleBot zum Beispiel in eine Küche oder ein Wohnzimmer stellen – das sollte reichen, denn es gibt viele Wände und Hindernisse, die Sie noch vermeiden müssen.

Schritt 4: 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 5: Programmierung des GiggleBot - Teil I

Zuerst richten wir das Skript des GiggleBot ein. Dieses Skript lässt den GiggleBot seinen Servomotor um 160 Grad (80 Grad in jede Richtung) drehen, während gleichzeitig 10 Messwerte vom Distanzsensor pro Umdrehung erfasst werden.

Nach dem Einschalten steht der GiggleBot in Bereitschaft, bis er einen Befehl von der Fernbedienung erhält. Es kann nur 3 Befehle geben: vorwärts, nach links oder nach rechts.

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.

Ferngesteuerter LIDAR-basierter GiggleBot

aus dem Gigglebot-Import*

from distance_sensor import DistanceSensor

aus Mikrobit-Import Schlaf

aus utime importieren ticks_us, sleep_us

ustruct importieren

Radio importieren

# den Roboter stoppen, wenn er sich bereits bewegt

halt()

# Radio aktivieren

radio.on()

# Distanzsensorobjekt

ds = DistanzSensor()

ds.start_continuous()

rotate_time =0.7# gemessen in Sekunden

rotate_span =160# gemessen in Grad

Dreh_Schritte =10

Overhead_Compensation =1.05# in Prozent definiert

time_per_step =10**6* rotation_time / (rotate_steps * Overhead_Compensation)

last_read_time =0

Radar = bytearray (rotate_steps)

servo_rotate_direction =0# 0 für nach oben gehen (0->160) und 1 sonst

Radarindex =0

set_servo(RECHTS, 0)

whileTrue:

# vom Radar gelesen

if ticks_us() - last_read_time > time_per_step:

# vom Distanzsensor gelesen

Radar[radar_index] =int(ds.read_range_continuous() /10)

last_read_time = ticks_us()

print(radar_index)

# mache die Logik zum Drehen des Servos von links nach rechts

if radar_index == rotation_steps -1und servo_rotate_direction ==0:

set_servo(RECHTS, 0)

servo_rotate_direction =1

elif radar_index ==0und servo_rotate_direction ==1:

set_servo (RECHTS, rotiere_spanne)

servo_rotate_direction =0

anders:

radar_index +=1if servo_rotate_direction ==0else-1

# und sende die Radarwerte

radio.send_bytes (Radar)

Versuchen:

# Roboterbefehle lesen

lmotor, rmotor = ustruct.unpack('bb', radio.receive_bytes())

# und die Motoren ansteuern, wenn Befehle empfangen werden

set_speed (lmotor, rmotor)

Fahrt()

außerTypeError:

passieren

rawgigglebot_lidar_robot.py anzeigen, gehostet mit ❤ von GitHub

Schritt 6: Programmierung der Fernbedienung - Teil II

Was noch zu tun ist, ist die Programmierung des zweiten BBC micro:bit, der als Fernbedienung fungiert.

Die Fernbedienung wird verwendet, um auf ihrem 5-x-5-Pixel-Bildschirm die relative Entfernung zu Hindernissen anzuzeigen. Es werden höchstens 10 Pixel aktiviert.

Gleichzeitig bietet Ihnen die Fernbedienung die Möglichkeit, den GiggleBot durch Drücken seiner 2 Tasten fernzusteuern: vorwärts, nach links und nach rechts.

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.

Ferngesteuerter LIDAR-basierter GiggleBot - Remote Code

aus Mikrobit importieren sleep, display, button_a, button_b

ustruct importieren

Radio importieren

Mathematik importieren

radio.on()

Dreh_Schritte =10

rotate_span =160# in Grad

Dreh_Schritt = Dreh_Span / Dreh_Schritte

max_distance =50# in Zentimetern

side_length_leds =3# gemessen in der Pixelanzahl

Radar = bytearray (rotate_steps)

xar =bytearray(rotate_steps)

yar =bytearray(rotate_steps)

saved_xar =bytearray(rotate_steps)

saved_yar =bytearray(rotate_steps)

motor_speed =50

whileTrue:

status = radio.receive_bytes_into(radar)

wenn statusnotNone ist:

# display.clear()

für c, val inenumerate(radar):

if Radar[c] <= max_distance:

# 2D-Koordinaten jeder Entfernung berechnen

Winkel = Dreh_Schritte / (Dreh_Schritte -1) * Dreh_Schritt * c

Winkel += (180- rotation_span) /2.0

x_c = math.cos(Winkel * math.pi /180.0) * Radar[c]

y_c = math.sin(Winkel * math.pi /180.0) * Radar[c]

# skalieren Sie die Abstände so, dass sie auf das 5x5-Mikrobit-Display passen

x_c = x_c * (side_length_leds -1) / max_distance

y_c = y_c * (side_length_leds +1) / max_distance

# Koordinaten neu positionieren

x_c += (side_length_leds -1)

y_c = (side_length_leds +1) - y_c

# runden Koordinaten genau dort, wo sich die LEDs befinden

if x_c - math.floor(x_c) <0.5:

x_c = math.etage(x_c)

anders:

x_c = math.ceil(x_c)

if y_c - math.floor(y_c) <0.5:

y_c = math.etage(y_c)

anders:

y_c = math.ceil(y_c)

xar[c] = x_c

yar[c] = y_c

anders:

xar[c] =0

yar[c] =0

display.clear()

für x, y inzip(xar, yar):

display.set_pixel(x, y, 9)

# print(list(zip(xar, yar, radar)))

stateA = button_a.is_pressed()

stateB = button_b.is_pressed()

wenn ZustandA und ZustandB:

radio.send_bytes(ustruct.pack('bb', motor_speed, motor_speed))

print('vorwärts')

wenn ZustandA und nicht ZustandB:

radio.send_bytes(ustruct.pack('bb', motor_speed, -motor_speed))

print('links')

wenn nicht stateA und stateB:

radio.send_bytes(ustruct.pack('bb', -motor_speed, motor_speed))

print('richtig')

ifnot stateA andnot stateB:

radio.send_bytes(ustruct.pack('bb', 0, 0))

print('stopp')

rawgigglebot_lidar_remote.py anzeigen, gehostet mit ❤ von GitHub

Schritt 7: Interpretieren des Remote-Bildschirms

"loading="lazy" den GiggleBot zu steuern, haben Sie folgende Möglichkeiten:

1. Drücken Sie Taste A und Taste B, um den GiggleBot vorwärts zu bewegen.
2. Drücken Sie Knopf A, um den GiggleBot nach links zu drehen.
3. Drücken Sie Knopf B, um den GiggleBot nach rechts zu drehen.

Um zu sehen, in welche Richtung die nächsten Hindernisse erkannt werden, schauen Sie einfach auf den Bildschirm der Fernbedienung (das BBC micro:bit der Fernbedienung, das Sie halten). Sie sollten in der Lage sein, den GiggleBot aus der Ferne zu steuern, ohne ihn anzusehen.