Hay al menos 4 o 5 otros proyectos en Instructables.com para modificar o controlar el brazo robótico de OWI. El objetivo de este proyecto se resume en estos puntos.

1. Movilidad: este proyecto monta el brazo en un vehículo sobre orugas para que la movilidad pueda expandir la facilidad de uso del brazo.

2. Inalámbrico: el brazo se controla de forma inalámbrica con bluetooth.

3. Control: con la combinación del controlador de Wii y nunchuck tenemos entradas de control de movimiento, joystick, botones direccionales y numerosos botones pulsadores para trabajar. La implementación de nunchuck en este proyecto permite al operador operar todas las articulaciones del brazo agarrando el nunchuck con una mano y moviéndolo de una manera intuitiva para colocar fácilmente el brazo en la posición deseada. Algunas de las juntas tienen control proporcional para mayor precisión.

Usaremos la Raspberry Pi para controlar este robot. Lo programaremos con el lenguaje de programación Python usando la biblioteca CWiiD y la biblioteca Bluetooth para el controlador de Wii.

Aquí hay un par de videos de Youtube que muestran el robot en funcionamiento. Mi objetivo para este proyecto era poder controlar el brazo robótico con precisión y usar movimientos de la mano que se sientan naturales y estén estrechamente relacionados con el movimiento del brazo robótico.

Suministros:

Paso 1: Piezas

Partes necesarias para este proyecto.

1. OWI Robotic Arm Edge: este es el brazo robótico en forma de kit.

2. Kit de chasis de vehículos con orugas de Tamiya

3. Caja de cambios doble Tamiya 70168 L / R Independ 4-Speed

4. Módulo de la placa del controlador del variador de motor L298N Puente doble H - Cantidad 4 -

5. Ordenador Raspberry Pi

6. Banco de energía de 5 voltios y 1 amperio diseñado para cargar el teléfono celular - Cantidad 2 -

7. Control remoto de Wii y controlador Nunchuck

Compré todo esto en Amazon, excepto el controlador de Wii que ya tenía

Paso 2: Comencemos

Comencé poniendo el kit de pista juntos. Esta es una foto del kit de pista totalmente juntos. Así ensamblada, la pista solo irá hacia adelante o hacia atrás. Queremos poder girar a la derecha y también a la izquierda. Para hacer esto necesitas comprar la caja de engranajes doble Tamiya 70168.

Paso 3: armar la caja de cambios doble

Es necesario montar la caja de cambios doble de un kit. Se puede montar para ir a una de cuatro velocidades. Lo hice para correr a la velocidad más lenta que también tiene la mayor torsión.

Paso 4: Monte la caja de cambios dual en el kit de riel

Los orificios de montaje de la caja de cambios dual son demasiado anchos para la base estándar, por lo que pegué un bloque que es lo suficientemente ancho para los tornillos pero no lo suficientemente ancho como para interferir con las pistas. Ahora puedes seguir adelante y montar la caja de cambios.

Paso 5: Añadir soportes y base

El vehículo de la pista está diseñado para correr con las pistas más cortas en el suelo. Por motivos de estabilidad, lo volteé para tener la sección larga de la pista en el suelo. Pegado en dos soportes de montaje, luego hice una base en la que el brazo se puede sentar y también tengo espacio para los cuatro controladores de motor L298N Dual H Bridge.

Paso 6: Diseño de la base

La base permite que el brazo robótico se siente en el medio con espacio para una batería y controladores de motor en ambos lados.

Paso 7: construir el brazo robótico

Ahora necesitamos ensamblar el brazo robótico del kit. Hay muchos instructables ya en la construcción del brazo. Le sugiero que busque uno de ellos si desea más ayuda. Me pareció que el kit era de alta calidad y todo encajaba muy bien.

Nota importante: siga adelante y construya el kit, excepto la unidad de control cableada y la caja de la batería. No usaremos ninguno de estos en este proyecto.

Paso 8: hacer espacio para la batería principal

Luego, usé mi herramienta Dremel para quitar algo de plástico en la caja de la batería para que mi banco de baterías encajara en ella. Terminé cortando por completo el extremo para dejar espacio para el enchufe USB (no se muestra en esta imagen).

Paso 9: cablear los controladores del motor

Hay 5 motores en el brazo robótico y 2 motores en la unidad de pista. El L298N Dual H Bridge puede manejar 2 motores cada uno, por lo que necesitamos 4 de ellos con un lugar de sobra. Cada Dual H Bridge está empaquetado con 2 controladores de motor en la misma placa. Trabajan totalmente independientes y se empaquetan en el mismo tablero estrictamente para su comodidad.

Aquí es cómo cablear el controlador del motor

Permite usar los motores de rotación de base y de movimiento de base (vertical) como ejemplo

Cortar el conector de la base girar el grupo de 2 cables del motor. Un cable va a Out1 y el otro a Out2.

Corte el conector del grupo de 2 cables del motor de movimiento de la base. Un cable va a Out3 y el otro a Out4.

Mira la imagen y encuentra "Conectar el motor aquí" (2 lugares)

Conecte la batería del motor donde dice. Terreno y + 5V

Una nota aquí: Todos los motores en este proyecto fueron diseñados originalmente para funcionar a 3 voltios. Los estoy ejecutando a 5 voltios. Con la mayoría de estos pequeños motores de CC, esto no es un problema a menos que aumente demasiado el voltaje.

Cubriremos la entrada de control en el siguiente paso.

Paso 10: Controlando los controladores del motor

El control del motor de rotación de la base se realizará mediante In1 e In2.

El control del motor de movimiento base se realizará mediante In3 e In4.

Así que en este ejemplo, los pines 10,11,12 y 13 se cablearán de la siguiente manera

También cada conjunto (In1 e In2) - (In3 e In4) tiene un pin de habilitación.El controlador viene con el pin de activación puenteado a +5 voltios que lo habilita todo el tiempo. En este proyecto, queremos controlar algunos de los motores con modulación de pulso que permite controlar la velocidad del motor activando y desactivando el pin de activación muy rápido. Observe cómo los pines 31 y 33 están conectados a los pines de habilitación respectivos.

Lista de todos los pines GPIO del código python

LeftMotorTrackA = 3

LeftMotorTrackB = 5

RightMotorTrackA = 7

RightMotorTrackB = 8

MotorBaseRotateA = 10 ----- In1

MotorBaseRotateB = 11 ----- In2

MotorBaseMotionA = 12 ----- In3

MotorBaseMotionB = 13 ----- In4

MotorElbowA = 15

MotorElbowB = 16

MotorWristA = 18

MotorWristB = 19

MotorGripperA = 21

MotorGripperB = 22

BaseMotionEnable = 31 ----- Habilitar pin para In3-In4

BaseRotateEnable = 33 ----- Habilitar pin para In1-in2

GripperEnable = 35

Paso 11: cablea el resto de los controladores del motor

Sobre la base de los dos últimos pasos, debería poder repetir el proceso en los 3 controladores de motor restantes. Coloqué los controladores en el estuche según la longitud de los cables que provienen del brazo. No tuve que extender ninguno de los cables más allá de su longitud original. Deberá conectar la energía de la batería para todos los controladores del motor juntos. También deberá conectar la tierra de la Raspberry Pi al pin de tierra en uno de los controladores. Sus bases están conectadas a través de las conexiones de alimentación para que funcionen. La imagen 2 pasos atrás muestra la conexión a tierra de la Raspberry Pi.

Paso 12: Configurando la Raspberry Pi

Usaremos la Raspberry Pi para controlar este robot. Lo programaremos con el lenguaje de programación Python usando la biblioteca CWiiD y la biblioteca Bluetooth para el controlador de Wii.

Primero necesitamos instalar bluetooth

Comience por conectar su dispositivo USB Bluetooth en su Pi y reinícielo.

Puede comprobar el dongle escribiendo lsusb

pi @ raspberrypi ~ $ lsusb

Bus 001 Dispositivo 002: ID 0424: 9514 Standard Microsystems Corp.

Bus 001 Device 001: ID 1d6b: 0002 concentrador raíz de Linux Foundation 2.0

Bus 001 Dispositivo 003: ID 0424: ec00 Standard Microsystems Corp.

Bus 001 Dispositivo 004: ID 0a12: 0001 Cambridge Silicon Radio, Ltd Bluetooth Dongle (modo HCI)

Para asegurarse de que tiene instalado Bluetooth, ejecute lo siguiente

sudo apt-get update

sudo apt-get install bluetooth

instala una biblioteca de Python llamada CWiiD

Para obtener información del Wiimote a través de Bluetooth, tenemos que instalar una biblioteca de Python llamada CWiiD, es como un "controlador" si lo desea. Para instalarlo, es muy simple, solo escribe:

sudo apt-get install python-cwiid

Paso 13: Sobre el Código

Ok sobre el código:

1. Primero asignaremos todos los pines GPIO que controlarán los controladores del motor.

2. A continuación, crea funciones para todos los movimientos posibles del brazo y la pista.

3. Busque el controlador de Wii y conéctelo.

4. Configure la modulación de ancho de pulso (PWM) para la rotación de la base, el movimiento de la base y la pinza. Esto nos permite reducir la velocidad de los motores para una sensación precisa al cambiar el ciclo de trabajo del pulso.

Aquí hay un muy buen artículo sobre PWM.

raspi.tv/2013/rpi-gpio-0-5-2a-now-has-software-pwm-how-to-use-it

5. El resto del código es un gran bucle que busca la entrada del controlador de Wii y Nunchuck

Para obtener más información sobre la programación de Wii, aquí hay un instructivo que muestra el uso de cada botón de la Wii que usé como referencia.

www.instructables.com/id/Raspberry-Pi-and-Wiimote-controlled-Robot-Arm/step5/The-Code/

importar cwiid

tiempo de importación

importación OS

Importar RPi.GPIO como GPIO

desde el momento de la importación del sueño

GPIO.cleanup ()

# asigne pines GPIO

LeftMotorTrackA = 3

LeftMotorTrackB = 5

RightMotorTrackA = 7

RightMotorTrackB = 8

MotorBaseRotateA = 10

MotorBaseRotateB = 11

MotorBaseMotionA = 12

MotorBaseMotionB = 13

MotorElbowA = 15

MotorElbowB = 16

MotorWristA = 18

MotorWristB = 19

MotorGripperA = 21

MotorGripperB = 22

BaseMotionEnable = 31

BaseRotateEnable = 33

GripperEnable = 35

GripperLED = 40

#set pines GPIO a la salida

GPIO.setmode (GPIO.BOARD)

GPIO.setup (LeftMotorTrackA, GPIO.OUT)

GPIO.setup (LeftMotorTrackB, GPIO.OUT)

GPIO.setup (RightMotorTrackA, GPIO.OUT)

GPIO.setup (RightMotorTrackB, GPIO.OUT)

GPIO.setup (MotorBaseRotateA, GPIO.OUT)

GPIO.setup (MotorBaseRotateB, GPIO.OUT)

GPIO.setup (MotorBaseMotionA, GPIO.OUT)

GPIO.setup (MotorBaseMotionB, GPIO.OUT)

GPIO.setup (MotorElbowA, GPIO.OUT)

GPIO.setup (MotorElbowB, GPIO.OUT)

GPIO.setup (MotorWristA, GPIO.OUT)

GPIO.setup (MotorWristB, GPIO.OUT)

GPIO.setup (MotorGripperA, GPIO.OUT)

GPIO.setup (MotorGripperB, GPIO.OUT)

GPIO.setup (BaseMotionEnable, GPIO.OUT)

GPIO.setup (BaseRotateEnable, GPIO.OUT)

GPIO.setup (GripperEnable, GPIO.OUT)

GPIO.setup (GripperLED, GPIO.OUT)

def TrackDriveForward ():

GPIO.output (LeftMotorTrackA, GPIO.HIGH)

GPIO.output (LeftMotorTrackB, GPIO.LOW)

GPIO.output (RightMotorTrackA, GPIO.HIGH)

GPIO.output (RightMotorTrackB, GPIO.LOW)

def TrackDriveReverse ():

GPIO.output (LeftMotorTrackA, GPIO.LOW)

GPIO.output (LeftMotorTrackB, GPIO.HIGH)

GPIO.output (RightMotorTrackA, GPIO.LOW)

GPIO.output (RightMotorTrackB, GPIO.HIGH)

def TrackDriveLeft ():

GPIO.output (LeftMotorTrackA, GPIO.LOW)

GPIO.output (LeftMotorTrackB, GPIO.HIGH)

GPIO.output (RightMotorTrackA, GPIO.HIGH)

GPIO.output (RightMotorTrackB, GPIO.LOW)

def TrackDriveRight ():

GPIO.output (LeftMotorTrackA, GPIO.HIGH)

GPIO.output (LeftMotorTrackB, GPIO.LOW)

GPIO.output (RightMotorTrackA, GPIO.LOW)

GPIO.output (RightMotorTrackB, GPIO.HIGH)

def TrackDriveStop ():

GPIO.output (LeftMotorTrackA, GPIO.LOW)

GPIO.output (LeftMotorTrackB, GPIO.LOW)

GPIO.output (RightMotorTrackA, GPIO.LOW)

GPIO.output (RightMotorTrackB, GPIO.LOW)

def BaseRotateRight ():

GPIO.output (MotorBaseRotateA, GPIO.HIGH)

GPIO.output (MotorBaseRotateB, GPIO.LOW)

def BaseRotateLeft ():

GPIO.output (MotorBaseRotateA, GPIO.LOW)

GPIO.output (MotorBaseRotateB, GPIO.HIGH)

def BaseMotionUp ():

GPIO.output (MotorBaseMotionA, GPIO.HIGH)

GPIO.output (MotorBaseMotionB, GPIO.LOW)

def BaseMotionDown ():

GPIO.output (MotorBaseMotionA, GPIO.LOW)

GPIO.output (MotorBaseMotionB, GPIO.HIGH)

def BaseXStop ():

GPIO.output (MotorBaseRotateA, GPIO.LOW)

GPIO.output (MotorBaseRotateB, GPIO.LOW)

def BaseYStop ():

GPIO.output (MotorBaseMotionA, GPIO.LOW)

GPIO.output (MotorBaseMotionB, GPIO.LOW)

def ElbowUp ():

GPIO.output (MotorElbowA, GPIO.LOW)

GPIO.output (MotorElbowB, GPIO.HIGH)

def ElbowDown ():

GPIO.output (MotorElbowA, GPIO.HIGH)

GPIO.output (MotorElbowB, GPIO.LOW)

def ElbowStop ():

GPIO.output (MotorElbowA, GPIO.LOW)

GPIO.output (MotorElbowB, GPIO.LOW)

def WristDown ():

GPIO.output (MotorWristA, GPIO.HIGH)

GPIO.output (MotorWristB, GPIO.LOW)

def WristUp ():

GPIO.output (MotorWristA, GPIO.LOW)

GPIO.output (MotorWristB, GPIO.HIGH)

def WristStop ():

GPIO.output (MotorWristA, GPIO.LOW)

GPIO.output (MotorWristB, GPIO.LOW)

def GripperOpen ():

GPIO.output (MotorGripperA, GPIO.HIGH)

GPIO.output (MotorGripperB, GPIO.LOW)

def GripperClose ():

GPIO.output (MotorGripperA, GPIO.LOW)

GPIO.output (MotorGripperB, GPIO.HIGH)

def GripperStop ():

GPIO.output (MotorGripperA, GPIO.LOW)

GPIO.output (MotorGripperB, GPIO.LOW)

#set modulación de ancho de pulso a 50 hz.

BMpw = GPIO.PWM (BaseMotionEnable, 50)

BRpw = GPIO.PWM (BaseRotateEnable, 50)

GRpw = GPIO.PWM (GripperEnable, 50)

#start base pwm al 50%

BMpw.start (50)

BRpw.start (50)

# juego de pinzas en un 40% constante para que funcione más lento

GRpw.start (40)

# Hacer que el dongle Bluetooth sea detectable

os.system ("sudo hciconfig hci0 piscan")

#conectando al Wiimote. Esto permite varios intentos.

# como los primeros pocos suelen fallar.

Imprimir 'Presiona 1 + 2 en tu Wiimote ahora …'

wm = Ninguno

i = 2

mientras que no wm:

tratar:

wm = cwiid.Wiimote ()

excepto RuntimeError:

si (i> 10):

Imprimir "Renunciar a la conexión"

dejar()

descanso

Imprimir "Error al abrir la conexión wiimote"

imprimir "intento" + str (i)

i + = 1

# Pausa un poco

time.sleep (0.2)

#Got aquí, dile al usuario

Imprimir "¡Éxito, nos hemos conectado!"

# configurar las entradas que estamos buscando

wm.rpt_mode = cwiid.RPT_BTN | cwiid.RPT_ACC | cwiid.RPT_EXT

#Espera un poco

time.sleep (0.5)

# Haz un ruido

wm.rumble = Verdadero

time.sleep (0.5)

wm.rumble = Falso

#Ahora comience a verificar las presiones de los botones

Imprimir "Listo para recibir pulsaciones de botones y entrada del acelerómetro"

#Loop para siempre detectar

tratar:

mientras que True

# Configura un objeto de botón para verificar

buttons = wm.state 'buttons'

Si los botones & cwiid.BTN_UP:

imprimir "botón ARRIBA"

TrackDriveForward ()

botones elif y cwiid.BTN_DOWN:

imprimir "botón ABAJO"

TrackDriveReverse ()

Elif buttons & cwiid.BTN_LEFT:

imprimir "botón IZQUIERDA"

TrackDriveLeft ()

Elif buttons & cwiid.BTN_RIGHT:

Imprimir "botón DERECHA"

TrackDriveRight ()

más:

imprimir "parada de pista"

TrackDriveStop ()

if (buttons & cwiid.BTN_MINUS):

Imprimir 'Minus presionado'

GripperClose ()

elif (botones & cwiid.BTN_PLUS):

imprimir 'Plus presionado'

GripperOpen ()

elif (botones & cwiid.BTN_1):

imprimir '1 pulsado'

elif (botones & cwiid.BTN_2):

imprimir '2 pulsados'

más:

GripperStop ()

imprimir "else stop"

#El LED se opera directamente con el voltaje GPIO. Todos los motores utilizan un driver.

if (buttons & cwiid.BTN_A):

GPIO.output (GripperLED, GPIO.HIGH)

imprimir 'a presionado'

más:

GPIO.output (GripperLED, GPIO.LOW)

#stopear todo presionando el botón B - parada de pánico

if (buttons & cwiid.BTN_B):

imprimir 'b presionado'

GPIO.cleanup ()

#Aquí manejamos el nunchuk, junto con el joystick y los botones

mientras (1):

si wm.state.has_key ('nunchuk'):

tratar:

# Aquí están los datos para el palo nunchuk:

#X eje: LeftMax = 25, Medio = 125, RightMax = 225

NunchukStickX = (wm.state 'nunchuk' 'stick' cwiid.X)

#Y eje: DownMax = 30, Middle = 125, UpMax = 225

NunchukStickY = (wm.state 'nunchuk' 'stick' cwiid.Y)

#Las variables 'NunchukStickX' y 'NunchukStickY' ahora almacenan los valores de palo

imprimir NunchukStickX

imprimir NunchukStickY

si (NunchukStickY> 160):

Imprimir "codo abajo"

#fina sintonizar los movimientos del brazo cambiando el ciclo de trabajo

BMpw.ChangeDutyCycle (20)

ElbowDown ()

elif (NunchukStickY <110):

Imprimir "codo arriba"

BMpw.ChangeDutyCycle (40)

ElbowUp ()

más:

ElbowStop ()

imprimir "ystop"

#Aquí nos ocupamos de todos nuestros datos para el acelerómetro.

#El nunchuk tiene un acelerómetro que registra de manera similar al wiimote, pero el rango numérico es diferente

# El rango X es: 70 si está inclinado 90 grados hacia la izquierda y 175 si está inclinado 90 grados hacia la derecha

# El rango Y es: 70 si está inclinado 90 grados hacia abajo (los botones apuntan hacia abajo), y 175 si está inclinado 90 grados hacia arriba (botones $

numchkX = wm.state 'nunchuk' 'acc' cwiid.X

numchkY = wm.state 'nunchuk' 'acc' cwiid.Y

#hacer el movimiento del brazo proporcional al nunchuck cambiando PWM

if (numchkY> 160):

si (numchkY <170):

BMpw.ChangeDutyCycle (20)

BaseMotionDown ()

más:

BMpw.ChangeDutyCycle (40)

BaseMotionDown ()

elif (numchkY <120):

if (numchkY> 110):

BMpw.ChangeDutyCycle (60)

BaseMotionUp ()

más:

BMpw.ChangeDutyCycle (95)

BaseMotionUp ()

más:

BaseYStop ()

si (numchkX <100):

if (numchkX> 80):

BRpw.CambiarDutyCycle (20)

BaseRotateLeft ()

más:

BRpw.CambiarDutyCycle (40)

BaseRotateLeft ()

elif (numchkX> 140):

si (numchkX <160):

BRpw.CambiarDutyCycle (20)

BaseRotateRight ()

más:

BRpw.CambiarDutyCycle (45)

BaseRotateRight ()

más:

BaseXStop ()

imprimir str (numchkX) + '' + str (numchkY)

ChukBtn = wm.state 'nunchuk' 'buttons'

si (ChukBtn == 1):

Muñeca ()

elif (ChukBtn == 2):

WristUp ()

más:

Muñequera ()

descanso

excepto KeyError:

Imprimir 'No se detectó nunchuk'.

más:

si (Contador == 10000):

Imprimir 'No se detectó nunchuk'.

Contador = Contador / 10000

descanso

Contador = Contador + 1

descanso

# Chill por un momento

time.sleep (0.3)

excepto KeyboardInterrupt:

pasar

Imprimir "Goodby"

Paso 14: Iniciar automáticamente el programa Python

Cuando quiera usar el robot, me gustaría encender la batería del motor, encender la batería de la computadora y estar listo para conectarme a la Wii. Simplemente presiona el botón 1 y 2 en la Wii y espera a que suene, entonces sabes que está conectado. Aquí es cómo configurarlo de esa manera:

Primero abre el archivo /etc/rc.local

sudo nano /etc/rc.local

Ahora que está abierto inserto la siguiente línea justo delante de #Imprimir la dirección IP

python /home/pi/pythoncode/robottrackarm.py &

Esto ejecutará Python y mi programa en el inicio

#! / bin / sh -e

#

# rc.local

#

# Este script se ejecuta al final de cada nivel de ejecución multiusuario.

# Asegúrese de que el script "salga de 0" en caso de éxito o cualquier otro

# valor en error.

#

# Para habilitar o deshabilitar este script solo cambia la ejecución

# bits.

#

# Por defecto este script no hace nada.

python /home/pi/pythoncode/robottrackarm.py &

# Imprimir la dirección IP

_IP = $ (nombre de host -I) || cierto

si "$ _IP"; entonces

printf "Mi dirección IP es% s n" "$ _IP"

fi

salida 0

Paso 15: Aquí está el paquete final

Con eso termina este proyecto. Aquí está el aspecto final con todo enchufado y las cubiertas superiores puestas. Espero haber inspirado a alguien a intentarlo. Déjame saber qué te parece el proyecto.