Vyrobte si robota vedeného Lidarom s GiggleBot: 8 krokov

2024 Autor: John Day | [email protected]. Naposledy zmenené: 2024-01-30 11:58

V tomto tutoriáli robíme GiggleBot riešením problémov bludiska.

Na GiggleBot montujeme servo, na ktoré pripevňujeme snímač vzdialenosti. Pri behu sa servo bude otáčať tam a späť, aby snímač vzdialenosti mohol merať vzdialenosť až po každú prekážku. Funguje to podobne ako snímač LIDAR, ktorý je zvyčajne oveľa drahší.

GiggleBot zároveň odosiela tieto údaje na vzdialený mikro bit: BBC, ktorý zobrazuje na svojej matici diód 5 x 5 svoju relatívnu polohu voči prekážkam.

Vašou úlohou je ovládať GiggleBot iba tak, že sa pozriete na to, čo je zobrazené na druhom mikro: bite BBC. Na ovládanie GiggleBotu slúžia tlačidlá na diaľkovom BBC micro: bite.

To znie zábavne! Poďme na to, nie?

Krok 1: Požadované komponenty

Budeme potrebovať:

1. GiggleBot.
2. Batéria pre BBC micro: bit. Dodáva sa spolu s micro: bitom BBC v balení.
3. x3 AA batérie pre GiggleBot.
4. Kábel Grove na pripojenie snímača vzdialenosti k GiggleBot.
5. Servo sada od spoločnosti DexterIndustries.
6. x3 BBC micro: bity. Jeden pre GiggleBot a druhý slúžiaci na ovládanie robota z diaľky.
7. Senzor vzdialenosti od spoločnosti DexterIndustries.

Získajte robota GiggleBot pre BBC micro: bit tu!

Krok 2: Zostavenie robota

Aby bol GiggleBot pripravený na programovanie, musíme ho zostaviť, aj keď nie je potrebné veľa robiť.

Vložte 3 batérie AA do priehradky na spodnej strane zariadenia GiggleBot.

Zostavte servo balíček. Na jeho otočné rameno serva pomocou posledného otvoru pripevnite servo k predným konektorom GiggleBot. Na zaistenie väčšej stability na svojom mieste môžete použiť skrutku a/alebo nejaký drôt. Alebo ho môžete za tepla prilepiť na dosku. V mojom prípade som použil skrutku a krátky drôt na pripevnenie ramena serva k doske GiggleBot.

Pri montáži ramena serva na servo sa uistite, že je servo už nastavené na polohu 80. Môžete to urobiť zavolaním na gigglebot.set_servo (gigglebot. RIGHT, 80). Viac si o tom môžete prečítať tu.

Potom umiestnite snímač vzdialenosti na prednú stranu balíka serva a upevnite ho ako vo vyššie uvedenom príklade.

Nakoniec pripojte snímač vzdialenosti káblom Grove k akémukoľvek z 2 portov I2C a servomotor k pravému portu sediacemu na GiggleBot - je na ňom uvedený pravý port.

Krok 3: Vytvorte si vlastné bludisko - voliteľné

V tomto prípade som použil veľa boxov na vytvorenie dráhy s uzavretou slučkou, podobnej tej na NASCAR.

V tomto kroku môžete byť skutočne kreatívni a urobiť to tak skrútené, ako chcete, alebo ho predĺžiť, pretože je to naozaj len na vás.

Alebo ak vôbec nechcete trať, môžete GiggleBot dať napríklad do kuchyne alebo obývačky - to by malo stačiť, pretože je tu veľa stien a prekážok, ktorým sa ešte musíte vyhnúť.

Krok 4: Nastavenie prostredia

Aby ste mohli programovať micro: bit BBC v MicroPythone, musíte preň nastaviť editor (Mu Editor) a nastaviť jeho runtime ako GiggleBot MicroPython Runtime. Na to musíte postupovať podľa pokynov na tejto stránke. Od tohto momentu sa používa verzia v0.4.0 runtime.

Krok 5: Programovanie GiggleBot - časť I

Najprv si nastavme skript GiggleBot. Tento skript prinúti GiggleBot otáčať servomotor o 160 stupňov (80 stupňov v každom smere) a súčasne odčítať 10 meraní zo snímača vzdialenosti za otáčku.

Po zapnutí bude GiggleBot stáť, kým nedostane príkaz z diaľkového ovládača. Môžu existovať iba 3 príkazy: pohyb dopredu, doľava alebo doprava.

Poznámka: Nasledujúci skript môže mať prázdne medzery, a zdá sa, že je to kvôli nejakému problému so zobrazovaním GitHub Gists. Kliknutím na podstatu sa dostanete na stránku GitHub, kde môžete skopírovať a prilepiť kód.

Diaľkovo ovládaný GiggleBot na báze LIDAR

z importu gigglebot*

from distance_sensor import DistanceSensor

zo spánku importu mikrobitov

z utim importu ticks_us, sleep_us

dovozná štruktúra

dovozné rádio

# Zastavte robota, ak sa už pohybuje

zastaviť ()

# povoliť rádio

radio.on ()

# objekt senzora vzdialenosti

ds = DistanceSensor ()

ds.start_continuous ()

rotate_time = 0,7# merané v sekundách

rotate_span = 160# merané v stupňoch

rotate_steps = 10

overhead_compensation = 1,05# definované v percentách

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

last_read_time = 0

radar = bytearray (rotate_steps)

servo_rotate_direction = 0# 0 pre stúpanie nahor (0-> 160) a 1 inak

radar_index = 0

set_servo (SPRÁVNE, 0)

whileTrue:

# prečítané z radaru

if ticks_us () - last_read_time> time_per_step:

# odčítané zo snímača vzdialenosti

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

last_read_time = ticks_us ()

tlač (radar_index)

# Vykonajte logiku otáčania serva zľava doprava

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

set_servo (SPRÁVNE, 0)

servo_rotate_direction = 1

elif radar_index == 0 a smer servo_rotate_= = 1:

set_servo (RIGHT, rotate_span)

servo_rotate_direction = 0

inak:

radar_index += 1 ak smer_ servo_rotate_= = 0 inak-1

# a pošlite hodnoty radaru

radio.send_bytes (radar)

skús:

# čítať príkazy robota

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

# a aktivujte motory, ak existujú nejaké prijaté príkazy

set_speed (lmotor, rmotor)

riadiť ()

kroměTypeError:

prejsť

zobraziť rawgigglebot_lidar_robot.py hostený s ❤ od GitHub

Krok 6: Programovanie diaľkového ovládača - časť II

Zostáva naprogramovať 2. BBC micro: bit, ktorý funguje ako diaľkové ovládanie.

Diaľkový ovládač slúži na zobrazenie relatívnej vzdialenosti od prekážok na obrazovke vyrobenej 5 x 5 pixelov. Zapnutých bude maximálne 10 pixelov.

Diaľkový ovládač vám zároveň poskytuje možnosti diaľkového ovládania GiggleBot stlačením jeho dvoch tlačidiel: posun dopredu, doľava a doprava.

Poznámka: Nasledujúci skript môže mať prázdne medzery, a zdá sa, že je to kvôli nejakému problému so zobrazovaním GitHub Gists. Kliknutím na podstatu sa dostanete na stránku GitHub, kde môžete skopírovať a prilepiť kód.

Diaľkovo ovládaný GiggleBot na báze LIDAR - diaľkový kód

z importu mikrobitov spánok, displej, tlačidlo_a, tlačidlo_b

dovozná štruktúra

dovozné rádio

importná matematika

radio.on ()

rotate_steps = 10

rotate_span = 160# v stupňoch

rotate_step = rotate_span / rotate_steps

max_distance = 50# v centimetroch

side_length_leds = 3 # merané v # pixeloch

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)

ak stav nie je žiadny:

# display.clear ()

pre c, val inenumerate (radar):

ak radar [c] <= max_distance:

# vypočítajte 2d súradnice každej vzdialenosti

uhol = kroky_krútenia / (kroky_otáčania -1) * krok otáčania * c

uhol += (180- rotate_span) /2,0

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

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

# upravte vzdialenosti tak, aby sa zmestili na mikrobitový displej 5x5

x_c = x_c * (dĺžka_strany_leds -1) / max_distance

y_c = y_c * (side_length_leds +1) / max_distance

# súradnice premiestnenia

x_c += (dĺžka_dĺžky_ledov -1)

y_c = (dĺžka_dĺžky_ +1 +1) - y_c

# okrúhle súradnice presne tam, kde sa nachádzajú diódy LED

ak x_c - matemat.podlaha (x_c) <0,5:

x_c = math.floor (x_c)

inak:

x_c = math.ceil (x_c)

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

y_c = math.floor (y_c)

inak:

y_c = math.ceil (y_c)

xar [c] = x_c

yar [c] = y_c

inak:

xar [c] = 0

yar [c] = 0

display.clear ()

pre x, y inzip (xar, yar):

display.set_pixel (x, y, 9)

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

stateA = button_a.is_pressed ()

stateB = button_b.is_pressed ()

ak stateA a stateB:

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

tlačiť („dopredu“)

ak stateA a nie stavB:

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

tlač („vľavo“)

ifnot stateA a stateB:

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

vytlačiť („vpravo“)

ifnot stateA andnot stateB:

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

vytlačiť („zastaviť“)

zobraziť rawgigglebot_lidar_remote.py hostiteľom ❤ od GitHub

Krok 7: Interpretácia vzdialenej obrazovky

"Load =" lenivý "ovláda GiggleBot, máte nasledujúce možnosti:

1. Stlačením tlačidiel A a B posuniete GiggleBot dopredu.
2. Stlačením tlačidla A otočte GiggleBot doľava.
3. Stlačením tlačidla B otočte GiggleBot doprava.

Ak sa chcete dozvedieť, ktorým smerom sú detekované najbližšie prekážky, stačí sa pozrieť na obrazovku diaľkového ovládača (diaľkový mikro BBC: bit, ktorý držíte). Mali by ste byť schopní ovládať GiggleBot z diaľky bez toho, aby ste sa na to pozerali.