Spisu treści:
- Autor John Day [email protected].
- Public 2024-01-30 11:30.
- Ostatnio zmodyfikowany 2025-01-23 15:03.
Tym razem programujemy w MicroPythonie Dexter Industries GiggleBot, aby podążał za czarną linią za pomocą wbudowanego czujnika śledzenia linii.
GiggleBot musi być sparowany z BBC micro:bit, aby można było nim odpowiednio sterować.
Jeśli ten samouczek jest dla Ciebie zbyt zaawansowany, a programowanie GiggleBota to na razie za dużo, zawsze możesz przejść przez samouczek dla początkujących, który pokazuje, jak można zaprogramować robota w MakeCode tutaj. Połączony samouczek przeprowadzi Cię przez podstawy.
Krok 1: Wymagane składniki
Wymagane są następujące komponenty sprzętowe:
- x3 baterie AA - w moim przypadku używam akumulatorów, które mają ogólnie niższe napięcie.
- Robot Dexter Industries GiggleBot dla micro:bit.
- BBC micro:bit.
Oczywiście do zaprogramowania BBC micro:bit potrzebny jest również kabel micro USB - ten kabel zazwyczaj znajduje się w pakiecie BBC micro:bit lub zawsze można użyć takiego, który służy do ładowania smartfonów (Android).
Pobierz GiggleBot dla micro:bit tutaj
Krok 2: Skonfiguruj ścieżki
Będziesz musiał wydrukować kilka kafelków i zaprojektować własne tory. Możesz użyć naszych własnych płytek, aby mieć 100% pewności, że odtwarzasz nasze warunki. A jeśli masz ochotę na przygodę, możesz użyć czarnej taśmy i zrobić własną. Oto plik PDF kafelków, których użyliśmy.
Powyższy tor składa się z następującej liczby różnych płytek:
- 12 płytek typu 1.
- 5 płytek typu #2.
- 3 szablony płytek typu #5.
- 3 szablony płytek typu #6 - tutaj otrzymasz jedną dodatkową płytkę.
Następnie wydrukuj je i wytnij. Spróbuj umieścić je tak, jak na powyższym zdjęciu i pamiętaj, że po prawej górnej stronie toru, 2 kafelki muszą zachodzić na siebie - jest to normalne, jeśli zastanawiasz się, czy robisz coś źle.
Krok 3: 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 4: Programowanie GiggleBot
Zanim przejdziemy do tego, środowisko uruchomieniowe GiggleBot MicroPython zawiera klasyczne środowisko uruchomieniowe dla BBC micro:bit i innych bibliotek obsługujących GiggleBot i inne czujniki Dexter Industries.
Po skonfigurowaniu otwórz następujący skrypt w edytorze Mu i kliknij Flash. Spowoduje to flashowanie GiggleBot MicroPython Runtime i skryptu, który właśnie otworzyłeś, do BBC micro:bit. Skrypt jest również pokazany poniżej.
Po zakończeniu procesu flashowania umieść BBC micro:bit w GiggleBot z neopikselami skierowanymi do przodu, umieść go na torze i włącz.
Zauważ, że w skrypcie PID i inne 2 stałe (nastawa prędkości i minimalne stałe prędkości) są już ustawione.
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.
GiggleBot PID Line Follower - dostrojony za pomocą NeoPixels
| z importu mikrobitów* |
| z importu gigglebot* |
| z utime importuj sleep_ms, ticks_us |
| importuj ustruktur |
| # inicjalizuj neopiksele GB |
| neo = init() |
| # wyczucie czasu |
| aktualizacja_rate = 50 |
| # wzmocnienia/stałe (przy założeniu, że napięcie akumulatora wynosi około 4,0 V) |
| Kp = 25,0 |
| Ki = 0,5 |
| Kd = 35,0 |
| punkt_wyzwalania = 0,3 |
| min_speed_percent = 0,3 |
| prędkość_bazowa =70 |
| wartość zadana =0,5 |
| ostatnia pozycja = wartość zadana |
| całka =0,0 |
| run_neopixels = Prawda |
| center_pixel =5# gdzie środkowy piksel uśmiechu znajduje się na GB |
| # turkus = tuple(map(lambda x:int(x/5), (64, 224, 208))) # kolor do narysowania błędu za pomocą neopikseli |
| # turkus = (12, 44, 41) # czyli dokładnie ten turkus skomentowany powyżej |
| error_width_per_pixel =0.5/3# maksymalny błąd podzielony przez liczbę segmentów pomiędzy każdym neopikselem |
| defupper_bound_linear_speed_reducer(błąd_abs, punkt_wyzwalania, górna_granica, najmniejsza_moc_silnika, najwyższa_moc_silnika): |
| globalna prędkość bazowa |
| jeśli abs_error >= trigger_point: |
| # x0 = 0,0 |
| # y0 = 0,0 |
| # x1 = górna granica - punkt_wyzwalania |
| # y1 = 1,0 |
| # x = błąd_abs - punkt_wyzwalania |
| # y = y0 + (x - x0) * (y1 - y0) / (x1 - x0) |
| # taki sam jak |
| y = (błąd_abs - punkt_wyzwalania) / (granica górna - punkt_wyzwalania) |
| moc_silnika = prędkość_podstawowa * (najmniejsza_moc_silnika + (1-y) * (najwyższa_moc_silnika - najmniejsza_moc_silnika)) |
| powrót moc_silnika |
| w przeciwnym razie: |
| zwróć prędkość_podstawową * najwyższa_moc_silnika |
| uruchom =Fałsz |
| poprzedni_błąd = 0 |
| podczas gdy prawda: |
| # jeśli przycisk a zostanie naciśnięty, zacznij podążać |
| jeśli button_a.is_pressed(): |
| uruchom =prawda |
| # ale jeśli przycisk b zostanie naciśnięty, zatrzymaj podążającego za linią |
| jeśli button_b.is_pressed(): |
| uruchom =Fałsz |
| całka =0,0 |
| poprzedni_błąd = 0,0 |
| wył_piksele() |
| zatrzymać() |
| sen_ms(500) |
| jeśli run is True: |
| # odczytaj czujniki linii |
| start_time = ticks_us() |
| prawo, lewo = read_sensor (LINE_SENSOR, BOTH) |
| # linia jest po lewej stronie, gdy pozycja < 0,5 |
| # linia jest po prawej stronie, gdy pozycja > 0,5 |
| # linia jest w środku, gdy pozycja = 0.5 |
| # to ważona średnia arytmetyczna |
| próbować: |
| pozycja = prawo /float(lewo + prawo) |
| z wyjątkiem ZeroDivisionError: |
| pozycja = 0.5 |
| # zakres musi być (0, 1), a nie [0, 1] |
| jeśli pozycja ==0: pozycja =0.001 |
| jeśli pozycja ==1: pozycja =0.999 |
| # użyj kontrolera PD |
| błąd = pozycja - wartość zadana |
| całka += błąd |
| korekta = Kp * błąd + Ki * całka + Kd * (błąd - poprzedni_błąd) |
| poprzedni_błąd = błąd |
| # obliczyć prędkości silnika |
| prędkość_silnika = górna_granica_liniowej_reduktora_prędkości(abs(błąd), nastawa * punkt_wyzwalania, nastawa, min_prędkość_procent, 1.0) |
| leftMotorSpeed = prędkość_silnika + korekta |
| rightMotorSpeed = prędkość_silnika - korekta |
| # rozświetl neopiksele zgodnie z podanym błędem |
| jeśli run_neopixels isTrue i total_counts %3==0: |
| dla i inb'\x00\x01\x02\x03\x04\x05\x06\x07\x08': |
| neo = (0, 0, 0) |
| dla i inb'\x00\x01\x02\x03': |
| ifabs(błąd) > szerokość_błędu na piksel * i: |
| jeśli błąd <0: |
| # neo[center_pixel + i] = turkus |
| neo[center_pixel + i] = (12, 44, 41) |
| w przeciwnym razie: |
| # neo[center_pixel - i] = turkus |
| neo[center_pixel + i] = (12, 44, 41) |
| w przeciwnym razie: |
| procent =1- (szerokość_błędu_na_piksel * i -abs(błąd)) / szerokość_błędu_na_piksel |
| # podświetl bieżący piksel |
| jeśli błąd <0: |
| # neo[center_pixel + i] = krotka(map(lambda x: int(x * procent), turkus)) |
| neo[center_pixel + i] = (int(64* procent /5), int(224* procent /5), int(208* procent /5)) |
| w przeciwnym razie: |
| # neo[center_pixel - i] = krotka(map(lambda x: int(x * procent), turkus)) |
| neo[center_pixel - i] = (int(64* procent /5), int(224* procent /5), int(208* procent /5)) |
| przerwa |
| neo.pokaż() |
| próbować: |
| # obcinanie prędkości silnika |
| jeśli lewyMotorSpeed >100: |
| lewa prędkość silnika =100 |
| rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100 |
| jeśli prawyPrędkość silnika >100: |
| prawa Prędkość Silnika =100 |
| leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100 |
| jeśli lewyMotorSpeed <-100: |
| lewa prędkość silnika =-100 |
| jeśli prawyMotorSpeed <-100: |
| prawa Prędkość Silnika =-100 |
| # uruchomić silniki |
| set_speed(lewaPrędkośćMotora, prawaPrędkośćMotora) |
| prowadzić samochód() |
| # print((błąd, prędkość silnika)) |
| z wyjątkiem: |
| # na wypadek, gdybyśmy mieli jakiś problem, którego nie da się naprawić |
| przechodzić |
| # i utrzymuj częstotliwość pętli |
| end_time = ticks_us() |
| delay_diff = (end_time - start_time) /1000 |
| if1000.0/ update_rate - delay_diff >0: |
| sen (1000.0/ częstotliwość_aktualizacji - różnica_opóźnień) |
zobacz rawgigglebot_tuned_line_follower.py hostowane z ❤ przez GitHub
Krok 5: Pozwól mu działać
Na BBC micro:bit znajdują się 2 przyciski: przycisk A i przycisk B:
- Naciśnięcie przycisku A powoduje, że GiggleBot podąża za linią (jeśli taka istnieje).
- Naciśnięcie przycisku B zatrzymuje GiggleBot i resetuje wszystko, aby można było go ponownie użyć.
Zdecydowanie zaleca się, aby nie podnosić GiggleBota, gdy podąża on za linią, a następnie umieszczać go z powrotem, ponieważ obliczany błąd może się kumulować i całkowicie zepsuć trasę robota. Jeśli chcesz go podnieść, naciśnij przycisk B, a następnie, gdy go odłożysz, ponownie naciśnij przycisk A.
Zalecana:
Jak stworzyć swoje pierwsze proste oprogramowanie przy użyciu Pythona: 6 kroków
Jak zrobić swoje pierwsze proste oprogramowanie przy użyciu Pythona: Cześć, witaj w tej instrukcji. Tutaj opowiem jak stworzyć własne oprogramowanie. Tak, jeśli masz pomysł… ale wiesz, jak wdrożyć lub jesteś zainteresowany tworzeniem nowych rzeczy, to jest dla Ciebie… Wymagania wstępne: Powinieneś mieć podstawową wiedzę z
Pulpit nawigacyjny COVID19 na mapie świata (przy użyciu Pythona): 16 kroków
Pulpit nawigacyjny COVID19 na mapie świata (przy użyciu Pythona): Wiem, że prawie każdy z nas zna większość informacji o COVID19. A ta instrukcja dotyczy tworzenia mapy bąbelkowej, aby wykreślić dane w czasie rzeczywistym (przypadków) na mapie świata. Dla większej wygody , dodałem program do repozytorium Github: https://github.co
Eksperymenty z zaawansowanym rejestrowaniem danych (przy użyciu Pythona): 11 kroków
Eksperymenty w zaawansowanym rejestrowaniu danych (przy użyciu Pythona): Istnieje wiele instrukcji dotyczących rejestrowania danych, więc kiedy chciałem zbudować własny projekt rejestrowania, rozejrzałem się po kilku. Niektóre były dobre, inne nie, więc postanowiłem wziąć kilka lepszych pomysłów i stworzyć własną aplikację. Ten wynik
Planetarium zasilane siecią neuronową przy użyciu Pythona, elektronu i Keras: 8 kroków
Planetarium zasilane siecią neuronową za pomocą Pythona, elektronu i Keras: W tej instrukcji pokażę, jak napisałem automatyczny generator planetarium 3D, używając Pythona i elektronu. Powyższy film pokazuje jedno z losowych planetariów wygenerowanych przez program.**Uwaga: Ten program nie jest w żaden sposób doskonały, a w pewnym miejscu
Neopixel Ws2812 Rainbow LED Glow z M5stick-C - Uruchamianie Rainbow na Neopixel Ws2812 przy użyciu M5stack M5stick C przy użyciu Arduino IDE: 5 kroków
Neopixel Ws2812 Rainbow LED Glow z M5stick-C | Uruchamianie Rainbow na Neopixel Ws2812 Używając M5stack M5stick C Używając Arduino IDE: Cześć chłopaki, w tej instrukcji dowiemy się, jak używać neopikselowych ws2812 LED lub taśmy LED lub matrycy LED lub pierścienia LED z płytką rozwojową m5stack m5stick-C z Arduino IDE i zrobimy wzór tęczy z nim