HexaWalker: 5 pasos

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

Hemos echo un grupo de estudiantes de la UAB un robot hexapodo autonomo con una webcam con micrófono mediante la cual puedes interactuar con el. La idea era hacer un robot amistoso que reconociera órdenes de voz y pueda seguir mediante la cámara una pelota. Algo así como una "mascota" rebotica.

Cabe comentar que la estructura que hemos utilizado para nuestro hexapodo la hemos sacado del robot open source Hexy de ArcBotics.

Aquí el link al codigo:

Suministros

- batería lipo 7.4V 2700mmAh

- Servocontrolador adafruit x2

- x18 micro servos SG90s

- cámara web playstation eye

-raspberry pi -LM2596 reductor -x2 interruptores - LED RGB

- cables varios

Paso 1: Paso 1: Imprimir Todas Las Piezas De La Estructura

Es necesario imprimir todas las piezas.

Aqui podreis encontrar todos los archivos.stl:

Cabe destacar que las hemos impreso con las siguientes propiedades:

material: PLA

relleno: 25%

altura de capa: 0.12

velocidad: 55 mm / s

Paso 2: Montaje De La Estructura

Para el montaje de la estructura recomendamos seguir la guía del autor de las piezas 3D:

guía:

No es necesario seguir las instrucciones estrictamente para el buen funcionamiento del robot, ya que en nuestro caso, solo las hemos utilizado como ayuda.

Nota: no fijéis los tornillos de los servos antes de calibrarlos en el apartado de código.

Paso 3: Montaje De La Electronica

Aquí va una lista de los componentes utilizados y algunos consejos para el montaje.- lipo baterry 7.4V 2700mmAh - x2 adafruit servo driver

- x18 micro servos SG90s

- cámara web playstation eye

-rambuesa pi

-LM2596 baja

-x2 conmutadores

- LED RGB

- cables varios

Es importante que para conectar 2 servo drivers adafruits, se suelde el bridge A0 de la segunda placa. En este enlace esta detallado: https://learn.adafruit.com/16-channel-pwm-servo-d… Respecto a los servos el orden en el que conecta los pines es indiferente ya que tendrás que configurar los mas adelante en el código. Explicado en el apartado de código.

Paso 4: Software: Calibraje De Servos

Antes de nada se tiene que configurar los pulsos máximos y mínimo de vuestros servos así como los pines donde estén conectados en el archivo hexapod_core.py.

cada servo esta identificado según la leyenda de abajo, por cada servo se tiene que indicar, el pin de conexión al servo driver, pulso mínimo, pulso máximo y el ultimo parámetro es por si el servo esta funcionando al revés de como debería, solo tenies que cambiarlo de signo.

"" "convención de teclas de articulación: R - derecha, L - izquierda F - frontal, M - medio, B - atrás H - cadera, K - rodilla, A - Tecla de tobillo: (canal, longitud_mínima_pulso, longitud_máxima_pulso)" "" GPIO.setwarnings (Falso) GPIO.setmode (GPIO. BOARD)

joint_properties = {

'LFH': (0, 248, 398, -1), 'LFK': (1, 195, 492, -1), 'LFA': (2, 161, 580, -1), 'RFH': (31, 275, 405, 1), 'RFK': (30, 260, 493, -1), 'RFA': (29, 197, 480, -1), 'LMH': (3, 312, 451, -1), 'LMK': (4, 250, 520, -1), 'LMA': (5, 158, 565, -1), 'RMH': (28, 240, 390, 1), 'RMK': (27, 230, 514, -1), 'RMA': (26, 150, 620, -1), 'LBH': (6, 315, 465, 1), 'LBK': (8, 206, 498, -1), 'LBA': (7, 150, 657, -1), 'RBH': (25, 320, 480, 1), 'RBK': (24, 185, 490, -1), 'RBA': (23, 210, 645, -1), 'N': (18, 150, 650, 1)}

Paso 5: Software: Modulos

Módulo de reconocimiento de voz:

Para la implementación de éste módulo hemos hecho úso de la API de Google 'Speech-to-Text'. Establecemos un streaming con la nube de Google, para obtener las respuestas en texto, y así poder procesarlas para accionar solo en los casos que nos interesan.

Para poder hacer úso de esta API necesitamos tener un proyecto registrado en Google Cloud, y de este descargar las credenciales para poder autenticar el robot.

Para guardar las credenciales en una variable de entorno tenemos que ejecutar el siguiente comando (Raspbian):

exportar GOOGLE_APPLICATION_CREDENTIALS = "/ tu / ruta / hacia / las / credenciales.json"

Una vez hemos realizado este comando ya podemos hacer úso de la API de speech-to-text.

El código para realizar el streaming está proporcionado por google en su página oficial, muy bien documentado:

La función principal del streaming es 'listen_print_loop', la encargada de decidir cual es la respuesta que se aproxima más al input recibido, y donde hemos controlado las respuestas para poder comunicarle al robot cuando ha de hacer una acción, o para avisarle que el comando de voz no es reconocido, para que el robot realice un movimiento que simula no haber entendido al usuario.

El código adaptado se encuentra en el repositorio de git Hexawalker

github.com/RLP2019/HEXAWALKER/blob/master/…

PASO 1: INSTALL OPENCVHemos seguido la instalación de un profesional como es Adrian Rosebrock, en su página web:

PASO 2: PROBAR LA CAMARA Primero de todo una vez instalado opencv, lo que vamos a hacer es un pequeño script en python para probar la camara. Para ello haremos que se abran dos ventanas, una con la imagen original y otra con la imagen en blanco y negro.

importar numpy como np

importar cv2

cap = cv2. VideoCapture (0)

while (Verdadero): ret, frame = cap.read () gray = cv2.cvtColor (frame, cv2. COLOR_BGR2GRAY) cv2.imshow ('frame', frame) cv2.imshow ('gray', gray) if cv2.waitKey (1) & 0xFF == ord ('q'): romper

cap.release ()

cv2.destroyAllWindows ()

PASO 3: DETECCIÓN DEL COLOR CON OPENCV Para el siguiente paso lo que vamos a realizar es una detección de color. Para ello, primero de todo vamos a realizar un script que nos permita convertir un color en orden BGR a HSV (formato en el que opencv es capaz de interpretar).

importar sys

import numpy as np import cv2 blue = sys.argv [1] green = sys.argv [2] red = sys.argv [3] color = np.uint8 (

Una vez hayamos hecho la conversión de nuestro color deseado, el script nos printará por el límite por debajo y el límite por arriba, el cual nos servirá para que la detección tenga una gama de colores entre dos colores hsv y no únicamente uno, lo cual dificultaría la detección por problemas de luz o contraste.

El siguiente paso es con una imagen realizada previamente, crear otro script el cual nos servirá para probar el paso anterior. Lo que nos mostrará como resultado será la imagen que nosotros le pasemos (con el color u objeto a detectar) convertida en una máscara, aislando todos los colores que no se encuentran en ese rango hsv que hemos definido.

importar cv2

importar numpy como np

# Leer la imagen - El 1 significa que queremos la imagen en BGR

img = cv2.imread ('objeto_amarillo.jpg', 1)

# cambiar el tamaño de la imagen al 20% en cada eje

img = cv2.resize (img, (0, 0), fx = 0.2, fy = 0.2) # convertir la imagen BGR en una imagen HSV hsv = cv2.cvtColor (img, cv2. COLOR_BGR2HSV)

# NumPy para crear matrices para contener el rango inferior y superior

# El "dtype = np.uint8" significa que el tipo de datos es un entero de 8 bits

rango_inferior = np.array ([24, 100, 100], dtype = np.uint8)

rango_uperior = np.array ([44, 255, 255], dtype = np.uint8)

# crea una máscara para la imagen

máscara = cv2.inRange (hsv, rango_inferior, rango_uperior)

# mostrar la máscara y la imagen una al lado de la otra

cv2.imshow ('máscara', máscara) cv2.imshow ('imagen', img)

# espere a que el usuario presione [ESC]

while (1): k = cv2.waitKey (0) if (k == 27): romper cv2.destroyAllWindows ()

PASO 4: POSICIONAMIENTO DEL OBJETO En este paso probaremos que una vez la cámara se encuentre en funcionamiento y hayamos establecido nuestro rango mínimo y máximo de color hsv, que este sea capaz de encontrar las coordenadas x e y del centro de nuestro objeto. En este caso lo que crearemos será un script para que cuando el radio de nuestro objeto sea mayor a 10, dibuje un circulo sobre el objeto y nos vaya mostrando por pantalla la posición en tiempo real sus coordenadas x e y.

# solo proceda si el radio cumple con un tamaño mínimo

if radio> 10: # dibuja el círculo y el centroide en el marco, # luego actualiza la lista de puntos rastreados cv2.circle (frame, (int (x), int (y)), int (radius), (0, 255, 255), 2) cv2.circle (frame, center, 5, (0, 0, 255), -1) # imprime las coordenadas del centro del círculo mapObjectPosition (int (x), int (y)) # si el led es aún no está encendido, encienda el LED si no es ledOn: GPIO.output (redLed, GPIO. HIGH) ledOn = True def mapObjectPosition (x, y): print ("[INFO] Coordenadas del centro del objeto en X0 = {0} e Y0 = {1} ". Formato (x, y))

Con esto lo que vamos a conseguir es en el siguiente paso poder jugar con las coordenadas para establecer los límites de lo que será girar a la derecha nuestro robot, girar a la izquierda o bien no realizar ningún movimiento al no salir por ningún límite.

PASO 5: SEGUIMIENTO DE OBJETOS Llegamos al paso final. Una vez realizados los puntos anteriores, estaremos listos para poder configurar un par de parámetros y poner a funcionar nuestra detección. Para ello utilizaremos como hemos dicho anteriormente, los parámetros del color hsv máximo y mínimo para poder crear la máscara y dtectar el objeto.

colorLower = (-2, 100, 100)

colorUpper = (18, 255, 255)

También necesitaremos las coordenadas x e y para el límite derecho y el límite izquierdo elegidos en el paso anterior.

si (x 280):

print ("[ACCIÓN] GIRAR DERECHA") self.hexa.rotate (desplazamiento = -15, repeticiones = 1)

Lo que estamos realizando con los condicionales anteriores es decir que si nuestra coordenada x es más pequeña que 220, gire a la izquierda. En el caso de que sea más grande, gire a la derecha.

Para el caso en el que quiera avanzar hacia adelante lo que se utilizará es utilizar la variable dónde calcular el radio para marcar otro límite en caso de proximidad de la pelota. Cuanto más cerca este la pelota de nuestro robot ¡, más grande será su radio y por tanto más cerca estará nuestro robot en conseguir su objetivo.

si radio <105: self.hexa.walk (swing = 40, repeticiones = 1, elevado = -30, piso = 50, t = 0.3)

A partir de este punto el programador ya es libre de realizar modificaciones e ir jugando con parámetros y colores.