Haga un robot guiado por Lidar con el GiggleBot: 8 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

En este tutorial, estamos haciendo que el GiggleBot aborde las dificultades de un laberinto.

Estamos montando un servo en el GiggleBot al que conectamos un sensor de distancia. Mientras se ejecuta, el servo girará hacia adelante y hacia atrás para que el sensor de distancia pueda medir la distancia hasta cada obstáculo. Esto funciona de forma muy similar a un sensor LIDAR que suele ser mucho más caro.

Al mismo tiempo, el GiggleBot envía estos datos a un micro: bit BBC remoto que muestra en su matriz de LED de 5 por 5 su posición relativa a los obstáculos.

Su trabajo es poder navegar por GiggleBot solo mirando lo que se muestra en el otro micro: bit de la BBC. Para controlar el GiggleBot, se utilizan los botones del control remoto BBC micro: bit.

¡Eso suena divertido! Vayamos al grano, ¿de acuerdo?

Paso 1: componentes necesarios

Vamos a necesitar:

1. Un GiggleBot.
2. Un paquete de baterías para BBC micro: bit. Viene con un BBC micro: bit en su paquete.
3. x3 pilas AA para el GiggleBot.
4. Un cable Grove para conectar el sensor de distancia al GiggleBot.
5. Un kit de servo de DexterIndustries.
6. x3 BBC micro: bits. Uno para el GiggleBot y otro para controlar el robot desde lejos.
7. Un sensor de distancia de DexterIndustries.

¡Obtén el robot GiggleBot para BBC micro: bit aquí!

Paso 2: Montaje del robot

Para que el GiggleBot esté listo para ser programado, necesitamos ensamblarlo, aunque no hay mucho que hacer.

Inserte las 3 baterías AA en su compartimiento debajo del GiggleBot.

Ensamble el paquete de servo. Para su brazo giratorio del servo, use el último orificio para fijar el servo en los conectores frontales del GiggleBot. Puede usar un tornillo y / o algún cable para hacerlo más estable en su lugar. O puede pegarlo en caliente al tablero. En mi caso, utilicé un tornillo y un cable corto para atar el brazo del servo a la placa GiggleBot.

Cuando monte el brazo del servo en el servo, asegúrese de que el servo ya esté en la posición 80. Puede hacerlo llamando a gigglebot.set_servo (gigglebot. RIGHT, 80). Puedes leer mas al respecto aquí.

A continuación, coloque el sensor de distancia en la parte frontal del paquete de servo y fíjelo como en el ejemplo anterior.

Finalmente, conecte el sensor de distancia con un cable Grove a cualquiera de los 2 puertos I2C y el servomotor al puerto derecho que se encuentra en el GiggleBot; el puerto derecho se menciona en él.

Paso 3: Crea tu propio laberinto - Opcional

En este caso, he usado un montón de cajas para crear una pista de circuito cerrado, similar a una de NASCAR.

En este paso, puedes ser realmente creativo y hacerlo tan retorcido como quieras o hacerlo súper largo porque realmente depende de ti.

O si no quieres una pista en absoluto, puedes poner el GiggleBot en una cocina o una sala de estar, por ejemplo, eso debería ser lo suficientemente bueno porque hay muchas paredes y obstáculos que aún debes evitar.

Paso 4: Configurar el entorno

Para que pueda programar BBC micro: bit en MicroPython, debe configurar un editor para él (el Editor Mu) y configurar GiggleBot MicroPython Runtime como su tiempo de ejecución. Para eso, debes seguir las instrucciones de esta página. A partir de este momento se utiliza la versión v0.4.0 del runtime.

Paso 5: Programación del GiggleBot - Parte I

Primero, configuremos el script de GiggleBot. Este script hará que el GiggleBot gire su servomotor 160 grados (80 grados en cada dirección) mientras que al mismo tiempo tomará 10 lecturas del sensor de distancia por vuelta.

Cuando se enciende, el GiggleBot estará en espera hasta que reciba un comando del control remoto. Solo puede haber 3 comandos: avanzar, hacia la izquierda o hacia la derecha.

Nota: Es posible que falten espacios en blanco en el siguiente script y esto parece deberse a algún problema al mostrar GitHub Gists. Haga clic en la esencia para que lo lleve a su página de GitHub, donde puede copiar y pegar el código.

GiggleBot basado en LIDAR con control remoto

desde la importación de gigglebot *

from distance_sensor importar DistanceSensor

desde el sueño de importación de microbit

desde utime import ticks_us, sleep_us

importar ustruct

importar radio

# detener el robot si ya se está moviendo

parada()

# habilitar radio

radio.on ()

# objeto sensor de distancia

ds = Sensor de distancia ()

ds.start_continuous ()

rotate_time = 0.7 # medido en segundos

rotate_span = 160 # medido en grados

rotate_steps = 10

overhead_compensation = 1.05 # definido en porcentajes

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

last_read_time = 0

radar = bytearray (rotate_steps)

servo_rotate_direction = 0 # 0 para ir hacia arriba (0-> 160) y 1 en caso contrario

radar_index = 0

set_servo (DERECHA, 0)

whileTrue:

# leer desde el radar

if ticks_us () - last_read_time> time_per_step:

# leer del sensor de distancia

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

last_read_time = ticks_us ()

imprimir (radar_index)

# hacer la lógica para rotar el servo de izquierda a derecha

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

set_servo (DERECHA, 0)

servo_rotate_direction = 1

elif radar_index == 0 y servo_rotate_direction == 1:

set_servo (DERECHA, rotate_span)

servo_rotate_direction = 0

demás:

radar_index + = 1 si servo_rotate_direction == 0else-1

# y envía los valores del radar

radio.send_bytes (radar)

tratar:

# leer los comandos del robot

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

# y accionar los motores si se reciben comandos

set_speed (lmotor, rmotor)

conducir()

exceptTypeError:

aprobar

ver rawgigglebot_lidar_robot.py alojado con ❤ por GitHub

Paso 6: Programación del control remoto - Parte II

Lo que queda por hacer es programar el segundo BBC micro: bit que actúa como control remoto.

El control remoto se usa para mostrar en su pantalla de 5 por 5 píxeles la distancia relativa a los obstáculos. Como máximo, habrá 10 píxeles activados.

Al mismo tiempo, el control remoto le brinda la capacidad de controlar remotamente el GiggleBot presionando sus 2 botones: avanzar, a la izquierda y a la derecha.

Nota: Es posible que falten espacios en blanco en el siguiente script y esto parece deberse a algún problema al mostrar GitHub Gists. Haga clic en la esencia para que lo lleve a su página de GitHub, donde puede copiar y pegar el código.

GiggleBot basado en LIDAR con control remoto - Código remoto

desde microbit import sleep, display, button_a, button_b

importar ustruct

importar radio

importar matemáticas

radio.on ()

rotate_steps = 10

rotate_span = 160 # en grados

rotate_step = rotate_span / rotate_steps

distancia_máxima = 50 # en centímetros

side_length_leds = 3 # medido en el # de píxeles

radar = bytearray (rotate_steps)

xar = bytearray (rotate_steps)

yar = bytearray (rotate_steps)

Saved_xar = bytearray (rotate_steps)

año_de_salvado = bytearray (pasos_de_rotaciones)

velocidad_motor = 50

whileTrue:

status = radio.receive_bytes_into (radar)

si el estado no es Ninguno:

# display.clear ()

para c, val inenumerate (radar):

si radar [c] <= distancia_máxima:

# calcular las coordenadas 2d de cada distancia

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

ángulo + = (180- rotate_span) /2.0

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

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

# escale las distancias para que quepan en la pantalla de microbit 5x5

x_c = x_c * (side_length_leds -1) / max_distance

y_c = y_c * (side_length_leds +1) / max_distance

# reposicionar coordenadas

x_c + = (side_length_leds -1)

y_c = (side_length_leds +1) - y_c

# coordenadas redondas exactamente donde se encuentran los LED

si x_c - math.floor (x_c) <0.5:

x_c = matemáticas.floor (x_c)

demás:

x_c = math.ceil (x_c)

si y_c - math.floor (y_c) <0.5:

y_c = math.floor (y_c)

demás:

y_c = math.ceil (y_c)

xar [c] = x_c

yar [c] = y_c

demás:

xar [c] = 0

yar [c] = 0

display.clear ()

para x, y en zip (xar, yar):

display.set_pixel (x, y, 9)

# print (lista (zip (xar, yar, radar)))

stateA = button_a.is_pressed ()

stateB = button_b.is_pressed ()

si stateA y stateB:

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

imprimir ('adelante')

si el estado A y no el estado B:

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

imprimir ('izquierda')

ifnot stateA y stateB:

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

imprimir ('derecha')

ifnot stateA y not stateB:

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

imprimir ('detener')

ver rawgigglebot_lidar_remote.py alojado con ❤ por GitHub

Paso 7: interpretación de la pantalla remota

"loading =" lazy "controla el GiggleBot, tienes las siguientes opciones:

1. Presione el botón A y el botón B para mover el GiggleBot hacia adelante.
2. Presione el botón A para girar el GiggleBot hacia la izquierda.
3. Presione el botón B para girar el GiggleBot hacia la derecha.

Para ver en qué dirección se detectan los obstáculos más cercanos, simplemente mire en la pantalla del control remoto (el BBC micro: bit remoto que está sosteniendo). Debería poder controlar el GiggleBot desde lejos sin mirarlo.