GiggleBot Line Follower przy użyciu Pythona: 5 kroków

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

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:

1. x3 baterie AA - w moim przypadku używam akumulatorów, które mają ogólnie niższe napięcie.
2. Robot Dexter Industries GiggleBot dla micro:bit.
3. 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.