Brazo robótico simple e inteligente usando Arduino !!!: 5 pasos (con imágenes)

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

En este instructable haré un brazo robótico simple. Eso se controlará mediante un brazo maestro. El brazo recordará los movimientos y jugará en secuencia. El concepto no es nuevo. Conseguí la Idea del "mini brazo robótico, de Stoerpeak". Quería hacer esto durante mucho tiempo, pero en ese entonces era totalmente novato y no tenía conocimientos de programación. Ahora finalmente estoy construyendo uno, manteniéndolo simple, barato y compartiéndolo con todos ustedes.

Entonces empecemos….

Paso 1: Cosas que necesitará: -

Aquí hay una lista de cosas que necesitará: -

1. Servomotores x 5 Enlace para EE. UU.: - https://amzn.to/2OxbSH7Link para Europa: -

2. Potenciómetros x 5 (he usado 100k.) Enlace para EE. UU.: - https://amzn.to/2ROjhDMLink para Europa: -

3. Arduino UNO. (También puede usar Arduino Nano) Enlace para EE. UU.: - https://amzn.to/2DBbENW Enlace para Europa: -

4. Tablero de pruebas. (Sugiero este kit) Enlace para EE. UU.: - https://amzn.to/2Dy86w4 Enlace para Europa: -

5. Batería. (opcional, estoy usando un adaptador de 5v)

6. Cartón / Madera / Sun-board / acrílico lo que esté disponible o sea fácil de encontrar.

Y también necesitará Arduino IDE instalado.

Paso 2: Hacer el brazo: -

Aquí he usado palitos de helado para hacer el brazo. Puede utilizar cualquier material que esté disponible para usted. Y puede probar diferentes diseños mecánicos para hacer un brazo aún mejor. mi diseño no es muy estable.

Solo usé cinta adhesiva de doble cara para pegar los servos al palito de paleta y sujetarlos con tornillos.

Para el brazo maestro, pegué potenciómetros a palitos de helado e hice el brazo.

Refiriéndose a las imágenes le dará una mejor idea.

He montado todo en un lienzo de tamaño A4 que se utiliza como base.

Paso 3: hacer conexiones: -

En este paso haremos todas las conexiones necesarias, consulte las imágenes de arriba.

• Primero conecte todos los servos en paralelo a la fuente de alimentación (el cable rojo a + ve y el cable negro o marrón a tierra)
• A continuación, conecte los cables de señal, es decir, el cable amarillo o naranja al pin PWM de arduino.
• Ahora conecte los potenciómetros a + 5v y Gnd de arduino en paralelo.
• Conecte el terminal del medio al pin analógico de ardunio.

Aquí los pines digitales 3, 5, 6, 9 y 10 se utilizan para controlar los servos

Los pines analógicos A0 a A4 se utilizan para la entrada de potenciómetros.

El servo conectado al pin 3 será controlado por un potenciómetro conectado a A0

El servo conectado al pin 5 será controlado por el potenciómetro en A1, y así sucesivamente….

Nota: - Aunque los servos no funcionan con arduino, asegúrese de conectar la Gnd de los servos a arduino o de lo contrario el brazo no funcionará.

Paso 4: Codificación: -

La lógica de este código es bastante simple, los valores de los potenciómetros se almacenan en una matriz, los registros luego se recorren usando un bucle for y los servos hacen los pasos según los valores. Puede consultar este tutorial que utilicé como referencia "Arduino Potentiometer Servo Control & Memory"

Código: - (Archivo descargable adjunto a continuación).

Primero declararemos todas las variables necesarias globalmente para que podamos usarlas en todo el programa. No se necesita una explicación especial para esto

#incluir

// Servo Objetos Servo Servo_0; Servo Servo_1; Servo Servo_2; Servo Servo_3; Servo Servo_4; // Objetos de potenciómetro int Pot_0; int Pot_1; int Pot_2; int Pot_3; int Pot_4; // Variable para almacenar Servo Position int Servo_0_Pos; int Servo_1_Pos; int Servo_2_Pos; int Servo_3_Pos; int Servo_4_Pos; // Variable para almacenar los valores de la posición anterior int Prev_0_Pos; int Prev_1_Pos; int Prev_2_Pos; int Prev_3_Pos; int Prev_4_Pos; // Variable para almacenar los valores de la posición actual int Current_0_Pos; int Current_1_Pos; int Current_2_Pos; int Current_3_Pos; int Current_4_Pos; int Servo_Position; // Almacena el ángulo int Servo_Number; // Almacena no de servo int Storage [600]; // Matriz para almacenar datos (Aumentar el tamaño de la matriz consumirá más memoria) int Index = 0; // El índice de la matriz comienza desde la posición 0 char data = 0; // variable para almacenar datos de la entrada en serie.

Ahora escribiremos una función de configuración, donde configuramos los pines y sus funciones. Esta es la función principal que se ejecuta primero

configuración vacía ()

{Serial.begin (9600); // Para comunicación serial entre arduino e IDE. // Los objetos servo se adjuntan a los pines PWM. Servo_0.attach (3); Servo_1.attach (5); Servo_2.attach (6); Servo_3.attach (9); Servo_4.attach (10); // Los servos se establecen en la posición 100 en la inicialización. Servo_0.write (100); Servo_1.write (100); Servo_2.write (100); Servo_3.write (100); Servo_4.write (100); Serial.println ("Presione 'R' para grabar y 'P' para reproducir"); }

Ahora tenemos que leer los valores de los potenciómetros usando pines de Entrada Analógica y mapearlos para controlar los servos. Para esto definiremos una función y la llamaremos Map_Pot ();, puede nombrarlo como desee, es una función definida por el usuario

vacío Map_Pot ()

{/ * Los servos giran 180 grados, pero usarlos al límite no es una buena idea, ya que hace que los servos vibren continuamente, lo cual es molesto, por lo que limitamos el servo para moverse entre: 1-179 * / Pot_0 = analogRead (A0); // Leer la entrada de pot y almacenarla en la variable Pot_0. Servo_0_Pos = mapa (Pot_0, 0, 1023, 1, 179); // Asignar servos según el valor entre 0 y 1023 Servo_0.write (Servo_0_Pos); // Mueve el servo a esa posición. Pot_1 = analogRead (A1); Servo_1_Pos = mapa (Pot_1, 0, 1023, 1, 179); Servo_1.write (Servo_1_Pos); Pot_2 = analogRead (A2); Servo_2_Pos = mapa (Pot_2, 0, 1023, 1, 179); Servo_2.write (Servo_2_Pos); Pot_3 = analogRead (A3); Servo_3_Pos = mapa (Pot_3, 0, 1023, 1, 179); Servo_3.write (Servo_3_Pos); Pot_4 = analogRead (A4); Servo_4_Pos = map (Pot_4, 0, 1023, 1, 179); Servo_4.write (Servo_4_Pos); }

Ahora escribiremos la función de bucle:

bucle vacío ()

{Map_Pot (); // Llamada a la función para leer los valores del bote while (Serial.available ()> 0) {data = Serial.read (); if (data == 'R') Serial.println ("Grabando Movimientos…"); if (data == 'P') Serial.println ("Reproduciendo movimientos grabados …"); } if (data == 'R') // Si se ingresa 'R', comience a grabar. {// Almacenar los valores en una variable Prev_0_Pos = Servo_0_Pos; Prev_1_Pos = Servo_1_Pos; Prev_2_Pos = Servo_2_Pos; Prev_3_Pos = Servo_3_Pos; Prev_4_Pos = Servo_4_Pos; Map_Pot (); // Función de mapa recuperada para comparación if (abs (Prev_0_Pos == Servo_0_Pos)) // el valor absoluto se obtiene comparando {Servo_0.write (Servo_0_Pos); // Si los valores coinciden, el servo se reposiciona if (Current_0_Pos! = Servo_0_Pos) // Si los valores no coinciden {Storage [Index] = Servo_0_Pos + 0; // Se agrega valor a la matriz Index ++; // Valor del índice incrementado en 1} Current_0_Pos = Servo_0_Pos; } / * De manera similar, la comparación de valores se realiza para todos los servos, se agrega +100 cada uno para ingresar como valor diferencial. * / if (abs (Prev_1_Pos == Servo_1_Pos)) {Servo_1.write (Servo_1_Pos); if (Current_1_Pos! = Servo_1_Pos) {Storage [Index] = Servo_1_Pos + 100; Índice ++; } Current_1_Pos = Servo_1_Pos; } if (abs (Prev_2_Pos == Servo_2_Pos)) {Servo_2.write (Servo_2_Pos); if (Current_2_Pos! = Servo_2_Pos) {Storage [Index] = Servo_2_Pos + 200; Índice ++; } Current_2_Pos = Servo_2_Pos; } if (abs (Prev_3_Pos == Servo_3_Pos)) {Servo_3.write (Servo_3_Pos); if (Current_3_Pos! = Servo_3_Pos) {Storage [Index] = Servo_3_Pos + 300; Índice ++; } Current_3_Pos = Servo_3_Pos; } if (abs (Prev_4_Pos == Servo_4_Pos)) {Servo_4.write (Servo_4_Pos); if (Current_4_Pos! = Servo_4_Pos) {Storage [Index] = Servo_4_Pos + 400; Índice ++; } Current_4_Pos = Servo_4_Pos; } / * Los valores se imprimen en el monitor en serie, '\ t' es para mostrar los valores en formato tabular * / Serial.print (Servo_0_Pos); Serial.print ("\ t"); Serial.print (Servo_1_Pos); Serial.print ("\ t"); Serial.print (Servo_2_Pos); Serial.print ("\ t"); Serial.print (Servo_3_Pos); Serial.print ("\ t"); Serial.println (Servo_4_Pos); Serial.print ("Índice ="); Serial.println (índice); retraso (50); } if (data == 'P') // SI se ingresa 'P', comienza a reproducir los movimientos grabados. {for (int i = 0; i <Index; i ++) // Recorre la matriz usando el bucle for {Servo_Number = Storage / 100; // Encuentra el número de servo Servo_Position = Storage % 100; // Encuentra la posición del interruptor de servo (Servo_Number) {case 0: Servo_0.write (Servo_Position); rotura; caso 1: Servo_1.write (Servo_Position); rotura; caso 2: Servo_2.write (Servo_Position); rotura; caso 3: Servo_3.write (Servo_Position); rotura; caso 4: Servo_4.write (Servo_Position); rotura; } retraso (50); }}}

Una vez que el código esté listo, cárguelo en la placa arduino

El brazo inteligente está listo para trabajar. La función aún no es tan fluida como la realizada por Stoerpeak.

Si puede mejorar el código o tiene alguna sugerencia para mí, hágamelo saber en la sección de comentarios.

Dicho esto, pasemos a las pruebas….

Paso 5: Prueba: -

Después de cargar el código en la placa con éxito, abra 'Monitor de serie', puede encontrarlo en la opción Herramientas. Cuando el monitor serial se inicia, el arduino se reiniciará. Ahora puede controlar el brazo robótico con el brazo maestro. Pero no se registra nada.

Para comenzar a grabar, ingrese 'R' en el monitor, ahora puede realizar los movimientos que desea grabar.

Una vez finalizados los movimientos, debe ingresar 'P' para poder reproducir los movimientos grabados. Los servos continuarán realizando los movimientos mientras no se reinicie la placa.