„GiggleBot“linijos sekėjo derinimas - išplėstinis: 7 žingsniai

2024 Autorius: John Day | [email protected]. Paskutinį kartą keistas: 2024-01-30 10:47

Šioje labai trumpoje instrukcijoje ketinate sureguliuoti savo „GiggleBot“, kad ji laikytųsi juodos linijos. Šioje kitoje pamokoje „GiggleBot Line Follower“mes sunkiai užkoduodavome derinimo vertes, kad jos veiktų pagal tą scenarijų. Galbūt norėsite, kad ji geriau elgtųsi sugalvodama kitų laimėjimų.

Šioje pamokoje mes parodome jums 2 scenarijus, kuriuos abu galima įkelti į skirtingus BBC mikro: bitus, kad vienas iš jų būtų įdėtas į „GiggleBot“, o su kitu - 2 mygtukai naudojami norint pereiti į meniu ir suderinti skirtingus parametrus. Šie atnaujinti parametrai siunčiami per radiją.

1 žingsnis: reikalingi komponentai

Jums reikės:

1. „GiggleBot“robotas, skirtas „micro: bit“.
2. x3 AA baterijos
3. x2 BBC mikro: bitai - vienas skirtas „GiggleBot“, o kitas veikia kaip nuotolinio valdymo pultas parametrams derinti.
4. „BBC micro: bit“baterija - tokia, kokia yra „BBC micro: bit“pakuotėje.

Gaukite „GiggleBot Robot“, skirtą „BBC micro: bit“, čia

2 veiksmas: takelių ir aplinkos nustatymas

Jūs taip pat turite sukurti savo takelius (atsisiųsti, spausdinti, iškirpti ir klijuoti plyteles) ir tada nustatyti aplinką (IDE ir veikimo laikas).

Kadangi ši pamoka yra labai susijusi su šia pamoka, pavadinta „GiggleBot Line Follower“, tiesiog eikite ten ir atlikite 2 ir 3 veiksmus ir grįžkite čia.

Kalbant apie IDE, galite naudoti „Mu“redaktorių, o vykdymo metu turite atsisiųsti „GiggleBot MicroPython Runtime“. Runtime galima atsisiųsti iš jo dokumentacijos čia. Pereikite prie dokumentacijos skyriaus „Pradžia“ir vadovaukitės šiomis aplinkos nustatymo instrukcijomis. Šiuo metu naudojama vykdymo laiko versija v0.4.0.

3 veiksmas: „GiggleBot“nustatymas

Prieš paleisdami „GiggleBot“vykdymo laiką, įsitikinkite, kad pasirinkote norimą „GiggleBot“greitį ir atnaujinimo greitį: pagal numatytuosius nustatymus greitis nustatytas kaip 100 (bazinio greičio kintamasis), o atnaujinimo dažnis - 70 (kintamasis atnaujinimo koeficientas).

Atsižvelgiant į dabartinį diegimą, didžiausias atnaujinimo dažnis, kurį galima pasiekti, yra 70, o jei „run_neopixels“nustatytas kaip „True“, tada pasiekiamas tik 50. Taigi tam tikra prasme galite pasakyti, kad numatytasis atnaujinimo greitis yra ties tuo, ką gali padaryti „BBC micro: bit“.

Tik įrašui, linijos sekimo jutiklis gali grąžinti atnaujinimus 100 kartų per sekundę.

Pastaba: šiame scenarijuje gali nebūti tarpų ir atrodo, kad tai įvyko dėl tam tikrų problemų rodant „GitHub Gists“. Spustelėkite esmę, kad pateksite į jo „GitHub“puslapį, kuriame galite nukopijuoti ir įklijuoti kodą.

„GiggleBot“PID linijos sekimo imtuvas (norint jį sureguliuoti reikia nuotolinio valdymo pulto) - xjfls23

iš mikrobitų importo*

iš „Gigglebot“importo*

iš utime importuoti sleep_ms, ticks_us

importuoti radiją

importo ustruktūra

# inicijuokite radiją ir GB neopikselius

radio.on ()

neo = init ()

# laikas

atnaujinimo koeficientas = 70

# numatytosios stiprinimo vertės

Kp = 0,0

Ki = 0,0

Kd = 0,0

nustatytoji vertė = 0,5

trigerio taškas = 0,0

min_speed_percent = 0,2

bazinis greitis = 100

last_position = nustatytoji vertė

integralas = 0,0

run_neopixels = Netiesa

centre_pikselis = 5#, kur centrinis šypsenos pikselis yra GB

# turquoise = tuple (žemėlapis (lambda x: int (x / 5), (64, 224, 208))) # spalva, naudojama norint piešti klaidą naudojant neopikselius

# turquoise = (12, 44, 41) # tai yra aukščiau nurodyta turkio spalva

error_width_per_pixel = 0.5/3# max klaida, padalyta iš segmentų skaičiaus tarp kiekvieno neopikselio

defupper_bound_linear_speed_reducer (abs_error, trigger_point, viršutinė_bound, mažiausia_motor_power, didžiausia_motor_power):

pasaulinis bazinis greitis

jei abs_error> = trigger_point:

# x0 = 0,0

# y0 = 0,0

# x1 = viršutinė riba - trigerio taškas

# y1 = 1,0

# x = abs_error - trigger_point

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

# taip pat kaip

y = (abs_error - trigger_point) / (viršutinė_bound - trigger_point)

variklio galia = bazinis greitis * (mažiausia_variklio galia + (1 -y) * (didžiausia_variklio galia - mažiausia_variklio galia))

grąžinti variklio energiją

Kitas:

grąžinti bazinį greitį * didžiausią_motorinę galią

paleisti = klaidinga

ankstesnė klaida = 0

bendras laikas = 0,0

total_counts = 0

o tiesa:

# jei paspausite mygtuką a, pradėkite sekti

jei mygtukas_a.paspaudžiamas ():

paleisti = tiesa

# bet jei paspaudžiamas mygtukas b, sustabdykite linijos sekimą

jei mygtukas_b.is_pressed ():

paleisti = klaidinga

integralas = 0,0

ankstesnė klaida = 0,0

display.scroll ('{} - {}'. formatas (bendras laikas, bendras skaičius), uždelsimas = 100, laukimas = klaidinga)

bendras laikas = 0,0

total_counts = 0

pixels_off ()

sustabdyti()

miego_ms (500)

jei paleisti isTrue:

# perskaitykite linijos jutiklius

pradžios_ laikas = erkės_ (()

# patikrinkite, ar atnaujinome Kp/Kd stiprinimą nuotolinio valdymo pultu

bandyti:

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

set_eyes ()

išskyrusTypeError:

praeiti

dešinėn, kairėn = skaitymo jutiklis (LINE_SENSOR, Abi)

# eilutė yra kairėje, kai padėtis <0,5

# eilutė yra dešinėje, kai padėtis> 0,5

# eilutė yra viduryje, kai padėtis = 0,5

# tai svertinis aritmetinis vidurkis

bandyti:

padėtis = dešinė /plūdė (kairė + dešinė)

išskyrus „ZeroDivisionError“:

padėtis = 0,5

jei pozicija == 0: pozicija = 0,001

jei pozicija == 1: pozicija = 0,999

# naudokite PD valdiklį

klaida = padėtis - nustatytoji vertė

integralas += klaida

taisymas = Kp * klaida + Ki * integralas + Kd * (klaida - ankstesnė klaida)

previous_error = klaida

# apskaičiuokite variklio greitį

variklio greitis = viršutinis_prilygtas_linijinis_sumažėjimo greitis

leftMotorSpeed = motor_speed + korekcija

rightMotorSpeed = motor_speed - korekcija

# apšvieskite neopikselius, kad parodytumėte, kuria kryptimi turi eiti „GiggleBot“

jei 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 (klaida)> error_width_per_pixel * i:

jei klaida <0:

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

Kitas:

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

Kitas:

procentas = 1- (error_width_per_pixel * i -abs (klaida)) / error_width_per_pixel

# užsidega dabartinis pikselis

jei klaida <0:

# neo [centre_pixel + i] = kortelė (žemėlapis (lambda x: int (x * procentas), turkis))

neo [centro_pikselis + i] = (int (12* proc.), int (44* proc.), int (41* proc.))

Kitas:

# neo [centre_pixel - i] = kortelė (žemėlapis (lambda x: int (x * procentas), turkis))

neo [centro_pikselis - i] = (int (12* proc.), int (44* proc.), int (41* proc.))

pertrauka

neo.show ()

bandyti:

# prikabinkite variklius

jei kairėMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

jei rightMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - dešinėMotorSpeed +100

jei kairėMotorSpeed <-100:

leftMotorSpeed = -100

jei teisingaiMotorSpeed <-100:

rightMotorSpeed = -100

# įjunkite variklius

set_speed (leftMotorSpeed, rightMotorSpeed)

vairuoti ()

# spausdinti ((klaida, variklio greitis))

išskyrus:

# jei patektume į neištaisomą problemą

praeiti

# ir palaikykite ciklo dažnį

pabaigos_ laikas = erkės_ (()

delay_diff = (pabaigos laikas - pradžios laikas) /1000

total_time += delay_diff

total_counts += 1

if1.0/ update_rate - delay_diff> 0:

miego režimas (1.0/ update_rate - delay_diff)

peržiūrėti rawgigglebot_line_follower_tuner.py, kurį priglobė „GitHub“❤

4 veiksmas: imtuvo nustatymas (nuotolinis)

Kitas dalykas, kurį turime padaryti, yra blykstės ir scenarijaus perkėlimas į antrąjį BBC mikro: bitą. Šis antrasis „micro: bit“veiks kaip „GiggleBot“nuotolinio valdymo pultas, kuris bus naudojamas šiems parametrams sureguliuoti:

1. Kp = proporcingas PID valdiklio padidėjimas.
2. Ki = integruotas PID valdiklio pelnas.
3. Kd = PID valdiklio išvestinis pelnas.
4. trigger_point = taškas, išreikštas procentais tarp minimalaus ir didžiausio „GiggleBot“greičio, kai greitis pradeda mažėti tiesiškai, kol pasiekia minimalų greitį.
5. min_speed_percent = mažiausias greitis, išreikštas didžiausio greičio procentais.

Kiti 2 likę kintamieji, kuriuos galima sureguliuoti, yra tiesiogiai užkoduoti „GiggleBot“esančiame scenarijuje: atnaujinimo_dalykas ir bazinis greitis, kuris nurodo didžiausią greitį. Kaip aprašyta dokumentacijoje, didžiausias greitis, kurį galima nustatyti „GiggleBot“, yra 100, o tai taip pat yra numatytoji mūsų „GiggleBot“vertė.

Pastaba: šiame scenarijuje gali nebūti tarpų ir atrodo, kad tai įvyko dėl tam tikrų problemų rodant „GitHub Gists“. Spustelėkite esmę, kad pateksite į jo „GitHub“puslapį, kuriame galite nukopijuoti ir įklijuoti kodą.

„GiggleBot“nuotolinis PID linijos sekimo imtuvas (reikalinga kita dalis) - xjfls23

iš mikrobitų importo*

iš utime importuoti sleep_ms

importuoti radiją

importo ustruktūra

# 1 elementas yra Kp padidėjimas

# 2 elementas yra Ki padidėjimas

# 3 elementas yra Kd padidėjimas

# 4 elementas yra trigerio taškas varikliams sumažinti greitį (0 -> 1)

# 5 elementas yra mažiausias variklių greitis, išreikštas procentais (0 -> 1)

pelnas = [0,0, 0,0, 0,0, 1,0, 0,0]

stepSize = 0,1

# 0 ir 1 - 1 elementas

2 ir 3 - 2 elementas

currentSetting = 0

defshowMenu ():

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

radio.on ()

showMenu ()

o tiesa:

atnaujinta = klaidinga

jei mygtukas_a.paspaudžiamas ():

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

atnaujinta = tiesa

jei mygtukas_b.is_pressed ():

if currentSetting %2 == 0:

# padidinti pelną, kai dabartinis Nustatymas yra 0 arba 2 arba..

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

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

Kitas:

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

Kitas:

# padidinti pelną, kai dabartinis Nustatymas yra 1 arba 3 arba..

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

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

Kitas:

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

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

atnaujinta = tiesa

jei atnaujinama:

showMenu ()

miego_ms (200)

peržiūrėti rawgigglebot_line_follower_configurator.py, kurį priglobė „GitHub“❤

5 žingsnis: sureguliuokite „GiggleBot“

Padėkite „GiggleBot“ant takelio, įjunkite ir leiskite jam veikti. Tuo tarpu turėsite nuolat jį grąžinti į takelį ir suderinti naudą/parametrus naudodami kitą BBC mikro: bitą, kurį laikote rankoje.

Norėdami paleisti „GiggleBot“, paspauskite „A“, esantį „GiggleBot“„BBC micro: bit“, ir, norėdami jį sustabdyti ir iš naujo nustatyti būseną, paspauskite mygtuką B.

Nuotoliniame „BBC micro: bit“paspaudus mygtuką A bus peržiūrėta kiekviena jo meniu parinktis, o mygtukas B padidins/sumažins atitinkamą vertę. Tai tarsi laikrodžio nustatymas seno automobilio prietaisų skydelyje. Parinktys yra tokios:

1. 0-1 variantai skirti Kp padidėjimui.
2. 2–3 variantai yra skirti Ki padidėjimui.
3. Kd padidinimui yra 4-5 variantai.
4. 6-7 parinktys yra skirtos nustatytam momentui, kai varikliai pradeda lėtėti.
5. 8-9 parinktys yra skirtos minimaliam greičiui nustatyti.

Turėkite omenyje, kad lyginiai skaičiai meniu yra skirti atitinkamoms reikšmėms padidinti, o nelyginiams - visiškai priešingai.

Be to, paspaudę „B“mygtuką „GiggleBot“„BBC micro: bit“, savo „Neopixel“sukurtame ekrane pamatysite praėjusių milisekundžių skaičių nuo paskutinio atstatymo ir ciklų, kuriuos robotas atliko, skaičių - galite apskaičiuoti roboto atnaujinimo dažnis.

Galiausiai ir svarbiausia, aš sugalvojau 2 „GiggleBot“derinimus. Vienas iš jų skirtas išjungti „Neopixel“šviesos diodus, o kitas - kai yra kitaip. „Neopixel“šviesos diodai naudojami parodyti, kuria kryptimi klaida susikaupė.

Pirmasis parametrų derinimo rinkinys (išjungus „NeoPixel“šviesos diodus)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0,3 (tai yra 30%)
5. min_speed_percent = 0,2 (tai yra 20%)
6. bazinis greitis = 100 (dar žinomas kaip maksimalus greitis)
7. update_rate = 70 (veikia @70 Hz)

Antrasis parametrų derinimo rinkinys (su įjungtais „NeoPixel“šviesos diodais)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0,3 (tai yra 30%)
5. min_speed_percent = 0,3 (tai yra 30%)
6. bazinis greitis = 70 (dar žinomas kaip maksimalus greitis)
7. update_rate = 50 (veikia @50Hz)
8. Be to, scenarijus, kuris įkeliamas į „GiggleBot“BBC mikro: bitą, turi būti nustatytas kaip kintamasis run_neopixels. Dėl to „NeoPixel“šviesos diodai mirksės taip, kad nurodytų, kuria kryptimi klaida kaupiasi.

6 veiksmas: „GiggleBot“veikia išjungus „NeoPixels“

Tai yra pavyzdys, kaip paleisti „GiggleBot“su 1 derinimo parametrais, rastais ankstesniame žingsnyje. Šiame pavyzdyje „NeoPixel“šviesos diodai yra išjungti.

7 žingsnis: „GiggleBot“veikia įjungus neopikselius

Tai yra pavyzdys, kaip paleisti „GiggleBot“su antruoju derinimo parametrų rinkiniu, rastu 5 veiksme. Šiame pavyzdyje įjungti „NeoPixel“šviesos diodai.

Atkreipkite dėmesį, kaip šiame pavyzdyje „GiggleBot“sunkiau sekti liniją - taip yra todėl, kad „Neopixel“šviesos diodai „valgo“BBC mikro: bitų procesoriaus laiką. Štai kodėl turėjome sumažinti atnaujinimo dažnį nuo 70 iki 50.