A GiggleBot vonalkövető hangolása - Haladó: 7 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:41

Ebben a nagyon rövid utasításban a saját GiggleBotját egy fekete vonal követésére hangolja. Ebben a másik oktatóanyagban, a GiggleBot vonalkövetőben keményen kódoltuk a hangolási értékeket, hogy az adott forgatókönyv szerint működjenek. Érdemes más viselkedéssel előállítani, hogy jobban viselkedjen.

Ebben az oktatóanyagban 2 szkriptet mutatunk be, amelyek mindkettőt különböző BBC mikro: bitekre tölthetik be, hogy az egyiket a GiggleBotba tegyék, a másikkal pedig a 2 gombot használják a menü áttekintésére és a különböző hangolásra. paramétereket. A frissített paraméterek elküldése rádión keresztül történik.

1. lépés: Szükséges összetevők

A következőkre lesz szüksége:

1. GiggleBot robot a micro: bithez.
2. x3 AA elem
3. x2 BBC mikro: bitek - az egyik a GiggleBot számára, a másik pedig távirányítóként működik a paraméterek beállításához.
4. Akkumulátor a BBC micro: bit számára - mint amilyen a BBC micro: bit csomagban található.

Szerezd meg a GiggleBot robotot a BBC mikro: bithez itt

2. lépés: A nyomvonalak és a környezet beállítása

Ezenkívül létre kell hoznia a zeneszámokat (letöltés, nyomtatás, kivágás és ragasztás), majd be kell állítania a környezetet (az IDE és a futási idő).

Mivel ez az oktatóanyag nagyon kapcsolódik ehhez a másik, GiggleBot vonalkövető című oktatóanyaghoz, csak menjen oda, kövesse a 2. és 3. lépést, majd térjen vissza ide.

Ami az IDE -t illeti, használhatja a Mu szerkesztőt, és a futásidőben le kell töltenie a GiggleBot MicroPython Runtime -ot. A futási idő letölthető a dokumentációból itt. Lépjen át a dokumentáció Első lépések fejezetéhez, és kövesse a környezet beállításával kapcsolatos utasításokat. Ettől a pillanattól kezdve a futási idő v0.4.0 verziója használatos.

3. lépés: A GiggleBot beállítása

Mielőtt a GiggleBot futási idejét villogtatná, győződjön meg arról, hogy a kívánt sebességet és frissítési gyakoriságot választotta a GiggleBot számára: alapértelmezés szerint a sebesség 100 (alap_sebesség változó), a frissítési ráta pedig 70 (update_rate változó).

A jelenlegi implementációt figyelembe véve a legnagyobb elérhető frissítési arány 70, és ha a run_neopixels értéke True, akkor csak 50 érhető el. Tehát bizonyos értelemben azt mondhatnánk, hogy az alapértelmezett frissítési arány a BBC micro: bit képességeinek határán van.

Csak a feljegyzés kedvéért a vonalkövető érzékelő másodpercenként 100 -szor tudja visszaadni a frissítéseket.

Megjegyzés: A következő szkriptben hiányozhatnak szóközök, és úgy tűnik, hogy ez a GitHub Gists megjelenítésével kapcsolatos probléma miatt van. A lényegre kattintva eljuthat a GitHub oldalára, ahol másolhatja és beillesztheti a kódot.

GiggleBot PID vonalkövető tuner (hangolásához távirányító szükséges) - xjfls23

mikrobit importból*

a gigglebot importálásból*

utime importból sleep_ms, ticks_us

import rádió

import ustruct

# inicializálja a rádiót és a GB neopixeleket

radio.on ()

neo = init ()

# időzítés

update_rate = 70

# alapértelmezett erősítési érték

Kp = 0,0

Ki = 0,0

Kd = 0,0

alapjel = 0,5

trigger_pont = 0,0

min_speed_percent = 0,2

alapsebesség = 100

last_position = alapjel

integrál = 0,0

run_neopixels = Hamis

center_pixel = 5# ahol a mosoly középső képpontja található a GB -on

# türke

# türkiz = (12, 44, 41) # ami pontosan a fenti türkiz, amelyet e fölött kommentáltunk

error_width_per_pixel = 0,5/3# max hiba osztva az egyes neopixelek közötti szegmensek számával

defupper_bound_linear_speed_reducer (abszolút hiba, trigger_pont, felső_határ, legkisebb_motor teljesítmény, legnagyobb_motor_erő):

globális bázis_sebesség

ha abszolút hiba> = trigger_pont:

# x0 = 0,0

# y0 = 0,0

# x1 = felső_határ - trigger_pont

# y1 = 1,0

# x = abszolút hiba - trigger_pont

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

# ugyanaz, mint a

y = (abszolút hiba - trigger_pont) / (felső_határ - trigger_pont)

motor_erő = bázis_sebesség * (legkisebb_motor_teljesítmény + (1- y) * (legnagyobb_motor_teljesítmény - legkisebb_motor_teljesítmény))

visszatér motor_teljesítmény

más:

visszatérési alapsebesség * legnagyobb_motor_teljesítmény

fut = hamis

előző_hiba = 0

összes_idő = 0,0

total_counts = 0

míg igaz:

# Ha megnyomja az a gombot, akkor kezdje el követni

ha button_a.is_pressed ():

fut = Igaz

# de ha megnyomja a b gombot, állítsa le a vonalkövetőt

ha button_b.is_pressed ():

fut = hamis

integrál = 0,0

előző_hiba = 0,0

display.scroll ('{} - {}'. formátum (total_time, total_counts), delay = 100, wait = False)

összes_idő = 0,0

total_counts = 0

pixels_off ()

álljon meg()

alvás_ms (500)

ha a futás igaz:

# olvassa el a vonalérzékelőket

start_time = kullancsok ()

# ellenőrizze, hogy frissítettük -e a Kp/Kd nyereséget egy távirányítóval

próbáld ki:

Kp, Ki, Kd, trigger_pont, min_speed_percent = ustruct.unpack ('fffff', radio.recept_bytes ())

set_eyes ()

izņemotTypeError:

passz

jobb, bal = olvasásérzékelő (LINE_SENSOR, MINDKÉT)

# vonal a bal oldalon, ha a pozíció <0,5

# vonal a jobb oldalon, ha a pozíció> 0,5

# sor középen van, ha a pozíció = 0,5

# ez egy súlyozott számtani átlag

próbáld ki:

pozíció = jobb /úszó (bal + jobb)

kivéve ZeroDivisionError:

pozíció = 0,5

ha pozíció == 0: pozíció = 0,001

ha pozíció == 1: pozíció = 0,999

# használjon PD vezérlőt

hiba = pozíció - alapjel

integrál += hiba

javítás = Kp * hiba + Ki * integrál + Kd * (hiba - előző_hiba)

előző_hiba = hiba

# kiszámítja a motor fordulatszámát

motor_sebesség = felső_kötött_ lineáris_sebességcsökkentő (absz (hiba), alapjel * trigger_pont, alapérték, min_sebességi százalék, 1.0)

leftMotorSpeed = motor_sebesség + korrekció

rightMotorSpeed = motor_sebesség - korrekció

# világítsa meg a neopixeleket, hogy megmutassa, melyik irányba kell haladnia a GiggleBotnak

ha a run_neopixels isTrueand total_counts %3 == 0:

i inb '\ x00 / x01 / x02 / x03 / x04 / x05 / x06 / x07 / x08' esetén:

neo = (0, 0, 0)

i inb '\ x00 / x01 / x02 / x03' esetén:

ifabs (hiba)> error_width_per_pixel * i:

ha a hiba <0:

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

más:

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

más:

százalék = 1- (error_width_per_pixel * i -abs (error)) / error_width_per_pixel

# világítsa meg az aktuális pixelt

ha a hiba <0:

# neo [center_pixel + i] = sor (térkép (lambda x: int (x * százalék), türkiz))

neo [center_pixel + i] = (int (12* százalék), int (44* százalék), int (41* százalék))

más:

# neo [center_pixel - i] = sor (térkép (lambda x: int (x * százalék), türkiz))

neo [center_pixel - i] = (int (12* százalék), int (44* százalék), int (41* százalék))

szünet

neo.show ()

próbáld ki:

# rögzítse a motorokat

ha balraMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

ha rightMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

ha balraMotorSpeed <-100:

leftMotorSpeed = -100

ha rightMotorSpeed <-100:

rightMotorSpeed = -100

# működtesse a motorokat

set_speed (leftMotorSpeed, rightMotorSpeed)

hajtás()

# print ((hiba, motor_sebesség))

kivéve:

# hátha valamilyen javíthatatlan problémába ütközünk

passz

# és tartsa fenn a hurokfrekvenciát

end_time = kullancsok ()

delay_diff = (vége_idő - kezdési idő) /1000

teljes_idő += késleltetési_diff

total_counts += 1

if1.0/ update_rate - delay_diff> 0:

alvás (1.0/ update_rate - delay_diff)

Tekintse meg a rawgigglebot_line_follower_tuner.py -t, amelyet a GitHub ❤ üzemeltet

4. lépés: A tuner beállítása (távoli)

A következő dolog, amit meg kell tennünk, hogy a futásidejű + szkriptet a 2. BBC micro: bit -re kell villanni. Ez a második mikro: bit a GiggleBot távirányítójaként fog működni, amely a következő paraméterek hangolására szolgál:

1. Kp = arányos erősítés a PID szabályozóhoz.
2. Ki = a PID szabályozó integrált erősítése.
3. Kd = a PID szabályozó derivált nyeresége.
4. trigger_pont = a GiggleBot minimális és maximális sebessége közötti százalékban kifejezett pont, ahol a sebesség lineárisan csökkenni kezd, amíg el nem éri a minimális sebességet.
5. min_speed_percent = a minimális sebesség a maximális sebesség százalékában kifejezve.

A másik 2 fennmaradó, hangolható változó közvetlenül keményen kódolva van a GiggleBot -on található szkriptben: az update_rate és a base_speed, ami a maximális sebességet jelenti. A dokumentációban leírtak szerint a GiggleBot számára beállítható maximális sebesség 100, ami egyben a GiggleBot alapértelmezett értéke is.

Megjegyzés: A következő szkriptben hiányozhatnak szóközök, és úgy tűnik, hogy ez a GitHub Gists megjelenítésével kapcsolatos probléma miatt van. A lényegre kattintva eljuthat a GitHub oldalára, ahol másolhatja és beillesztheti a kódot.

GiggleBot távoli PID vonalkövető tuner (a másik része szükséges) - xjfls23

mikrobit importból*

utime importból sleep_ms

import rádió

import ustruct

# 1. elem a Kp nyereség

# 2. elem a Ki erősítés

# 3. elem a Kd erősítés

# 4. elem a trigger_pontja a motoroknak a sebesség csökkentéséhez (0 -> 1)

Az 5. elem a motorok minimális fordulatszáma százalékban kifejezve (0 -> 1)

nyereség = [0,0, 0,0, 0,0, 1,0, 0,0]

stepSize = 0,1

# 0 és 1 az első elemhez

# 2 és 3 a második elemhez

currentSetting = 0

defshowMenu ():

display.scroll ('{} - {}'. formátum (currentSetting, nyereségek [int (currentSetting /2)]), delay = 100, wait = False)

radio.on ()

showMenu ()

míg igaz:

frissítve = Hamis

ha button_a.is_pressed ():

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

frissítve = Igaz

ha button_b.is_pressed ():

if currentSetting %2 == 0:

# növeli a nyereséget, ha a jelenlegi beállítás 0 vagy 2 vagy..

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

nyereség [int (currentSetting /2)] += 10* stepSize

más:

nyereség [int (currentSetting /2)] += stepSize

más:

# növeli a nyereséget, ha a jelenlegi beállítás 1 vagy 3 vagy..

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

nyereség [int (currentSetting /2)] -= 10* stepSize

más:

nyereség [int (currentSetting /2)] -= stepSize

radio.send_bytes (ustruct.pack ('fffff', *nyereség))

frissítve = Igaz

ha frissítve:

showMenu ()

alvás_ms (200)

a rawgigglebot_line_follower_configurator.py megtekintése, amelyet a GitHub ❤ üzemeltet

5. lépés: A GiggleBot hangolása

Helyezze a GiggleBotot a pályára, kapcsolja be és hagyja futni. Addig is folyamatosan vissza kell tennie a pályára, és a nyereséget/paramétereket be kell hangolnia a másik BBC mikro: bit segítségével, amelyet a kezében tart.

A GiggleBot elindításához nyomja meg az A gombot a GiggleBot BBC micro: bitjén, és állítsa le, és állítsa vissza az állapotát a B gomb megnyomásával.

A távoli BBC micro: bit -en az A gomb megnyomása végigvezeti a menü minden opcióján, a B gomb pedig növeli/csökkenti a megfelelő értéket. Olyan ez, mint egy óra beállítása egy régi autó műszerfalán. A lehetőségek a következők:

1. 0-1 opció a Kp erősítésre vonatkozik.
2. 2-3 lehetőség a Ki erősítésre.
3. 4-5 lehetőség van a Kd erősítésre.
4. A 6-7 opció az alapjel beállítására szolgál, amikor a motorok lassítani kezdenek.
5. A 8-9 opció a minimális sebesség beállítására szolgál.

Ne feledje, hogy a páros számok a menüben a megfelelő értékek növelésére szolgálnak, a páratlanoknál pedig éppen az ellenkezője.

Továbbá, ha megnyomja a B gombot a GiggleBot BBC micro: bitjén, akkor a Neopixel gyártmányú képernyőjén látni fogja az utolsó nullázás óta eltelt ezredmásodpercek számát és a robot által végrehajtott ciklusok számát - ezzel a 2 -vel kiszámíthatja a robot frissítési aránya.

Végül és ami a legfontosabb, 2 hangolást találtam ki a GiggleBot számára. Az egyik arra szolgál, amikor a Neopixel LED -ek ki vannak kapcsolva, a másik pedig arra, amikor másképp van. A Neopixel LED -ek azt mutatják, hogy a hiba milyen irányba halmozódott fel.

A paraméterek hangolásának első csoportja (kikapcsolt NeoPixel LED -ekkel)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0,3 (ami 30%)
5. min_speed_percent = 0,2 (ami 20%)
6. alap_sebesség = 100 (más néven maximális sebesség)
7. update_rate = 70 (70 Hz -en fut)

A paraméterek hangolásának második csoportja (bekapcsolt NeoPixel LED -ekkel)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0,3 (ami 30%)
5. min_speed_percent = 0,3 (ami 30%)
6. alap_sebesség = 70 (más néven maximális sebesség)
7. update_rate = 50 (50 Hz -en fut)
8. Továbbá a Run_neopixels változót True értékre kell állítani a GiggleBot BBC mikro: bitjére betöltött szkriptben. Ettől a NeoPixel LED -ek úgy villognak, hogy jelzik, melyik irányba halmozódik fel a hiba.

6. lépés: A GiggleBot fut a kikapcsolt NeoPixellel

Ez egy példa a GiggleBot futtatására az előző lépésben található 1. hangolási paraméterekkel. Ebben a példában a NeoPixel LED -ek ki vannak kapcsolva.

7. lépés: A GiggleBot fut, ha a neopixelek be vannak kapcsolva

Ez egy példa a GiggleBot futtatására az 5. lépésben található második hangolási paraméterkészlettel. Ebben a példában a NeoPixel LED -ek be vannak kapcsolva.

Figyeljük meg, hogy ebben a példában a GiggleBot nehezebben követi a vonalat - ez azért van, mert a Neopixel LED -ek "megeszik" a BBC micro: bit CPU idejét. Ezért csökkentenünk kellett a frissítési arányt 70 -ről 50 -re.