Gör en Lidar-guidad robot med GiggleBot: 8 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:44

I denna handledning gör vi GiggleBot för att ta itu med svårigheterna med en labyrint.

Vi monterar en servo på GiggleBot som vi fäster en avståndssensor på. Under körning kommer servon att rotera fram och tillbaka så att avståndssensorn kan mäta avståndet upp till varje hinder. Detta fungerar ungefär som en LIDAR -sensor som vanligtvis är mycket dyrare.

Samtidigt skickar GiggleBot denna data till en avlägsen BBC micro: bit som visar sin 5-till-5 matris av lysdioder sin relativa position till hindren.

Ditt jobb är att bara kunna navigera i GiggleBot genom att titta på vad det visas på den andra BBC micro: bit. För att styra GiggleBot används knapparna på fjärrkontrollen BBC micro: bit.

Det låter kul! Låt oss göra det, ska vi?

Steg 1: Obligatoriska komponenter

Vi kommer att behöva:

1. En GiggleBot.
2. Ett batteri för BBC micro: bit. Det följer med en BBC micro: bit i paketet.
3. x3 AA -batterier för GiggleBot.
4. En Grove -kabel för att ansluta avståndssensorn till GiggleBot.
5. Ett servokit från DexterIndustries.
6. x3 BBC micro: bitar. En för GiggleBot och en som används för att styra roboten på långt håll.
7. En distanssensor från DexterIndustries.

Skaffa GiggleBot -roboten för BBC micro: bit här!

Steg 2: Montering av roboten

För att göra GiggleBot redo att programmeras måste vi montera den, även om det inte behövs mycket att göra.

Sätt i de 3 AA -batterierna i facket under GiggleBot.

Montera servopaketet. Till dess roterande arm på servon, använd det sista hålet i den för att fästa servon på GiggleBots främre kontakter. Du kan använda en skruv och/eller någon tråd för att göra den mer stabil på sin plats. Eller så kan du hetlimma det på brädet. I mitt fall använde jag en skruv och en kort tråd för att knyta servoarmen till GiggleBot -kortet.

När du monterar servoarmen på servon, se till att servon redan är inställd på position 80. Du kan göra det genom att ringa till gigglebot.set_servo (gigglebot. RIGHT, 80). Du kan läsa mer om det här.

Placera sedan avståndssensorn på framsidan av servopaketet och fixa det som i exemplet ovan.

Slutligen ansluter du avståndssensorn med en Grove -kabel till någon av de 2 I2C -portarna och servomotorn till den högra porten som sitter på GiggleBot - den rätta porten nämns på den.

Steg 3: Skapa din egen labyrint - valfritt

I det här fallet har jag använt ett gäng lådor för att skapa ett spår med sluten slinga, liknande en NASCAR.

I det här steget kan du bli riktigt kreativ och göra det hur vridna du vill eller göra det superlångt eftersom det verkligen är upp till dig.

Eller om du inte alls vill ha ett spår kan du placera GiggleBot i ett kök eller ett vardagsrum till exempel - det borde vara tillräckligt bra eftersom det finns gott om väggar och hinder du fortfarande måste undvika.

Steg 4: Konfigurera miljön

För att du ska kunna programmera BBC micro: bit i MicroPython måste du ställa in en editor för den (Mu Editor) och ställa in GiggleBot MicroPython Runtime som dess körtid. För det måste du följa instruktionerna på den här sidan. Från och med nu används version v0.4.0 av körtiden.

Steg 5: Programmering av GiggleBot - Del I

Låt oss först konfigurera GiggleBots manus. Detta manus kommer att få GiggleBot att rotera sin servomotor 160 grader (80 grader i varje riktning) samtidigt som den tar 10 avläsningar från avståndssensorn per varv.

När den är påslagen kommer GiggleBot att stå kvar tills den får ett kommando från fjärrkontrollen. Det kan bara finnas tre kommandon: gå framåt, till vänster eller till höger.

Obs! Följande skript kan sakna blanksteg och detta verkar bero på problem med visning av GitHub -listor. Klicka på kärnan för att ta dig till dess GitHub-sida där du kan kopiera och klistra in koden.

Fjärrstyrd LIDAR-baserad GiggleBot

från gigglebot import*

från distance_sensor importera DistanceSensor

från mikrobit import sömn

från utime import ticks_us, sleep_us

importera struktur

importera radio

# stoppa roboten om den redan rör sig

sluta()

# aktivera radio

radio.on ()

# avståndssensorobjekt

ds = DistanceSensor ()

ds.start_continuous ()

rotate_time = 0,7# mätt i sekunder

rotate_span = 160# mätt i grader

rotera_steg = 10

overhead_compensation = 1,05# definierat i procent

time_per_step = 10 ** 6* rotate_time / (rotate_steps* overhead_compensation)

last_read_time = 0

radar = bytearray (rotera_steg)

servo_rotate_direction = 0# 0 för att gå uppåt (0-> 160) och 1 annars

radar_index = 0

set_servo (HÖGER, 0)

whileTrue:

# läst från radarn

if ticks_us () - last_read_time> time_per_step:

# avläst från avståndssensorn

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

last_read_time = ticks_us ()

print (radar_index)

# gör logiken för att rotera servon från vänster till höger

om radar_index == rotate_steps -1och servo_rotate_direction == 0:

set_servo (HÖGER, 0)

servo_rotate_direction = 1

elif radar_index == 0och servo_rotate_direction == 1:

set_servo (RIGHT, rotate_span)

servo_rotate_direction = 0

annan:

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

# och skicka radarvärdena

radio.send_bytes (radar)

Prova:

# läs robotkommandon

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

# och aktivera motorerna om det finns mottagna kommandon

set_speed (lmotor, rmotor)

kör()

exceptTypeError:

passera

visa rawgigglebot_lidar_robot.py värd med ❤ av GitHub

Steg 6: Programmering av fjärrkontrollen - Del II

Det som återstår att göra är att programmera den andra BBC micro: bit som fungerar som en fjärrkontroll.

Fjärrkontrollen används för att visa den relativa avståndet till hinder på sin 5-by-5 pixel-gjorda skärm. Som mest kommer det att vara 10 pixlar påslagna.

Samtidigt ger fjärrkontrollen dig möjlighet att fjärrstyra GiggleBot genom att trycka på dess 2 knappar: gå framåt, till vänster och till höger.

Obs! Följande skript kan sakna blanksteg och detta verkar bero på problem med visning av GitHub -listor. Klicka på kärnan för att ta dig till dess GitHub-sida där du kan kopiera och klistra in koden.

Fjärrstyrd LIDAR -baserad GiggleBot - fjärrkod

från mikrobit importera sömn, display, button_a, button_b

importera struktur

importera radio

import matematik

radio.on ()

rotera_steg = 10

rotate_span = 160# i grader

rotate_step = rotate_span / rotate_steps

max_distance = 50# i centimeter

side_length_leds = 3 # mätt i antalet pixlar

radar = bytearray (rotera_steg)

xar = bytearray (rotera_steg)

yar = bytearray (rotera_steg)

save_xar = bytearray (rotera_steg)

save_yar = bytearray (rotera_steg)

motorhastighet = 50

whileTrue:

status = radio.receive_bytes_into (radar)

om status inte är Ingen:

# display.clear ()

för c, val inumerate (radar):

om radar [c] <= max_distance:

# beräkna 2d -koordinater för varje avstånd

vinkel = rotera_steg / (rotera_steg -1) * rotera_steg * c

vinkel += (180- rotate_span) /2.0

x_c = math.cos (vinkel * math.pi /180.0) * radar [c]

y_c = math.sin (vinkel * math.pi /180.0) * radar [c]

# skala avstånden så att de passar på 5x5 mikrobitskärmen

x_c = x_c * (sidlängd_leds -1) / max_distans

y_c = y_c * (side_length_leds +1) / max_distance

# flytta koordinater

x_c += (sidlängd_leds -1)

y_c = (sidlängd_leds +1) - y_c

# runda koordinater exakt där lysdioderna finns

om x_c - matte. golv (x_c) <0,5:

x_c = matte. golv (x_c)

annan:

x_c = math.ceil (x_c)

om y_c - matte. golv (y_c) <0,5:

y_c = matematik. golv (y_c)

annan:

y_c = math.ceil (y_c)

xar [c] = x_c

yar [c] = y_c

annan:

xar [c] = 0

yar [c] = 0

display.clear ()

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

display.set_pixel (x, y, 9)

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

stateA = button_a.is_pressed ()

stateB = button_b.is_pressed ()

om stateA och stateB:

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

print ('framåt')

om stateA och inte staten B:

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

tryck ('vänster')

ifnot stateA och stateB:

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

print ('höger')

ifnot stateA och not stateB:

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

print ('stopp')

visa rawgigglebot_lidar_remote.py värd med ❤ av GitHub

Steg 7: Tolkning av fjärrskärmen

"loading =" lat "styr GiggleBot, du har följande alternativ:

1. Tryck på knapp A och knapp B för att flytta GiggleBot framåt.
2. Tryck på knapp A för att snurra GiggleBot åt vänster.
3. Tryck på knappen B för att snurra GiggleBot åt höger.

För att se i vilken riktning de närmaste hindren upptäcks, titta bara på fjärrkontrollens (fjärr -BBC -mikro: bit som du håller) skärmen. Du borde kunna styra GiggleBot långt ifrån utan att titta på den.