Obsah:
2025 Autor: John Day | [email protected]. Naposledy zmenené: 2025-01-13 06:58
V tomto tutoriáli robíme GiggleBot riešením problémov bludiska.
Na GiggleBot montujeme servo, na ktoré pripevňujeme snímač vzdialenosti. Pri behu sa servo bude otáčať tam a späť, aby snímač vzdialenosti mohol merať vzdialenosť až po každú prekážku. Funguje to podobne ako snímač LIDAR, ktorý je zvyčajne oveľa drahší.
GiggleBot zároveň odosiela tieto údaje na vzdialený mikro bit: BBC, ktorý zobrazuje na svojej matici diód 5 x 5 svoju relatívnu polohu voči prekážkam.
Vašou úlohou je ovládať GiggleBot iba tak, že sa pozriete na to, čo je zobrazené na druhom mikro: bite BBC. Na ovládanie GiggleBotu slúžia tlačidlá na diaľkovom BBC micro: bite.
To znie zábavne! Poďme na to, nie?
Krok 1: Požadované komponenty
Budeme potrebovať:
- GiggleBot.
- Batéria pre BBC micro: bit. Dodáva sa spolu s micro: bitom BBC v balení.
- x3 AA batérie pre GiggleBot.
- Kábel Grove na pripojenie snímača vzdialenosti k GiggleBot.
- Servo sada od spoločnosti DexterIndustries.
- x3 BBC micro: bity. Jeden pre GiggleBot a druhý slúžiaci na ovládanie robota z diaľky.
- Senzor vzdialenosti od spoločnosti DexterIndustries.
Získajte robota GiggleBot pre BBC micro: bit tu!
Krok 2: Zostavenie robota
Aby bol GiggleBot pripravený na programovanie, musíme ho zostaviť, aj keď nie je potrebné veľa robiť.
Vložte 3 batérie AA do priehradky na spodnej strane zariadenia GiggleBot.
Zostavte servo balíček. Na jeho otočné rameno serva pomocou posledného otvoru pripevnite servo k predným konektorom GiggleBot. Na zaistenie väčšej stability na svojom mieste môžete použiť skrutku a/alebo nejaký drôt. Alebo ho môžete za tepla prilepiť na dosku. V mojom prípade som použil skrutku a krátky drôt na pripevnenie ramena serva k doske GiggleBot.
Pri montáži ramena serva na servo sa uistite, že je servo už nastavené na polohu 80. Môžete to urobiť zavolaním na gigglebot.set_servo (gigglebot. RIGHT, 80). Viac si o tom môžete prečítať tu.
Potom umiestnite snímač vzdialenosti na prednú stranu balíka serva a upevnite ho ako vo vyššie uvedenom príklade.
Nakoniec pripojte snímač vzdialenosti káblom Grove k akémukoľvek z 2 portov I2C a servomotor k pravému portu sediacemu na GiggleBot - je na ňom uvedený pravý port.
Krok 3: Vytvorte si vlastné bludisko - voliteľné
V tomto prípade som použil veľa boxov na vytvorenie dráhy s uzavretou slučkou, podobnej tej na NASCAR.
V tomto kroku môžete byť skutočne kreatívni a urobiť to tak skrútené, ako chcete, alebo ho predĺžiť, pretože je to naozaj len na vás.
Alebo ak vôbec nechcete trať, môžete GiggleBot dať napríklad do kuchyne alebo obývačky - to by malo stačiť, pretože je tu veľa stien a prekážok, ktorým sa ešte musíte vyhnúť.
Krok 4: Nastavenie prostredia
Aby ste mohli programovať micro: bit BBC v MicroPythone, musíte preň nastaviť editor (Mu Editor) a nastaviť jeho runtime ako GiggleBot MicroPython Runtime. Na to musíte postupovať podľa pokynov na tejto stránke. Od tohto momentu sa používa verzia v0.4.0 runtime.
Krok 5: Programovanie GiggleBot - časť I
Najprv si nastavme skript GiggleBot. Tento skript prinúti GiggleBot otáčať servomotor o 160 stupňov (80 stupňov v každom smere) a súčasne odčítať 10 meraní zo snímača vzdialenosti za otáčku.
Po zapnutí bude GiggleBot stáť, kým nedostane príkaz z diaľkového ovládača. Môžu existovať iba 3 príkazy: pohyb dopredu, doľava alebo doprava.
Poznámka: Nasledujúci skript môže mať prázdne medzery, a zdá sa, že je to kvôli nejakému problému so zobrazovaním GitHub Gists. Kliknutím na podstatu sa dostanete na stránku GitHub, kde môžete skopírovať a prilepiť kód.
Diaľkovo ovládaný GiggleBot na báze LIDAR
| z importu gigglebot* |
| from distance_sensor import DistanceSensor |
| zo spánku importu mikrobitov |
| z utim importu ticks_us, sleep_us |
| dovozná štruktúra |
| dovozné rádio |
| # Zastavte robota, ak sa už pohybuje |
| zastaviť () |
| # povoliť rádio |
| radio.on () |
| # objekt senzora vzdialenosti |
| ds = DistanceSensor () |
| ds.start_continuous () |
| rotate_time = 0,7# merané v sekundách |
| rotate_span = 160# merané v stupňoch |
| rotate_steps = 10 |
| overhead_compensation = 1,05# definované v percentách |
| time_per_step = 10 ** 6* rotate_time / (rotate_steps* overhead_compensation) |
| last_read_time = 0 |
| radar = bytearray (rotate_steps) |
| servo_rotate_direction = 0# 0 pre stúpanie nahor (0-> 160) a 1 inak |
| radar_index = 0 |
| set_servo (SPRÁVNE, 0) |
| whileTrue: |
| # prečítané z radaru |
| if ticks_us () - last_read_time> time_per_step: |
| # odčítané zo snímača vzdialenosti |
| radar [radar_index] = int (ds.read_range_continuous () /10) |
| last_read_time = ticks_us () |
| tlač (radar_index) |
| # Vykonajte logiku otáčania serva zľava doprava |
| ak radar_index == rotate_steps -1 a servo_rotate_direction == 0: |
| set_servo (SPRÁVNE, 0) |
| servo_rotate_direction = 1 |
| elif radar_index == 0 a smer servo_rotate_= = 1: |
| set_servo (RIGHT, rotate_span) |
| servo_rotate_direction = 0 |
| inak: |
| radar_index += 1 ak smer_ servo_rotate_= = 0 inak-1 |
| # a pošlite hodnoty radaru |
| radio.send_bytes (radar) |
| skús: |
| # čítať príkazy robota |
| lmotor, rmotor = ustruct.unpack ('bb', radio.receive_bytes ()) |
| # a aktivujte motory, ak existujú nejaké prijaté príkazy |
| set_speed (lmotor, rmotor) |
| riadiť () |
| kroměTypeError: |
| prejsť |
zobraziť rawgigglebot_lidar_robot.py hostený s ❤ od GitHub
Krok 6: Programovanie diaľkového ovládača - časť II
Zostáva naprogramovať 2. BBC micro: bit, ktorý funguje ako diaľkové ovládanie.
Diaľkový ovládač slúži na zobrazenie relatívnej vzdialenosti od prekážok na obrazovke vyrobenej 5 x 5 pixelov. Zapnutých bude maximálne 10 pixelov.
Diaľkový ovládač vám zároveň poskytuje možnosti diaľkového ovládania GiggleBot stlačením jeho dvoch tlačidiel: posun dopredu, doľava a doprava.
Poznámka: Nasledujúci skript môže mať prázdne medzery, a zdá sa, že je to kvôli nejakému problému so zobrazovaním GitHub Gists. Kliknutím na podstatu sa dostanete na stránku GitHub, kde môžete skopírovať a prilepiť kód.
Diaľkovo ovládaný GiggleBot na báze LIDAR - diaľkový kód
| z importu mikrobitov spánok, displej, tlačidlo_a, tlačidlo_b |
| dovozná štruktúra |
| dovozné rádio |
| importná matematika |
| radio.on () |
| rotate_steps = 10 |
| rotate_span = 160# v stupňoch |
| rotate_step = rotate_span / rotate_steps |
| max_distance = 50# v centimetroch |
| side_length_leds = 3 # merané v # pixeloch |
| radar = bytearray (rotate_steps) |
| xar = bytearray (rotate_steps) |
| yar = bytearray (rotate_steps) |
| save_xar = bytearray (rotate_steps) |
| save_yar = bytearray (rotate_steps) |
| motor_speed = 50 |
| whileTrue: |
| status = radio.receive_bytes_into (radar) |
| ak stav nie je žiadny: |
| # display.clear () |
| pre c, val inenumerate (radar): |
| ak radar [c] <= max_distance: |
| # vypočítajte 2d súradnice každej vzdialenosti |
| uhol = kroky_krútenia / (kroky_otáčania -1) * krok otáčania * c |
| uhol += (180- rotate_span) /2,0 |
| x_c = math.cos (uhol * math.pi /180,0) * radar [c] |
| y_c = math.sin (uhol * math.pi /180,0) * radar [c] |
| # upravte vzdialenosti tak, aby sa zmestili na mikrobitový displej 5x5 |
| x_c = x_c * (dĺžka_strany_leds -1) / max_distance |
| y_c = y_c * (side_length_leds +1) / max_distance |
| # súradnice premiestnenia |
| x_c += (dĺžka_dĺžky_ledov -1) |
| y_c = (dĺžka_dĺžky_ +1 +1) - y_c |
| # okrúhle súradnice presne tam, kde sa nachádzajú diódy LED |
| ak x_c - matemat.podlaha (x_c) <0,5: |
| x_c = math.floor (x_c) |
| inak: |
| x_c = math.ceil (x_c) |
| ak y_c - math.floor (y_c) <0,5: |
| y_c = math.floor (y_c) |
| inak: |
| y_c = math.ceil (y_c) |
| xar [c] = x_c |
| yar [c] = y_c |
| inak: |
| xar [c] = 0 |
| yar [c] = 0 |
| display.clear () |
| pre x, y inzip (xar, yar): |
| display.set_pixel (x, y, 9) |
| # print (zoznam (zip (xar, yar, radar))) |
| stateA = button_a.is_pressed () |
| stateB = button_b.is_pressed () |
| ak stateA a stateB: |
| radio.send_bytes (ustruct.pack ('bb', motor_speed, motor_speed)) |
| tlačiť („dopredu“) |
| ak stateA a nie stavB: |
| radio.send_bytes (ustruct.pack ('bb', motor_speed, -motor_speed)) |
| tlač („vľavo“) |
| ifnot stateA a stateB: |
| radio.send_bytes (ustruct.pack ('bb', -motor_speed, motor_speed)) |
| vytlačiť („vpravo“) |
| ifnot stateA andnot stateB: |
| radio.send_bytes (ustruct.pack ('bb', 0, 0)) |
| vytlačiť („zastaviť“) |
zobraziť rawgigglebot_lidar_remote.py hostiteľom ❤ od GitHub
Krok 7: Interpretácia vzdialenej obrazovky
"Load =" lenivý "ovláda GiggleBot, máte nasledujúce možnosti:
- Stlačením tlačidiel A a B posuniete GiggleBot dopredu.
- Stlačením tlačidla A otočte GiggleBot doľava.
- Stlačením tlačidla B otočte GiggleBot doprava.
Ak sa chcete dozvedieť, ktorým smerom sú detekované najbližšie prekážky, stačí sa pozrieť na obrazovku diaľkového ovládača (diaľkový mikro BBC: bit, ktorý držíte). Mali by ste byť schopní ovládať GiggleBot z diaľky bez toho, aby ste sa na to pozerali.