GiggleBot līnijas sekotāja regulēšana - uzlabota: 7 soļi

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:55

Šajā ļoti īsajā pamācībā jūs noregulēsit savu GiggleBot, lai tas sekotu melnai līnijai. Šajā citā apmācībā GiggleBot Line Follower mēs stingri kodējām noregulēšanas vērtības, lai tās darbotos saskaņā ar šo scenāriju. Iespējams, vēlēsities panākt labāku uzvedību, piedāvājot citus ieguvumus.

Šajā apmācībā mēs parādām 2 skriptus, kurus var ielādēt dažādos BBC mikro: bitos, lai viens no tiem tiktu ievietots GiggleBot, bet ar otru - divas pogas tiek izmantotas, lai izietu izvēlnē un noregulētu dažādas parametrus. Šo atjaunināto parametru nosūtīšana tiek veikta, izmantojot radio.

1. darbība. Nepieciešamās sastāvdaļas

Jums būs nepieciešams:

1. GiggleBot robots micro: bit.
2. x3 AA baterijas
3. x2 BBC mikro: biti - viens GiggleBot un otrs darbojas kā tālvadības pults parametru noregulēšanai.
4. BBC micro: bit akumulators - līdzīgs tam, kas ietilpst BBC micro: bit iepakojumā.

Iegūstiet GiggleBot robotu BBC mikro: bitam šeit

2. darbība. Ierakstu un vides iestatīšana

Jums arī faktiski jāveido ieraksti (lejupielādēt, drukāt, izgriezt un lentēt flīzes) un pēc tam iestatīt vidi (IDE un izpildlaiks).

Tā kā šī apmācība ir ļoti saistīta ar šo citu pamācību ar nosaukumu GiggleBot līnijas sekotājs, vienkārši dodieties turp un izpildiet 2. un 3. darbību un pēc tam atgriezieties šeit.

Kas attiecas uz IDE, varat izmantot Mu redaktoru, un izpildlaika laikā jums ir jālejupielādē GiggleBot MicroPython Runtime. Izpildlaiku var lejupielādēt no tā dokumentācijas šeit. Pārejiet uz dokumentācijas nodaļu Darba sākšana un izpildiet šos norādījumus par vides iestatīšanu. No šī brīža tiek izmantota izpildlaika versija v0.4.0.

3. darbība. GiggleBot iestatīšana

Pirms GiggleBot izpildlaika mirgošanas pārliecinieties, vai esat izvēlējies GiggleBot vēlamo ātrumu un atjaunināšanas ātrumu: pēc noklusējuma ātrums ir iestatīts uz 100 (bāzes_speed mainīgais) un atjaunināšanas ātrums ir iestatīts uz 70 (update_rate mainīgais).

Ņemot vērā pašreizējo ieviešanu, augstākais atjaunināšanas ātrums, ko var sasniegt, ir 70 un, ja run_neopixels ir iestatīts uz True, tad ir sasniedzams tikai 50. Tātad savā ziņā jūs varētu teikt, ka noklusējuma atjaunināšanas ātrums ir uz robežas ar to, ko var darīt BBC micro: bit.

Tikai zināšanai līnijas sekotāja sensors var atgriezt atjauninājumus 100 reizes sekundē.

Piezīme. Šim skriptam, iespējams, trūkst atstarpes, un šķiet, ka tas ir saistīts ar kādu problēmu, parādot GitHub Gists. Noklikšķiniet uz būtības, lai nokļūtu tās GitHub lapā, kur varat kopēt un ielīmēt kodu.

GiggleBot PID līnijas sekotājs (lai to noregulētu, nepieciešama tālvadības pults) - xjfls23

no mikrobitu importa*

no gigglebot importēšanas*

no utime importēt sleep_ms, ticks_us

importēt radio

importēt ustruktu

# inicializējiet radio un GB neopikseļus

radio.on ()

neo = init ()

# laiks

update_rate = 70

# noklusējuma pastiprinājuma vērtības

Kp = 0,0

Ki = 0,0

Kd = 0,0

uzdotā vērtība = 0,5

sprūda_punkts = 0,0

min_speed_percent = 0.2

bāzes_ātrums = 100

last_position = uzdotā vērtība

integrālis = 0,0

run_neopixels = Nepareizi

center_pixel = 5# kur smaida centrālais pikselis atrodas GB

# tirkīzs = kortekss (karte (lambda x: int (x / 5), (64, 224, 208))) # krāsa, ko izmantot, lai uzzīmētu kļūdu ar neopikseliem

# tirkīzs = (12, 44, 41) # kas ir tieši iepriekš aprakstītais tirkīzs

error_width_per_pixel = 0.5/3# max kļūda dalīta ar segmentu skaitu starp katru neopikseli

defupper_bound_linear_speed_reducer (abs_error, trigger_point, ylä_bound, mazākais_motor_power, augstākais_motor_power):

globālais bāzes ātrums

ja abs_error> = trigger_point:

# x0 = 0,0

# y0 = 0,0

# x1 = augšējā robeža - sprūda_punkts

# y1 = 1,0

# x = abs_error - trigger_point

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

# tāds pats kā

y = (abs_kļūda - sprūda_punkts) / (augšējā_pozīcija - sprūda_punkts)

motora_jauda = bāzes_ātrums * (mazākais_motora_jauda + (1 -g) * (augstākā_motora_jauda - mazākā_motora_jauda))

atgriezt motor_power

cits:

atgriezt bāzes_speed * lielāko_motora_jaudu

palaist = Nepareizi

iepriekšējā_kļūda = 0

kopējais_laiks = 0,0

total_counts = 0

kamēr patiesība:

# ja tiek nospiesta poga a, sāciet sekot

ja poga_a.is_piespiesta ():

palaist = taisnība

# bet, ja tiek nospiesta poga b, apturiet līnijas sekotāju

ja poga_b.is_piespiesta ():

palaist = Nepareizi

integrālis = 0,0

iepriekšējā_kļūda = 0,0

display.scroll ('{} - {}'. formāts (total_time, total_counts), kavēšanās = 100, gaidīt = False)

kopējais_laiks = 0,0

total_counts = 0

pixels_off ()

apstāties ()

miega_ms (500)

ja palaist isTrue:

#lasiet līnijas sensorus

start_time = ticks_us ()

# pārbaudiet, vai ar tālvadības pulti esam atjauninājuši Kp/Kd ieguvumus

pamēģini:

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

set_eyes ()

izņemotTypeError:

iziet

pa labi, pa kreisi = lasīšanas sensors (LINE_SENSOR, ABET)

# līnija atrodas kreisajā pusē, ja pozīcija ir <0,5

# līnija atrodas labajā pusē, ja pozīcija> 0,5

# līnija atrodas vidū, kad pozīcija = 0,5

# tas ir vidējais svērtais aritmētiskais

pamēģini:

pozīcija = labais /pludiņš (pa kreisi + pa labi)

izņemot ZeroDivisionError:

pozīcija = 0,5

ja pozīcija == 0: pozīcija = 0,001

ja pozīcija == 1: pozīcija = 0,999

# izmantojiet PD kontrolieri

kļūda = pozīcija - uzdotā vērtība

integrālis += kļūda

labojums = Kp * kļūda + Ki * integrālis + Kd * (kļūda - iepriekšējā_kļūda)

iepriekšējā_kļūda = kļūda

# aprēķiniet motora apgriezienus

motora ātrums = augšējais_saistītais_ lineārais_ātruma samazinātājs (abs (kļūda), uzdotā vērtība * sprūda_punkts, iestatītā vērtība, min_speed_percent, 1.0)

leftMotorSpeed = motor_speed + korekcija

rightMotorSpeed = motor_speed - korekcija

# iedegiet neopikseļus, lai parādītu, kurā virzienā GiggleBot jāiet

ja run_neopixels isTrueand total_counts %3 == 0:

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

neo = (0, 0, 0)

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

ifabs (kļūda)> error_width_per_pixel * i:

ja kļūda <0:

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

cits:

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

cits:

procenti = 1- (error_width_per_pixel * i -abs (kļūda)) / error_width_per_pixel

# iedegas pašreizējais pikselis

ja kļūda <0:

# neo [center_pixel + i] = kortele (karte (lambda x: int (x * procenti), tirkīza krāsa))

neo [center_pixel + i] = (int (12* procenti), int (44* procenti), int (41* procenti))

cits:

# neo [center_pixel - i] = karte (karte (lambda x: int (x * procenti), tirkīza krāsa))

neo [centra_pikseļi - i] = (int (12* procenti), int (44* procenti), int (41* procenti))

pārtraukums

neo.show ()

pamēģini:

# saspiediet motorus

ja pa kreisiMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - pa kreisiMotorSpeed +100

ja rightMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

ja pa kreisiMotora ātrums <-100:

leftMotorSpeed = -100

ja pareiziMotorSpeed <-100:

rightMotorSpeed = -100

# iedarbiniet motorus

set_speed (leftMotorSpeed, rightMotorSpeed)

braukt ()

# drukāt ((kļūda, motora ātrums))

izņemot:

# gadījumā, ja mēs nonākam pie kādas nefiksējamas problēmas

iziet

# un saglabājiet cilpas frekvenci

end_time = ticks_us ()

delay_diff = (beigu laiks - sākuma laiks) /1000

total_time += delay_diff

total_counts += 1

if1.0/ update_rate - delay_diff> 0:

miega režīms (1.0/ update_rate - delay_diff)

apskatīt rawgigglebot_line_follower_tuner.py, ko mitina GitHub ar ❤

4. darbība: uztvērēja (tālvadības) iestatīšana

Nākamā lieta, kas mums jādara, ir pārraidīt izpildlaiku + skriptu uz 2. BBC micro: bit. Šis otrais mikro: bits darbosies kā GiggleBot tālvadības pults, kas tiks izmantots, lai noregulētu šādus parametrus:

1. Kp = proporcionāls pastiprinājums PID regulatoram.
2. Ki = neatņemams PID regulatora ieguvums.
3. Kd = PID regulatora atvasinājuma ieguvums.
4. trigger_point = punkts, kas izteikts procentos starp GiggleBot minimālo un maksimālo ātrumu, kur ātrums sāk samazināties lineāri, līdz tas sasniedz minimālo ātrumu.
5. min_speed_percent = minimālais ātrums, kas izteikts procentos no maksimālā ātruma.

Pārējie 2 atlikušie maināmie, kurus var noregulēt, ir tieši kodēti skriptā, kas atrodas GiggleBot: update_rate un base_speed, kas apzīmē maksimālo ātrumu. Kā aprakstīts dokumentācijā, maksimālais ātrums, ko var iestatīt GiggleBot, ir 100, kas ir arī mūsu GiggleBot noklusējuma vērtība.

Piezīme. Šim skriptam, iespējams, trūkst atstarpes, un šķiet, ka tas ir saistīts ar kādu problēmu, parādot GitHub Gists. Noklikšķiniet uz būtības, lai nokļūtu tās GitHub lapā, kur varat kopēt un ielīmēt kodu.

GiggleBot tālvadības PID līnijas sekotājs (nepieciešama otra daļa) - xjfls23

no mikrobitu importa*

no utime importēt sleep_ms

importēt radio

importēt ustruktu

# 1. elements ir Kp pieaugums

# 2. elements ir Ki pastiprinājums

# 3. elements ir Kd pastiprinājums

# Ceturtais elements ir sprūda_punkts motoriem, lai samazinātu ātrumu (0 -> 1)

# 5. elements ir minimālais dzinēju ātrums, kas izteikts procentos (0 -> 1)

peļņa = [0.0, 0.0, 0.0, 1.0, 0.0]

stepSize = 0,1

# 0 un 1 1. elementam

2. un 3. elements 2. elementam

currentSetting = 0

defshowMenu ():

display.scroll ('{} - {}'. formāts (currentSetting, guvumi [int (currentSetting /2)]), kavēšanās = 100, gaidīt = nepatiesa)

radio.on ()

showMenu ()

kamēr patiesība:

atjaunināts = nepatiess

ja poga_a.is_piespiesta ():

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

atjaunināts = True

ja poga_b.is_piespiesta ():

if currentSetting %2 == 0:

# palielināt pastiprinājumu, ja pašreizējais Iestatījums ir 0 vai 2 vai..

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

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

cits:

peļņa [int (currentSetting /2)] += stepSize

cits:

# palielināt pastiprinājumu, ja pašreizējais Iestatījums ir 1 vai 3 vai..

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

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

cits:

peļņa [int (currentSetting /2)] -= stepSize

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

atjaunināts = True

ja atjaunināts:

showMenu ()

miega_ms (200)

apskatīt rawgigglebot_line_follower_configurator.py, ko mitina GitHub ar ❤

5. solis: GiggleBot regulēšana

Novietojiet GiggleBot trasē, ieslēdziet to un ļaujiet tai darboties. Pa to laiku jums tas nepārtraukti būs jāatliek trasē un jāpielāgo ieguvumi/parametri, izmantojot citu BBC mikro: bitu, ko jūs turat rokā.

Lai palaistu GiggleBot, nospiediet pogu A uz GiggleBot BBC micro: bit un, lai apturētu to un tādējādi atiestatītu tā stāvokli, nospiediet pogu B.

Attālinātajā BBC micro: bit, nospiežot pogu A, tiks parādītas visas izvēlnes opcijas, un poga B palielina/samazina atbilstošo vērtību. Tas ir tāpat kā iestatīt pulksteni uz vecas automašīnas paneļa. Iespējas ir šādas:

1. 0-1 iespējas ir paredzētas Kp pieaugumam.
2. 2-3 iespējas ir Ki ieguvumam.
3. Kd pieaugumam ir 4-5 iespējas.
4. 6-7 opcijas ir paredzētas, lai iestatītu brīdi, kad motori sāk palēnināties.
5. 8-9 iespējas ir minimālā ātruma iestatīšanai.

Paturiet prātā, ka pāra skaitļi izvēlnē ir paredzēti atbilstošo vērtību palielināšanai, bet nepāra - tieši pretēji.

Turklāt, nospiežot pogu B GiggleBot BBC mikro: bitā, tā Neopixel veidotajā ekrānā redzēsiet pagājušās milisekundes kopš pēdējās atiestatīšanas un ciklu skaitu robots ir izgājis - ar šiem 2 jūs varat aprēķināt robota atjaunināšanas ātrums.

Visbeidzot un pats galvenais - esmu izdomājis 2 GiggleBot skaņojumus. Viens no tiem ir paredzēts, kad Neopixel gaismas diodes ir izslēgtas, bet otrs ir paredzēts, ja ir citādi. Neopixel gaismas diodes tiek izmantotas, lai parādītu, kurā virzienā kļūda ir uzkrāta.

1. parametru iestatīšanas komplekts (ar izslēgtām NeoPixel gaismas diodēm)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0.3 (kas ir 30%)
5. min_speed_percent = 0.2 (kas ir 20%)
6. bāzes_ātrums = 100 (pazīstams arī kā maksimālais ātrums)
7. update_rate = 70 (darbojas @70Hz)

Otrais parametru iestatīšanas komplekts (ar ieslēgtām NeoPixel gaismas diodēm)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0.3 (kas ir 30%)
5. min_speed_percent = 0.3 (kas ir 30%)
6. bāzes_ātrums = 70 (pazīstams arī kā maksimālais ātrums)
7. update_rate = 50 (darbojas @50Hz)
8. Arī mainīgajam run_neopixels ir jābūt iestatītam uz True skriptā, kas tiek ielādēts GiggleBot BBC mikro: bitā. Tādējādi NeoPixel gaismas diodes mirgos tā, ka tās norāda, kurā virzienā kļūda tiek uzkrāta.

6. darbība. GiggleBot darbojas, kad NeoPixels ir izslēgts

Šis ir piemērs GiggleBot palaišanai ar 1. regulēšanas parametriem, kas atrasti iepriekšējā solī. Šajā piemērā ir izslēgtas NeoPixel gaismas diodes.

7. darbība. GiggleBot darbojas ar ieslēgtiem neopikseliem

Šis ir piemērs GiggleBot palaišanai ar 2. regulēšanas parametru kopu, kas atrodama 5. solī. Šajā piemērā ir ieslēgtas NeoPixel gaismas diodes.

Ievērojiet, kā šajā piemērā GiggleBot ir grūtāk sekot līnijai - tas ir tāpēc, ka Neopixel gaismas diodes "ēd" BBC mikro: bit CPU laiku. Tāpēc mums bija jāsamazina atjaunināšanas ātrums no 70 līdz 50.