Kuweka Mfuasi wa Mstari wa GiggleBot - Advanced: Hatua 7

2024 Mwandishi: John Day | [email protected]. Mwisho uliobadilishwa: 2024-01-30 12:51

Katika Maagizo haya mafupi sana utaenda kukagua GiggleBot yako mwenyewe kufuata laini nyeusi. Katika Mfuasi mwingine wa mafunzo ya GiggleBot, tuliweka nambari ngumu za kufanya kazi kulingana na hali hiyo. Unaweza kutaka kuifanya iwe bora kuishi kwa kupata faida zingine.

Katika mafunzo haya, tunakuonyesha hati 2 ambazo zinaweza kupakiwa kwenye vijidudu tofauti vya BBC: bits ili moja yao iwekwe kwenye GiggleBot na kwa hiyo nyingine, vifungo 2 vinatumiwa kupitia menyu na tune tofauti. vigezo. Utumaji wa vigezo hivi vilivyosasishwa hufanywa kupitia redio.

Hatua ya 1: Vipengele vinavyohitajika

Utahitaji yafuatayo:

1. Roboti ya GiggleBot kwa micro: bit.
2. x3 AA Betri
3. x2 ndogo ya BBC: bits - moja kwa GiggleBot na ile nyingine inafanya kama kijijini kwa vigezo vya kuweka.
4. Betri kwa kipeo cha BBC: kidogo - kama ile inayokuja ndani ya kifurushi cha BBC micro: bit.

Pata GiggleBot Robot kwa BBC ndogo: kidogo hapa

Hatua ya 2: Kuanzisha Nyimbo na Mazingira

Lazima pia ujenge nyimbo zako (pakua, uchapishe, ukate na vigae vya mkanda) kisha uweke mazingira (IDE na wakati wa kukimbia).

Kwa kuwa mafunzo haya yanahusiana sana na mafunzo haya mengine yaliyoitwa GiggleBot Line Mfuasi, nenda tu hapo na fuata hatua 2 na 3 kisha urudi hapa.

Kwa IDE, unaweza kutumia mhariri wa Mu na wakati wa kukimbia, unahitaji kupakua GiggleBot MicroPython Runtime. Wakati wa kukimbia unaweza kupakuliwa kutoka kwa nyaraka zake hapa. Elekea kwenye sura ya kuanza ya nyaraka na ufuate maagizo hayo juu ya kuweka mazingira. Kufikia wakati huu, toleo la v0.4.0 la wakati wa kukimbia linatumika.

Hatua ya 3: Kuweka GiggleBot

Kabla ya kuwasha wakati wa kukimbia kwa GiggleBot, hakikisha umechagua kasi yako unayotaka na kusasisha kiwango cha GiggleBot: kwa chaguo-msingi, kasi imewekwa hadi 100 (base_speed variable) na kiwango cha sasisho kimewekwa 70 (sasisho_pya kutofautisha).

Kwa kuzingatia utekelezaji wa sasa, kiwango cha juu zaidi cha sasisho kinachoweza kupatikana ni 70 na ikiwa run_neopixels imewekwa kuwa Kweli, basi ni 50 tu inayoweza kufikiwa. Kwa hivyo kwa njia, unaweza kusema kwamba kiwango cha sasisho chaguomsingi kiko sawa kwenye ukingo wa kile ambacho BBC ndogo: kidogo inaweza kufanya.

Kwa rekodi tu, sensa ya mfuatiliaji wa laini inaweza kurudisha visasisho mara 100 kwa sekunde.

Kumbuka: Hati ifuatayo inaweza kuwa na nafasi nyeupe na hii inaonekana kuwa ni kwa sababu ya suala fulani katika kuonyesha GitHub Gists. Bonyeza kwenye kiini kukupeleka kwenye ukurasa wake wa GitHub ambapo unaweza kunakili-kubandika nambari.

Kifurushi cha Mfuatiliaji wa Mstari wa GiggleBot PID (inahitaji kijijini kuirekebisha) - xjfls23

kutoka kuagiza microbit *

kutoka kuagiza gigglebot *

kutoka wakati wote kuagiza sleep_ms, ticks_us

kuagiza redio

kuagiza ustruct

# anzisha redio na GB neopixels

redio. kwenye ()

neo = init ()

majira

sasisho_pya = 70

Thamani # za kupata chaguo-msingi

Kp = 0.0

Ki = 0.0

Kd = 0.0

setpoint = 0.5

trigger_point = 0.0

Asilimia_mzito_mwendo = 0.2

kasi_ya kasi = 100

nafasi ya mwisho = setpoint

ujumuishaji = 0.0

run_neopixels = Uongo

kituo_pikseli = 5 # ambapo pixel ya katikati ya tabasamu iko kwenye GB

# turquoise = tuple (ramani (lambda x: int (x / 5), (64, 224, 208))) # rangi ya kutumia kuteka kosa na neopixels

# turquoise = (12, 44, 41) # ambayo ni turquoise iliyo juu hapo juu

kosa_width_per_pixel = 0.5 / 3 # makosa mengi yamegawanywa na idadi ya sehemu kati ya kila neopixel

defupper_bound_linear_speed_reducer (abs_error, trigger_point, high_bound, ndogo_motor_power, nguvu_motor_power):

kasi ya kimataifa

ikiwa abs_error> = trigger_point:

# x0 = 0.0

# y0 = 0.0

# x1 = juu_bound - trigger_point

# y1 = 1.0

# x = abs_error - alama ya kuchochea

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

# sawa na

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

motor_power = base_speed * (ndogo_motor_power + (1- y) * (high_motor_power - ndogo_motor_power))

kurudi motor_power

mwingine:

kurudi base_speed * highest_motor_power

kukimbia = Uongo

uliopita_error = 0

jumla_ wakati = 0.0

jumla_mahesabu = 0

wakatiKweli:

# ikiwa kifungo ni taabu kisha anza kufuata

ikiwa button_a.is_pressed ():

run = Kweli

# lakini ikiwa kitufe b kimeshinikizwa simama mfuatiliaji wa laini

ikiwa kitufe_b.inashinikizwa ():

kukimbia = Uongo

ujumuishaji = 0.0

uliopita_error = 0.0

fomati ya onyesho ('{} - {}'

jumla_ wakati = 0.0

jumla_mahesabu = 0

pikseli_za ()

simama ()

kulala_ms (500)

ikiwa kukimbia ni Kweli:

# soma sensorer za mstari

kuanza_wakati = ticks_us ()

# angalia ikiwa tumesasisha faida ya Kp / Kd na kijijini

jaribu:

Kp, Ki, Kd, trigger_point, min_speed_percent = ustruct.unpack ('fffff', redio.pokea_byte ())

set_eyes ()

isipokuwaTypeError:

kupita

kulia, kushoto = soma_sauti (LINE_SENSOR, WOTE)

Mstari # uko kushoto wakati nafasi <0.5

# mstari uko kulia wakati nafasi> 0.5

# mstari uko katikati wakati msimamo = 0.5

# ni maana ya hesabu yenye uzito

jaribu:

msimamo = kulia / kuelea (kushoto + kulia)

exceptZeroDivisionError:

nafasi = 0.5

ikiwa msimamo == 0: nafasi = 0.001

ikiwa msimamo == 1: nafasi = 0.999

# tumia kidhibiti PD

kosa = msimamo - setpoint

ujumuishaji + = kosa

marekebisho = Kp * kosa + Ki * muhimu + Kd * (kosa - uliopita_error)

previous_error = kosa

# mahesabu ya kasi ya magari

motor_speed = high_bound_linear_speed_reducer (abs (makosa), setpoint * trigger_point, setpoint, min_speed_percent, 1.0)

leftMotorSpeed = marekebisho ya mwendo wa kasi

rightMotorSpeed = motor_speed - marekebisho

#washa neopixels kuonyesha ni wapi mwelekeo wa GiggleBot unapaswa kwenda

ikiwa run_neopixels isTrueand total_counts% 3 == 0:

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

neo = (0, 0, 0)

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

ifabs (kosa)> kosa_upita_per_pixel * i:

ikiwa kosa <0:

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

mwingine:

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

mwingine:

asilimia = 1 -

#washa pikseli ya sasa

ikiwa kosa <0:

# neo [center_pixel + i] = tuple (ramani (lambda x: int (asilimia x *), zumaridi))

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

mwingine:

# neo [center_pixel - i] = tuple (ramani (lambda x: int (asilimia x *), zumaridi))

neo [kituo_pikseli - i] = (int (asilimia 12 *), int (asilimia 44 *), int (asilimia 41 *))

kuvunja

onyesha ()

jaribu:

# klipu motors

ikiwa kushotoMotorSpeed> 100:

KushotoMotorSpeed = 100

rightMotorSpeed = hakiMotorSpeed - kushotoMotorSpeed +100

ikiwa sawaMotorSpeed> 100:

kasiMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - kuliaMotorSpeed +100

ikiwa kushotoMotorSpeed <-100:

kushotoMotorSpeed = -100

ikiwa sawaMotorSpeed <-100:

SawaMotorSpeed = -100

# tengeneza motors

set_speed (kushotoMotorSpeed, kuliaMotorSpeed)

kuendesha ()

# kuchapisha ((kosa, mwendo wa gari))

isipokuwa:

# ikiwa tutaingia kwenye swala lisiloweza kutumiwa

kupita

# na kudumisha mzunguko wa kitanzi

mwisho_wakati = ticks_us ()

kuchelewesha_diff = (muda wa mwisho - wakati wa kuanza) / 1000

Jumla_wakati + = kuchelewesha_tofauti

jumla_mahesabu + = 1

if1.0 / update_rate - delay_diff> 0:

kulala (1.0 / update_rate - delay_diff)

tazama rawgigglebot_line_follower_tuner.py iliyoandaliwa na ❤ na GitHub

Hatua ya 4: Kuanzisha Kitanishi (Kijijini)

Jambo la pili tunalopaswa kufanya ni kuangazia muda wa kukimbia + kwa 2 BBC ndogo: kidogo. Micro ndogo hii ya pili itafanya kama kijijini kwa GiggleBot, ambayo itatumika kurekebisha vigezo vifuatavyo:

1. Kp = faida sawia kwa mtawala wa PID.
2. Ki = faida muhimu kwa mdhibiti wa PID.
3. Kd = faida inayotokana na mtawala wa PID.
4. trigger_point = hatua iliyoonyeshwa kwa asilimia kati ya kiwango cha chini na kiwango cha juu cha GiggleBot ambapo kasi huanza kupunguzwa kwa laini hadi kufikia kasi ya chini.
5. min_speed_percent = kasi ya chini iliyoonyeshwa kwa asilimia ya kasi ya juu.

Vigeuzi vingine 2 vilivyobaki ambavyo vinaweza kusanidiwa vimewekwa ngumu moja kwa moja kwenye hati ambayo inakaa kwenye GiggleBot: sasisho_ya kusasisha na base_speed ambayo inawakilisha kasi kubwa. Kama ilivyoelezewa katika nyaraka, kasi kubwa ambayo inaweza kuwekwa kwa GiggleBot ni 100, ambayo pia ni dhamana ya msingi kwa GiggleBot yetu.

Kumbuka: Hati ifuatayo inaweza kuwa na nafasi nyeupe na hii inaonekana kuwa ni kwa sababu ya suala fulani katika kuonyesha GitHub Gists. Bonyeza kwenye kiini kukupeleka kwenye ukurasa wake wa GitHub ambapo unaweza kunakili-kubandika nambari.

Tuner ya Mfuatiliaji wa PID ya Mbali ya GiggleBot (inahitaji sehemu nyingine) - xjfls23

kutoka kuagiza microbit *

kutoka wakati wote kuagiza sleep_ms

kuagiza redio

kuagiza ustruct

# 1 kipengee ni faida ya Kp

# 2 kipengele ni faida ya Ki

# 3 kipengele ni faida ya Kd

# 4 elementi ni trigger_point ya motors kupunguza kasi (0 -> 1)

Sehemu ya 5 ni kasi ya min kwa motors kama inavyoonyeshwa kwa asilimia (0 -> 1)

faida = [0.0, 0.0, 0.0, 1.0, 0.0]

stepSize = 0.1

# 0 na 1 kwa kipengee cha 1

# 2 na 3 kwa kipengee cha 2

Kuweka sasa = 0

defshowMenu ():

fomati ya kuonyesha.

redio. kwenye ()

onyeshaMenu ()

wakatiKweli:

imesasishwa = Uongo

ikiwa button_a.is_pressed ():

Kuweka sasa = (Kuweka sasa + 1)% (2 * 5)

imesasishwa = Kweli

ikiwa kitufe_b.inashinikizwa ():

ikiwa Kuweka sasa% 2 == 0:

Ongeza faida wakati seti ya sasa ni 0 au 2 au..

ifint (sasaSetting / 2) katika [0, 2]:

faida [int (currentSetting / 2)] + = 10 * hatuaSize

mwingine:

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

mwingine:

Ongeza faida wakati seti ya sasa ni 1 au 3 au..

ifint (sasaSetting / 2) katika [0, 2]:

faida [int (currentSetting / 2)] - = 10 * hatuaSize

mwingine:

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

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

imesasishwa = Kweli

ikiwa imesasishwa:

onyeshaMenu ()

kulala_ms (200)

angalia rawgigglebot_line_follower_configurator.py iliyohifadhiwa na ❤ na GitHub

Hatua ya 5: Kuweka GiggleBot

Weka GiggleBot kwenye wimbo, uiwashe na uiruhusu iendeshe. Wakati huo huo, itabidi uirudishe kwenye wimbo na urekebishe faida / vigezo na kipengee kingine cha BBC: kidogo ambacho umeshikilia mkononi mwako.

Kuanza GiggleBot, bonyeza kitufe cha A kwenye GiggleBot's Micro micro: kidogo na kuisimamisha na hivyo kuweka upya hali yake kwa kitufe cha B.

Kwenye kidude cha mbali cha BBC: kidogo, kitufe cha kubonyeza A kitakuchukua kila chaguo kwenye menyu na kitufe B kinaongeza / hupunguza thamani inayolingana. Ni kama kuweka saa kwenye dashibodi ya zamani ya gari. Chaguzi ni kama hii:

1. Chaguzi 0-1 ni kwa faida ya Kp.
2. Chaguzi 2-3 ni kwa faida ya Ki.
3. Chaguzi 4-5 ni kwa faida ya Kd.
4. Chaguzi 6-7 ni kwa kuweka setpoint kwa wakati motors zinaanza kupungua.
5. Chaguzi 8-9 ni kwa kuweka kasi ya chini.

Kumbuka kwamba hata nambari kwenye menyu ni ya kuongeza maadili yanayolingana na ile isiyo ya kawaida ni kinyume kabisa.

Pia, wakati wa kubonyeza kitufe B kwenye GiggleBot ya BBC ndogo: utaona kwenye skrini iliyotengenezwa na Neopixel idadi ya milisekunde zilizopita tangu kuweka upya mwisho na idadi ya mizunguko ambayo roboti imepita - na hizi 2 unaweza kuhesabu kiwango cha sasisho la roboti.

Mwishowe na muhimu zaidi, nimekuja na tunings 2 za GiggleBot. Moja yao ni kwa wakati LED za Neopixel zimezimwa na nyingine ni wakati ni vinginevyo. LED za Neopixel hutumiwa kuonyesha ni wapi mwelekeo umekusanya kosa.

Seti ya 1 ya kuweka vigezo (ikiwa na LED za NeoPixel zimezimwa)

1. Kp = 32.0
2. Ki = 0.5
3. Kd = 80.0
4. trigger_setpoint = 0.3 (ambayo ni 30%)
5. min_speed_percent = 0.2 (ambayo ni 20%)
6. base_speed = 100 (kasi ya juu ya aka)
7. sasisho_pya = 70 (inaendesha @ 70Hz)

Seti ya 2 ya kuweka vigezo (ikiwa imewashwa na NeoPixel LEDs)

1. Kp = 25.0
2. Ki = 0.5
3. Kd = 35.0
4. trigger_setpoint = 0.3 (ambayo ni 30%)
5. min_speed_percent = 0.3 (ambayo ni 30%)
6. base_speed = 70 (kasi ya juu ya aka)
7. sasisho_pya = 50 (inayoendesha @ 50Hz)
8. Pia, run_neopixels zinazobadilika zinapaswa kuwekwa kuwa Kweli katika hati ambayo inapakiwa kwenye GiggleBot ya BBC micro: bit. Hii itafanya taa za NeoPixel zionekane kwa njia ambayo zinaonyesha ni wapi mwelekeo wa kosa unakusanywa.

Hatua ya 6: GiggleBot inayoendesha na NeoPixels Imezimwa

Huu ni mfano wa kuendesha GiggleBot na vigezo vya 1 vya kuweka vilivyopatikana katika hatua ya awali. Mfano huu LED za NeoPixel zimezimwa.

Hatua ya 7: GiggleBot inayoendesha na Neopixels Imewashwa

Huu ni mfano wa kuendesha GiggleBot na seti ya 2 ya vigezo vya kupangilia vilivyopatikana katika hatua ya 5. Mfano huu umewashwa na LED za NeoPixel.

Angalia jinsi katika mfano huu, GiggleBot ina wakati mgumu kufuata mstari - hiyo ni kwa sababu LED za Neopixel "zinakula" wakati wa CPU wa BBC micro: bit. Ndio sababu tulilazimika kupunguza kiwango cha sasisho kutoka 70 hadi 50.