Vytvořte robota vedeného Lidarem s GiggleBot: 8 kroků

2024 Autor: John Day | [email protected]. Naposledy změněno: 2024-01-30 08:22

V tomto tutoriálu se snažíme GiggleBota vypořádat s obtížemi bludiště.

Na GiggleBot montujeme servo, na které připevňujeme snímač vzdálenosti. Při běhu se servo bude otáčet tam a zpět, aby senzor vzdálenosti mohl měřit vzdálenost až ke každé překážce. Funguje to podobně jako snímač LIDAR, který je obvykle mnohem dražší.

Současně GiggleBot posílá tato data na vzdálený BBC micro: bit, který zobrazuje na své matici LED 5 na 5 svou relativní polohu vůči překážkám.

Vaším úkolem je umět navigovat GiggleBot pouze prohlížením toho, co je ukázáno na druhém micro: bitu BBC. K ovládání GiggleBot slouží tlačítka na vzdáleném BBC micro: bit.

To zní jako zábava! Pojďme na to, ano?

Krok 1: Požadované součásti

Budeme potřebovat:

1. GiggleBot.
2. Sada baterií pro BBC micro: bit. Součástí balení je micro: bit BBC.
3. x3 AA baterie pro GiggleBot.
4. Kabel Grove pro připojení senzoru vzdálenosti k GiggleBot.
5. Servo sada od DexterIndustries.
6. x3 BBC micro: bity. Jeden pro GiggleBot a jeden sloužící k ovládání robota z velké dálky.
7. Senzor vzdálenosti od DexterIndustries.

Získejte robota GiggleBot pro BBC micro: bit zde!

Krok 2: Sestavení robota

Aby byl GiggleBot připraven k programování, musíme jej sestavit, i když není třeba mnoho dělat.

Vložte 3 baterie AA do přihrádky na spodní straně GiggleBot.

Sestavte servo balíček. K jeho rotujícímu ramenu serva použijte jeho poslední otvor k upevnění serva na přední konektory GiggleBot. Můžete použít šroub a/nebo nějaký drát, aby byl na svém místě stabilnější. Nebo ho můžete za horka přilepit na desku. V mém případě jsem pomocí šroubu a krátkého drátu přivázal rameno serva k desce GiggleBot.

Při montáži ramene serva na servo se ujistěte, že je servo již nastaveno do polohy 80. To lze provést zavoláním gigglebot.set_servo (gigglebot. RIGHT, 80). Více si o tom můžete přečíst zde.

Poté umístěte snímač vzdálenosti na přední stranu servopohonu a upevněte jej jako ve výše uvedeném příkladu.

Nakonec připojte snímač vzdálenosti pomocí kabelu Grove ke kterémukoli ze 2 portů I2C a servomotoru k pravému portu, který sedí na GiggleBot - je na něm uveden správný port.

Krok 3: Vytvořte si vlastní bludiště - volitelně

V tomto případě jsem použil spoustu krabic k vytvoření uzavřené smyčky, podobné NASCAR.

V tomto kroku můžete být opravdu kreativní a udělat to tak zkrouceně, jak chcete, nebo to udělat super dlouhým, protože je to opravdu jen na vás.

Nebo pokud dráhu vůbec nechcete, můžete GiggleBot dát například do kuchyně nebo obývacího pokoje - to by mělo stačit, protože je zde spousta stěn a překážek, kterým se ještě musíte vyhnout.

Krok 4: Nastavení prostředí

Abyste mohli programovat micro: bit BBC v programu MicroPython, musíte pro něj nastavit editor (editor Mu) a nastavit běhový čas GiggleBot MicroPython Runtime. Chcete -li to provést, musíte postupovat podle pokynů na této stránce. Od tohoto okamžiku se používá verze v0.4.0 modulu runtime.

Krok 5: Programování GiggleBot - část I

Nejprve nastavíme skript GiggleBot. Tento skript způsobí, že GiggleBot otočí svůj servomotor o 160 stupňů (80 stupňů v každém směru) a současně odebírá 10 měření ze snímače vzdálenosti za otáčku.

Když je GiggleBot zapnutý, bude stát, dokud nedostane příkaz z dálkového ovladače. Mohou existovat pouze 3 příkazy: pohyb vpřed, doleva nebo doprava.

Poznámka: Následující skript může mít chybějící mezery a zdá se, že je to způsobeno nějakým problémem při zobrazování GitHub Gists. Kliknutím na podstatu se dostanete na stránku GitHub, kde můžete zkopírovat a vložit kód.

Dálkově ovládaný GiggleBot na bázi LIDAR

z importu gigglebot*

from distance_sensor import DistanceSensor

ze spánku importu mikrobitů

z utime import ticks_us, sleep_us

dovozní ustruct

importovat rádio

# zastavte robota, pokud se již pohybuje

stop()

# povolit rádio

radio.on ()

# objekt senzoru vzdálenosti

ds = DistanceSensor ()

ds.start_continuous ()

rotate_time = 0,7# měřeno v sekundách

rotate_span = 160# měřeno ve stupních

rotate_steps = 10

overhead_compensation = 1,05# definováno v procentech

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

last_read_time = 0

radar = bytearray (rotate_steps)

servo_rotate_direction = 0# 0 pro pohyb nahoru (0-> 160) a 1 jinak

radar_index = 0

set_servo (VPRAVO, 0)

whileTrue:

# přečteno z radaru

if ticks_us () - last_read_time> time_per_step:

# načteno ze snímače vzdálenosti

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

last_read_time = ticks_us ()

tisk (radar_index)

# proveďte logiku otáčení serva zleva doprava

pokud radar_index == rotate_steps -1 a servo_rotate_direction == 0:

set_servo (VPRAVO, 0)

servo_rotate_direction = 1

elif radar_index == 0 a servo_rotate_direction == 1:

set_servo (RIGHT, rotate_span)

servo_rotate_direction = 0

jiný:

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

# a odešlete hodnoty radaru

radio.send_bytes (radar)

Snaž se:

# číst příkazy robota

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

# a spusťte motory, pokud budou přijaty nějaké příkazy

set_speed (lmotor, rmotor)

řídit()

kroměTypeError:

složit

zobrazit rawgigglebot_lidar_robot.py hostované s ❤ od GitHub

Krok 6: Programování dálkového ovladače - část II

Nezbývá než naprogramovat 2. BBC micro: bit, který funguje jako dálkový ovladač.

Dálkový ovladač slouží k zobrazení relativní vzdálenosti od překážek na obrazovce o velikosti 5 x 5 pixelů. Zapnuto bude maximálně 10 pixelů.

Dálkový ovladač vám současně poskytuje možnosti dálkového ovládání GiggleBot stisknutím jeho 2 tlačítek: pohyb vpřed, doleva a doprava.

Poznámka: Následující skript může mít chybějící mezery a zdá se, že je to způsobeno nějakým problémem při zobrazování GitHub Gists. Kliknutím na podstatu se dostanete na stránku GitHub, kde můžete zkopírovat a vložit kód.

Dálkově ovládaný GiggleBot na bázi LIDAR - vzdálený kód

z mikrobitů import spánku, zobrazení, button_a, button_b

dovozní ustruct

importovat rádio

importní matematika

radio.on ()

rotate_steps = 10

rotate_span = 160# ve stupních

rotate_step = rotate_span / rotate_steps

max_distance = 50# v centimetrech

side_length_leds = 3 # měřeno v # pixelech

radar = bytearray (rotate_steps)

xar = bytearray (rotate_steps)

yar = bytearray (rotate_steps)

save_xar = bytearray (rotate_steps)

save_yar = bytearray (rotate_steps)

motor_speed = 50

whileTrue:

status = radio.receive_bytes_into (radar)

pokud stav není Žádný:

# display.clear ()

pro c, val inenumerate (radar):

pokud radar [c] <= max_distance:

# vypočítat 2d souřadnice každé vzdálenosti

úhel = rotate_steps / (rotate_steps -1) * rotate_step * c

úhel += (180- rotate_span) /2,0

x_c = math.cos (úhel * math.pi /180,0) * radar [c]

y_c = math.sin (úhel * math.pi /180,0) * radar [c]

# změňte vzdálenosti tak, aby se vešly na mikrobitový displej 5x5

x_c = x_c * (side_length_leds -1) / max_distance

y_c = y_c * (side_length_leds +1) / max_distance

# souřadnice polohy

x_c += (side_length_leds -1)

y_c = (side_length_leds +1) - y_c

# kulaté souřadnice přesně tam, kde jsou LED diody

if x_c - math.floor (x_c) <0,5:

x_c = math.floor (x_c)

jiný:

x_c = math.ceil (x_c)

if y_c - math.floor (y_c) <0,5:

y_c = math.floor (y_c)

jiný:

y_c = math.ceil (y_c)

xar [c] = x_c

yar [c] = y_c

jiný:

xar [c] = 0

yar [c] = 0

display.clear ()

pro x, y inzip (xar, yar):

display.set_pixel (x, y, 9)

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

stateA = button_a.is_pressed ()

stateB = button_b.is_pressed ()

pokud stateA a stateB:

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

tisk ('vpřed')

if stateA andnot stateB:

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

tisk ('vlevo')

ifnot stateA a stateB:

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

tisk ('vpravo')

ifnot stateA andnot stateB:

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

tisk ('stop')

zobrazit rawgigglebot_lidar_remote.py hostované s ❤ od GitHub

Krok 7: Interpretace vzdálené obrazovky

"loading =" líný "ovládá GiggleBot, máte následující možnosti:

1. Stisknutím tlačítka A a tlačítka B posuňte GiggleBot dopředu.
2. Stisknutím tlačítka A otočte GiggleBot doleva.
3. Stisknutím tlačítka B otočte GiggleBot doprava.

Chcete -li zjistit, kterým směrem jsou detekovány nejbližší překážky, stačí se podívat na obrazovku dálkového ovladače (vzdálený micro: bit BBC, který držíte). Měli byste být schopni ovládat GiggleBot z velké dálky, aniž byste se na něj dívali.