Spisu treści:
2025 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2025-01-13 06:58
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ć:
- GiggleBot.
- Akumulator do BBC micro:bit. Jest dostarczany wraz z BBC micro:bit w swoim opakowaniu.
- 3 baterie AA do GiggleBot.
- Kabel Grove do podłączenia czujnika odległości do GiggleBot.
- Zestaw Servo firmy DexterIndustries.
- x3 BBC mikro:bity. Jeden do GiggleBot i jeden do sterowania robotem z daleka.
- 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:
- Naciśnij przycisk A i przycisk B, aby przesunąć GiggleBota do przodu.
- Naciśnij przycisk A, aby obrócić GiggleBota w lewo.
- 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.