Akordimi i ndjekësit të linjës GiggleBot - i avancuar: 7 hapa

2024 Autor: John Day | [email protected]. E modifikuara e fundit: 2024-01-30 12:19

Në këtë Instructables shumë të shkurtër ju do të rregulloni GiggleBot -in tuaj për të ndjekur një vijë të zezë. Në këtë tutorial tjetër GiggleBot Line Follower, ne kemi koduar me vështirësi vlerat e akordimit për të punuar sipas atij skenari. Ju mund të dëshironi ta bëni atë të sillet më mirë duke dalë me përfitime të tjera.

Në këtë tutorial, ne po ju tregojmë 2 skripte që të dy mund të ngarkohen në mikro të ndryshëm të BBC: pjesë në mënyrë që njëri prej tyre të futet në GiggleBot dhe me tjetrin, 2 butonat përdoren për të kaluar nëpër një menu dhe për të akorduar të ndryshme parametrat. Dërgimi i këtyre parametrave të azhurnuar bëhet përmes radios.

Hapi 1: Komponentët e kërkuar

Ju do të keni nevojë për sa vijon:

1. Një robot GiggleBot për mikro: bit.
2. x3 Bateri AA
3. x2 BBC micro: bit - njëra për GiggleBot dhe tjetra që vepron si telekomandë për parametrat e akordimit.
4. Një bateri për një mikro BBC: bit - si ajo që vjen brenda paketës së mikro: bit të BBC.

Merrni Robotin GiggleBot për mikro BBC: pak këtu

Hapi 2: Vendosja e Gjurmëve dhe Mjedisit

Ju gjithashtu duhet të ndërtoni gjurmët tuaja (shkarkoni, printoni, prerë dhe ngjitni pllaka) dhe më pas vendosni mjedisin (IDE dhe koha e ekzekutimit).

Meqenëse ky mësim lidhet shumë me këtë mësim tjetër të titulluar GiggleBot Line Follower, thjesht shkoni atje dhe ndiqni hapat 2 dhe 3 dhe pastaj kthehuni këtu.

Sa i përket IDE, ju mund të përdorni redaktorin Mu dhe për kohën e ekzekutimit, ju duhet të shkarkoni GiggleBot MicroPython Runtime. Koha e ekzekutimit mund të shkarkohet nga dokumentacioni i saj këtu. Shkoni te kapitulli Fillimi i dokumentacionit dhe ndiqni ato udhëzime për krijimin e mjedisit. Deri në këtë moment, përdoret versioni v0.4.0 i kohës së ekzekutimit.

Hapi 3: Vendosja e GiggleBot

Para se të ndizni kohën e ekzekutimit në GiggleBot, sigurohuni që keni zgjedhur shpejtësinë dhe shpejtësinë e dëshiruar të përditësimit për GiggleBot: si parazgjedhje, shpejtësia është vendosur në 100 (ndryshorja e shpejtësisë bazë) dhe shkalla e azhurnimit është vendosur në 70 (ndryshorja e ndryshimit të vlerës).

Duke pasur parasysh zbatimin aktual, shkalla më e lartë e përditësimit që mund të arrihet është 70 dhe nëse run_neopixels vendoset në True, atëherë vetëm 50 është e arritshme. Pra, në një farë mënyre, ju mund të thoni se norma e parazgjedhur e azhurnimit është pikërisht në prag të asaj që mikro BBC mund të bëjë.

Vetëm për regjistrim, sensori i ndjekësit të linjës mund të kthejë azhurnimet 100 herë në sekondë.

Shënim: Skenari i mëposhtëm mund të ketë mungesë të hapësirave të bardha dhe kjo duket të jetë për shkak të ndonjë problemi në shfaqjen e GitHub Gists. Klikoni në thelbin për t'ju çuar në faqen e tij GitHub ku mund të kopjoni-ngjisni kodin.

GiggleBot PID Line Follower Tuner (kërkon një telekomandë për ta akorduar atë) - xjfls23

nga importi i mikrobitit*

nga importi i gigglebot*

nga importi i gjumit sleep_ms, ticks_us

radio e importit

import ustruct

# inicializoni radion dhe neopixel GB

radio në ()

neo = init ()

# koha

përqindja e përditësimit = 70

# vlera të paracaktuara të fitimit

Kp = 0.0

Ki = 0.0

Kd = 0.0

pika e përcaktimit = 0.5

pika_ -nxitëse = 0.0

përqindja_min e shpejtësisë = 0.2

shpejtësia bazë = 100

pozicioni i fundit = pika e caktuar

integral = 0.0

run_neopixels = E gabuar

center_pixel = 5# ku pikseli qendror i buzëqeshjes ndodhet në GB

# bruz = tuple (harta (lambda x: int (x / 5), (64, 224, 208))) # ngjyra për t'u përdorur për të nxjerrë gabimin me neopixelët

# bruz = (12, 44, 41) # që është pikërisht bruzja e mësipërme e komentuar mbi këtë

error_width_per_pixel = 0.5/3# gabim max i ndarë me numrin e segmenteve midis secilit neopixel

defupper_bound_linear_speed_reducer (abs_error, trigger_point, above_bound, më i vogël_motor_power, më i lartë_motor_power):

shpejtësia bazë_ globale

nëse abs_error> = pika_të shkaktimit:

# x0 = 0.0

# y0 = 0.0

# x1 = pjesa e sipërme -e lidhur - pika -shkas

# y1 = 1.0

# x = abs_error - pika_të shkaktimit

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

# e njejta si

y = (abs_error - point_ trigger) / (above_bound - point_ trigger)

fuqia motorike = shpejtësia_baza * (fuqia_motor_ e vogël + (1- vjeç) * (fuqia_më e lartë_motor - fuqia_motor_motor])

fuqia motorike e kthimit

tjeter:

kthehu shpejtësinë bazë * fuqinë më të lartë_motore

vrap = E gabuar

gabimi i mëparshëm = 0

koha_ totale = 0.0

totali_shumë = 0

ndërsa e vërtetë:

# nëse shtypet butoni a atëherë filloni të ndiqni

nëse butoni_a.është shtypur ():

drejtuar = E vërtetë

# por nëse shtypet butoni b ndaloni ndjekësin e linjës

nëse button_b.is_pressed ():

vrap = E gabuar

integral = 0.0

gabimi i mëparshëm = 0.0

display.scroll ('{} - {}'. format (total_koha, totali_ numërime), vonesë = 100, pritje = E gabuar)

koha_ totale = 0.0

totali_shumë = 0

pixels_off ()

ndal ()

ms_gjumës (500)

nëse ekzekutohet është e vërtetë:

# lexoni sensorët e linjës

koha e fillimit = ticks_us ()

# kontrolloni nëse i kemi përditësuar fitimet Kp/Kd me një telekomandë

provo:

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

sytë_të_vendosur ()

përveçTypeError:

kaloj

djathtas, majtas = sensori i leximit (LINE_SENSOR, TO DYT)

# rreshti është në të majtë kur pozicioni <0.5

# rreshti është në të djathtë kur pozicioni> 0.5

# rreshti është në mes kur pozicioni = 0.5

# është një mesatare aritmetike e ponderuar

provo:

pozicioni = djathtas /noton (majtas + djathtas)

përveçZeroDivisionError:

pozicioni = 0.5

nëse pozicioni == 0: pozicioni = 0.001

nëse pozicioni == 1: pozicioni = 0.999

# përdorni një kontrollues PD

gabim = pozicioni - pika e caktuar

integral += gabim

korrigjim = Kp * gabim + Ki * integral + Kd * (gabim - gabimi_paraprak)

gabimi i mëparshëm = gabim

# llogarit shpejtësinë e motorit

motor_speed = e sipërme_bound_linear_speed_reducer (abs (gabim), pika e përcaktuar * pika e shkasit, pika e caktuar, min_speed_percent, 1.0)

leftMotorSpeed = shpejtësia motorike + korrigjimi

rightMotorSpeed = shpejtësia_ motorike - korrigjim

# ndriçoni neopixelët për të treguar në cilin drejtim duhet të shkojë GiggleBot

nëse run_neopixels ështëTë vërteta dhe totali_llogarit %3 == 0:

për i inb '\ x00 / x01 / x02 / x03 / x04 / x05 / x06 / x07 / x08':

neo = (0, 0, 0)

për i inb '\ x00 / x01 / x02 / x03':

ifabs (gabim)> error_width_per_pixel * i:

nëse gabimi <0:

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

tjeter:

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

tjeter:

për qind = 1- (error_width_per_pixel * i -abs (error)) / error_width_per_pixel

# ndriçoni pikselin aktual

nëse gabimi <0:

# neo [center_pixel + i] = tuple (harta (lambda x: int (x * përqindja), bruz))

neo [center_pixel + i] = (int (12* përqind), int (44* përqind), int (41* përqind))

tjeter:

# neo [center_pixel - i] = tuple (harta (lambda x: int (x * përqindja), bruz))

neo [qendra_pixel - i] = (int (12* përqind), int (44* përqind), int (41* përqind))

pushim

neo.shfaqje ()

provo:

# kap motorët

nëse lihetMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

nëse është e drejtëMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

nëse lihetMotorShpejtësia <-100:

leftMotorSpeed = -100

nëse është e drejtëMotorSpeed <-100:

rightMotorSpeed = -100

# aktivizoni motorët

set_speed (leftMotorSpeed, rightMotorSpeed)

ngas ()

# print ((gabim, shpejtësia_ motorike))

përveç:

# në rast se futemi në ndonjë çështje të pazgjidhshme

kaloj

# dhe ruani frekuencën e lakut

koha e mbarimit = ticks_us ()

vonesa_diff = (koha e mbarimit - koha e fillimit) /1000

koha totale += ndryshimi i vonesës

llogaritjet e përgjithshme += 1

if1.0/ update_rate - delay_diff> 0:

gjumë (1.0/ norma e përditësimit - vonesë_diff)

shiko rawgigglebot_line_follower_tuner.py e pritur me ❤ nga GitHub

Hapi 4: Konfigurimi i sintonizuesit (telekomandë)

Gjëja tjetër që duhet të bëjmë është të ndezim skriptin e ekzekutimit + në mikroin e dytë të BBC: bit. Ky mikro: bit i dytë do të veprojë si telekomandë për GiggleBot, i cili do të përdoret për të akorduar parametrat e mëposhtëm:

1. Kp = fitim proporcional për kontrolluesin PID.
2. Ki = fitim integral për kontrolluesin PID.
3. Kd = fitimi derivativ për kontrolluesin PID.
4. trigger_point = pika e shprehur në përqindje midis shpejtësive minimale dhe maksimale të GiggleBot ku shpejtësia fillon të zvogëlohet në mënyrë lineare derisa të arrijë shpejtësinë minimale.
5. min_speed_percent = shpejtësia minimale e shprehur në përqindje të shpejtësisë maksimale.

2 ndryshoret e tjera të mbetura që mund të akordohen janë të koduara drejtpërdrejt në skriptin që gjendet në GiggleBot: shpejtësia e përditësimit dhe shpejtësia bazë e cila paraqet shpejtësinë maksimale. Siç përshkruhet në dokumentacion, shpejtësia maksimale që mund të vendoset për GiggleBot është 100, e cila është gjithashtu vlera e paracaktuar për GiggleBot -in tonë.

Shënim: Skenari i mëposhtëm mund të ketë mungesë të hapësirave të bardha dhe kjo duket të jetë për shkak të ndonjë problemi në shfaqjen e GitHub Gists. Klikoni në thelbin për t'ju çuar në faqen e tij GitHub ku mund të kopjoni-ngjisni kodin.

GiggleBot Remote PID Line Follower Tuner (kërkon pjesën tjetër) - xjfls23

nga importi i mikrobitit*

nga importi i gjumit sleep_ms

radio e importit

import ustruct

# Elementi i parë është fitimi i Kp

Elementi # 2 është fitimi Ki

# Elementi i tretë është fitimi i Kd

Elementi i 4 -të është pika e shkyçjes për motorët që të ulin shpejtësinë (0 -> 1)

Elementi # 5 është shpejtësia minimale për motorët e shprehur në përqindje (0 -> 1)

fitimet = [0.0, 0.0, 0.0, 1.0, 0.0]

hapi i madhësisë = 0.1

# 0 dhe 1 për elementin e parë

# 2 dhe 3 për elementin e dytë

aktualVendosja = 0

defshowMenu ():

display.scroll ('{} - {}'. format (currentSetting, fitimet [int (currentSetting /2)]), vonesa = 100, prit = False)

radio në ()

shfaq meny ()

ndërsa e vërtetë:

përditësuar = E pavërtetë

nëse butoni_a.është shtypur ():

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

përditësuar = E vërtetë

nëse button_b.is_pressed ():

nëse aktualeVendosja %2 == 0:

# rrisni fitimin kur aktualeCaktimi është 0 ose 2 ose..

ifint (aktualCetting /2) në [0, 2]:

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

tjeter:

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

tjeter:

# rris fitimin kur rrymaVendosja është 1 ose 3 ose..

ifint (aktualVendosja /2) në [0, 2]:

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

tjeter:

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

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

përditësuar = E vërtetë

nëse përditësohet:

shfaq meny ()

ms_gjumës (200)

shiko rawgigglebot_line_follower_configurator.py pritur me ❤ nga GitHub

Hapi 5: Akordimi i GiggleBot

Vendoseni GiggleBot në pistë, ndizeni dhe lëreni të funksionojë. Ndërkohë, vazhdimisht do të duhet ta ktheni atë në rrugën e duhur dhe të akordoni përfitimet/parametrat me mikro tjetër të BBC -së: copë që po mbani në dorën tuaj.

Për të filluar GiggleBot, shtypni butonin A në mikro BBC të GiggleBot: bit dhe për ta ndaluar atë dhe kështu rivendosni gjendjen e tij shtypni butonin B.

Në mikro të largët të BBC: bit, shtypja e butonit A do t'ju çojë në çdo opsion në menunë e tij dhe butoni B rrit/zvogëlon vlerën përkatëse. Likeshtë si të vendosësh orën në pultin e një makine të vjetër. Opsionet janë si më poshtë:

1. Opsionet 0-1 janë për fitimin e Kp.
2. 2-3 opsione janë për fitimin Ki.
3. 4-5 opsione janë për fitimin e Kd.
4. 6-7 opsione janë për vendosjen e pikës së caktuar për momentin kur motorët fillojnë të ngadalësohen.
5. 8-9 opsione janë për vendosjen e shpejtësisë minimale.

Mbani në mend se numrat çift në meny janë për rritjen e vlerave përkatëse dhe për ato tek është pikërisht e kundërta.

Gjithashtu, kur shtypni butonin B në mikro BBC të GiggleBot: bit, në ekranin e tij të bërë nga Neopixel do të shihni numrin e milisekondave të kaluara që nga rivendosja e fundit dhe numrin e cikleve që ka kaluar roboti - me këto 2 mund të llogaritni shkalla e përditësimit të robotit.

Së fundmi dhe më e rëndësishmja, unë kam dalë me 2 akordime për GiggleBot. Njëra prej tyre është për kur LED -et Neopixel janë fikur dhe tjetra është për kur është ndryshe. LED -të Neopixel përdoren për të treguar në cilin drejtim është grumbulluar gabimi.

Grupi i parë i akordimit të parametrave (me LED të NeoPixel të fikur)

1. Kp = 32.0
2. Ki = 0.5
3. Kd = 80.0
4. trigger_setpoint = 0.3 (që është 30%)
5. min_speed_percent = 0.2 (që është 20%)
6. shpejtësia bazë = 100 (aka shpejtësia maksimale)
7. përqindja e përditësimit = 70 (funksionon në 70Hz)

Grupi i dytë i akordimit të parametrave (me LED të NeoPixel të ndezur)

1. Kp = 25.0
2. Ki = 0.5
3. Kd = 35.0
4. trigger_setpoint = 0.3 (që është 30%)
5. min_speed_percent = = 0.3 (që është 30%)
6. shpejtësia bazë = 70 (aka shpejtësia maksimale)
7. përqindja e përditësimit = 50 (funksionon në 50Hz)
8. Gjithashtu, variabli run_neopixels duhet të vendoset në True në skenarin që ngarkohet në mikro: bit të GiggleBot BBC. Kjo do t'i bëjë LED -të NeoPixel të ndizen në atë mënyrë që të tregojnë drejt drejtimit të të cilit grumbullohet gabimi.

Hapi 6: GiggleBot që funksionon me NeoPixels të fikur

Ky është një shembull i drejtimit të GiggleBot me parametrat e parë të akordimit të gjetur në hapin e mëparshëm. Ky shembull ka LED -et NeoPixel të fikur.

Hapi 7: Drejtimi i GiggleBot Me Neopixelët e Aktivizuar

Ky është një shembull i drejtimit të GiggleBot me grupin e dytë të parametrave të akordimit të gjetur në hapin 5. Ky shembull ka LED -et NeoPixel të ndezura.

Vini re se si në këtë shembull, GiggleBot e ka më të vështirë të ndjekë linjën - kjo ndodh sepse LED -të Neopixel po "hanë" kohën e CPU -së së mikro BBC: bit. Kjo është arsyeja pse na u desh të ulim normën e azhurnimit nga 70 në 50.