Tartalomjegyzék:
- Szerző John Day [email protected].
- Public 2024-01-30 09:41.
- Utoljára módosítva 2025-01-23 14:48.
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:
- GiggleBot robot a micro: bithez.
- x3 AA elem
- 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.
- 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:
- Kp = arányos erősítés a PID szabályozóhoz.
- Ki = a PID szabályozó integrált erősítése.
- Kd = a PID szabályozó derivált nyeresége.
- 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.
- 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:
- 0-1 opció a Kp erősítésre vonatkozik.
- 2-3 lehetőség a Ki erősítésre.
- 4-5 lehetőség van a Kd erősítésre.
- A 6-7 opció az alapjel beállítására szolgál, amikor a motorok lassítani kezdenek.
- 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)
- Kp = 32,0
- Ki = 0,5
- Kd = 80,0
- trigger_setpoint = 0,3 (ami 30%)
- min_speed_percent = 0,2 (ami 20%)
- alap_sebesség = 100 (más néven maximális sebesség)
- update_rate = 70 (70 Hz -en fut)
A paraméterek hangolásának második csoportja (bekapcsolt NeoPixel LED -ekkel)
- Kp = 25,0
- Ki = 0,5
- Kd = 35,0
- trigger_setpoint = 0,3 (ami 30%)
- min_speed_percent = 0,3 (ami 30%)
- alap_sebesség = 70 (más néven maximális sebesség)
- update_rate = 50 (50 Hz -en fut)
- 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.
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
UCL beágyazott - B0B a vonalkövető: 9 lépés
UCL beágyazott-B0B a vonalkövető: Ez a B0B.*A B0B egy általános rádióvezérelt autó, amely ideiglenesen egy vonalkövető robot alapját szolgálja. Mint megannyi vonalkövető robot, ő is mindent megtesz, hogy maradjon a vonal, amelyet a padló és az AC közötti átmenet okoz
PID vonalkövető Atmega328P: 4 lépés
PID vonalkövető Atmega328P: BEVEZETÉS Ez az oktatóanyag arról szól, hogy hatékony és megbízható vonalkövetőt hozzunk létre az agyában futó PID (arányos-integrál-származékos) vezérléssel (matematikai). A vonalkövető egy autonóm robot, amely bármelyik b
Vonalkövető robot PICO -val: 5 lépés (képekkel)
Vonalkövető robot PICO -val: Mielőtt képes lenne létrehozni egy robotot, amely véget vethet a civilizációnak, ahogy mi ismerjük, és képes véget vetni az emberi fajnak. Először képesnek kell lennie létrehozni az egyszerű robotokat, azokat, amelyek követhetik a földön meghúzott vonalat, és itt találja meg
GiggleBot vonalkövető Python használatával: 5 lépés
GiggleBot vonalkövető Python használatával: Ezúttal a MicroPython programozásával programozzuk a Dexter Industries GiggleBot-ot, hogy kövessen egy fekete vonalat a beépített vonalkövető érzékelővel. A GiggleBot-ot párosítani kell egy BBC mikro: bit-el ahhoz, hogy megfelelően ellenőrizni kell. Ha