Készítsen egy Lidar-vezérelt robotot a GiggleBot segítségével: 8 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:41

Ebben az oktatóanyagban arra késztetjük a GiggleBot -ot, hogy megoldja a labirintus nehézségeit.

Szervót szerelünk a GiggleBotra, amelyre egy távolságérzékelőt rögzítünk. Futás közben a szervó előre -hátra forog, hogy a távolságérzékelő meg tudja mérni az egyes akadályok távolságát. Ez úgy működik, mint egy LIDAR érzékelő, amely általában sokkal drágább.

Ugyanakkor a GiggleBot elküldi ezeket az adatokat egy távoli BBC mikro: bitnek, amely megjeleníti az 5x5-ös LED-mátrixán az akadályokhoz viszonyított helyzetét.

Az Ön feladata, hogy navigálhasson a GiggleBot -ban csak úgy, hogy megnézi, mit mutat a másik BBC mikro: bit. A GiggleBot vezérléséhez a BBC micro: bit távoli gombjait kell használni.

Jól hangzik! Térjünk rá, nem?

1. lépés: Szükséges összetevők

Szükségünk lesz:

1. Egy GiggleBot.
2. Akkumulátor a BBC micro: bit számára. A csomagban egy BBC micro: bit található.
3. x3 AA elem a GiggleBot számára.
4. Grove kábel a távolságérzékelő és a GiggleBot csatlakoztatásához.
5. Servo készlet a DexterIndustries cégtől.
6. x3 BBC mikro: bitek. Az egyik a GiggleBot számára, a másik pedig a robot távoli irányítására szolgál.
7. Távolságérzékelő a DexterIndustries cégtől.

Szerezd meg a GiggleBot robotot a BBC mikro: bithez itt!

2. lépés: A robot összeszerelése

Ahhoz, hogy a GiggleBot programozásra kész legyen, össze kell szerelnünk, bár nincs sok tennivaló.

Helyezze be a 3 AA elemet a GiggleBot alatti rekeszébe.

Szerelje össze a szervocsomagot. A szervó forgó karjához az utolsó lyuk segítségével rögzítse a szervót a GiggleBot elülső csatlakozóira. Használhat csavart és/vagy drótot, hogy stabilabb legyen a helyén. Vagy melegen ragaszthatja a táblához. Az én esetemben egy csavart és rövid vezetéket használtam a szervókarnak a GiggleBot táblához való kötéséhez.

Amikor a szervókarot a szervóra szereli, győződjön meg arról, hogy a szervó már a 80 -as pozícióba van állítva. Ezt megteheti a gigglebot.set_servo (gigglebot. RIGHT, 80) hívásával. Erről itt olvashat bővebben.

Ezután helyezze a távolságérzékelőt a szervocsomag elülső oldalára, és rögzítse, mint a fenti példában.

Végül csatlakoztassa a távolságérzékelőt Grove kábellel a 2 I2C port bármelyikéhez, a szervo motort pedig a GiggleBoton található jobb porthoz - a megfelelő port szerepel rajta.

3. lépés: Hozza létre saját útvesztőjét - opcionális

Ebben az esetben egy csomó dobozt használtam egy zárt hurkú sáv létrehozásához, hasonlóan a NASCAR -hoz.

Ebben a lépésben igazán kreatívvá válhat, és tetszés szerint kicsavarhatja, vagy szuperhosszúvá teheti, mert ez igazán rajtatok múlik.

Vagy ha egyáltalán nem szeretne pályát, akkor a GiggleBotot például egy konyhába vagy egy nappaliba helyezheti - ennek elég jónak kell lennie, mert rengeteg falat és akadályt kell elkerülnie.

4. lépés: A környezet beállítása

Annak érdekében, hogy a BBC micro: bit programozható legyen a MicroPython programban, be kell állítania egy szerkesztőt (a Mu Editor), és a GiggleBot MicroPython Runtime -t kell beállítania futási idejének. Ehhez kövesse az ezen az oldalon található utasításokat. Ettől a pillanattól kezdve a futási idő v0.4.0 verziója használatos.

5. lépés: A GiggleBot programozása - I. rész

Először állítsuk be a GiggleBot szkriptjét. Ez a szkript arra készteti a GiggleBot -ot, hogy forgassa el szervo motorját 160 fokkal (minden irányban 80 fokkal), miközben fordulatonként 10 leolvasást végez a távolságérzékelőből.

Amikor be van kapcsolva, a GiggleBot addig lesz készenlétben, amíg parancsot nem kap a távirányítótól. Csak 3 parancs lehet: előre, balra vagy jobbra.

Megjegyzés: A következő szkriptben hiányozhatnak szóközök, és úgy tűnik, hogy ez a GitHub Gists megjelenítésével kapcsolatos probléma miatt van. A lényegre kattintva eljuthat a GitHub oldalára, ahol másolhatja és beillesztheti a kódot.

Távirányítású LIDAR-alapú GiggleBot

a gigglebot importálásból*

from distance_sensor import DistanceSensor

a mikrobit import alvásból

utime importból kullancsok, alvás_

import ustruct

import rádió

# állítsa le a robotot, ha már mozog

álljon meg()

# engedélyezze a rádiót

radio.on ()

# távolságérzékelő objektum

ds = DistanceSensor ()

ds.start_continuous ()

rotate_time = 0.7# másodpercben mérve

rotate_span = 160# fokban mérve

rotate_steps = 10

overhead_compensation = 1.05# százalékban megadva

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

last_read_time = 0

radar = bytearray (rotate_steps)

servo_rotate_direction = 0# 0 felfelé haladáshoz (0-> 160) és 1 különben

radar_index = 0

set_servo (JOBB, 0)

míg igaz:

# olvasni a radarból

ha kullancsok () - utolsó olvasás ideje> idő_per_step:

# olvasható a távolságérzékelőből

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

last_read_time = kullancsok ()

nyomtatás (radar_index)

# végezze el a szervo balról jobbra forgatásának logikáját

ha radar_index == rotate_steps -1 és servo_rotate_direction == 0:

set_servo (JOBB, 0)

servo_rotate_direction = 1

elif radar_index == 0 és szervo_rotate_direction == 1:

set_servo (RIGHT, rotate_span)

servo_rotate_direction = 0

más:

radar_index += 1ha szervo_rotate_direction == 0else-1

# és küldje el a radar értékeit

radio.send_bytes (radar)

próbáld ki:

# olvassa el a robotparancsokat

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

# és működtesse a motorokat, ha bármilyen parancs érkezett

set_speed (lmotor, rmotor)

hajtás()

izņemotTypeError:

passz

Tekintse meg a rawgigglebot_lidar_robot.py webhelyet, amelyet a GitHub ❤ üzemeltet

6. lépés: A távirányító programozása - II

Már csak a második BBC micro: bit programozása szükséges, ami távirányítóként működik.

A távirányító az 5x5 pixeles képernyőn mutatja az akadályokhoz viszonyított távolságot. Legfeljebb 10 pixel lesz bekapcsolva.

Ugyanakkor a távirányító lehetővé teszi a GiggleBot távvezérlését a 2 gomb megnyomásával: előre, balra és jobbra.

Megjegyzés: A következő szkriptben hiányozhatnak szóközök, és úgy tűnik, hogy ez a GitHub Gists megjelenítésével kapcsolatos probléma miatt van. A lényegre kattintva eljuthat a GitHub oldalára, ahol másolhatja és beillesztheti a kódot.

Távirányítású LIDAR -alapú GiggleBot - Távoli kód

microbit importálásból alvó állapot, kijelző, button_a, button_b

import ustruct

import rádió

matematika importálása

radio.on ()

rotate_steps = 10

rotate_span = 160# fokban

rotate_step = rotate_span / rotate_steps

max_distance = 50# centiméterben

side_length_leds = 3 # pixelszámban mérve

radar = bytearray (rotate_steps)

xar = bytearray (rotate_steps)

yar = bytearray (rotate_steps)

Save_xar = bytearray (rotate_steps)

Save_yar = bytearray (rotate_steps)

motor_sebesség = 50

míg igaz:

állapot = rádió.recept_bytes_into (radar)

ha az állapot nem: Nincs:

# display.clear ()

c, val számolhatatlan (radar):

ha radar [c] <= max_distance:

# minden távolság 2d koordinátáinak kiszámítása

szög = rotate_steps / (rotate_steps -1) * rotate_step * c

szög += (180- rotate_span) /2.0

x_c = math.cos (szög * math.pi /180,0) * radar [c]

y_c = math.sin (szög * math.pi /180,0) * radar [c]

# skálázza a távolságokat, hogy illeszkedjen az 5x5 -ös mikrobites kijelzőhöz

x_c = x_c * (oldalsó_hosszúságok -1) / max_distance

y_c = y_c * (oldalsó_hosszúság +1) / max_távolság

# áthelyezési koordináták

x_c += (oldalsó_hosszúságok -1)

y_c = (oldalsó_hosszúság +1) - y_c

# kerek koordináták, ahol a LED -ek találhatók

ha x_c - matematikai.padló (x_c) <0,5:

x_c = matematikai.padló (x_c)

más:

x_c = matek.ceil (x_c)

ha y_c - matematika.padló (y_c) <0,5:

y_c = matematika.padló (y_c)

más:

y_c = matematika.ceil (y_c)

xar [c] = x_c

yar [c] = y_c

más:

xar [c] = 0

yar [c] = 0

display.clear ()

x, y inzip esetén (xar, yar):

display.set_pixel (x, y, 9)

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

stateA = button_a.is_pressed ()

stateB = button_b.is_pressed ()

ha A és B állapot:

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

nyomtatás ('előre')

ha állapotA és nem állapotB:

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

nyomtatás ('bal')

ha nem állapotA és állapotB:

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

nyomtatás ('jobb')

ifnot stateA és not stateB:

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

nyomtatás ("stop")

Tekintse meg a rawgigglebot_lidar_remote.py webhelyet, amelyet a GitHub ❤ üzemeltet

7. lépés: A távoli képernyő értelmezése

A "loading =" lusta "vezérli a GiggleBotot, a következő lehetőségek közül választhat:

1. Nyomja meg az A és a B gombot a GiggleBot előre mozgatásához.
2. Nyomja meg az A gombot a GiggleBot balra forgatásához.
3. Nyomja meg a B gombot a GiggleBot jobbra forgatásához.

Annak megtekintéséhez, hogy a legközelebbi akadályokat melyik irányba észlelik, csak nézze meg a távirányító (a távoli BBC mikro: bit, amit tart) képernyőjén. Képesnek kell lennie arra, hogy távolról irányítsa a GiggleBotot anélkül, hogy ránézne.