Tuning van die GiggleBot -lynvolgers - Gevorderd: 7 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:25

In hierdie baie kort instruksies gaan u u eie GiggleBot afstem om 'n swart lyn te volg. In hierdie ander tutoriaal GiggleBot Line Follower het ons die stemwaardes hard gekodeer om volgens die scenario te werk. U kan dit beter laat optree deur ander winste te behaal.

In hierdie tutoriaal wys ons u twee skrifte wat albei op verskillende BBC -mikro -stukkies gelaai kan word, sodat een van hulle in die GiggleBot geplaas word, en met die ander een word die twee knoppies gebruik om deur 'n spyskaart te gaan en verskillende af te stem grense. Die stuur van hierdie bygewerkte parameters word via die radio gedoen.

Stap 1: Vereiste komponente

U benodig die volgende:

1. 'N GiggleBot -robot vir die micro: bit.
2. x3 AA -batterye
3. x2 BBC -mikro: stukkies - een vir die GiggleBot en die ander een wat as afstandsbediening dien om parameters in te stel.
4. 'N Battery vir 'n BBC micro: bit - soos die een wat in die BBC micro: bit -pakket voorkom.

Kry die GiggleBot -robot vir die BBC micro: bit hier

Stap 2: Die opstel van die snitte en omgewing

U moet ook u snitte bou (aflaai, druk, sny en teëls plak) en dan die omgewing opstel (die IDE en die tydsduur).

Aangesien hierdie tutoriaal baie verband hou met hierdie ander tutoriaal getiteld GiggleBot Line Follower, gaan u daarheen en volg stap 2 en 3 en kom dan weer hierheen.

Wat die IDE betref, kan u die Mu -redakteur gebruik, en vir die tydsduur moet u die GiggleBot MicroPython Runtime aflaai. Die tydsduur kan hier van die dokumentasie afgelaai word. Gaan na die Aan die slag -hoofstuk van die dokumentasie en volg die instruksies oor die opstel van die omgewing. Vanaf hierdie oomblik word weergawe v0.4.0 van die tydsduur gebruik.

Stap 3: Die opstel van die GiggleBot

Voordat u die runtime na die GiggleBot flits, moet u seker maak dat u die gewenste spoed en opdateringstempo vir die GiggleBot gekies het: die spoed is standaard ingestel op 100 (basis_snelheidsveranderlike) en die opdateringsnelheid is ingestel op 70 (opdateringswaarde).

Gegewe die huidige implementering, is die hoogste opdateringsnelheid 70 wat bereik kan word, en as run_neopixels op True gestel is, is slegs 50 haalbaar. Op 'n manier kan u sê dat die standaard opdateringsnelheid presies is op die rand van wat die BBC micro: bit kan doen.

Net vir die rekord, die lynvolgersensor kan opdaterings 100 keer per sekonde terugstuur.

Let wel: die volgende skrip ontbreek moontlik witruimtes, en dit lyk asof dit 'n probleem is met die vertoning van GitHub Gists. Klik op die kern om u na die GitHub-bladsy te neem, waar u die kode kan kopieer en plak.

GiggleBot PID Line Follower Tuner (benodig 'n afstandsbediening om dit af te stem) - xjfls23

vanaf mikrobit -invoer*

vanaf gigglebot invoer*

invoer slaap_ms, bosluise_us vanaf die ou tyd

radio invoer

invoerstruktuur

# initialiseer radio- en GB -neopixels

radio.on ()

neo = init ()

# tydsberekening

update_rate = 70

# standaard versterkingswaardes

Kp = 0,0

Ki = 0,0

Kd = 0,0

setpoint = 0,5

trigger_point = 0.0

min_snelheidspersent = 0,2

base_speed = 100

last_position = setpoint

integraal = 0.0

run_neopixels = Onwaar

center_pixel = 5# waar die middelste pixel van die glimlag op die GB geleë is

# turkoois = tupel (kaart (lambda x: int (x / 5), (64, 224, 208))) # kleur om te gebruik om die fout met die neopixels te teken

# turkoois = (12, 44, 41) # wat presies die bogenoemde turkoois hierbo is

error_width_per_pixel = 0.5/3# maksimum fout gedeel deur die aantal segmente tussen elke neopixel

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

globale basis_snelheid

as abs_fout> = trigger_point:

# x0 = 0.0

# y0 = 0.0

# x1 = boonste_gebonde - snellerpunt

# y1 = 1.0

# x = abs_fout - trigger_point

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

# dieselfde as

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

motorpower = basisspoed * (kleinste_motorpower + (1- y) * (hoogste_motorpower - kleinste_motorpower))

stuur motorkrag terug

anders:

gee basissnelheid terug * hoogste_motoriese krag

hardloop = Onwaar

vorige_fout = 0

totale tyd = 0.0

totaal_getalle = 0

terwyl dit waar is:

# as knoppie a gedruk word, begin dan volg

as button_a.is_pressed ():

hardloop = waar

# maar as die knoppie b ingedruk word, stop die lynvolger

as button_b.is_pressed ():

hardloop = Onwaar

integraal = 0.0

vorige_fout = 0.0

display.scroll ('{} - {}'. formaat (total_time, total_counts), vertraging = 100, wag = onwaar)

totale tyd = 0.0

totaal_getalle = 0

pixels_off ()

stop ()

slaap_ms (500)

as run isTrue:

# lees die lynsensors

start_time = ticks_us ()

# kyk of ons die Kp/Kd -winste opgedateer het met 'n afstandsbediening

probeer:

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

stel_ogies ()

behalwe TypeError:

slaag

regs, links = lees_sensor (LINE_SENSOR, BEIDE)

# lyn is aan die linkerkant as posisie <0.5

# lyn is aan die regterkant as posisie> 0.5

# lyn is in die middel as posisie = 0,5

# dit is 'n geweegde rekenkundige gemiddelde

probeer:

posisie = regs /dryf (links + regs)

behalwe ZeroDivisionError:

posisie = 0,5

as posisie == 0: posisie = 0.001

as posisie == 1: posisie = 0,999

# gebruik 'n PD -beheerder

fout = posisie - setpoint

integraal += fout

regstelling = Kp * fout + Ki * integraal + Kd * (fout - vorige_fout)

vorige_fout = fout

# bereken motorsnelhede

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

leftMotorSpeed = motor_speed + regstelling

rightMotorSpeed = motor_speed - regstelling

# lig die neopixels aan om te wys in watter rigting die GiggleBot moet gaan

as run_neopixels waar is en totale_getalle %3 == 0:

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

neo = (0, 0, 0)

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

ifabs (fout)> error_width_per_pixel * i:

as fout <0:

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

anders:

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

anders:

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

# lig die huidige pixel op

as fout <0:

# neo [center_pixel + i] = tuple (kaart (lambda x: int (x * persentasie), turkoois))

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

anders:

# neo [middel_pixel - i] = tupel (kaart (lambda x: int (x * persentasie), turkoois))

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

breek

neo.show ()

probeer:

# knip die motors

as linksMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

as dit reg is MotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - regsMotorSpeed +100

as linksMotorSpeed <-100:

leftMotorSpeed = -100

as dit reg is MotorSpeed <-100:

rightMotorSpeed = -100

# aktiveer die motors

set_speed (leftMotorSpeed, rightMotorSpeed)

ry ()

# druk ((fout, motorsnelheid))

behalwe:

# ingeval ons 'n onoplosbare probleem ondervind

slaag

# en handhaaf die lusfrekwensie

end_time = ticks_us ()

delay_diff = (end_time - start_time) /1000

total_time += delay_diff

totaal_getalle += 1

if1.0/ update_rate - delay_diff> 0:

slaap (1.0/ update_rate - delay_diff)

sien rawgigglebot_line_follower_tuner.py aangebied deur ❤ deur GitHub

Stap 4: Die opstel van die ontvanger (afstandbeheer)

Die volgende ding wat ons moet doen, is om die runtime + script na die 2de BBC micro: bit te flits. Hierdie tweede micro: bit dien as 'n afstandbeheer van die GiggleBot, wat gebruik sal word om die volgende parameters in te stel:

1. Kp = proporsionele versterking vir die PID -beheerder.
2. Ki = integrale versterking vir die PID -beheerder.
3. Kd = afgeleide wins vir die PID -beheerder.
4. trigger_point = die punt uitgedruk in persentasies tussen die minimum en maksimum snelhede van die GiggleBot waar die snelheid lineêr begin verminder totdat dit die minimum spoed bereik.
5. min_speed_percent = die minimum spoed uitgedruk in persentasie van die maksimum spoed.

Die ander twee oorblywende veranderlikes wat ingestel kan word, word direk hard gekodeer in die script wat op die GiggleBot sit: die update_rate en base_speed wat die maksimum snelheid verteenwoordig. Soos in die dokumentasie beskryf, is die maksimum snelheid wat vir die GiggleBot gestel kan word, 100, wat ook die standaardwaarde vir ons GiggleBot is.

Let wel: die volgende skrip ontbreek moontlik witruimtes, en dit lyk asof dit 'n probleem is met die vertoning van GitHub Gists. Klik op die kern om u na die GitHub-bladsy te neem, waar u die kode kan kopieer en plak.

GiggleBot -afstandsbediener vir PID -lyn -afstandbeheer (benodig die ander deel) - xjfls23

vanaf mikrobit -invoer*

invoer slaap_ms van utime

radio invoer

invoerstruktuur

# 1ste element is die Kp -wins

# 2de element is die Ki -wins

# 3de element is die Kd -wins

# 4de element is die trigger_point vir motors om die snelheid te verlaag (0 -> 1)

# 5de element is die min spoed vir motors, uitgedruk in persentasies (0 -> 1)

winste = [0.0, 0.0, 0.0, 1.0, 0.0]

stepSize = 0.1

# 0 en 1 vir 1ste element

# 2 en 3 vir 2de element

currentSetting = 0

defshowMenu ():

display.scroll ('{} - {}'. formaat (currentSetting, winste [int (currentSetting /2)]), vertraging = 100, wag = onwaar

radio.on ()

showMenu ()

terwyl dit waar is:

opgedateer = Onwaar

as button_a.is_pressed ():

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

opgedateer = Waar

as button_b.is_pressed ():

as currentSetting %2 == 0:

# verhoog wins wanneer huidige instelling 0 of 2 is of..

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

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

anders:

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

anders:

# verhoog wins wanneer huidige instelling 1 of 3 is of..

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

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

anders:

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

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

opgedateer = Waar

indien opgedateer:

showMenu ()

slaap_ms (200)

sien rawgigglebot_line_follower_configurator.py aangebied deur ❤ deur GitHub

Stap 5: Stel die GiggleBot af

Plaas die GiggleBot op die baan, skakel dit aan en laat dit loop. Intussen moet u dit voortdurend op die baan plaas en die winste/parameters afstem met die ander BBC micro: bit wat u in u hand hou.

Om die GiggleBot te begin, druk op knoppie A op die GiggleBot se BBC micro: bit en om dit te stop en sodoende sy toestand terug te stel, druk op knoppie B.

Op die afgeleë BBC micro: bit, deur op knoppie A te druk, word u deur elke opsie in die spyskaart geneem en knoppie B verhoog/verlaag die ooreenstemmende waarde. Dit is soos om die horlosie op 'n ou motor se paneelbord te stel. Die opsies is soos volg:

1. 0-1 opsies is vir die Kp-wins.
2. 2-3 opsies is vir die Ki-wins.
3. 4-5 opsies is vir die Kd-wins.
4. Daar is 6-7 opsies om die setpoint in te stel vir die oomblik dat die motors begin vertraag.
5. Daar is 8-9 opsies om die minimum spoed in te stel.

Hou in gedagte dat ewe getalle in die spyskaart die ooreenstemmende waardes verhoog en dat die vreemde presies die teenoorgestelde is.

As u op knoppie B op die GiggleBot se BBC micro: bit druk, sien u ook op sy op Neopixel gemaakte skerm die aantal millisekondes wat verloop het sedert die laaste reset en die aantal siklusse wat die robot deurgemaak het - met hierdie 2 kan u bereken die opdateringsnelheid van die robot.

Laastens en die belangrikste, ek het twee stemme vir die GiggleBot gekry. Een daarvan is vir wanneer die Neopixel LED's afgeskakel word en die ander is vir wanneer dit anders is. Die Neopixel LED's word gebruik om aan te dui in watter rigting die fout opgehoop het.

1ste stel om die parameters af te stel (met NeoPixel LED's af)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0,3 (wat 30%is)
5. min_snelheidspersent = 0,2 (wat 20%is)
6. base_speed = 100 (ook bekend as maksimum spoed)
7. update_rate = 70 (loop by 70Hz)

2de stel parameters afstem (met die NeoPixel LED's aan)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0,3 (wat 30%is)
5. min_snelheidspersent = 0,3 (wat 30%is)
6. base_speed = 70 (aka maksimum spoed)
7. update_rate = 50 (loop by 50Hz)
8. Veranderlike run_neopixels moet ook op True gestel word in die script wat op die GiggleBot se BBC micro: bit gelaai word. Dit laat die NeoPixel LED's so flikker dat dit aandui in watter rigting die fout ophoop.

Stap 6: GiggleBot hardloop terwyl die NeoPixels uitgeskakel is

Dit is 'n voorbeeld van die uitvoering van die GiggleBot met die eerste afstemparameters wat in die vorige stap gevind is. In hierdie voorbeeld is die NeoPixel LED's afgeskakel.

Stap 7: GiggleBot hardloop met die neopixels aangeskakel

Dit is 'n voorbeeld van die werking van die GiggleBot met die 2de stel tuningparameters wat in stap 5 gevind is. In hierdie voorbeeld is die NeoPixel LED's aangeskakel.

Let op hoe die GiggleBot in hierdie voorbeeld moeiliker is om die lyn te volg - dit is omdat die Neopixel LED's die CPU -tyd van die BBC micro: bit "eet". Daarom moes ons die opdateringsnelheid van 70 tot 50 verminder.