Pag-tune ng GiggleBot Line Follower - Advanced: 7 Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:13

Sa napakadaling Mga Instruction na ito ay tune mo ng iyong sariling GiggleBot upang sundin ang isang itim na linya. Sa iba pang tutorial na GiggleBot Line Follower na ito, hard-code namin ang mga halaga ng pag-tune upang gumana alinsunod sa senaryong iyon. Baka gusto mong gawing mas mahusay ang pag-uugali nito sa pamamagitan ng pag-isip ng iba pang mga nakamit.

Sa tutorial na ito, ipinapakita namin sa iyo ang 2 mga script na maaaring parehong mai-load sa iba't ibang BBC micro: mga bit upang ang isa sa kanila ay mailagay sa GiggleBot at sa isa pa, ginagamit ang 2 mga pindutan upang dumaan sa isang menu at magkakaiba ng tune mga parameter Ang pagpapadala ng mga na-update na parameter na ito ay ginagawa sa pamamagitan ng radyo.

Hakbang 1: Kinakailangan na Mga Sangkap

Kakailanganin mo ang sumusunod:

1. Isang robot na GiggleBot para sa micro: bit.
2. x3 Mga Baterya ng AA
3. x2 BBC micro: bits - isa para sa GiggleBot at ang isa pa ay kumikilos bilang isang remote para sa mga parameter ng pag-tune.
4. Isang baterya para sa isang BBC micro: bit - tulad ng isa na dumarating sa loob ng BBC micro: bit package.

Kunin ang GiggleBot Robot para sa BBC micro: kaunti dito

Hakbang 2: Pag-set up ng Mga Track at Kapaligiran

Kailangan mo ring buuin ang iyong mga track (i-download, i-print, i-cut at i-tape ang mga tile) at pagkatapos ay i-set up ang kapaligiran (ang IDE at ang runtime).

Dahil ang tutorial na ito ay napaka-kaugnay sa iba pang tutorial na pinamagatang GiggleBot Line Follower, pumunta lamang doon at sundin ang mga hakbang 2 at 3 at pagkatapos ay bumalik dito.

Tulad ng para sa IDE, maaari mong gamitin ang Mu editor at para sa runtime, kailangan mong i-download ang GiggleBot MicroPython Runtime. Maaaring mai-download ang runtime mula sa mga dokumentasyon dito. Tumungo sa kabanata ng pagsisimula ng dokumentasyon at sundin ang mga tagubiling iyon sa pag-set up ng kapaligiran. Tulad ng sa sandaling ito, ginagamit ang bersyon v0.4.0 ng runtime.

Hakbang 3: Pag-set up ng GiggleBot

Bago i-flashing ang runtime sa GiggleBot, tiyaking napili mo ang nais mong rate ng bilis at pag-update para sa GiggleBot: bilang default, ang bilis ay nakatakda sa 100 (base_speed variable) at ang rate ng pag-update ay nakatakda sa 70 (variable ng update_rate).

Dahil sa kasalukuyang pagpapatupad, ang pinakamataas na rate ng pag-update na maaaring makamit ay 70 at kung ang run_neopixels ay nakatakda sa True, pagkatapos ay 50 lamang ang makakamit. Kaya't sa isang paraan, maaari mong sabihin na ang default na rate ng pag-update ay nasa gilid mismo ng magagawa ng BBC micro: kaunti.

Para lamang sa talaan, ang sensor ng tagasunod sa linya ay maaaring magbalik ng mga pag-update nang 100 beses sa isang segundo.

Tandaan: Ang sumusunod na script ay maaaring may mga nawawalang mga whitespaces at tila ito ay sanhi ng ilang isyu sa pagpapakita ng GitHub Gists. Mag-click sa buod upang dalhin ka sa pahina ng GitHub na kung saan maaari mong kopyahin-i-paste ang code.

Ang GiggleBot PID Line Follower Tuner (nangangailangan ng isang remote upang ibagay ito) - xjfls23

mula sa microbit import *

mula sa gigglebot import *

mula sa utime import sleep_ms, ticks_us

mag-import ng radyo

mag-import ng us konstruksyon

# ipasimula ang radio at GB neopixels

radio.on ()

neo = init ()

# tiyempo

update_rate = 70

# default na mga halaga ng makakuha

Kp = 0.0

Ki = 0.0

Kd = 0.0

setpoint = 0.5

trigger_point = 0.0

min_speed_percent = 0.2

base_speed = 100

last_position = setpoint

integral = 0.0

run_neopixels = Mali

center_pixel = 5 # kung saan matatagpuan ang center pixel ng ngiti sa GB

# turquoise = tuple (mapa (lambda x: int (x / 5), (64, 224, 208))) # Kulay na gagamitin upang iguhit ang error sa mga neopixel

# turquoise = (12, 44, 41) # na eksakto sa itaas na turkesa ay nagkomento sa itaas nito

error_width_per_pixel = 0.5 / 3 # max error na hinati sa bilang ng mga segment sa pagitan ng bawat neopixel

defupper_bound_linear_speed_reducer (abs_error, trigger_point, upper_bound, pinakamaliit na_motor_power, pinakamataas_motor_power):

pandaigdigang base_pabilis

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

# katulad ng

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

motor_power = base_speed * (pinakamaliit_motor_power + (1- y) * (pinakamataas_motor_power - pinakamaliit_motor_power))

ibalik ang motor_power

iba pa:

ibalik ang base_speed * pinakamataas_motor_power

takbo = Mali

nakaraang_error = 0

total_time = 0.0

total_count = 0

habang Totoo:

Ang # kung pindutan a ay pinindot pagkatapos simulang sundin

kung ang button_a.is_pressed ():

patakbuhin = Totoo

# ngunit kung ang pindutan b ay pinindot itigil ang tagasunod sa linya

kung ang button_b.is_pressed ():

takbo = Mali

integral = 0.0

nakaraang_error = 0.0

display.scroll ('{} - {}'. format (total_time, total_count), pagkaantala = 100, maghintay = Maling)

total_time = 0.0

total_count = 0

pix_off ()

huminto ()

sleep_ms (500)

kung tatakbo ay Totoo:

# basahin ang mga sensor ng linya

start_time = ticks_us ()

# suriin kung na-update namin ang mga nakuha sa Kp / Kd gamit ang isang remote

subukan:

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

set_eyes ()

maliban sa TypeError:

pumasa

kanan, kaliwa = read_sensor (LINE_SENSOR, BOTH)

Ang # linya ay nasa kaliwa kapag ang posisyon <0.5

Ang # linya ay nasa kanan kapag posisyon> 0.5

Ang # linya ay nasa gitna kapag posisyon = 0.5

# ito ay isang bigat na ibig sabihin ng arithmetic

subukan:

posisyon = kanan / float (kaliwa + kanan)

exceptZeroDivisionError:

posisyon = 0.5

kung posisyon == 0: posisyon = 0.001

kung posisyon == 1: posisyon = 0.999

# Gumamit ng isang PD Controller

error = posisyon - setpoint

integral + = error

pagwawasto = Kp * error + Ki * integral + Kd * (error - nakaraang_error)

nakaraang_error = error

# kalkulahin ang bilis ng motor

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

leftMotorSpeed = motor_speed + pagwawasto

rightMotorSpeed = motor_speed - pagwawasto

# sindihan ang mga neopixel upang maipakita sa aling direksyon ang dapat puntahan ng GiggleBot

kung ang run_neopixels ayTrueand total_counts% 3 == 0:

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

neo = (0, 0, 0)

para sa inb '\ x00 / x01 / x02 / x03':

ifabs (error)> error_width_per_pixel * i:

kung error <0:

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

iba pa:

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

iba pa:

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

# sindihan ang kasalukuyang pixel

kung error <0:

# neo [center_pixel + i] = tuple (mapa (lambda x: int (x * porsyento), turkesa))

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

iba pa:

# neo [center_pixel - i] = tuple (mapa (lambda x: int (x * porsyento), turkesa))

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

pahinga

neo.show ()

subukan:

# clip ang mga motor

kung leftMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

kung tamaMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - kananMotorSpeed +100

kung leftMotorSpeed <-100:

leftMotorSpeed = -100

kung tamaMotorSpeed <-100:

rightMotorSpeed = -100

# i-aktibo ang mga motor

set_speed (leftMotorSpeed, kananMotorSpeed)

drive ()

# print ((error, motor_speed))

maliban sa:

# kung sakaling mapunta kami sa ilang hindi na-aayos na isyu

pumasa

# at panatilihin ang dalas ng loop

end_time = ticks_us ()

delay_diff = (end_time - start_time) / 1000

total_time + = delay_diff

total_count + = 1

if1.0 / update_rate - delay_diff> 0:

pagtulog (1.0 / update_rate - delay_diff)

tingnan ang rawgigglebot_line_follower_tuner.py naka-host sa ❤ ng GitHub

Hakbang 4: Pag-set up ng Tuner (Remote)

Ang susunod na dapat nating gawin ay i-flash ang runtime + script sa ika-2 BBC micro: bit. Ang pangalawang micro: bit ay kumikilos bilang isang remote sa GiggleBot, na gagamitin upang ibagay ang mga sumusunod na parameter:

1. Kp = proporsyonal na pakinabang para sa taga-kontrol ng PID.
2. Ki = mahalagang pakinabang para sa taga-kontrol ng PID.
3. Kd = nakukuhang nakuha para sa taga-kontrol ng PID.
4. trigger_point = ang puntong ipinahayag sa mga porsyento sa pagitan ng minimum at maximum na bilis ng GiggleBot kung saan ang bilis ay nagsisimulang mabawasan nang linearly hanggang sa maabot ang pinakamaliit na bilis.
5. min_speed_percent = ang minimum na bilis na ipinahiwatig sa porsyento ng maximum na bilis.

Ang iba pang 2 natitirang mga variable na maaaring ma-tune ay direktang mahirap naka-code sa script na nakaupo sa GiggleBot: ang update_rate at base_speed na kumakatawan sa maximum na bilis. Tulad ng inilarawan sa dokumentasyon, ang maximum na bilis na maaaring maitakda para sa GiggleBot ay 100, na kung saan ay ang default na halaga din para sa aming GiggleBot.

Tandaan: Ang sumusunod na script ay maaaring may mga nawawalang mga whitespaces at tila ito ay sanhi ng ilang isyu sa pagpapakita ng GitHub Gists. Mag-click sa buod upang dalhin ka sa pahina ng GitHub na kung saan maaari mong kopyahin-i-paste ang code.

Ang GiggleBot Remote PID Line Follower Tuner (nangangailangan ng iba pang bahagi) - xjfls23

mula sa microbit import *

mula sa utime import sleep_ms

mag-import ng radyo

mag-import ng us konstruksyon

# Ika-1 elemento ay ang Kp makakuha

# Ika-2 elemento ay ang nakakuha ng Ki

# Ika-3 elemento ay ang nakuha ng Kd

Ang ika-4 na elemento ay ang trigger_point para sa mga motor na babaan ang bilis (0 -> 1)

Ang ika-5 elemento ay ang bilis ng min para sa mga motor na ipinahiwatig sa mga porsyento (0 -> 1)

mga nadagdag = [0.0, 0.0, 0.0, 1.0, 0.0]

stepSize = 0.1

# 0 at 1 para sa ika-1 elemento

# 2 at 3 para sa ika-2 elemento

currentSetting = 0

defshowMenu ():

display.scroll ('{} - {}'. format (kasalukuyangSetting, mga nakuha [int (currentSetting / 2)]), pagkaantala = 100, maghintay = Maling)

radio.on ()

showMenu ()

habang Totoo:

na-update = Mali

kung ang button_a.is_pressed ():

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

na-update = Totoo

kung ang button_b.is_pressed ():

kung kasalukuyangSetting% 2 == 0:

# dagdagan ang nakuha kapag ang kasalukuyangSetting ay 0 o 2 o..

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

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

iba pa:

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

iba pa:

# dagdagan ang nakuha kapag ang kasalukuyangSetting ay 1 o 3 o..

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

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

iba pa:

mga nakuha [int (currentSetting / 2)] - = stepSize

radio.send_bytes (us konstr.pack ('fffff', * mga nadagdag))

na-update = Totoo

kung na-update:

showMenu ()

sleep_ms (200)

tingnan ang rawgigglebot_line_follower_configurator.py naka-host sa ❤ ng GitHub

Hakbang 5: Pag-tune ng GiggleBot

Ilagay ang GiggleBot sa track, i-on ito at hayaang tumakbo ito. Pansamantala, patuloy mong ibabalik ito sa track at ibagay ang mga nadagdag / parameter sa iba pang BBC micro: kaunting hawak mo sa iyong kamay.

Upang simulan ang GiggleBot, pindutin ang pindutan A sa GiggleBot's BBC micro: bit at upang pigilan ito at sa gayon ay i-reset ang state press sa button B.

Sa remote BBC micro: bit, ang pagpindot sa pindutan A ay magdadala sa iyo sa bawat pagpipilian sa menu nito at ang button B ay nagdaragdag / bumababa ng kaukulang halaga. Ito ay tulad ng pagtatakda ng orasan sa dashboard ng isang lumang kotse. Ang mga pagpipilian ay tulad nito:

1. Ang 0-1 na pagpipilian ay para sa Kp na nakuha.
2. 2-3 mga pagpipilian ay para sa Ki makakuha.
3. 4-5 pagpipilian ay para sa Kd makakuha.
4. Ang mga pagpipilian sa 6-7 ay para sa pagtatakda ng setpoint para sa sandaling ito kapag ang mga motor ay nagsisimulang bumagal.
5. Ang mga pagpipilian sa 8-9 ay para sa pagtatakda ng minimum na bilis.

Tandaan na kahit na ang mga numero sa menu ay para sa pagtaas ng mga kaukulang halaga at para sa mga kakatwa ay eksaktong kabaligtaran nito.

Gayundin, kapag pinindot ang pindutan B sa GiggleBot's BBC micro: kaunti, makikita mo sa screen na ginawa ng Neopixel ang bilang ng mga lumipas na milliseconds mula noong huling pag-reset at ang bilang ng mga pag-ikot na nadaanan ng robot - sa mga 2 maaari mong kalkulahin ang rate ng pag-update ng robot.

Panghuli at pinakamahalaga, nakaisip ako ng 2 mga pag-tune para sa GiggleBot. Ang isa sa mga ito ay para sa kapag ang mga Neopixel LEDs ay naka-patay at ang iba pa ay para sa kung hindi man. Ginagamit ang Neopixel LEDs upang maipakita sa aling direksyon ang naipon ng error.

Ika-1 na hanay ng pag-tune ng mga parameter (na may NeoPixel LEDs off)

1. Kp = 32.0
2. Ki = 0.5
3. Kd = 80.0
4. trigger_setpoint = 0.3 (na 30%)
5. min_speed_percent = 0.2 (na kung saan ay 20%)
6. base_speed = 100 (aka maximum na bilis)
7. update_rate = 70 (tumatakbo @ 70Hz)

Pangalawang set ng pag-tune ng mga parameter (kasama ang NeoPixel LEDs)

1. Kp = 25.0
2. Ki = 0.5
3. Kd = 35.0
4. trigger_setpoint = 0.3 (na 30%)
5. min_speed_percent = 0.3 (na kung saan ay 30%)
6. base_speed = 70 (aka maximum na bilis)
7. update_rate = 50 (tumatakbo @ 50Hz)
8. Gayundin, ang mga variable run_neopixels ay dapat itakda sa True sa script na na-load sa GiggleBot's BBC micro: bit. Gagawin nitong flash ang NeoPixel LEDs sa isang paraan na ipahiwatig nila patungo sa aling direksyon na naipon ang error.

Hakbang 6: Tumatakbo ang GiggleBot Gamit ang Mga NeoPixels na Nakapatay

Ito ay isang halimbawa ng pagpapatakbo ng GiggleBot na may mga 1st parameter ng pag-tune na natagpuan sa nakaraang hakbang. Ang halimbawang ito ay naka-off ang NeoPixel LEDs.

Hakbang 7: Tumatakbo ang GiggleBot Gamit ang Mga Neopixels Na-On

Ito ay isang halimbawa ng pagpapatakbo ng GiggleBot na may ika-2 hanay ng mga parameter ng pag-tune na matatagpuan sa hakbang 5. Ang halimbawang ito ay naka-on ang NeoPixel LEDs.

Pansinin kung paano sa halimbawang ito, ang GiggleBot ay may isang mas mahirap oras sa pagsunod sa linya - iyon ay dahil ang Neopixel LEDs ay "kumakain" sa oras ng CPU ng BBC micro: bit. Iyon ang dahilan kung bakit kinailangan naming bawasan ang rate ng pag-update mula 70 hanggang 50.