Tuning GiggleBot Line Follower - Advanced: 7 Steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:44

I denna mycket korta instruktion kommer du att ställa in din egen GiggleBot för att följa en svart linje. I denna andra handledning GiggleBot Line Follower, hårdkodade vi inställningsvärdena för att fungera enligt det scenariot. Du kanske vill få det att bete sig bättre genom att komma med andra vinster.

I denna handledning visar vi dig två skript som båda kan laddas på olika BBC micro: bitar så att en av dem sätts in i GiggleBot och med den andra används de två knapparna för att gå igenom en meny och ställa in olika parametrar. Sändningen av dessa uppdaterade parametrar sker via radion.

Steg 1: Obligatoriska komponenter

Du behöver följande:

1. En GiggleBot -robot för micro: bit.
2. x3 AA -batterier
3. x2 BBC micro: bitar - en för GiggleBot och den andra fungerar som fjärrkontroll för att ställa in parametrar.
4. Ett batteri för ett BBC micro: bit - som det som ingår i BBC micro: bit -paketet.

Skaffa GiggleBot -roboten för BBC micro: bit här

Steg 2: Konfigurera spår och miljö

Du måste också faktiskt bygga dina spår (ladda ner, skriva ut, klipp ut och tejpa brickor) och sedan ställa in miljön (IDE och körtid).

Eftersom denna handledning är mycket relaterad till denna andra handledning med titeln GiggleBot Line Follower, gå bara dit och följ steg 2 och 3 och kom sedan tillbaka hit.

När det gäller IDE kan du använda Mu -redigeraren och för körtiden måste du ladda ner GiggleBot MicroPython Runtime. Körtiden kan laddas ner från dess dokumentation här. Gå till kapitlet Komma igång i dokumentationen och följ instruktionerna för att ställa in miljön. Från och med nu används version v0.4.0 av körtiden.

Steg 3: Konfigurera GiggleBot

Innan du blinkar körtiden till GiggleBot, se till att du har valt önskad hastighet och uppdateringshastighet för GiggleBot: som standard är hastigheten inställd på 100 (bas_hastighetsvariabel) och uppdateringshastigheten är inställd på 70 (uppdateringshastighetsvariabel).

Med tanke på den nuvarande implementeringen är den högsta uppdateringshastigheten som kan uppnås 70 och om run_neopixels är satt till True är det bara 50 som kan uppnås. Så på ett sätt kan du säga att standarduppdateringshastigheten ligger precis vid kanten av vad BBC micro: bit kan göra.

Bara för ordens skull kan radföljarsensorn returnera uppdateringar 100 gånger i sekunden.

Obs! Följande skript kan sakna blanksteg och detta verkar bero på problem med visning av GitHub -listor. Klicka på kärnan för att ta dig till dess GitHub-sida där du kan kopiera och klistra in koden.

GiggleBot PID Line Follower Tuner (kräver en fjärrkontroll för att ställa in den) - xjfls23

från mikrobitimport*

från gigglebot import*

från utime import sleep_ms, ticks_us

importera radio

importera struktur

# initiera radio och GB neopixlar

radio.on ()

neo = init ()

# timing

update_rate = 70

# standardförstärkningsvärden

Kp = 0,0

Ki = 0,0

Kd = 0,0

börvärde = 0,5

trigger_point = 0,0

min_hastighet_procent = 0,2

bashastighet = 100

last_position = börvärde

integral = 0,0

run_neopixels = Falskt

center_pixel = 5# där leppets mittpixel finns på GB

# turkos = tupel (karta (lambda x: int (x / 5), (64, 224, 208))) # färg att använda för att rita felet med neopixlarna

# turkos = (12, 44, 41) # vilket är exakt den ovan turkosa kommenterade ovanför detta

error_width_per_pixel = 0,5/3# max fel dividerat med antalet segment mellan varje neopixel

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

global bas_hastighet

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

# samma som

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

motor_kraft = bashastighet * (minsta_motor_kraft + (1- y) * (högsta_motor_kraft - minsta_motor_kraft))

return motor_power

annan:

returnera bashastighet * högsta_motor_kraft

kör = falskt

föregående_fel = 0

total_tid = 0,0

total_counts = 0

whileTrue:

# om knappen a trycks in börjar du följa

if button_a.is_pressed ():

kör = Sant

# men om knappen b trycks in, stoppa linjeföljaren

om button_b.is_pressed ():

kör = falskt

integral = 0,0

föregående_fel = 0,0

display.scroll ('{} - {}'. format (total_tid, totalt_räkning), fördröjning = 100, vänta = falskt)

total_tid = 0,0

total_counts = 0

pixlar_off ()

sluta()

sleep_ms (500)

if run isTrue:

# läs linjesensorerna

start_time = ticks_us ()

# kontrollera om vi har uppdaterat Kp/Kd -vinsterna med en fjärrkontroll

Prova:

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

set_eyes ()

exceptTypeError:

passera

höger, vänster = läs_sensor (LINE_SENSOR, BÅDE)

# rad är till vänster när position <0,5

# linje är till höger när position> 0,5

# linje är i mitten när position = 0,5

# det är ett vägat aritmetiskt medelvärde

Prova:

position = höger /flyt (vänster + höger)

utomZeroDivisionError:

position = 0,5

om position == 0: position = 0,001

om position == 1: position = 0,999

# använd en PD -controller

fel = position - börvärde

integral += fel

korrigering = Kp * fel + Ki * integral + Kd * (fel - föregående_fel)

previous_error = fel

# beräkna motorvarvtal

motor_speed = upper_bound_linear_speed_reducer (abs (fel), börvärde * trigger_point, börvärde, min_hastighet_procent, 1.0)

leftMotorSpeed = motor_speed + korrigering

rightMotorSpeed = motor_speed - korrigering

# tänd neopixlarna för att visa åt vilket håll GiggleBot måste gå

om run_neopixels isTrueand total_counts %3 == 0:

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

neo = (0, 0, 0)

för i inb '\ x00 / x01 / x02 / x03':

ifabs (fel)> error_width_per_pixel * i:

om fel <0:

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

annan:

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

annan:

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

# tända den aktuella pixeln

om fel <0:

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

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

annan:

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

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

ha sönder

neo.show ()

Prova:

# klipp motorerna

om kvar MotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

om rätt MotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

if leftMotorSpeed <-100:

leftMotorSpeed = -100

om rätt MotorSpeed <-100:

rightMotorSpeed = -100

# aktivera motorerna

set_speed (leftMotorSpeed, rightMotorSpeed)

kör()

# print ((fel, motorhastighet))

bortsett från:

# om vi skulle hamna i något oföränderligt problem

passera

# och behåll loopfrekvensen

end_time = ticks_us ()

delay_diff = (end_time - start_time) /1000

total_tid += delay_diff

total_counts += 1

if1.0/ update_rate - delay_diff> 0:

sömn (1.0/ update_rate - delay_diff)

visa rawgigglebot_line_follower_tuner.py värd med ❤ av GitHub

Steg 4: Installera tunern (fjärrkontroll)

Nästa sak vi måste göra är att blinka runtime + -skriptet till andra BBC micro: bit. Denna andra mikro: bit fungerar som en fjärrkontroll till GiggleBot, som kommer att användas för att ställa in följande parametrar:

1. Kp = proportionell förstärkning för PID -regulatorn.
2. Ki = integrerad förstärkning för PID -regulatorn.
3. Kd = derivatförstärkning för PID -regulatorn.
4. trigger_point = den punkt som uttrycks i procent mellan lägsta och högsta hastighet för GiggleBot där hastigheten börjar minskas linjärt tills den når lägsta hastighet.
5. min_speed_percent = minsta hastighet uttryckt i procent av maxhastigheten.

De andra två återstående variablerna som kan ställas in är direkt hårdkodade i skriptet som sitter på GiggleBot: update_rate och base_speed som representerar maxhastigheten. Som beskrivs i dokumentationen är den maximala hastigheten som kan ställas in för GiggleBot 100, vilket också är standardvärdet för vår GiggleBot.

Obs! Följande skript kan sakna blanksteg och detta verkar bero på problem med visning av GitHub -listor. Klicka på kärnan för att ta dig till dess GitHub-sida där du kan kopiera och klistra in koden.

GiggleBot Remote PID Line Follower Tuner (kräver den andra delen) - xjfls23

från mikrobitimport*

från utime import sleep_ms

importera radio

importera struktur

# 1: a elementet är Kp -förstärkningen

# 2: a elementet är Ki -vinsten

# 3: e elementet är Kd -förstärkningen

# 4: e elementet är trigger_point för motorer för att sänka varvtalet (0 -> 1)

# 5: e elementet är minsta varvtal för motorer uttryckt i procent (0 -> 1)

vinster = [0.0, 0.0, 0.0, 1.0, 0.0]

stepSize = 0,1

# 0 och 1 för första elementet

# 2 och 3 för 2: a elementet

currentSetting = 0

defshowMenu ():

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

radio.on ()

showMenu ()

whileTrue:

uppdaterad = falskt

if button_a.is_pressed ():

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

updated = True

om button_b.is_pressed ():

if currentSetting %2 == 0:

# öka förstärkning när aktuell inställning är 0 eller 2 eller..

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

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

annan:

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

annan:

# öka vinsten när aktuell inställning är 1 eller 3 eller..

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

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

annan:

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

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

updated = True

om uppdaterad:

showMenu ()

sleep_ms (200)

visa rawgigglebot_line_follower_configurator.py värd med ❤ av GitHub

Steg 5: Tuning GiggleBot

Placera GiggleBot på banan, sätt på den och låt den springa. Under tiden måste du ständigt lägga tillbaka den på banan och ställa in vinster/parametrar med den andra BBC micro: bit som du håller i handen.

För att starta GiggleBot, tryck på knapp A på GiggleBots BBC micro: bit och för att stoppa den och därmed återställa dess tillstånd tryck på knapp B.

På den avlägsna BBC micro: bit, genom att trycka på knapp A tar du dig igenom alla alternativ i menyn och knapp B ökar/minskar motsvarande värde. Det är som att ställa klockan på en gammal bils instrumentbräda. Alternativen är så här:

1. 0-1 alternativ är för Kp-vinsten.
2. 2-3 alternativ är för Ki-vinsten.
3. 4-5 alternativ är för Kd-vinsten.
4. 6-7 alternativ finns för att ställa in börvärdet för det ögonblick när motorerna börjar sakta ner.
5. 8-9 alternativ är för inställning av minsta hastighet.

Tänk på att jämna nummer i menyn är för att öka motsvarande värden och för de udda är det exakt motsatsen.

När du trycker på knapp B på GiggleBots BBC micro: bit ser du på dess Neopixel -gjorda skärm antalet förflutna millisekunder sedan den senaste återställningen och antalet cykler som roboten har gått igenom - med dessa 2 kan du beräkna uppdateringshastigheten för roboten.

Slutligen och viktigast av allt, har jag kommit på två stämningar för GiggleBot. En av dem är för när Neopixel -lysdioderna är avstängda och den andra är för när det är annat. Neopixels lysdioder används för att visa i vilken riktning felet har ackumulerats.

Första uppsättningen för att ställa in parametrarna (med NeoPixel -lysdioder avstängda)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0,3 (vilket är 30%)
5. min_speed_percent = 0,2 (vilket är 20%)
6. base_speed = 100 (aka maxhastighet)
7. update_rate = 70 (kör @70Hz)

Andra uppsättningen för att ställa in parametrarna (med NeoPixel -lysdioderna på)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0,3 (vilket är 30%)
5. min_speed_percent = 0,3 (vilket är 30%)
6. bashastighet = 70 (aka maxhastighet)
7. update_rate = 50 (kör @50Hz)
8. Variabel run_neopixels måste också ställas in på True i skriptet som laddas på GiggleBots BBC micro: bit. Detta får NeoPixel -lysdioderna att blinka på ett sådant sätt att de indikerar åt vilket håll felet ackumuleras.

Steg 6: GiggleBot körs med NeoPixels avstängd

Detta är ett exempel på hur du kör GiggleBot med de första tuningparametrarna som hittades i föregående steg. I detta exempel har NeoPixel -lysdioderna stängts av.

Steg 7: GiggleBot kör med Neopixels påslagen

Detta är ett exempel på hur du kör GiggleBot med den andra uppsättningen av inställningsparametrar som finns i steg 5. Detta exempel har NeoPixel -lysdioderna tända.

Lägg märke till hur GiggleBot i detta exempel har svårare att följa linjen - det beror på att Neopixel -lysdioderna "äter" CPU -tiden för BBC micro: bit. Det var därför vi var tvungna att minska uppdateringshastigheten från 70 ner till 50.