Tuning af GiggleBot Line Follower - Avanceret: 7 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:28

I denne meget korte Instructables vil du tune din egen GiggleBot for at følge en sort linje. I denne anden tutorial GiggleBot Line Follower hardkodede vi tuningsværdierne til at fungere i henhold til dette scenario. Du vil måske få det til at opføre sig bedre ved at komme med andre gevinster.

I denne vejledning viser vi dig 2 scripts, der begge kan indlæses på forskellige BBC micro: bits, så en af dem sættes i GiggleBot, og med den anden bruges de 2 knapper til at gå gennem en menu og indstille forskellige parametre. Sendingen af disse opdaterede parametre sker via radioen.

Trin 1: Påkrævede komponenter

Du skal bruge følgende:

1. En GiggleBot -robot til mikro: bit.
2. x3 AA -batterier
3. x2 BBC micro: bits - en til GiggleBot og den anden fungerer som fjernbetjening til tuning af parametre.
4. Et batteri til en BBC micro: bit - som det, der følger med BBC micro: bit -pakken.

Få GiggleBot Robot til BBC micro: bit her

Trin 2: Opsætning af spor og miljø

Du skal også faktisk bygge dine spor (downloade, udskrive, klippe og tape fliser) og derefter opsætte miljøet (IDE og runtime).

Da denne vejledning er meget relateret til denne anden vejledning med titlen GiggleBot Line Follower, skal du bare gå derhen og følge trin 2 og 3 og derefter komme tilbage her.

Hvad angår IDE, kan du bruge Mu -editoren, og for runtime skal du downloade GiggleBot MicroPython Runtime. Køretiden kan downloades fra dokumentationen her. Gå til kapitlet Kom godt i gang i dokumentationen, og følg disse instruktioner om opsætning af miljøet. Fra dette øjeblik bruges version v0.4.0 af runtime.

Trin 3: Opsætning af GiggleBot

Inden du blinker runtime til GiggleBot, skal du sørge for at have valgt din ønskede hastighed og opdateringshastighed for GiggleBot: Som standard er hastigheden indstillet til 100 (base_speed -variabel) og opdateringshastighed er sat til 70 (variabel opdateringsrate).

I betragtning af den nuværende implementering er den højeste opdateringshastighed 70, og hvis run_neopixels er indstillet til True, er det kun 50, der kan opnås. Så på en måde kan du sige, at standardopdateringshastigheden er lige på kanten af, hvad BBC micro: bit kan.

Bare for ordens skyld kan linjefølgersensoren returnere opdateringer 100 gange i sekundet.

Bemærk: Følgende script mangler muligvis mellemrum, og det ser ud til at skyldes et problem med visning af GitHub Gists. Klik på kernen for at tage dig til dens GitHub-side, hvor du kan kopiere og indsætte koden.

GiggleBot PID Line Follower Tuner (kræver en fjernbetjening for at indstille den) - xjfls23

fra mikrobitimport*

fra gigglebot import*

fra utime import sleep_ms, ticks_us

importere radio

import ustruct

# initialiser radio og GB neopixel

radio.on ()

neo = init ()

# timing

opdateringsrate = 70

# standard gevinstværdier

Kp = 0,0

Ki = 0,0

Kd = 0,0

setpunkt = 0,5

trigger_point = 0,0

min_hastighed_procent = 0,2

base_hastighed = 100

sidste_position = setpunkt

integral = 0,0

run_neopixels = Falsk

center_pixel = 5#, hvor smilets midterpixel er placeret på GB

# turkis = tupel (kort (lambda x: int (x / 5), (64, 224, 208))) # farve, der skal bruges til at tegne fejlen med neopixel

# turkis = (12, 44, 41) # hvilket er præcis ovenstående turkis kommenteret over dette

error_width_per_pixel = 0,5/3# max fejl divideret med antallet af segmenter mellem hver neopixel

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

global base_hastighed

hvis 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)

# samme som

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

motor_power = basis_hastighed * (mindste_motor_power + (1- y) * (højeste_motor_power - mindste_motor_power))

return motor_power

andet:

returner base_hastighed * højeste_motor_kraft

løb = Falsk

foregående_fejl = 0

total_tid = 0,0

total_counts = 0

whileTrue:

# hvis der trykkes på knappen a, skal du begynde at følge

hvis button_a.is_pressed ():

run = True

# men hvis der trykkes på knap b, stop linjefølgeren

hvis button_b.is_pressed ():

løb = Falsk

integral = 0,0

foregående_fejl = 0.0

display.scroll ('{} - {}'. format (total_time, total_counts), forsinkelse = 100, vent = falsk)

total_tid = 0,0

total_counts = 0

pixels_off ()

hold op()

sleep_ms (500)

hvis kørsel er sandt:

# læs linjesensorerne

start_time = ticks_us ()

# tjek om vi har opdateret Kp/Kd -gevinsterne med en fjernbetjening

prøve:

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

set_eyes ()

exceptTypeError:

passere

højre, venstre = læs_sensor (LINE_SENSOR, BÅDE)

# linje er til venstre, når position <0,5

# linje er til højre, når position> 0,5

# linje er i midten, når position = 0,5

# det er et vægtet aritmetisk middel

prøve:

position = højre /flyde (venstre + højre)

undtagenZeroDivisionError:

position = 0,5

hvis position == 0: position = 0,001

hvis position == 1: position = 0,999

# brug en PD -controller

fejl = position - setpunkt

integral += fejl

korrektion = Kp * fejl + Ki * integral + Kd * (fejl - foregående_fejl)

previous_error = fejl

# beregne motorhastigheder

motor_speed = upper_bound_linear_speed_reducer (abs (fejl), setpunkt * trigger_point, setpunkt, min_hastighed_procent, 1,0)

leftMotorSpeed = motor_speed + korrektion

rightMotorSpeed = motor_speed - korrektion

# tænd neopixelerne for at vise i hvilken retning GiggleBot skal gå

hvis run_neopixels isTrueand total_counts %3 == 0:

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

neo = (0, 0, 0)

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

ifabs (fejl)> error_width_per_pixel * i:

hvis fejl <0:

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

andet:

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

andet:

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

# tænde den aktuelle pixel

hvis fejl <0:

# neo [center_pixel + i] = tuple (map (lambda x: int (x * procent), turkis))

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

andet:

# neo [center_pixel - i] = tuple (kort (lambda x: int (x * procent), turkis))

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

pause

neo.show ()

prøve:

# klip motorerne

hvis venstreMotorSpeed> 100:

leftMotorSpeed = 100

højreMotorSpeed = højreMotorSpeed - venstreMotorSpeed +100

hvis rightMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = venstreMotorSpeed - højreMotorSpeed +100

hvis venstreMotorSpeed <-100:

leftMotorSpeed = -100

hvis rightMotorSpeed <-100:

rightMotorSpeed = -100

# aktiver motorerne

set_speed (venstreMotorSpeed, højreMotorSpeed)

køre()

# print ((fejl, motorhastighed))

undtagen:

# i tilfælde af at vi kommer ind i et uopretteligt problem

passere

# og opretholde sløjfrekvensen

end_time = ticks_us ()

delay_diff = (end_time - start_time) /1000

total_tid += forsinkelses_forskel

total_counts += 1

if1.0/ update_rate - delay_diff> 0:

sove (1.0/ opdateringshastighed - forsinkelses_diff)

se rawgigglebot_line_follower_tuner.py hostet af ❤ af GitHub

Trin 4: Opsætning af tuneren (fjernbetjening)

Den næste ting, vi skal gøre, er at flash runtime + scriptet til 2. BBC micro: bit. Denne anden micro: bit fungerer som en fjernbetjening til GiggleBot, som vil blive brugt til at indstille følgende parametre:

1. Kp = proportionel forstærkning for PID -controlleren.
2. Ki = integreret forstærkning for PID -controlleren.
3. Kd = derivatforstærkning for PID -controlleren.
4. trigger_point = det punkt udtrykt i procent mellem minimum og maksimum hastigheder for GiggleBot, hvor hastigheden begynder at blive reduceret lineært, indtil den når minimumshastigheden.
5. min_speed_percent = minimumshastigheden udtrykt i procent af den maksimale hastighed.

De to andre resterende variabler, der kan indstilles, er direkte hårdt kodet i scriptet, der sidder på GiggleBot: update_rate og base_speed, der repræsenterer den maksimale hastighed. Som beskrevet i dokumentationen er den maksimale hastighed, der kan indstilles for GiggleBot 100, hvilket også er standardværdien for vores GiggleBot.

Bemærk: Følgende script mangler muligvis mellemrum, og det ser ud til at skyldes et problem med visning af GitHub Gists. Klik på kernen for at tage dig til dens GitHub-side, hvor du kan kopiere og indsætte koden.

GiggleBot Remote PID Line Follower Tuner (kræver den anden del) - xjfls23

fra mikrobitimport*

fra utime import sleep_ms

importere radio

import ustruct

# 1. element er Kp -forstærkningen

# 2. element er Ki -forstærkningen

# 3. element er Kd -forstærkningen

# 4. element er trigger_point for motorer til at sænke hastigheden (0 -> 1)

# 5. element er min. Hastighed for motorer udtrykt i procent (0 -> 1)

gevinster = [0,0, 0,0, 0,0, 1,0, 0,0]

stepSize = 0,1

# 0 og 1 for 1. element

# 2 og 3 for 2. element

currentSetting = 0

defshowMenu ():

display.scroll ('{} - {}'. format (currentSetting, gain [int (currentSetting /2)]), forsinkelse = 100, vent = Falsk)

radio.on ()

showMenu ()

whileTrue:

opdateret = Falsk

hvis button_a.is_pressed ():

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

updated = True

hvis button_b.is_pressed ():

hvis currentSetting %2 == 0:

# forøg gevinst, når nuværende indstilling er 0 eller 2 eller..

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

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

andet:

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

andet:

# forøg gevinst, når nuværende indstilling er 1 eller 3 eller..

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

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

andet:

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

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

updated = True

hvis opdateret:

showMenu ()

sleep_ms (200)

se rawgigglebot_line_follower_configurator.py hostet af ❤ af GitHub

Trin 5: Tuning af GiggleBot

Placer GiggleBot på sporet, tænd for det og lad det køre. I mellemtiden skal du konstant sætte det tilbage på sporet og indstille gevinster/parametre med den anden BBC micro: bit, som du holder i hånden.

For at starte GiggleBot skal du trykke på knap A på GiggleBots BBC micro: bit og stoppe den og dermed nulstille dens tilstand ved at trykke på knap B.

På den eksterne BBC micro: bit vil et tryk på knap A føre dig igennem alle muligheder i menuen, og knap B øger/formindsker den tilsvarende værdi. Det er som at stille uret på en gammel bils instrumentbræt. Mulighederne er sådan her:

1. 0-1 muligheder er for Kp gevinst.
2. 2-3 muligheder er for Ki-gevinsten.
3. 4-5 muligheder er for Kd-gevinsten.
4. 6-7 muligheder er til indstilling af setpunktet for det øjeblik, hvor motorerne begynder at bremse.
5. 8-9 muligheder er til indstilling af minimumshastigheden.

Husk, at lige tal i menuen er til at øge de tilsvarende værdier, og for de ulige er det præcis det modsatte.

Når du trykker på knap B på GiggleBots BBC micro: bit, ser du også på sin Neopixel -fremstillede skærm antallet af forløbne millisekunder siden den sidste nulstilling og antallet af cyklusser, robotten har gennemgået - med disse 2 kan du beregne opdateringshastigheden for robotten.

Endelig og vigtigst af alt er jeg kommet med 2 tunings til GiggleBot. Den ene er til, når Neopixel -lysdioderne er slukket, og den anden er til, når det er anderledes. Neopixel -lysdioderne bruges til at vise i hvilken retning fejlen er akkumuleret.

1. sæt tuning af parametrene (med NeoPixel LED'er slukket)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0,3 (hvilket er 30%)
5. min_hastighed_procent = 0,2 (hvilket er 20%)
6. base_speed = 100 (aka maksimal hastighed)
7. update_rate = 70 (kører @70Hz)

2. sæt tuning af parametrene (med NeoPixel -lysdioderne tændt)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0,3 (hvilket er 30%)
5. min_hastighed_procent = 0,3 (hvilket er 30%)
6. base_speed = 70 (aka maksimal hastighed)
7. update_rate = 50 (kører @50Hz)
8. Variabel run_neopixels skal også indstilles til True i scriptet, der bliver indlæst på GiggleBots BBC micro: bit. Dette får NeoPixel LED'erne til at blinke på en sådan måde, at de angiver i hvilken retning fejlen akkumuleres.

Trin 6: GiggleBot kører med NeoPixels slukket

Dette er et eksempel på at køre GiggleBot med de første tuningsparametre fundet i det foregående trin. I dette eksempel er NeoPixel -lysdioderne slukket.

Trin 7: GiggleBot kører med Neopixels slået til

Dette er et eksempel på at køre GiggleBot med det 2. sæt tuningparametre, der findes i trin 5. Dette eksempel har NeoPixel -lysdioderne tændt.

Læg mærke til, hvordan GiggleBot i dette eksempel har sværere ved at følge linjen - det er fordi Neopixel LED'erne "spiser" CPU -tiden for BBC micro: bit. Derfor var vi nødt til at reducere opdateringshastigheden fra 70 ned til 50.