Feu un robot guiat per Lidar amb el GiggleBot: 8 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:14

En aquest tutorial, estem fent que el GiggleBot abordi les dificultats d’un laberint.

Muntem un servo al GiggleBot al qual connectem un sensor de distància. Mentre funciona, el servo girarà endavant i enrere de manera que el sensor de distància pugui mesurar la distància fins a cada obstacle. Funciona de manera similar a un sensor LIDAR, que sol ser molt més car.

Al mateix temps, el GiggleBot envia aquestes dades a un micro BBC: bit remot que mostra a la seva matriu 5 per 5 de LEDs la seva posició relativa als obstacles.

El vostre treball és poder navegar pel GiggleBot només mirant el que es mostra a l’altre micro: bit de la BBC. Per controlar el GiggleBot, s’utilitzen els botons del micro: bit remot de la BBC.

Això sona divertit! Passem-hi, oi?

Pas 1: components necessaris

Necessitarem:

1. Un GiggleBot.
2. Un paquet de bateries per al micro: bit de la BBC. Inclou un paquet micro: bit de la BBC.
3. bateries AA de 3 x per al GiggleBot.
4. Un cable Grove per connectar el sensor de distància al GiggleBot.
5. Un kit de servo de DexterIndustries.
6. x3 BBC micro: bits. Un per al GiggleBot i un per controlar el robot des de molt lluny.
7. Un sensor de distància de DexterIndustries.

Aconsegueix el robot GiggleBot per al micro: bit de la BBC!

Pas 2: Muntatge del robot

Perquè el GiggleBot estigui a punt per programar-lo, hem de muntar-lo, tot i que no cal fer molt.

Introduïu les 3 piles AA al compartiment que hi ha a sota del GiggleBot.

Muntar el paquet de servo. Al braç giratori del servo, utilitzeu l'últim forat per fixar el servo als connectors frontals del GiggleBot. Podeu utilitzar un cargol i / o algun cable per fer-lo més estable al seu lloc. O podeu enganxar-lo a la pissarra. En el meu cas, he utilitzat un cargol i un cable curt per lligar el servo braç a la placa GiggleBot.

Quan monteu el braç del servo al servo, assegureu-vos que el servo ja estigui configurat a la posició 80. Podeu fer-ho trucant a gigglebot.set_servo (gigglebot. RIGHT, 80). Podeu llegir més sobre això aquí.

A continuació, col·loqueu el sensor de distància a la part frontal del paquet de servo i fixeu-lo com a l'exemple anterior.

Finalment, connecteu el sensor de distància amb un cable Grove a qualsevol dels 2 ports I2C i el servomotor al port dret assegut al GiggleBot; es menciona el port correcte.

Pas 3: creeu el vostre propi laberint: opcional

En aquest cas, he utilitzat un munt de caixes per crear una pista de bucle tancat, similar a una NASCAR.

En aquest pas, podeu ser realment creatiu i fer-lo tan torçat com vulgueu o fer-lo súper llarg perquè depèn de vosaltres.

O si no voleu una pista en absolut, podeu posar el GiggleBot a una cuina o una sala d'estar, per exemple; això hauria de ser prou bo perquè hi ha moltes parets i obstacles que encara heu d'evitar.

Pas 4: Configuració de l'entorn

Per tal que pugueu programar el micro: bit de la BBC a MicroPython, heu de configurar-ne un editor (l’editor Mu) i configurar el temps d’execució de GiggleBot MicroPython Runtime. Per a això, heu de seguir les instruccions d’aquesta pàgina. A partir d’aquest moment s’utilitza la versió v0.4.0 del temps d’execució.

Pas 5: Programació del GiggleBot - Part I

En primer lloc, configurem l’escriptura de GiggleBot. Aquest script farà que el GiggleBot giri el seu servomotor 160 graus (80 graus en cada direcció) i, alhora, prengui 10 lectures del sensor de distància per volta.

Quan està activat, el GiggleBot estarà en espera fins que rebi una ordre del control remot. Només hi pot haver 3 ordres: avançar, cap a l'esquerra o cap a la dreta.

Nota: És possible que el següent script no tingui espais en blanc i sembla que es deu a algun problema en mostrar GitHub Gists. Feu clic al resum per accedir a la pàgina de GitHub, on podeu copiar-enganxar el codi.

GiggleBot basat en LIDAR controlat a distància

des de la importació de gigglebot *

des de la importació de distance_sensor DistanceSensor

des de la importació de microbits de son

d'importació utime ticks_us, sleep_us

importar ustruct

importar ràdio

# atureu el robot si ja es mou

Atura()

# habilitar la ràdio

radio.on ()

# objecte sensor de distància

ds = Sensor de distància ()

ds.start_continuous ()

rotate_time = 0,7 # mesurat en segons

rotate_span = 160 # mesurat en graus

rotate_steps = 10

overhead_compensation = 1,05 # definit en percentatges

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

last_read_time = 0

radar = bytearray (rotate_steps)

servo_rotate_direction = 0 # 0 per pujar (0-> 160) i 1 en cas contrari

índex_radar = 0

set_servo (DRETA, 0)

whileTrue:

# llegida des del radar

if ticks_us () - last_read_time> time_per_step:

# llegida des del sensor de distància

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

last_read_time = ticks_us ()

imprimir (radar_index)

# feu la lògica per girar el servo d'esquerra a dreta

si radar_index == rotate_steps -1and servo_rotate_direction == 0:

set_servo (DRETA, 0)

direcció_rotació_servo = 1

elif radar_index == 0and servo_rotate_direction == 1:

set_servo (RIGHT, rotate_span)

direcció_rotació_servo = 0

en cas contrari:

radar_index + = 1 si la direcció_serva_rota == 0else-1

# i envieu els valors del radar

radio.send_bytes (radar)

provar:

# llegir les ordres del robot

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

# i accioneu els motors en cas que hi hagi ordres rebudes

set_speed (lmotor, rmotor)

conduir()

exceptTypeError:

passar

visualitza rawgigglebot_lidar_robot.py allotjat amb ❤ per GitHub

Pas 6: Programació del comandament a distància - Part II

El que queda per fer és programar el segon micro: bit de la BBC que actua com a control remot.

El comandament s’utilitza per mostrar a la pantalla de 5 per 5 píxels la distància relativa als obstacles. Com a màxim, hi haurà 10 píxels activats.

Al mateix temps, el comandament a distància us proporciona la possibilitat de controlar a distància el GiggleBot prement els seus 2 botons: avançar, cap a l’esquerra i cap a la dreta.

Nota: És possible que el següent script no tingui espais en blanc i sembla que es deu a algun problema en mostrar GitHub Gists. Feu clic al resum per accedir a la pàgina de GitHub, on podeu copiar-enganxar el codi.

GiggleBot basat en LIDAR controlat a distància: codi remot

des de la importació de microbits sleep, display, button_a, button_b

importar ustruct

importar ràdio

importar matemàtiques

radio.on ()

rotate_steps = 10

rotate_span = 160 # en graus

rotate_step = rotate_span / rotate_steps

max_distance = 50 # en centímetres

side_length_leds = 3 # mesurat en el nombre de píxels

radar = bytearray (rotate_steps)

xar = bytearray (rotate_steps)

yar = bytearray (rotate_steps)

saved_xar = bytearray (rotate_steps)

saved_yar = bytearray (rotate_steps)

velocitat_motor = 50

whileTrue:

status = radio.receive_bytes_into (radar)

si l'estat no és Cap:

# display.clear ()

per a c, val inenumerar (radar):

si radar [c] <= distància_màxima:

# calcular coordenades 2d de cada distància

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

angle + = (180- rotate_span) /2,0

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

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

# escalar les distàncies per ajustar-les a la pantalla de 5 x 5 microbits

x_c = x_c * (side_length_leds -1) / max_distance

y_c = y_c * (longitud_lateral_leds +1) / distància_màxima

# reposició de coordenades

x_c + = (longitud_lateral_lls -1)

y_c = (longitud_lateral_leds +1) - y_c

# coordenades rodones exactament on es troben els LED

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

x_c = math.floor (x_c)

en cas contrari:

x_c = math.ceil (x_c)

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

y_c = math.floor (y_c)

en cas contrari:

y_c = math.ceil (y_c)

xar [c] = x_c

yar [c] = y_c

en cas contrari:

xar [c] = 0

yar [c] = 0

display.clear ()

per a x, y inzip (xar, yar):

display.set_pixel (x, y, 9)

# imprimir (llista (zip (xar, yar, radar)))

stateA = button_a.is_pressed ()

stateB = button_b.is_pressed ()

si stateA i stateB:

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

imprimir ("endavant")

si estatA i no estatB:

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

imprimir ('esquerra')

ifnot stateA i stateB:

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

imprimir ('dreta')

ifnot stateA i not stateB:

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

imprimir ("aturar")

visualitza rawgigglebot_lidar_remote.py allotjat amb ❤ per GitHub

Pas 7: Interpretació de la pantalla remota

"loading =" lazy "controla el GiggleBot, teniu les opcions següents:

1. Premeu el botó A i el botó B per avançar el GiggleBot.
2. Premeu el botó A per fer girar el GiggleBot cap a l'esquerra.
3. Premeu el botó B per fer girar el GiggleBot cap a la dreta.

Per veure en quina direcció es detecten els obstacles més propers, només cal que mireu la pantalla del control remot (el bit BBC: bit remot que manteniu). Hauríeu de poder controlar el GiggleBot des de molt lluny sense mirar-lo.