Brazo robótico simple e inteligente con Arduino

Acerca de este proyecto

En este tutorial, haré un brazo robótico simple que se controlará con 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.

Así que comencemos ...

Paso 1:Cosas que necesitará

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

1. Servomotores x 5 (Amazon Link)

2. Potenciómetros x 5 (Amazon Link)

3. Arduino UNO. (Enlace de Amazon)

4. Batería. (Estoy usando un adaptador de 5v)

5. Tablero de pruebas. (Enlace de Amazon)

6. Cartón / Madera / Solarium / 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 puedes 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 paleta 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.

  #include  
 // Objetos Servo 
 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 la posición del servo 
 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 establecemos pines y sus funciones. Esta es la función principal que se ejecuta primero.

  void setup () 
 {
 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.

  void Map_Pot () 
 {
 / * Los servos giran 180 grados 
 pero usarlo hasta los límites no es 
 una buena idea ya que hace que el los servos suenan continuamente 
 lo cual es molesto así que limitamos el servo para moverse 
 entre:1-179 * / 
 Pot_0 =analogRead (A0); // Leer la entrada del potenciómetro y almacenarla en la variable Pot_0. 
 Servo_0_Pos =map (Pot_0, 0, 1023, 1, 179); // Asignar servos según el valor entre 0 y 1023 
 Servo_0.write (Servo_0_Pos); // Mueva el servo a esa posición. 
 
 Pot_1 =analogRead (A1); 
 Servo_1_Pos =map (Pot_1, 0, 1023, 1, 179); 
 Servo_1.write (Servo_1_Pos); 
 
 Pot_2 =analogRead (A2); 
 Servo_2_Pos =map (Pot_2, 0, 1023, 1, 179); 
 Servo_2.write (Servo_2_Pos); 
 
 Pot_3 =analogRead (A3); 
 Servo_3_Pos =map (Pot_3, 0, 1023, 1, 179); 
 Servo_3.write (Servo_3_Pos); 
 
 Pot_4 =analogRead (A4); 
 Servo_4_Pos =mapa (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. 
 {
 // Almacene los valores en un 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; 
 Mapa (); // 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 para la entrada 
 como valor diferencial. * / 
 if (abs (Prev_1_Pos ==Servo_1_Pos)) 
 {
 Servo_1.write (Servo_1_Pos); 
 if (Current_1_Pos! =Servo_1_Pos) 
 {
 Almacenamiento [Índice] =Servo_1_Pos + 100; 
 Index ++; 
} 
 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) 
 {
 Almacenamiento [Index] =Servo_2_Pos + 200; 
 Index ++; 
} 
 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) 
 {
 Almacenamiento [Index] =Servo_3_Pos + 300; 
 Index ++; 
} 
 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) 
 {
 Almacenamiento [Índice] =Servo_4_Pos + 400; 
 Index ++; 
} 
 Current_4_Pos =Servo_4_Pos; 
} 
 / * Los valores están impresos en el monitor serial, '\ t' es para mostrar 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', comience a reproducir movimientos grabados. 
 {
 for (int i =0; i  {
 Servo_Number =Storage [i] / 100; // Encuentra el número de servo 
 Servo_Position =Storage [i]% 100; // Encuentra la posición del conmutador 
 del servo (Servo_Number) 
 {
 case 0:
 Servo_0.write (Servo_Position); 
 break; 
 case 1:
 Servo_1.write (Servo_Position); 
 break; 
 caso 2:
 Servo_2.write (Servo_Position); 
 break; 
 caso 3:
 Servo_3.write (Servo_Position); 
 break; 
 caso 4:
 Servo_4.write (Servo_Position); 
 break; 
} 
 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 a 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 graba nada.

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

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

Espero que les guste el proyecto.

Gracias ...

 #include  // Objetos de servoServo Servo_0; Servo Servo_1; Servo Servo_2; Servo Servo_3; Servo Servo_4; // Objetos de potenciómetroint Pot_0; int Pot_1; int Pot_2; int Pot_3; int Pot_4; // Variable para almacenar Servo Positionint Servo_0_Pos; int Servo_1_Pos; int Servo_2_Pos; int Servo_3_Pos; int Servo_4_Pos; // Variable para almacenar valores de posición anteriorint 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 actualint 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 servoint 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 0char data =0; // variable para almacenar datos de la entrada en serie. 

 void setup () {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"); } 

 void 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);} 

 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 están impresos en el monitor de 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   
 
   Esquemas     
  
 

            


            

               Libros de tablero notables        
                INICIO:Una terminal ARduino independiente