Realizați un robot ghidat de lidar cu GiggleBot: 8 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

În acest tutorial, facem ca GiggleBot să abordeze dificultățile unui labirint.

Montăm un servo pe GiggleBot pe care atașăm un senzor de distanță. În timpul funcționării, servo se va roti înainte și înapoi, astfel încât senzorul de distanță să poată măsura distanța până la fiecare obstacol. Acest lucru funcționează la fel ca un senzor LIDAR, care este de obicei mult mai scump.

În același timp, GiggleBot trimite aceste date către un micro: bit BBC de la distanță care afișează pe matricea sa 5-pe-5 de LED-uri poziția sa relativă la obstacole.

Sarcina ta este să poți naviga pe GiggleBot doar uitându-te la ceea ce este afișat pe celălalt micro: bit BBC. Pentru a controla GiggleBot, se folosesc butoanele de pe telecomanda BBC micro: bit.

Sună distractiv! Să trecem la asta, nu-i așa?

Pasul 1: Componente necesare

Vom avea nevoie de:

1. Un GiggleBot.
2. Un pachet de baterii pentru BBC micro: bit. Vine împreună cu un micro: bit BBC în pachetul său.
3. baterii x3 AA pentru GiggleBot.
4. Un cablu Grove pentru conectarea senzorului de distanță la GiggleBot.
5. Un kit Servo de la DexterIndustries.
6. x3 BBC micro: biți. Unul pentru GiggleBot și unul folosit pentru a controla robotul de departe.
7. Un senzor de distanță de la DexterIndustries.

Obțineți robotul GiggleBot pentru micro: bit de la BBC aici!

Pasul 2: Asamblarea robotului

Pentru a face GiggleBot gata să fie programat, trebuie să-l montăm, deși nu este mult de făcut.

Introduceți cele 3 baterii AA în compartimentul său de sub GiggleBot.

Asamblați pachetul servo. La brațul rotativ al servo-ului, utilizați ultima gaură a acestuia pentru a fixa servo-ul pe conectorii frontali ai GiggleBot. Puteți utiliza un șurub și / sau un fir pentru a-l face mai stabil la locul său. Sau îl puteți lipi fierbinte pe tablă. În cazul meu, am folosit un șurub și un fir scurt pentru a lega brațul servo de placa GiggleBot.

Când montați brațul servo pe servo, asigurați-vă că servo-ul este deja setat pe poziția 80. Puteți face acest lucru apelând gigglebot.set_servo (gigglebot. RIGHT, 80). Puteți citi mai multe despre asta aici.

Apoi, așezați senzorul de distanță pe partea din față a pachetului servo și fixați-l ca în exemplul de mai sus.

În cele din urmă, conectați senzorul de distanță cu un cablu Grove la oricare dintre cele 2 porturi I2C și servomotorul la portul drept așezat pe GiggleBot - portul corect este menționat pe acesta.

Pasul 3: Creați-vă propriul labirint - Opțional

În acest caz, am folosit o grămadă de cutii pentru a crea o pistă cu buclă închisă, similară cu una NASCAR.

La acest pas, poți deveni foarte creativ și să-l faci cât de răsucit vrei sau să-l faci foarte lung, deoarece depinde de tine.

Sau dacă nu doriți deloc o pistă, puteți pune GiggleBot într-o bucătărie sau într-o cameră de zi, de exemplu - ar trebui să fie suficient de bun, deoarece există o mulțime de pereți și obstacole pe care trebuie totuși să le evitați.

Pasul 4: Configurarea mediului

Pentru a putea programa BBC micro: bit în MicroPython, trebuie să configurați un editor pentru acesta (Editorul Mu) și să setați GiggleBot MicroPython Runtime ca runtime. Pentru aceasta, trebuie să urmați instrucțiunile de pe această pagină. În acest moment, se folosește versiunea v0.4.0 a runtime-ului.

Pasul 5: Programarea GiggleBot - Partea I

În primul rând, să configurăm scriptul GiggleBot. Acest script va face ca GiggleBot să-și rotească servomotorul la 160 de grade (80 de grade în fiecare direcție), în timp ce ia simultan 10 citiri de la senzorul de distanță pe tură.

Când este pornit, GiggleBot va sta în picioare până când primește o comandă de la telecomandă. Pot exista doar 3 comenzi: avansați, spre stânga sau spre dreapta.

Notă: Următorul script ar putea să aibă spații albe lipsă și acest lucru se pare că se datorează unor probleme la afișarea GitHub Gists. Faceți clic pe esență pentru a vă duce la pagina GitHub, unde puteți copia-lipi codul.

GiggleBot bazat pe LIDAR controlat de la distanță

din importul gigglebot *

din importul senzor_distanță DistanțăSenzor

din somnul de import microbit

din utime import ticks_us, sleep_us

import ustruct

import radio

# opriți robotul dacă acesta este deja în mișcare

Stop()

# activați radioul

radio.on ()

# obiect senzor de distanță

ds = DistanceSensor ()

ds.start_continuous ()

rotate_time = 0,7 # măsurat în secunde

rotate_span = 160 # măsurat în grade

rotate_steps = 10

overhead_compensation = 1,05 # definit în procente

time_per_step = 10 ** 6 * rotate_time / (rotate_steps * overhead_compensation)

last_read_time = 0

radar = bytearray (rotate_steps)

servo_rotate_direction = 0 # 0 pentru a merge în sus (0-> 160) și 1 în caz contrar

radar_index = 0

set_servo (DREAPTA, 0)

whileTrue:

# citit din radar

dacă ticks_us () - last_read_time> time_per_step:

# citit din senzorul de distanță

radar [radar_index] = int (ds.read_range_continuous () / 10)

last_read_time = ticks_us ()

print (radar_index)

# faceți logica pentru rotirea servo-ului de la stânga la dreapta

dacă radar_index == rotate_steps -1and servo_rotate_direction == 0:

set_servo (DREAPTA, 0)

servo_rotate_direction = 1

elif radar_index == 0and servo_rotate_direction == 1:

set_servo (DREAPTA, rotire_span)

servo_rotate_direction = 0

altceva:

radar_index + = 1 dacă servo_rotate_direction == 0else-1

# și trimiteți valorile radar

radio.send_bytes (radar)

încerca:

# citiți comenzile robotului

lmotor, rmotor = ustruct.unpack ('bb', radio.receive_bytes ())

# și acționați motoarele în cazul în care există comenzi primite

set_speed (lmotor, rmotor)

conduce()

exceptTypeError:

trece

vizualizați rawgigglebot_lidar_robot.py găzduit cu ❤ de GitHub

Pasul 6: Programarea telecomenzii - Partea II

Ceea ce a mai rămas de făcut este programarea celui de-al doilea bit micro: BBC care acționează ca o telecomandă.

Telecomanda este utilizată pentru a afișa pe ecranul său realizat 5 x 5 pixeli distanța relativă la obstacole. Cel mult, vor fi activați 10 pixeli.

În același timp, telecomanda vă oferă capacitățile de a controla de la distanță GiggleBot apăsând cele 2 butoane ale acestuia: avansați, spre stânga și spre dreapta.

Notă: Următorul script ar putea să aibă spații albe lipsă și acest lucru se pare că se datorează unor probleme la afișarea GitHub Gists. Faceți clic pe esență pentru a vă duce la pagina GitHub, unde puteți copia-lipi codul.

GiggleBot bazat pe LIDAR controlat de la distanță - Cod de la distanță

din microbit import sleep, display, button_a, button_b

import ustruct

import radio

import matematica

radio.on ()

rotate_steps = 10

rotate_span = 160 # în grade

rotate_step = rotate_span / rotate_steps

max_distance = 50 # în centimetri

side_length_leds = 3 # măsurat în numărul de pixeli

radar = bytearray (rotate_steps)

xar = bytearray (rotate_steps)

yar = bytearray (rotate_steps)

saved_xar = bytearray (rotate_steps)

saved_yar = bytearray (rotate_steps)

motor_speed = 50

whileTrue:

status = radio.receive_bytes_into (radar)

dacă starea nu este Niciuna:

# display.clear ()

pentru c, valenumerate (radar):

dacă radar [c] <= max_distance:

# calculați coordonatele 2d ale fiecărei distanțe

angle = rotate_steps / (rotate_steps -1) * rotate_step * c

unghi + = (180- rotire_span) /2.0

x_c = math.cos (unghi * math.pi /180.0) * radar [c]

y_c = math.sin (angle * math.pi /180.0) * radar [c]

# scalați distanțele pentru a se potrivi pe afișajul de 5x5 microbiți

x_c = x_c * (side_length_leds -1) / max_distance

y_c = y_c * (side_length_leds +1) / max_distance

# repoziționați coordonatele

x_c + = (side_length_leds -1)

y_c = (side_length_leds +1) - y_c

# coordonate rotunde exact unde se găsesc LED-urile

dacă x_c - math.floor (x_c) <0,5:

x_c = math.floor (x_c)

altceva:

x_c = math.ceil (x_c)

dacă y_c - math.floor (y_c) <0,5:

y_c = math.floor (y_c)

altceva:

y_c = math.ceil (y_c)

xar [c] = x_c

yar [c] = y_c

altceva:

xar [c] = 0

yar [c] = 0

display.clear ()

pentru x, y inzip (xar, yar):

display.set_pixel (x, y, 9)

# print (listă (zip (xar, yar, radar)))

stateA = button_a.is_pressed ()

stateB = button_b.is_pressed ()

dacă stateA și stateB:

radio.send_bytes (ustruct.pack ('bb', motor_speed, motor_speed))

print ('înainte')

dacă stateA și nu stateB:

radio.send_bytes (ustruct.pack ('bb', motor_speed, -motor_speed))

print ('stânga')

dacă nu stateA și stateB:

radio.send_bytes (ustruct.pack ('bb', -motor_speed, motor_speed))

print ('dreapta')

ifnot stateA și not stateB:

radio.send_bytes (ustruct.pack ('bb', 0, 0))

print ('stop')

vizualizați rawgigglebot_lidar_remote.py găzduit cu ❤ de GitHub

Pasul 7: Interpretarea ecranului de la distanță

„încărcare =„ leneș”controlează GiggleBot, aveți următoarele opțiuni:

1. Apăsați butonul A și butonul B pentru a muta GiggleBot înainte.
2. Apăsați butonul A pentru a roti GiggleBot la stânga.
3. Apăsați butonul B pentru a roti GiggleBot la dreapta.

Pentru a vedea în ce direcție sunt detectate cele mai apropiate obstacole, trebuie doar să vă uitați la ecranul telecomenzii (bitul BBC: telecomandă pe care îl țineți). Ar trebui să poți controla GiggleBot de departe, fără să te uiți la el.