Brazo robótico controlado por Nunchuk (con Arduino)

Acerca de este proyecto

¡Los brazos robóticos son increíbles! Las tienen fábricas de todo el mundo, donde pintan, sueldan y transportan cosas con precisión. ¡También se pueden encontrar en exploración espacial, vehículos submarinos operados a distancia e incluso en aplicaciones médicas!

¡Y ahora puede tener una versión más económica en su propio hogar, oficina o laboratorio! ¿Estás cansado de hacer un trabajo repetitivo? Programa tu propio robot para que te ayude ... ¡o para estropear las cosas! :D

En este tutorial te muestro cómo montar un brazo robótico y cómo programarlo usando un Arduino Mega. Para este proyecto, también quería experimentar un método diferente para controlar un brazo robótico:¡usar un Nintendo Nunchuk! Son baratos, fáciles de encontrar y tienen muchos sensores.

Hay varias formas de utilizar este tutorial. Si no tiene un kit de brazo robótico (y no quiere comprar o construir uno), aún puede usarlo para aprender algo sobre la programación de Arduino y cómo conectar un Wii Nunchuk a sus propios proyectos. También puede usarlo para practicar sus habilidades mecánicas y electrónicas.

Paso 1:herramientas y materiales

En este proyecto se utilizaron las siguientes herramientas y materiales:

Herramientas y materiales:

• Soldador y alambre. Tuve que soldar algunos terminales a los cables de Nunchuk para poder conectarlo al Arduino;

• Tubo retráctil. Se utilizaron algunos trozos de tubo retráctil para un mejor aislamiento de los conductores;

• Destornillador. La estructura se monta mediante unos tornillos y tuercas;

• Brazo robótico de escritorio mecánico de 6 ejes (Enlace). Este impresionante kit ya viene con varios componentes como se describe a continuación. Es confiable y fácil de montar;

• Fuente de alimentación de 12 V (2 A o más);

• Controlador Nunchuk (Enlace). Se conecta a la placa Arduino y se utiliza para controlar el brazo robótico;

• Cables de puente macho (4 cables);

• Arduino Mega (enlace / enlace / enlace). Tenga en cuenta que el kit de brazo robótico que he usado también tiene un paquete de placa y controlador que ya viene con esta placa Arduino. Si no está usando uno de esos kits, también puede usar otras placas Arduino;

Más tarde me informaron que hay un adaptador Nunchuk que facilita la conexión a un breadboad (enlace / enlace). Es una buena opción si desea pasar un tiempo soldando y no desea destruir el conector original como se describe en el Paso 9.

El brazo de escritorio mecánico de 6 ejes Sain Smart ya viene con los siguientes componentes:

• Arduino Mega 2560 R3 (enlace)

• Escudo de la placa de control (enlace)

• NRF24L01 + Módulo transceptor inalámbrico (enlace)

• Giroscopio de 3 ejes MPU6050 y acelerómetro de 3 ejes (enlace)

• 71 x tornillo M3X8

• 47 x tuerca M3

• 2 x soporte en U

• 5 x soporte de servo

• 4 x 9 kg servo (enlace)

• 2 x 20 kg servo (enlace)

• 6 x bandeja de servo de metal

• 3 x soporte en U

• 21 x soporte en ángulo recto

• 3 x cojinete de brida

• 1 x pinza

Puede encontrar otros kits de brazos robóticos en línea o incluso diseñar el suyo propio. Hay algunos proyectos increíbles que puedes imprimir en 3D, por ejemplo.

En los siguientes 7 pasos, le mostraré cómo ensamblar el kit del brazo antes de conectar los circuitos. Si no tiene un kit similar, no dude en dar algunos pasos. Puede usar otro kit de brazo robótico, ensamblarlo y pasar directamente a los pasos de programación y electrónica.

En cada paso, hay un gif animado que muestra cómo se ensambló mi brazo robótico. Solo se ejecuta en la versión de escritorio del sitio web.

Paso 2:Montaje del brazo robótico Pt1 - Base

La primera pieza a ensamblar es la base del robot.

Está hecho de dos soportes en forma de U, unidos espalda con espalda mediante cuatro tornillos y tuercas M3, como se muestra en las imágenes. Esta es probablemente la parte más fácil de montar.

Paso 3:Montaje del brazo robótico Pt2 - Servo n. ° 1

El primer servomotor se monta perpendicular a la base, utilizando un soporte de servo. Este perfil se fija a la base mediante cuatro tornillos y tuercas M3, como se muestra en las imágenes. El servo n. ° 1 se coloca en su parte superior y se fija con cuatro pernos y tuercas M3.

Un cuerno de metal circular está unido al eje del servo. El kit viene con varios cuernos de plástico. No se utilizarán para ensamblar el robot.

Paso 4:Montaje del brazo robótico Pt3 - Servo n. ° 2

Otro soporte de servo está montado perpendicular al anterior. Está conectado a la bocina del servo n. ° 1 mediante cuatro pernos M3. El servo n. ° 2 se instala con cuatro pernos y tuercas M3, y también usa una bocina de metal circular.

Luego, se fija un soporte en U a la bocina con cuatro pernos. Observe que se usa un perno M3 opuesto al eje del servo. Da estabilidad a la estructura. Un cojinete encaja en este perno y se bloquea en su posición con otra tuerca M3. De esta manera, el soporte en U se une firmemente al eje central del servo n. ° 2.

Paso 5:Montaje del brazo robótico Pt4 - Servo n. ° 3

Otro soporte en U se monta con cuatro tornillos y tuercas M3.

En el otro extremo, se instala el servo n. ° 3, usando una bocina de metal circular y cuatro pernos. Un soporte de servo está conectado al servomotor, y un perfil en forma de L está vinculado al soporte del servo usando algunos pernos y tuercas.

Observe que se usa otro rodamiento opuesto al eje del servo, como se describió anteriormente.

Paso 6:Montaje del brazo robótico Pt4 - Servo n. ° 4

Otro soporte en U se conecta al perfil en forma de L mediante un juego de cuatro tornillos y tuercas M3. De manera similar al paso anterior, el servo # 4 se monta al soporte en U usando cuatro pernos. Otro soporte de servo está conectado al servo.

Paso 7:Montaje del brazo robótico Pt4 - Servo n. ° 5

El quinto servo se conecta perpendicular al servo n. ° 4 usando otro soporte de servo, instalado con cuatro pernos y tuercas M3.

Paso 8:Montaje del brazo robótico Pt4 - Servo n. ° 6

Luego, la pinza se conecta al eje del servo n. ° 5. En su parte superior, el servo n. ° 6 está conectado mediante algunos pernos, tuercas y una bocina de metal. La pinza tiene algunos engranajes, que convertirán la rotación del servo en un movimiento lineal de la pinza.

Paso 9:preparación del controlador Nunchuk

Para este proyecto, decidí usar un controlador Nintendo Nunchuk por varias razones:

• ¡Son baratos! Las réplicas pueden tener una calidad inferior, pero no necesitaba un controlador robusto para este proyecto;

• ¡Son fáciles de encontrar! Hay varias réplicas originales y económicas en línea.

• ¡Tiene muchos sensores! Cada controlador tiene dos botones (botones Z y C), un joystick de dos ejes (X e Y) y un acelerómetro de tres ejes;

• Tiene una biblioteca Arduino. Robert Eisele diseñó una biblioteca sorprendente y fácil de usar para leer el sensor Nunchuk. Compruébelo usted mismo:https://www.xarg.org/2016/12/using-a-wii-nunchuk-with-arduino/

Desafortunadamente, los joysticks Nunchuk tienen un conector complicado, difícil de conectar con otros dispositivos electrónicos. Para conectarlo al Arduino, tuve que cortar su cable y exponer sus cables. De esta manera, ya no funcionará con una Nintendo Wii ...:/

Primero tuve que cortar el conector del joystick y quitar el aislamiento de los cables. Usando un multímetro, y en base al color de cada cable, determiné la función de cada cable (Vcc, GND, SCL y SDA) en base al esquema del conector que se muestra en la imagen. El color de los cables no tiene estándar. Ya he oído hablar de las siguientes posibilidades:

Original:

• SDA =verde

• SCL =amarillo

• 3V3 =rojo

• GND =blanco

Réplica n. ° 1:

• SDA =amarillo

• SCL =blanco

• 3V3 =verde

• GND =rojo

Réplica n. ° 2:

• SDA =azul

• SCL =blanco

• 3V3 =rosa

• GND =verde

Soldé los cables a un puente macho, para una conexión más fácil a la placa Arduino. Para eso, utilicé un soldador y un tubo retráctil, como se muestra en las imágenes.

Más tarde me informaron que hay un adaptador Nunchuk que facilita la conexión a un breadboad (enlace / enlace). Es una buena opción si quiere pasar un tiempo soldando y no quiere destruir el conector original.

Paso 10:cableado de los circuitos

Una vez que la estructura esté ensamblada y los conectores Nunchuk estén terminados, estará listo para conectar los circuitos. Usé el protector de la placa de control que venía con mi kit de brazo robótico. Facilita la conexión de los componentes, ya que viene con conectores específicos para los servomotores, fuente de alimentación, etc.

Conecte los componentes de la siguiente manera:

Nunchuk:

• Nunchuk pin 6 (SCL) => Arduino Mega Pin 21 (SCL) (en el escudo)

• Nunchuk pin 1 (SDA) => Arduino Mega Pin 20 (SDA) (en el escudo)

• Nunchuk pin 3 (Vcc) => Ardino Mega Pin 3V3 (en el escudo)

• Nunchuk pin 4 (Gnd) => Arduino Mega Pin Gnd (en el escudo)

Si está utilizando un Arduino Uno, los pines SCL y SDA de Nunchuk se conectarán a diferentes pines de Arduino, de la siguiente manera:

• Nunchuk pin 6 (SCL) => Arduino Uno Pin A5

• Pin 1 de Nunchuk (SDA) => Pin A4 de Arduino Uno

• Pin 3 de Nunchuk (Vcc) => Pin 3V3 de Ardino Uno

• Nunchuk pin 4 (Gnd) => Arduino Uno Pin Gnd

Servos:

• Terminal de blindaje de control 11 => Servo # 1

• Terminal de blindaje de control 12 => Servo n. ° 2

• Terminal de blindaje de control 13 => Servo # 3

• Terminal de blindaje de control 8 => Servo # 4

• Terminal de blindaje de control 9 => Servo # 5

• Terminal de pantalla de control 10 => Servo # 6

Si no está usando el escudo de control, debe usar la siguiente configuración de pines:

• Pin 11 de Arduino => Servo # 1 (Sgn)

• Pin 12 de Arduino => Servo # 2 (Sgn)

• Pin 13 de Arduino => Servo # 3 (Sgn)

• Pin 8 de Arduino => Servo # 4 (Sgn)

• Pin 9 de Arduino => Servo # 5 (Sgn)

• Pin 10 de Arduino => Servo # 6 (Sgn)

• Arduino Gnd => Servos Gnd

• Fuente de alimentación de 6V => Servos Vcc

También necesitará conectar una fuente de alimentación externa de 12V. Sugiero uno con más de 2A de salida. Los servos consumen mucha energía, y si la fuente de alimentación no es lo suficientemente potente, los servos vibrarán y se calentarán mucho. También perderán su fuerza.

No conecte la fuente de alimentación hasta que haya cargado el código Arduino (que se muestra en pasos posteriores). Hay un botón de encendido en el escudo. Manténgalo en la posición de apagado.

Conecte un cable USB al Arduino y continúe con el siguiente paso.

Paso 11:Configura el IDE de Arduino

Ahora que el hardware está listo, es hora de trabajar en el código Arduino.

1. Descargue e instale la última versión de Arduino IDE Puede encontrar la última versión para Windows, Linux o MAC OSX en el sitio web de Arduino:https://www.arduino.cc/en/main/software

Descárguelo gratis, instálelo en su computadora y ejecútelo.

2. Añadiendo las bibliotecas

¡Para este proyecto utilicé la increíble biblioteca Nunchuk Arduino de Robert Eisele! Puede encontrar más información al respecto en su sitio web:

https://www.xarg.org/2016/12/using-a-wii-nunchuk-with-arduino/

Descargue la biblioteca en https://github.com/infusion/Fritzing/tree/master/Wii-Nunchuk

Vaya a Sketch-> Incluir biblioteca -> Administrar bibliotecas ... en su Arduino IDE para agregar la biblioteca.

¿Cómo funciona la biblioteca?

La biblioteca Nunchuk viene con un conjunto de funciones para leer los sensores del controlador:

nunchuk_buttonZ () :devuelve 1 si se presiona el botón Z, o 0 si no lo está; nunchuk_buttonC () :devuelve 1 si se presiona el botón C, o 0 si no lo está; nunchuk_joystickX () :devuelve el valor x del joystick (entre -127 y 127); nunchuk_joystickY () :devuelve el valor y del joystick (entre -127 y 127); nunchuk_pitch () :devuelve el ángulo del controlador en radianes (entre -180º y 180º); nunchuk_roll () :devuelve el ángulo de balanceo del controlador en radianes (entre -180º y 180º).

Los ángulos se devuelven en radianes. Convertí esos valores a grados en mi código Arduino.

Paso 12:Código Arduino

Descargue el archivo de boceto de Arduino.

Conecte el cable USB al puerto USB de su computadora y cargue el código. Cargar el código lleva algo de tiempo. ¡Puedes usar ese tiempo para dar un 'me gusta' y 'compartir' este tutorial mientras esperas! :D

Una vez completada la carga, desconecte el cable USB, conecte la fuente de alimentación y encienda el botón de encendido. El código comenzará a ejecutarse de inmediato.

Advertencia:cuando el código comienza a ejecutarse, el brazo robótico se moverá muy rápido a su posición inicial. ¡Tenga cuidado de no lastimarse o dañar el equipo cercano durante el inicio!

Posiblemente tendrá que reemplazar el ángulo de inicio de cada servomotor dependiendo de cómo estén montados sus servos.

Código explicado:

Antes de la configuración, el código importa las bibliotecas utilizadas en el boceto ( nunchuk.h, wire.h y servo.h ).

Se definen los pines que se utilizarán y se declaran las variables globales. El ángulo n. ° las variables enteras almacenan la posición inicial de cada servo. Si desea que su robot comience en una posición diferente, cambie los valores de esas variables.

servo # _speed Las variables definen la velocidad del movimiento de cada servo. Si desea que un servo específico se mueva más rápido, aumente su valor. ángulo # min y ángulo n. ° máx. Las variables se utilizan para limitar el ángulo máximo y mínimo para cada servo. Puede configurar esas variables para evitar colisiones entre juntas consecutivas del robot.

  // Incluir bibliotecas # include  #include  #include  // definir variables # definir SERV1 8 // servo 1 en el puerto digital 8 # definir SERV2 9 // servo 2 en el puerto digital 9 # definir SERV3 10 // servo 3 en el puerto digital 10 # definir SERV4 11 // servo 4 en el puerto digital 11 # definir SERV5 12 // servo 5 en el puerto digital 12 # definir SERV6 13 / / servo 6 en el puerto digital 13Servo s1; // servo 1Servo s2; // servo 2Servo s3; // servo 3Servo s4; // servo 4Servo s5; // servo 5Servo s6; // servo 6 // definir el ángulo de inicio para cada servo // elegir una posición segura para comenzar // ¡intentará moverse instantáneamente a esa posición cuando se encienda! // esos ángulos dependerán del ángulo de cada servo durante el ángulo de ensamblaje1 =90; // servo 1 actual angleint angle2 =30; // servo 2 actual angleint angle3 =0; // servo 3 actual angleint angle4 =90; // servo 4 actual angleint angle5 =90; // servo 5 actual angleint angle6 =45; // servo 6 actual angleint servo1_speed =3; // servo 1 speedint servo2_speed =3; // servo 2 speedint servo3_speed =3; // servo 3 speedint servo4_speed =1; // servo 4 speedint servo5_speed =1; // velocidad del servo 5 // definir restricciones para cada servo // esos ángulos dependerán del ángulo de cada servo durante el ensamblaje int angle1min =0; // servo 1 mínimo angleint angle1max =180; // servo 1 ángulo máximo en ángulo2min =0; // servo 2 mínimo angleint angle2max =180; // servo 2 ángulo máximo en ángulo3min =0; // servo 3 mínimo angleint angle3max =180; // servo 3 ángulo máximoint angle4min =0; // servo 4 mínimo angleint angle4max =180; // ángulo máximo del servo 4 angulo5min =0; // servo 5 mínimo angleint angle5max =180; // servo 5 ángulo máximo ánguloint ángulo6min =0; // servo 6 mínimo angleint angle6max =180; // servo 6 ángulo máximo booleano display_angles =true; // booleano utilizado para actualizar el ángulo de cada servo en el monitor serial  

Durante la configuración, cada servo se conecta a un pin específico y se inicia su posición.

La comunicación en serie (al monitor en serie) y la comunicación I2C con el Nunchuk también se inician aquí.

  // SETUPvoid ​​setup () {// adjunta cada servo a un pin y comienza su posición s1.attach (SERV1); s1.write (ángulo1); s2.attach (SERV2); s2.write (ángulo2); s3.attach (SERV3); s3.write (ángulo3); s4.attach (SERV4); s4.write (ángulo4); s5.attach (SERV5); s5.write (ángulo5); s6.attach (SERV6); s6.write (ángulo6); // iniciar la comunicación en serie Serial.begin (9600); // iniciar Nunchuk Wire.begin (); nunchuk_init ();}  

El bucle principal se repite una y otra vez. El estado de Nunchuk se lee en cada ciclo. Dependiendo de las lecturas, se ejecutan diferentes comandos.

  void loop () {// lee los sensores Nunchuk if (nunchuk_read ()) {int x =nunchuk_joystickX (); // posición X del joystick int y =nunchuk_joystickY (); // Posición Y del joystick booleano z =nunchuk_buttonZ (); // estado del botón z booleano c =nunchuk_buttonC (); // estado del botón c float pitch =nunchuk_pitch (); // ángulo de cabeceo float roll =nunchuk_roll (); // ángulo de balanceo  

Se utilizará el joystick X para mover el servo n. ° 1.

Se utilizó el siguiente bloque de código. Primero verifica si el valor del joystick es lo suficientemente grande. De esta forma, se descartan el ruido y las pequeñas variaciones. Si el valor cumple con los requisitos, el ángulo del servo aumentará / disminuirá a una velocidad determinada.

  // Gire a la izquierda / derecha (a una velocidad fija) // Gire a la izquierda if (x> 90) {angle1 - =servo1_speed; display_angles =true; if (ángulo1 <ángulo1min) {ángulo1 =ángulo1min; }} // Girar a la derecha if (x <-90) {angle1 + =servo1_speed; display_angles =true; if (ángulo1> ángulo1máx) {ángulo1 =ángulo1máx; }} s1.write (ángulo1); // actualizar la posición del servo  

Se utiliza un bloque similar para el joystick y. Se utiliza para cambiar el ángulo del servo n. ° 3. El servo n. ° 2 se mantiene fijo en este código.

La rotación de la pinza viene dada por los ángulos de inclinación y balanceo del controlador, medidos por su acelerómetro. Para facilitar el control del brazo, el ángulo de la pinza solo se actualiza cuando se presionan los botones C o Z.

Cuando solo se presiona el botón C, el código lee el ángulo de balanceo y lo usa como un punto de ajuste. el servo # 5 se gira hasta que alcanza el punto de ajuste. Su velocidad es proporcional al error entre la posición real y la deseada. Se usa un código similar para el servo # 4, que rastrea el ángulo de inclinación de Nunchuk.

  // Habilita el acelerómetro solo cuando se presionan los botones // Gira la pinza (solo se presiona el botón Z) if (c &&! z) {roll =roll * 57.0 + 90.0; // convertir grados servo5_speed =abs (angle5 - roll) / 10 + 1; // velocidad proporcional comete el error entre el ángulo real y el deseado if (roll> angle5) {angle5 + =servo5_speed; display_angles =true; } if (roll  

La pinza se cierra siempre que se presionan los botones C y Z. Cuando se suelta cualquiera de esos botones, el robot abrirá su pinza.

  // Abrir / cerrar pinza (ambos botones presionados) if (z &&c) {s6.write (90); // cerrar la pinza display_angles =true; } else {s6.write (45); // abra la pinza}  

Hay un bloque de código al final del boceto. Mostrará en el monitor serial el ángulo real de cada servomotor. Puede resultar útil para elegir el ángulo de arranque de cada motor.

nunchuk.ino

Paso 13:uso

¡Ahora que todo está listo, enciende el robot y diviértete!

El Nunchuk se utiliza para controlar los cinco movimientos que se muestran en las imágenes:rotación derecha / izquierda, movimiento arriba / abajo, rotación de la pinza, movimiento de la pinza arriba / abajo y movimientos de apertura / cierre de la pinza. Puede combinar esos movimientos para realizar diferentes tareas.

Puede modificar el código para tener diferentes movimientos basados ​​en una combinación de los botones y ángulos del joystick.

Código

• nunchuk.ino

nunchuk.ino Arduino

 Sin vista previa (solo descarga). 

Github

https://github.com/infusion/Fritzing/tree/master/Wii-Nunchukhttps://github.com/infusion/Fritzing/tree/master/Wii-Nunchuk

Zapatos inteligentes (autoajuste y generación de electricidad) TM1637 Reloj digital con configuración de hora y funcionalidad de alarma