Tartalomjegyzék:
- Szerző John Day [email protected].
- Public 2024-01-30 09:41.
- Utoljára módosítva 2025-01-23 14:47.
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:
- x3 AA elem - esetemben újratölthető elemeket használok, amelyek összességében alacsonyabb feszültségűek.
- Dexter Industries GiggleBot robot a micro: bithez.
- 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.
Ajánlott:
Vonalkövető a Tinkercad -on: 3 lépés
Vonalkövető a Tinkercad-on: Az A-Line Follower Robot, ahogy a neve is sugallja, egy automatizált vezetett jármű, amely a padlóra vagy a mennyezetre ágyazott vizuális vonalat követi. Általában a vizuális vonal az az út, amelyen a vonalkövető robot megy, és fekete vonal lesz egy
Haladó vonalkövető robot: 22 lépés (képekkel)
Haladó vonalkövető robot: Ez egy fejlett vonalkövető robot, amely a Teensy 3.6 és a QTRX vonalérzékelőre épül, és amelyeket én építettem, és amelyeken már régóta dolgozom. A korábbi vonalkövető robotom tervezésében és teljesítményében jelentős javulás tapasztalható. T
Vonalkövető robot Arduino Uno és L298N használatával: 5 lépés
Vonalkövető robot az Arduino Uno és az L298N használatával: A Line Flower egy nagyon egyszerű robot, amely ideális kezdő elektronikához
A gyorsulás felügyelete a Raspberry Pi és az AIS328DQTR használatával Python használatával: 6 lépés
A gyorsulás nyomon követése a Raspberry Pi és az AIS328DQTR használatával Python használatával: A gyorsulás véges, azt hiszem, a fizika egyes törvényei szerint.- Terry Riley A gepárd elképesztő gyorsulást és gyors sebességváltozásokat használ üldözés közben. A leggyorsabb lény a parton időnként kihasználja csúcssebességét a zsákmány elkapására. Az
A GiggleBot vonalkövető hangolása - Haladó: 7 lépés
A GiggleBot vonalkövető hangolása - Haladó: Ebben a nagyon rövid utasításban a saját GiggleBotját 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 lehet viselkedni