GiggleBot vonalkövető Python használatával: 5 lépés

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

Ezúttal a MicroPython programozásával programozzuk a Dexter Industries GiggleBot programot, hogy fekete vonalat kövessen a beépített vonalkövető érzékelővel.

A GiggleBot -ot párosítani kell egy BBC micro: bittel, hogy megfelelően vezérelhető legyen.

Ha ez az oktatóanyag túl fejlett az Ön számára, és a GiggleBot programozása egyelőre túl sok, akkor bármikor áttekintheti a kezdő oktatóanyagot, amely megmutatja, hogyan programozható a robot a MakeCode -ban itt. A linkelt bemutató végigvezeti az alapokon.

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

A következő hardverkomponensekre van szükség:

1. x3 AA elem - esetemben újratölthető elemeket használok, amelyek összességében alacsonyabb feszültségűek.
2. Dexter Industries GiggleBot robot a micro: bithez.
3. BBC mikro: bit.

Természetesen a BBC micro: bit programozásához szükség van egy mikro -USB -kábelre is - ez a kábel általában a BBC micro: bit csomagjában található, vagy mindig használhat egyet (Android) okostelefonok töltésére.

Szerezd meg a GiggleBot for micro: bit -et itt

2. lépés: Állítsa be a pályákat

Át kell mennie néhány csempe kinyomtatásán és a saját számok megtervezésén. Használhatja saját lapjainkat, így 100% -ig biztos abban, hogy megismétli feltételeinket. Vagy ha kalandosnak érzi magát, használhat fekete szalagot, és elkészítheti sajátját. Itt található a PDF az általunk használt csempékhez.

A fenti sáv a következő számú különböző lapkából áll:

• 12 db 1. típusú csempe.
• 5 db 2. típusú csempe.
• 3 sablon #5.
• Három sablon #6 típusú csempe - itt egy extra lapkát kap.

Ezután nyomtassa ki és vágja le őket. Próbálja meg elhelyezni őket, mint a fenti képen, és ne feledje, hogy a pálya jobb felső részén két lapnak kell átfednie egymást - ez akkor várható, ha kíváncsi, ha valamit rosszul csinál.

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

Annak érdekében, hogy a BBC micro: bit programozható legyen a MicroPython programban, be kell állítania egy szerkesztőt (a Mu Editor), és a GiggleBot MicroPython Runtime -t kell beállítania futási idejének. Ehhez kövesse az ezen az oldalon található utasításokat. Ettől a pillanattól kezdve a futási idő v0.4.0 verziója használatos.

4. lépés: A GiggleBot programozása

Mielőtt hozzáfogna, a GiggleBot MicroPython futásideje tartalmazza a BBC micro: bit és más könyvtárak klasszikus futási idejét a GiggleBot és más Dexter Industries érzékelők támogatására.

A beállítás után nyissa meg a következő parancsfájlt a Mu szerkesztőben, és kattintson a Flash elemre. Ez felvillanja a GiggleBot MicroPython Runtime -t és a szkriptet, amelyet most megnyitott a BBC micro: bit -jének. A szkript alább is látható.

Miután befejezte a villogást, rakja össze a BBC micro: bit -et a GiggleBotba úgy, hogy a tábla neopixelei előre nézzen, helyezze a pályára és kapcsolja be.

Vegye figyelembe, hogy a szkriptben a PID és a többi 2 konstans (a sebesség alapértéke és a minimális sebességállandó) már be van állítva.

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ő - NeoPixellel hangolva

mikrobit importból*

a gigglebot importálásból*

utime importból sleep_ms, ticks_us

import ustruct

# inicializálja a GB neopixeleket

neo = init ()

# időzítés

update_rate = 50

# nyereség/konstans (feltéve, hogy az akkumulátor feszültsége 4,0 volt körül van)

Kp = 25,0

Ki = 0,5

Kd = 35,0

trigger_pont = 0,3

min_speed_percent = 0,3

alapsebesség = 70

alapjel = 0,5

last_position = alapjel

integrál = 0,0

run_neopixels = Igaz

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

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

pixels_off ()

álljon meg()

alvás_ms (500)

ha a futás igaz:

# olvassa el a vonalérzékelőket

start_time = kullancsok ()

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

# a tartománynak (0, 1) kell lennie, és nem [0, 1]

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 a megadott hiba szerint

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] = türkiz

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

más:

# neo [center_pixel - i] = türkiz

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 (64* százalék /5), int (224* százalék /5), int (208* százalék /5))

más:

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

neo [center_pixel - i] = (int (64* százalék /5), int (224* százalék /5), int (208* százalék /5))

szünet

neo.show ()

próbáld ki:

# vágja le a motor fordulatszámát

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

if1000.0/ update_rate - delay_diff> 0:

alvás (1000.0/ update_rate - delay_diff)

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

5. lépés: Hagyja futni

A BBC micro -n 2 gomb található: bit: A gomb és B gomb:

• Az A gomb megnyomásával a GiggleBot követi a sort (ha van ilyen).
• Ha megnyomja a B gombot, a GiggleBot leáll, és mindent visszaállít, hogy újra használhassa.

Erősen tanácsos, hogy ne emelje fel a GiggleBotot, amíg követi a vonalat, majd tegye vissza rá, mert a számítási hiba felhalmozódhat és teljesen összezavarhatja a robot útvonalát. Ha fel akarja emelni, nyomja meg a B gombot, majd amikor visszahelyezi, nyomja meg újra az A gombot.