Dostrajanie obserwatora linii GiggleBot - zaawansowane: 7 kroków

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

W tych bardzo krótkich Instruktażach dostroisz swojego GiggleBot, aby podążał za czarną linią. W tym innym samouczku GiggleBot Line Follower zakodowaliśmy na stałe wartości dostrajania, aby działały zgodnie z tym scenariuszem. Możesz chcieć, aby zachowywał się lepiej, wymyślając inne korzyści.

W tym samouczku pokazujemy 2 skrypty, które można załadować do różnych BBC micro:bits, tak aby jeden z nich został umieszczony w GiggleBot, a drugi, 2 przyciski służą do przechodzenia przez menu i dostrajania różnych parametry. Wysyłanie tych zaktualizowanych parametrów odbywa się drogą radiową.

Krok 1: Wymagane składniki

Będziesz potrzebować:

1. Robot GiggleBot dla micro:bit.
2. 3 baterie AA
3. x2 BBC micro:bits - jeden dla GiggleBota, a drugi pełniący funkcję pilota do strojenia parametrów.
4. Bateria do BBC micro:bit - taka jak ta, która znajduje się w pakiecie BBC micro:bit.

Pobierz tutaj robota GiggleBot dla BBC micro:bit

Krok 2: Konfiguracja torów i środowiska

Musisz także faktycznie zbudować swoje ścieżki (pobrać, wydrukować, wyciąć i nagrać płytki), a następnie skonfigurować środowisko (IDE i środowisko wykonawcze).

Ponieważ ten samouczek jest bardzo powiązany z tym innym samouczkiem zatytułowanym GiggleBot Line Follower, po prostu idź tam i wykonaj kroki 2 i 3, a następnie wróć tutaj.

Jeśli chodzi o IDE, możesz użyć edytora Mu, a do uruchomienia musisz pobrać GiggleBot MicroPython Runtime. Środowisko wykonawcze można pobrać z jego dokumentacji tutaj. Przejdź do rozdziału dokumentacji Pierwsze kroki i postępuj zgodnie z instrukcjami dotyczącymi konfigurowania środowiska. Od tego momentu używana jest wersja v0.4.0 środowiska wykonawczego.

Krok 3: Konfigurowanie GiggleBot

Przed flashowaniem środowiska wykonawczego do GiggleBot upewnij się, że wybrałeś żądaną prędkość i częstotliwość aktualizacji dla GiggleBot: domyślnie prędkość jest ustawiona na 100 (zmienna base_speed), a częstotliwość aktualizacji na 70 (zmienna update_rate).

Biorąc pod uwagę obecną implementację, najwyższa szybkość aktualizacji, jaką można osiągnąć, wynosi 70, a jeśli run_neopixels jest ustawione na True, można osiągnąć tylko 50. W pewnym sensie można więc powiedzieć, że domyślna częstotliwość aktualizacji jest na granicy tego, co może zrobić BBC micro:bit.

Dla przypomnienia, czujnik śledzenia linii może zwracać aktualizacje 100 razy na sekundę.

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 Tuner (wymaga pilota do strojenia) - xjfls23

z importu mikrobitów*

z importu gigglebot*

z utime importuj sleep_ms, ticks_us

importuj radio

importuj ustruktur

# inicjalizuj radio i neopiksele GB

radio.on()

neo = init()

# wyczucie czasu

aktualizacja_rate = 70

# domyślne wartości wzmocnienia

Kp = 0,0

Ki = 0,0

Kd = 0,0

wartość zadana =0,5

punkt_wyzwalania =0.0

min_speed_percent = 0,2

prędkość_bazowa =100

ostatnia pozycja = wartość zadana

całka =0,0

run_neopixels =Fałsz

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

całkowity_czas = 0,0

całkowita_liczba = 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

display.scroll('{} - {}'.format(całkowity_czas, całkowita_liczba), opóźnienie=100, czekaj=False)

całkowity_czas = 0,0

całkowita_liczba = 0

wył_piksele()

zatrzymać()

sen_ms(500)

jeśli run is True:

# odczytaj czujniki linii

start_time = ticks_us()

# sprawdź czy zaktualizowaliśmy zyski Kp/Kd za pomocą pilota

próbować:

Kp, Ki, Kd, trigger_point, min_speed_percent = ustruct.unpack('ffffff', radio.receive_bytes())

zestaw_oczy()

z wyjątkiem błędu typu:

przechodzić

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

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, aby pokazać, w którym kierunku ma iść GiggleBot

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] = (12, 44, 41)

w przeciwnym razie:

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(12* procent), int(44* procent), int(41* procent))

w przeciwnym razie:

# neo[center_pixel - i] = krotka(map(lambda x: int(x * procent), turkus))

neo[center_pixel - i] = (int(12* procent), int(44* procent), int(41* procent))

przerwa

neo.pokaż()

próbować:

# przypnij silniki

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

całkowity_czas += opóźnienie_różnic

total_counts +=1

if1.0/ update_rate - delay_diff >0:

sen (1.0/ częstotliwość_aktualizacji - różnica_opóźnień)

zobacz rawgigglebot_line_follower_tuner.py hostowany z ❤ przez GitHub

Krok 4: Konfigurowanie tunera (zdalne)

Następną rzeczą, którą musimy zrobić, jest flashowanie runtime + skryptu do drugiego BBC micro:bit. Ten drugi micro:bit będzie działał jako pilot do GiggleBot, który będzie używany do dostrajania następujących parametrów:

1. Kp = wzmocnienie proporcjonalne dla regulatora PID.
2. Ki = wzmocnienie całkowania dla regulatora PID.
3. Kd = wzmocnienie różniczkujące dla regulatora PID.
4. trigger_point = punkt wyrażony w procentach między minimalną a maksymalną prędkością GiggleBot, przy której prędkość zaczyna się zmniejszać liniowo, aż osiągnie prędkość minimalną.
5. min_speed_percent = minimalna prędkość wyrażona w procentach maksymalnej prędkości.

Pozostałe 2 pozostałe zmienne, które można dostroić, są bezpośrednio zakodowane w skrypcie znajdującym się na GiggleBot: update_rate i base_speed, które reprezentują maksymalną prędkość. Jak opisano w dokumentacji, maksymalna prędkość, jaką można ustawić dla GiggleBot to 100, co jest również wartością domyślną dla naszego GiggleBot.

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 Remote PID Line Follower Tuner (wymaga drugiej części) - xjfls23

z importu mikrobitów*

z utime importuj sleep_ms

importuj radio

importuj ustruktur

# 1 element to wzmocnienie Kp

# Drugim elementem jest wzmocnienie Ki

# 3 element to wzmocnienie Kd

# Czwarty element to punkt_wyzwalania dla silników, aby obniżyć prędkość (0 -> 1)

# Piąty element to minimalna prędkość silników wyrażona w procentach (0 -> 1)

zyski = [0,0, 0,0, 0,0, 1,0, 0,0]

rozmiar kroku = 0,1

# 0 i 1 dla pierwszego elementu

# 2 i 3 dla drugiego elementu

obecneUstawienie =0

defshowMenu():

display.scroll('{} - {}'.format(currentSetting, gains[int(currentSetting /2)]), delay=100, wait=False)

radio.on()

Pokaż menu()

podczas gdy prawda:

zaktualizowano = Fałsz

jeśli button_a.is_pressed():

CurrentSetting = (currentSetting +1) % (2*5)

zaktualizowano = Prawda

jeśli button_b.is_pressed():

jeśli obecneUstawienie %2==0:

# zwiększ wzmocnienie, gdy currentSetting wynosi 0 lub 2 lub..

ifint(currentSetting /2) w [0, 2]:

zyski[int(currentSetting /2)] +=10* stepSize

w przeciwnym razie:

zyski[int(currentSetting /2)] += stepSize

w przeciwnym razie:

# zwiększ wzmocnienie, gdy currentSetting wynosi 1 lub 3 lub..

ifint(currentSetting /2) w [0, 2]:

zyski[int(currentSetting /2)] -=10* stepSize

w przeciwnym razie:

zyski[int(currentSetting /2)] -= stepSize

radio.send_bytes(ustruct.pack('fffff', *zyski))

zaktualizowano = Prawda

jeśli zaktualizowany:

Pokaż menu()

sen_ms(200)

wyświetl rawgigglebot_line_follower_configurator.py hostowany z ❤ przez GitHub

Krok 5: Dostrajanie GiggleBot

Umieść GiggleBot na torze, włącz go i pozwól mu działać. W międzyczasie będziesz musiał ciągle umieszczać go z powrotem na torze i dostrajać wzmocnienia/parametry za pomocą drugiego micro:bit BBC, który trzymasz w dłoni.

Aby uruchomić GiggleBot, naciśnij przycisk A na BBC micro:bit GiggleBota, a aby go zatrzymać, a tym samym zresetować jego stan, naciśnij przycisk B.

Na zdalnym BBC micro:bit naciśnięcie przycisku A spowoduje przejście przez każdą opcję w jego menu, a przycisk B zwiększy/zmniejszy odpowiednią wartość. To jak ustawienie zegara na desce rozdzielczej starego samochodu. Opcje są takie:

1. Opcje 0-1 dotyczą wzmocnienia Kp.
2. 2-3 opcje są dla wzmocnienia Ki.
3. 4-5 opcji dotyczy wzmocnienia Kd.
4. Opcje 6-7 służą do ustawienia wartości zadanej na moment, w którym silniki zaczną zwalniać.
5. 8-9 opcji służy do ustawienia minimalnej prędkości.

Pamiętaj, że liczby parzyste w menu służą do zwiększania odpowiednich wartości, a nieparzyste jest dokładnie odwrotnie.

Ponadto, po naciśnięciu przycisku B na BBC micro:bit GiggleBot, zobaczysz na ekranie wykonanym z Neopixela liczbę milisekund, które upłynęły od ostatniego resetu oraz liczbę cykli, które przeszedł robot - z tymi 2 możesz obliczyć częstotliwość aktualizacji robota.

Na koniec i co najważniejsze, wymyśliłem 2 stroje dla GiggleBot. Jedna z nich służy do wyłączania diod Neopixel, a druga do sytuacji, gdy jest inaczej. Diody LED Neopixel służą do wskazywania kierunku, w którym nagromadził się błąd.

Pierwszy zestaw dostrajania parametrów (z wyłączonymi diodami NeoPixel)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0,3 (czyli 30%)
5. min_speed_percent = 0,2 (czyli 20%)
6. base_speed = 100 (czyli maksymalna prędkość)
7. update_rate = 70 (działa przy 70 Hz)

2 zestaw dostrajania parametrów (z włączonymi diodami NeoPixel)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0,3 (czyli 30%)
5. min_speed_percent = 0,3 (czyli 30%)
6. base_speed = 70 (czyli maksymalna prędkość)
7. update_rate = 50 (działa przy 50 Hz)
8. Ponadto zmienna run_neopixels musi być ustawiona na True w skrypcie, który jest ładowany do BBC micro:bit GiggleBot. Spowoduje to, że diody NeoPixel będą migać w taki sposób, aby wskazywały kierunek kumulacji błędu.

Krok 6: GiggleBot działa z wyłączonymi NeoPixels

To jest przykład uruchomienia GiggleBota z pierwszymi parametrami strojenia znalezionymi w poprzednim kroku. W tym przykładzie diody LED NeoPixel są wyłączone.

Krok 7: GiggleBot działa z włączonymi neopikselami

To jest przykład uruchomienia GiggleBot z drugim zestawem parametrów strojenia znalezionym w kroku 5. Ten przykład ma włączone diody NeoPixel.

Zauważ, że w tym przykładzie GiggleBot ma trudności z podążaniem za linią - to dlatego, że diody Neopixel "zjadają" czas procesora BBC micro:bit. Dlatego musieliśmy zmniejszyć częstotliwość aktualizacji z 70 do 50.