Stwórz robota kierowanego Lidarem za pomocą GiggleBot: 8 kroków

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:30

W tym samouczku sprawimy, że GiggleBot poradzi sobie z trudnościami labiryntu.

Montujemy serwo na GiggleBocie, do którego przyczepiamy czujnik odległości. Podczas biegu serwo będzie się obracać w przód iw tył, aby czujnik odległości mógł zmierzyć odległość do każdej przeszkody. Działa to podobnie jak czujnik LIDAR, który zwykle jest znacznie droższy.

W tym samym czasie GiggleBot wysyła te dane do zdalnego BBC micro:bit, który wyświetla na macierzy 5 na 5 diod LED swoją pozycję względem przeszkód.

Twoim zadaniem jest nawigacja po GiggleBot tylko poprzez patrzenie na to, co jest wyświetlane na innym BBC micro:bit. Do sterowania GiggleBot używane są przyciski na zdalnym BBC micro:bit.

To brzmi jak zabawa! Przejdźmy do tego, dobrze?

Krok 1: Wymagane składniki

Będziemy potrzebować:

1. GiggleBot.
2. Akumulator do BBC micro:bit. Jest dostarczany wraz z BBC micro:bit w swoim opakowaniu.
3. 3 baterie AA do GiggleBot.
4. Kabel Grove do podłączenia czujnika odległości do GiggleBot.
5. Zestaw Servo firmy DexterIndustries.
6. x3 BBC mikro:bity. Jeden do GiggleBot i jeden do sterowania robotem z daleka.
7. Czujnik odległości od DexterIndustries.

Pobierz tutaj robota GiggleBot dla BBC micro:bit!

Krok 2: Montaż robota

Aby GiggleBot był gotowy do zaprogramowania, musimy go złożyć, chociaż nie trzeba wiele robić.

Włóż 3 baterie AA do komory pod GiggleBot.

Złóż pakiet serwo. Do jego obrotowego ramienia serwomechanizmu użyj ostatniego otworu, aby przymocować serwo do przednich złączy GiggleBot. Możesz użyć śruby i/lub drutu, aby był bardziej stabilny na swoim miejscu. Możesz też przykleić go na gorąco do deski. W moim przypadku użyłem śruby i krótkiego przewodu, aby związać ramię serwa z płytą GiggleBot.

Montując ramię serwa na serwo, upewnij się, że serwo jest już ustawione w pozycji 80. Możesz to zrobić, wywołując gigglebot.set_servo(gigglebot. RIGHT, 80). Więcej na ten temat przeczytasz tutaj.

Następnie umieść czujnik odległości na przedniej stronie pakietu serwomechanizmu i zamocuj go jak w powyższym przykładzie.

Na koniec podłącz czujnik odległości kablem Grove do dowolnego z 2 portów I2C, a serwomotor do prawego portu znajdującego się na GiggleBot – prawy port jest na nim wymieniony.

Krok 3: Stwórz własny labirynt - opcjonalnie

W tym przypadku użyłem kilku pudełek do stworzenia zamkniętej pętli, podobnej do NASCAR.

Na tym etapie możesz stać się naprawdę kreatywny i sprawić, by było tak zakręcone, jak chcesz, lub sprawić, by było bardzo długie, ponieważ to naprawdę zależy od Ciebie.

A jeśli w ogóle nie chcesz mieć toru, możesz umieścić GiggleBot na przykład w kuchni lub salonie – to powinno wystarczyć, ponieważ jest wiele ścian i przeszkód, których nadal musisz unikać.

Krok 4: Konfiguracja środowiska

Aby móc zaprogramować BBC micro:bit w MicroPython, musisz skonfigurować dla niego edytor (Edytor Mu) i ustawić GiggleBot MicroPython Runtime jako środowisko uruchomieniowe. W tym celu musisz postępować zgodnie z instrukcjami na tej stronie. Od tego momentu używana jest wersja v0.4.0 środowiska wykonawczego.

Krok 5: Programowanie GiggleBota - część I

Najpierw skonfigurujmy skrypt GiggleBota. Ten skrypt sprawi, że GiggleBot obróci swój serwomotor o 160 stopni (80 stopni w każdym kierunku), jednocześnie wykonując 10 odczytów z czujnika odległości na obrót.

Po włączeniu GiggleBot będzie czekał, dopóki nie otrzyma polecenia z pilota. Mogą być tylko 3 komendy: idź do przodu, w lewo lub w prawo.

Uwaga: w poniższym skrypcie może brakować białych znaków i wydaje się, że jest to spowodowane pewnym problemem z wyświetlaniem GitHub Gist. Kliknij treść, aby przejść do strony GitHub, gdzie możesz skopiować i wkleić kod.

Zdalnie sterowany GiggleBot oparty na LIDAR

z importu gigglebot*

from Distance_sensor import DistanceSensor

z microbit import sleep

z utime import ticks_us, sleep_us

importuj ustruktur

importuj radio

# zatrzymaj robota, jeśli już się porusza

zatrzymać()

# włącz radio

radio.on()

# obiekt czujnika odległości

ds = czujnik odległości()

ds.start_ciągły()

rotate_time = 0,7 # mierzony w sekundach

rotate_span =160# mierzony w stopniach

obróć_kroki = 10

overhead_compensation =1.05# określone w procentach

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

czas_ostatniego_odczytu =0

radar =tablica bajtów(obrót_kroków)

servo_rotate_direction =0#0 za jazdę w górę (0->160) i 1 w przeciwnym razie

indeks_radarowy = 0

set_servo(PRAWY, 0)

podczas gdy prawda:

# odczytane z radaru

if ticks_us() - last_read_time > time_per_step:

# odczyt z czujnika odległości

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

last_read_time = ticks_us()

drukuj(radar_index)

# wykonaj logikę obracania serwa od lewej do prawej

if radar_index == rotate_steps -1and servo_rotate_direction ==0:

set_servo(PRAWY, 0)

servo_rotate_direction =1

elif radar_index ==0i servo_rotate_direction ==1:

set_servo(PRAWY, obrót_zakresu)

servo_rotate_direction = 0

w przeciwnym razie:

radar_index +=1jeśli servo_rotate_direction ==0else-1

# i wyślij wartości radarowe

radio.send_bytes(radar)

próbować:

# przeczytaj polecenia robota

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

# i włącz silniki, jeśli zostaną odebrane jakieś polecenia

set_speed(lsilnik, rsilnik)

prowadzić samochód()

z wyjątkiem błędu typu:

przechodzić

zobacz rawgigglebot_lidar_robot.py hostowany z ❤ przez GitHub

Krok 6: Programowanie pilota - część II

Pozostało tylko zaprogramować drugi BBC micro:bit, który działa jak pilot.

Pilot służy do wyświetlania na ekranie o wymiarach 5 na 5 pikseli względnej odległości od przeszkód. Co najwyżej włączonych będzie 10 pikseli.

Jednocześnie pilot umożliwia zdalne sterowanie urządzeniem GiggleBot za pomocą 2 przycisków: przesuń się do przodu, w lewo i w prawo.

Uwaga: w poniższym skrypcie może brakować białych znaków i wydaje się, że jest to spowodowane pewnym problemem z wyświetlaniem GitHub Gist. Kliknij treść, aby przejść do strony GitHub, gdzie możesz skopiować i wkleić kod.

Zdalnie sterowany GiggleBot oparty na LIDAR - zdalny kod

z microbit importu snu, wyświetlacza, button_a, button_b

importuj ustruktur

importuj radio

importuj matematykę

radio.on()

obróć_kroki = 10

rotate_span =160# w stopniach

rotate_step = rotate_span / rotate_steps

max_distance =50# w centymetrach

side_length_leds = 3# mierzone w liczbie pikseli

radar =tablica bajtów(obrót_kroków)

xar =tablica bajtów(obrót_kroków)

yar =bajttablica(obrót_kroków)

save_xar = bajttablica (obrót_kroków)

save_yar =bytearray(rotate_steps)

prędkość_silnika =50

podczas gdy prawda:

status = radio.receive_bytes_into(radar)

jeśli stan nie jestBrak:

# display.clear()

dla c, val inenumerate(radar):

jeśli radar[c] <= max_distance:

# oblicz współrzędne 2d każdej odległości

kąt = obróć_kroki / (obróć_kroki -1) * obróć_krok * c

kąt += (180- obrót_rozpiętości) /2,0

x_c = math.cos(kąt * math.pi /180.0) * radar[c]

y_c = math.sin(kąt * math.pi /180.0) * radar[c]

# skaluj odległości, aby zmieściły się na wyświetlaczu mikrobitowym 5x5

x_c = x_c * (boczne_długość_led -1) / max_odległość

y_c = y_c * (długość_boków +1) / maksymalna_odległość

# zmiana położenia współrzędnych

x_c += (side_length_leds -1)

y_c = (boczne_długość_diod +1) - y_c

# okrągłe współrzędne dokładnie tam, gdzie znajdują się diody LED

jeśli x_c - matematyka.podłoga(x_c) <0.5:

x_c = matematyka.podłoga(x_c)

w przeciwnym razie:

x_c = matematyka.ceil(x_c)

jeśli y_c - matematyka.podłoga(y_c) <0.5:

y_c = matematyka.podłoga(y_c)

w przeciwnym razie:

y_c = matematyka.ceil(y_c)

xar[c] = x_c

yar[c] = y_c

w przeciwnym razie:

xar[c] =0

jar[c] =0

wyświetl.wyczyść()

dla x, y inzip(xar, yar):

display.set_pixel(x, y, 9)

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

stanA = przycisk_a.jest_wciśnięty()

stanB = button_b.is_pressed()

jeśli stan A i stan B:

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

print('naprzód')

jeśli stan A i nie stan B:

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

print('w lewo')

jeśli nie stan A i stan B:

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

print('prawo')

jeśli nie stan A i nie stan B:

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

print('stop')

zobacz rawgigglebot_lidar_remote.py hostowane z ❤ przez GitHub

Krok 7: Interpretacja zdalnego ekranu

"loading="leniwy" kontroluj GiggleBot, masz następujące opcje:

1. Naciśnij przycisk A i przycisk B, aby przesunąć GiggleBota do przodu.
2. Naciśnij przycisk A, aby obrócić GiggleBota w lewo.
3. Naciśnij przycisk B, aby obrócić GiggleBota w prawo.

Aby zobaczyć, w którym kierunku zostaną wykryte najbliższe przeszkody, po prostu spójrz na ekran pilota (przytrzymanego pilota BBC micro:bit). Powinieneś być w stanie kontrolować GiggleBot z daleka, nie patrząc na niego.