Reglarea urmăritorului de linie GiggleBot - Avansat: 7 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

În acest Instructables foarte scurt, veți regla propriul GiggleBot pentru a urma o linie neagră. În acest alt tutorial GiggleBot Line Follower, am codificat cu greu valorile de reglare pentru a funcționa în funcție de scenariul respectiv. S-ar putea să doriți să-l faceți să se comporte mai bine venind cu alte câștiguri.

În acest tutorial, vă prezentăm 2 scripturi care pot fi încărcate ambele pe diferite micro BBC: biți, astfel încât unul dintre ei să fie introdus în GiggleBot și, cu celălalt, cele 2 butoane sunt folosite pentru a trece printr-un meniu și pentru a regla diferite parametrii. Trimiterea acestor parametri actualizați se face prin radio.

Pasul 1: Componente necesare

Veți avea nevoie de următoarele:

1. Un robot GiggleBot pentru micro: bit.
2. x3 Baterii AA
3. x2 BBC micro: biți - unul pentru GiggleBot și celălalt acționând ca o telecomandă pentru reglarea parametrilor.
4. O baterie pentru un micro: bit BBC - ca cea care vine în pachetul BBC micro: bit.

Obțineți robotul GiggleBot pentru micro: bitul BBC aici

Pasul 2: Configurarea pieselor și a mediului

De asemenea, trebuie să vă construiți piesele (descărcați, imprimați, tăiați și lipiți plăci) și apoi să configurați mediul (IDE și timpul de execuție).

Deoarece acest tutorial este foarte legat de acest alt tutorial intitulat GiggleBot Line Follower, mergeți acolo și urmați pașii 2 și 3 și apoi reveniți aici.

În ceea ce privește IDE, puteți utiliza editorul Mu, iar pentru runtime, trebuie să descărcați GiggleBot MicroPython Runtime. Runtime-ul poate fi descărcat din documentația sa de aici. Accesați capitolul Introducere din documentație și urmați aceste instrucțiuni despre configurarea mediului. În acest moment, se folosește versiunea v0.4.0 a runtime-ului.

Pasul 3: Configurarea GiggleBot

Înainte de a afișa timpul de rulare pe GiggleBot, asigurați-vă că ați ales viteza și rata de actualizare dorite pentru GiggleBot: în mod implicit, viteza este setată la 100 (variabilă base_speed) și rata de actualizare este setată la 70 (variabilă update_rate).

Având în vedere implementarea actuală, cea mai mare rată de actualizare care poate fi atinsă este de 70 și dacă run_neopixels este setat la True, atunci doar 50 este realizabil. Deci, într-un fel, ați putea spune că rata de actualizare implicită este chiar la marginea a ceea ce poate face BBC micro: bit.

Doar pentru înregistrare, senzorul liniarului poate întoarce actualizări de 100 de ori pe secundă.

Notă: Următorul script ar putea să aibă spații albe lipsă și acest lucru se pare că se datorează unor probleme la afișarea GitHub Gists. Faceți clic pe esență pentru a vă duce la pagina GitHub, unde puteți copia-lipi codul.

Tuner GiggleBot PID Line Follower (necesită o telecomandă pentru a-l regla) - xjfls23

din importul microbitului *

din importul gigglebot *

din utime import sleep_ms, ticks_us

import radio

import ustruct

# inițializează neopixeli radio și GB

radio.on ()

neo = init ()

# calendarul

update_rate = 70

# valori de câștig implicite

Kp = 0,0

Ki = 0,0

Kd = 0,0

setpoint = 0,5

trigger_point = 0.0

min_speed_percent = 0,2

viteză_bază = 100

last_position = setpoint

integral = 0,0

run_neopixels = False

center_pixel = 5 # unde pixelul central al zâmbetului este situat pe GB

# turcoaz = tuplu (hartă (lambda x: int (x / 5), (64, 224, 208))) # culoare de utilizat pentru a desena eroarea cu neopixeli

# turcoaz = (12, 44, 41) # care este exact turcoazul de mai sus comentat mai sus

error_width_per_pixel = 0,5 / 3 # eroare maximă împărțită la numărul de segmente dintre fiecare neopixel

defupper_bound_linear_speed_reducer (abs_error, trigger_point, upper_bound, smallest_motor_power, maximum_motor_power):

viteză_bază globală

dacă abs_error> = trigger_point:

# x0 = 0,0

# y0 = 0,0

# x1 = upper_bound - trigger_point

# y1 = 1.0

# x = abs_error - trigger_point

# y = y0 + (x - x0) * (y1 - y0) / (x1 - x0)

# la fel ca

y = (abs_error - trigger_point) / (upper_bound - trigger_point)

motor_power = base_speed * (smallest_motor_power + (1- y) * (maximum_motor_power - smallest_motor_power))

returnează puterea_motor

altceva:

returnează viteza_bază * cea mai mare_puteră_motor

run = False

previous_error = 0

total_time = 0,0

total_counts = 0

whileTrue:

# dacă este apăsat butonul a, începeți să urmați

dacă button_a.is_pressed ():

alerga = Adevărat

# dar dacă butonul b este apăsat, opriți următorul linie

dacă button_b.is_pressed ():

run = False

integral = 0,0

previous_error = 0.0

display.scroll ('{} - {}'. format (total_time, total_counts), delay = 100, wait = False)

timp_total = 0,0

total_counts = 0

pixels_off ()

Stop()

sleep_ms (500)

dacă rulați este Adevărat:

# citiți senzorii de linie

start_time = ticks_us ()

# verificați dacă am actualizat câștigurile Kp / Kd cu o telecomandă

încerca:

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

set_eyes ()

exceptTypeError:

trece

dreapta, stânga = read_sensor (LINE_SENSOR, BOTH)

# linia este în stânga când poziția <0,5

# linia este în dreapta când poziția> 0,5

# linia este la mijloc când poziția = 0,5

# este o medie aritmetică ponderată

încerca:

poziție = dreapta / plutitor (stânga + dreapta)

exceptZeroDivisionError:

poziția = 0,5

dacă poziția == 0: poziția = 0,001

if position == 1: position = 0.999

# utilizați un controler PD

eroare = poziție - setpoint

integral + = eroare

corecție = eroare Kp * + Ki * integral + Kd * (eroare - eroare_anterioră)

previous_error = eroare

# calculați turațiile motorului

motor_speed = upper_bound_linear_speed_reducer (abs (eroare), setpoint * trigger_point, setpoint, min_speed_percent, 1.0)

leftMotorSpeed = motor_speed + corecție

rightMotorSpeed = motor_speed - corectare

# aprindeți neopixeli pentru a arăta în ce direcție trebuie să meargă GiggleBot

dacă run_neopixels este adevărat și total_counts% 3 == 0:

pentru i inb '\ x00 / x01 / x02 / x03 / x04 / x05 / x06 / x07 / x08':

neo = (0, 0, 0)

pentru i inb '\ x00 / x01 / x02 / x03':

ifabs (eroare)> error_width_per_pixel * i:

dacă eroarea <0:

neo [centru_pixel + i] = (12, 44, 41)

altceva:

neo [centru_pixel - i] = (12, 44, 41)

altceva:

procent = 1- (error_width_per_pixel * i -abs (error)) / error_width_per_pixel

# aprinde pixelul curent

dacă eroarea <0:

# neo [center_pixel + i] = tuplu (hartă (lambda x: int (x * procent), turcoaz))

neo [centru_pixel + i] = (int (12 * procente), int (44 * procente), int (41 * procente))

altceva:

# neo [center_pixel - i] = tuplu (hartă (lambda x: int (x * procent), turcoaz))

neo [centru_pixel - i] = (int (12 * procente), int (44 * procente), int (41 * procente))

pauză

neo.show ()

încerca:

# fixați motoarele

if leftMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

dacă rightMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

dacă leftMotorSpeed <-100:

leftMotorSpeed = -100

dacă rightMotorSpeed <-100:

rightMotorSpeed = -100

# acționați motoarele

set_speed (leftMotorSpeed, rightMotorSpeed)

conduce()

# print ((eroare, motor_speed))

cu exceptia:

# în caz că intrăm într-o problemă nesoluționată

trece

# și mențineți frecvența buclei

time_ end = ticks_us ()

delay_diff = (end_time - start_time) / 1000

total_time + = delay_diff

total_counts + = 1

if1.0 / update_rate - delay_diff> 0:

sleep (1.0 / update_rate - delay_diff)

vizualizați rawgigglebot_line_follower_tuner.py găzduit cu ❤ de GitHub

Pasul 4: Configurarea tunerului (telecomandă)

Următorul lucru pe care trebuie să-l facem este să trimitem scriptul runtime + la al doilea micro: bit BBC. Acest al doilea micro: bit va acționa ca o telecomandă pentru GiggleBot, care va fi folosit pentru a regla următorii parametri:

1. Kp = câștig proporțional pentru controlerul PID.
2. Ki = câștig integral pentru controlerul PID.
3. Kd = câștig derivat pentru controlerul PID.
4. trigger_point = punctul exprimat în procente între viteza minimă și maximă a GiggleBot în care viteza începe să se reducă liniar până când atinge viteza minimă.
5. min_speed_percent = viteza minimă exprimată în procente din viteza maximă.

Celelalte 2 variabile rămase care pot fi reglate sunt direct codate în scriptul care se află pe GiggleBot: update_rate și base_speed care reprezintă viteza maximă. După cum este descris în documentație, viteza maximă care poate fi setată pentru GiggleBot este 100, care este, de asemenea, valoarea implicită pentru GiggleBot.

Notă: Următorul script ar putea să aibă spații albe lipsă și acest lucru se pare că se datorează unor probleme la afișarea GitHub Gists. Faceți clic pe esență pentru a vă duce la pagina GitHub, unde puteți copia-lipi codul.

GiggleBot Remote PID Line Follower Tuner (necesită cealaltă parte) - xjfls23

din importul microbitului *

din utime import sleep_ms

import radio

import ustruct

Primul element este câștigul Kp

Al doilea element este câștigul Ki

Al treilea element este câștigul Kd

Al patrulea element este punctul de declanșare pentru motoare pentru a reduce viteza (0 -> 1)

# Elementul 5 este viteza minimă pentru motoare exprimată în procente (0 -> 1)

câștiguri = [0,0, 0,0, 0,0, 1,0, 0,0]

stepSize = 0,1

# 0 și 1 pentru primul element

# 2 și 3 pentru al doilea element

currentSetting = 0

defshowMenu ():

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

radio.on ()

showMenu ()

whileTrue:

actualizat = Fals

dacă button_a.is_pressed ():

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

actualizat = Adevărat

dacă button_b.is_pressed ():

dacă setarea curentă% 2 == 0:

# crește câștigul când setarea curentă este 0 sau 2 sau..

ifint (currentSetting / 2) în [0, 2]:

câștiguri [int (currentSetting / 2)] + = 10 * stepSize

altceva:

câștiguri [int (currentSetting / 2)] + = stepSize

altceva:

# crește câștigul când setarea curentă este 1 sau 3 sau..

ifint (currentSetting / 2) în [0, 2]:

câștiguri [int (currentSetting / 2)] - = 10 * stepSize

altceva:

câștiguri [int (currentSetting / 2)] - = stepSize

radio.send_bytes (ustruct.pack ('fffff', * câștiguri))

actualizat = Adevărat

dacă este actualizat:

showMenu ()

sleep_ms (200)

vizualizați rawgigglebot_line_follower_configurator.py găzduit cu ❤ de GitHub

Pasul 5: Reglarea GiggleBot

Așezați GiggleBot pe pistă, porniți-l și lăsați-l să ruleze. Între timp, va trebui să îl puneți în mod constant pe pistă și să reglați câștigurile / parametrii cu celălalt bit BBC: bit pe care îl țineți în mână.

Pentru a porni GiggleBot, apăsați butonul A de pe BBC micro: bit al GiggleBot și pentru al opri și a reseta starea acestuia, apăsați butonul B.

Pe telecomanda BBC micro: bit, apăsarea butonului A vă va duce prin fiecare opțiune din meniul său, iar butonul B crește / scade valoarea corespunzătoare. Este ca și cum ai seta ceasul pe tabloul de bord al unei mașini vechi. Opțiunile sunt astfel:

1. Opțiunile 0-1 sunt pentru câștigul Kp.
2. 2-3 opțiuni sunt pentru câștigul Ki.
3. 4-5 opțiuni sunt pentru câștigul Kd.
4. 6-7 opțiuni sunt pentru setarea valorii de referință pentru momentul în care motoarele încep să încetinească.
5. 8-9 opțiuni sunt pentru setarea vitezei minime.

Rețineți că numerele pare din meniu sunt pentru creșterea valorilor corespunzătoare și pentru cele impare este exact opusul.

De asemenea, când apăsați butonul B de pe micro-bit-ul GiggleBot BBC, veți vedea pe ecranul realizat de Neopixel numărul de milisecunde trecute de la ultima resetare și numărul de cicluri prin care a trecut robotul - cu aceste 2 puteți calcula rata de actualizare a robotului.

În cele din urmă și cel mai important, am venit cu 2 acorduri pentru GiggleBot. Una dintre ele este pentru momentul în care LED-urile Neopixel sunt stinse, iar cealaltă este pentru când este altfel. LED-urile Neopixel sunt utilizate pentru a arăta în ce direcție s-a acumulat eroarea.

Primul set de reglare a parametrilor (cu LED-uri NeoPixel stinse)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0.3 (care este 30%)
5. min_speed_percent = 0.2 (adică 20%)
6. base_speed = 100 (aka viteză maximă)
7. update_rate = 70 (rulează @ 70Hz)

Al doilea set de reglare a parametrilor (cu LED-urile NeoPixel aprinse)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0.3 (care este 30%)
5. min_speed_percent = 0.3 (adică 30%)
6. base_speed = 70 (aka viteză maximă)
7. update_rate = 50 (rulează @ 50Hz)
8. De asemenea, variabila run_neopixels trebuie setată la True în scriptul care se încarcă pe BBC-ul micro: bit al GiggleBot. Acest lucru va face ca LED-urile NeoPixel să clipească în așa fel încât să indice în ce direcție se acumulează eroarea.

Pasul 6: GiggleBot rulează cu NeoPixels oprit

Acesta este un exemplu de rularea GiggleBot cu primii parametri de reglare găsiți în pasul anterior. Acest exemplu are LED-urile NeoPixel oprite.

Pasul 7: GiggleBot rulează cu Neopixelii activați

Acesta este un exemplu de rularea GiggleBot cu al doilea set de parametri de reglare găsit la pasul 5. Acest exemplu are LED-urile NeoPixel activate.

Observați cum, în acest exemplu, GiggleBot este mai greu să urmeze linia - asta pentru că LED-urile Neopixel „mănâncă” timpul CPU al micro: bitului BBC. De aceea a trebuit să reducem rata de actualizare de la 70 la 50.