¿Cómo montar un brazo robótico con Arduino? Guía paso a paso

Si quieres montar un brazo robótico con una placa Arduino, entonces tendrás que seguir leyendo hasta el final. Te diremos, de manera detallada, toda la información que necesitas saber para llevar adelante este proyecto sin cometer errores.

Lo primero que te mostraremos son los componentes que necesitas para crear tu primer brazo robótico. Luego, te explicaremos el paso a paso que debes realizar para gestar estos proyectos con Arduino desde cero.

Por último, vas a poder leer acerca de los códigos de programación que usarás y los mejores kits de Arduino que puedes comprar para practicar los proyectos que te indicaremos. Echa un vistazo.

¿Qué necesito para montar un brazo robótico con Arduino desde cero?

Para montar un brazo robótico con Arduino desde cero vas a necesitar cubre los aspectos, el software y el hardware. Dentro del primer grupo se encuentra el entorno de programación de Arduino, llamado IDE.

Descargar IDE Arduino para Windows

Descargar IDE Arduino para MacOS

En cuanto al hardware vas a necesitar: 

• Una placa del modelo UNO de Arduino. Este dispositivo tiene un microcontrolador ATmega328, con 6 entradas analógicas y pines 14 digitales. Tiene un conector para la alimentación y otro para un puerto USB. Además, dispone de un botón para resetear las tareas.
• Un brazo robótico genérico que lo podrás fabricar con una impresora 3D, o bien un dispositivo de un modelo específico, por ejemplo, un Tinkerkit Braccio o un LittleArm MG995. Para que decidas por uno u otro modelo deberás tener en cuenta las funciones que quieres que realice el robot, para ello será necesario disponer de más o menos servos.
• Motores de corriente continua. Por lo general, un brazo robótico pequeño tiene entre cinco y seis servos. Estos motores ejecutan su ciclo de trabajo por medio de una PWM de 20 microsegundos. Por lo que vas a necesitar dos tipos de servos, uno; el modelo SpringRC SR311 para el giro de la muñeca y de la pinza, y el segundo; el SpringRC SR431 para accionar el cuerpo, hombro y brazo del robot.
• Un módulo para tecnología bluetooth HC-05. Con este hardware un vas a poder controlar el brazo robótico de forma inalámbrica. Se va a utilizar el protocolo estandarizado IEEE 802.15.1, por lo que necesitarás conectar los pines 1 y 2 con el puerto serie USART.
• Un joystick de 5v. Este potenciómetro trabajará entre 0 y 5v y tendrá en cuenta las señales de tensión en un plano Vx y Vy.
• Cables y conectores genéricos.

Aprende paso a paso cómo armar un brazo robótico con Arduino desde cero

A continuación, te mostraremos cómo debes proceder para el armado de tu primer brazo robótico:

Reconoce todos los pines y sectores de la placa Arduino

Lo primero que deberás hacer es familiarizarte con la placa de Arduino. Para esto es importante que comiences a leer las inspecciones que tienen grabadas en los circuitos electrónicos. Te darás cuenta de que hallarás una serie de pines o entradas qué se usan en diversos trabajos. En una esquina encontrarás un botón (RESET) que podrás utilizar para reiniciar la placa cuando está funcione mal o quieras que se reinicie todo el proceso. Dentro de ese mismo lado tendrás los pines analógicos, los de entrada de 5V y 3.3V y el Vin.

En el lateral más corto, vas a ver las entradas para la fuente de alimentación externa y el USB. Mientras que para el otro sector encontrarás los pines digitales, el pin de tierra (GND), la salida tx, la entrada rx y un pin de referencia analógico. Dentro de la placa tendrás el microcontrolador, resistencias, transistores y expansores. Una vez que tengas en claro todos los componentes del modelo UNO de Arduino estás en condiciones de comenzar con el ensamble de las piezas.

Lleva a cabo la conexión del módulo de bluetooth

En este paso vas a tener que conectar el módulo bluetooth a la placa de Arduino. Para ello tendrás que elegir el pin de 5v del HC-05 a la entrada de alimentación, el GND de Arduino a la masa y el tx del módulo al rx del Arduino. A su vez, vas a tener escribir el pin de recepción rx con el pin de transmisión del Arduino (es decir, el tx o pin1).

Configura el módulo HC-05

Después de haber unido la placa de bluetooth al Arduino, vas a tener que configurar el módulo. Para ello hay que conectar el pin 34 del HC-05 a una fuente de 3.3V, después transmitirle tensión y, por último, colocarlo en modo AT2 (te darás cuenta de esto cuando el led parpadee de forma lenta).

Ingresa a la consola COM y escribe en el siguiente orden los comandos que te mostramos a continuación: 

AT.

AT+RESET.

AT+ROLE.

AT+ROLE=<Rol>. Siendo Rol 0 el esclavo y 1 maestro.

AT+UART. Con 0 un bit de parada y 1 dos bits de parada. Es del tipo <Parity bit>.

AT+UART=<Baud rate>, <Stop bit>, <Parity bit>.

AT+NAME. Para buscar el nombre del dispositivo cuando se encuentre conectado.

AT+ROLE=<Name>.

AT+PSWD.

AT+PSWD=<Password>. La contraseña tendrá que ser 4 dígitos.

Realiza la conexión del joystick a la placa Arduino

Lo que deberás hacer ahora es unir a la placa de Arduino el joystick que comandará los movimientos del brazo robótico. La conexión es muy simple, solo debes liar ambos GND, unir el Vcc del joystick al pin 3.3V de la placa y el VRx al pin A0 del Arduino. Por último, vas a tener que unir el VRy al A1 y el SW del comando al pin 4 de la placa.

Une los servos al Arduino

Lo que tendrás que hacer ahora es conectar los motores a la placa por medio de cables. Para el modelo SpringRC SR311 vas a tener que usar la alimentación al pin 5V de Arduino, la tierra del motor al GND de la placa y por último el del amperaje al pin 9. Con relación al servo SpringRC SR431, vas unir el GND (marrón y negro) al tierra de Arduino, los Vcc entre sí y el SIG (blanco y naranja) a los pines 10 y 11, respectivamente.

Ensambla las demás piezas

Este paso dependerá del modelo del brazo robótico que poseas. Pero para que tengas una idea general deberás utilizar todos los tornillos para fijar las piezas restantes con las placas acrílicas y los plásticos que dispongas. Es muy importante que tengas a mano el manual del fabricante del dispositivo robótico para que comprendas la correcta unión de las piezas.

Realiza la programación en el IDE

Una vez que tengas todo conectado, ya estarás listo para programar tu brazo robótico. Pero a este paso lo veremos con más detalle a continuación.

Descubre cómo programar tu brazo robótico con Arduino para que haga lo que desees

Para programar el brazo robótico que acabas de armar, vas a tener que realizar este proceso de programación:

Diseña un diagrama de flujo

Lo primero que tendrás que hacer es crear todas las acciones y decisiones que deberá tomar los códigos de programación en el software de desarrollo. Teniendo en cuenta el ejemplo de un brazo robótico del modelo Tinkerkit Braccio de 6 servos vas a tener que considerar el siguiente esquema: Cuando inicie el proceso, el programa deberá calcular las coordenadas, si existe un error de verdad corregirlo o pasar directamente a los puntos articulares para establecer los límites.

En este paso deberá realizar el cálculo de TETHA1 para conocer si está dentro de los límites articulares. En caso de que los límites mencionados no correspondan se deberá dar fin al proceso. Pero si elev=elev_min y accesible=1, entonces el programa deberá determinar si es un punto accesible o se llega a la elevación máxima. Si la respuesta es positiva se deberá establecer si TETHA2, TETHA3 y TETHA4 se encuentran dentro de los límites articular.

Si no lo están finaliza el proceso, pero si pertenecen al límite, entonces será el cálculo de TETHAs para ejecutar el guardado de las variables articulares y recién finalizar el proceso. Por otro lado, si el punto accesible no llega a la elevación máxima se deberá establecer que el accesible=1 y producir el desacoplo cinemático. Este paso para que se calcule el centro de la muñeca del brazo robótico, o sea el punto W. Todo esto llevará a que el programa tenga que calcular TETHA2, TETHA3 y TETHA4 para determinar si están dentro de los límites articulares.

En caso de no estarlo, entonces se dará que accesible=0 y elev=elev+n y se volverá a determinar si es un punto accesible o se llega a una elevación máxima. Si TETHA2, TETHA3 y TETHA4 están dentro de los límites articulares, se procederá a su cálculo y se guardarán las variables articulares dentro de un vector auxiliar. Para que tengas de forma gráfica esta representación del diagrama de flujo, mira la imagen que hemos preparado.

Ingresa a IDE

Una vez que tienes en claro cuáles serán los procesos que realizará el brazo robótico de acuerdo con el diagrama de flujo, será necesario que ingreses al entorno de programación de Arduino, y el cual descargaste desde la página principal. Cuando hayas ejecutado el archivo, tendrás que abrir el IDE y dirigirte a la pestaña Archivo, luego vas a tener que pulsar en la opción Nuevo para escribir el código que deberás guardar después.

Configura la placa de Arduino

Procura que tengas configurado el modelo UNO, para ello vas a tener que ir a función Herramientas y luego hacer clic en Placa. Se desplegará un menú en el cual tendrás que elegir la versión de la placa de Arduino correcta.

Escribe los comandos del programa

Lo que deberás hacer ahora es copiar los códigos que te mostramos a continuación para ejecutar las acciones que realizará el brazo robótico Tinkerkit Braccio. Debes considerar que, si eliges otro modelo de dispositivo, los códigos serán los mismos, pero vas a tener que cambiar el nombre de las librerías.

Los pasos son: 

Obtén la librería del brazo robótico para Arduino

En este caso tomamos como ejemplo el hardware Braccio, por lo que te mostraremos los códigos que debes ingresar en el IDE de Arduino:

/ *

Comandos creados en este proyecto:

"/ arduino / custom / base / value: 80" -> Mueve la base del Brazo robótico a 80 grados

"/ arduino / custom / shoulder / value: 150" -> Mueve el hombro del Brazo robótico a 150 grados

"/ arduino / custom / elbow / value: 45" -> Mueve el codo del Brazo robótico a 45 grados

"/ arduino / custom / wristv / value: 10" -> Mueve la muñeca del Brazo robótico a 10 grados

"/ arduino / custom / wristr / value: 120" -> Mueve la muñeca del Brazo robótico a 120 grados

"/ arduino / custom / gripper / value: 73" -> Cerrar la pinza

"/ arduino / custom / ledon" -> Enciende el LED 13

"/ arduino / custom / ledoff" -> Apague el LED 13

"/ arduino / custom / servo: 3 / value: 73" -> Mueve el servo al pin 3 a 73 grados

"/ arduino / custom / sayAdios" -> Ejecute la función sayAdios (). Los Brazo robótico dicen "Adios" con la pinza

"/ arduino / custom / takesponge" -> Ejecuta la función takeponge (). El Brazo robótico lleva la esponja grande que puedes encontrar en su caja.

"/ arduino / custom / showsponge" -> Ejecuta la función showsponge (). El Brazo robótico muestra la esponja al usuario

"/ arduino / custom / throwsponge" -> Ejecuta la función throwsponge (). El Brazo robótico tira la esponja

/

# incluye < Wire.h >

# incluir < ArduinoWiFi.h >

# incluye < Servo.h >

# incluye < Braccio.h >

// Valor inicial para cada motor

int m1 = 0 ;

int m2 = 45 ;

int m3 = 180 ;

int m4 = 180 ;

int m5 = 90 ;

int m6 = 0 ;

booleano moveBraccio = falso ;

Base servo;

Hombro servo;

Codo servo;

Servo wrist_rot;

Servo wrist_ver;

Pinza servo;

configuración vacía () {

// Inicialización de Brazo robótico

comenzar ();

// Inicialización del Uno WiFi

comenzar ();

println ( "El servidor REST está activo " );

}

bucle vacío () {

// Espere hasta que la placa de Arduino reciba los comandos HTTP

mientras (Wifi. disponible ()) {

proceso (Wifi);

}

retraso ( 50 );

}

/ * *

Analiza un comando como: / arduino / custom / base / value: 45

Comando @param: el mensaje a analizar

@param type: la clave para analizar

@return el valor de la clave

/

int parseCommand (comando de cadena, tipo de cadena) {

int typeIndex = comando. indexOf (tipo);

int dotsIndex = comando. indexOf ( ' : ' , typeIndex + type. length ());

int idxtmp = dotsIndex + 4 ;

if ((dotsIndex + 4 )> comando. longitud ()) idxtmp = comando. longitud ();

String tmp = comando. subcadena (dotsIndex + 1 , idxtmp);

return tmp. toInt ();

}

/ * *

Procesa datos del protocolo HTTP

/

proceso nulo (cliente WifiData) {

// lee el comando

Comando de cadena = cliente. readString ();

toUpperCase ();

if (comando. indexOf ( " PERSONALIZADO " ) == - 1 ) {

println ( " Comando no válido: " + comando + " " );

volver ;

}

// El mensaje del remitente

Mensaje de cadena = comando. subcadena ( 16 );

// client.println (mensaje); //Depurar

/ *

Para cada mensaje, ejecute el comando adecuado

/

if (mensaje == " LEDON " ) {

// Enciende el Led 13

escritura digital ( 13 , ALTA);

// Devolver el mensaje al remitente (por ejemplo: el navegador)

println ( " alerta ('Led D13 ENCENDIDO'); " );

}

else if (mensaje == " LEDOFF " ) {

digitalWrite ( 13 , BAJO);

println ( " alerta ('Led D13 APAGADO'); " );

}

// Este comando le permite mover un servomotor deseado dando el

// Pin PWM donde está conectado

else if (mensaje. startsWith ( " SERVO " )) {

// Analizar el mensaje para recuperar cuál es el servo a mover

int servo = parseCommand (mensaje, " SERVO " );

// Analizar el mensaje para recuperar cuál es el valor del servo

int valor = parseCommand (mensaje, " VALOR " );

println ( " Mensaje: " + Cadena (mensaje) + " SERVO: " + Cadena (servo) + " " + Cadena (valor));

moveBraccio = verdadero ;

}

// Mando para la base del Brazo robótico (M1)

else if (mensaje. startsWith ( " BASE " )) {

m1 = parseCommand (mensaje, " VALOR " );

moveBraccio = verdadero ;

println ( " BASE: " + Cadena (m1));

}

// Mando para el hombro del Brazo robótico (M2)

else if (mensaje. startsWith ( " HOMBRO " )) {

m2 = parseCommand (mensaje, " VALOR " );

moveBraccio = verdadero ;

println ( " HOMBRO: " + Cadena (m2));

}

// Mando para el codo del Brazo robótico (M3)

else if (mensaje. startsWith ( " CODO " )) {

m3 = parseCommand (mensaje, " VALOR " );

moveBraccio = verdadero ;

println ( " CODO: " + Cadena (m3));

}

// Mando a la muñeca del Brazo robótico para moverlo hacia arriba y hacia abajo (M4)

else if (mensaje. startsWith ( " WRISTV " )) {

m4 = parseCommand (mensaje, " VALOR " );

moveBraccio = verdadero ;

println ( " WRISTV: " + Cadena (m4));

}

// Mando a la muñeca del Brazo robótico para rotarlo (M5)

else if (mensaje. startsWith ( " WRISTR " )) {

m5 = parseCommand (mensaje, " VALOR " );

moveBraccio = verdadero ;

println ( " WRISTR: " + Cadena (m5));

}

// Mando a la PINZA del Brazo robótico para abrirla y cerrarla (M6)

otra cosa si (mensaje. startsWith ( " PINZA " )) {

m6 = parseCommand (mensaje, " VALOR " );

moveBraccio = verdadero ;

println ( " PINZA : " + Cadena (m6));

}

// Comando para decir "Adiós"

else if (mensaje. startsWith ( " SAYADIOS " )) {

sayAdios ();

println ( " SAYADIOS: " + Cadena (m6));

}

// Comando para tomar la esponja

else if (mensaje. startsWith ( " TAKESPONGE " )) {

takeponge ();

println ( " TAKESPONGE: " + String (m6));

}

// Comando para mostrar la esponja o cualquier objeto

else if (mensaje. startsWith ( " SHOWSPONGE " )) {

showponge ();

println ( " SHOWSPONGE: " + Cadena (m6));

}

// Mando para tirar la esponja

else if (mensaje. startsWith ( " THROWSPONGE " )) {

lanzar esponja ();

println ( " THROWSPONGE: " + String (m6));

}

demás

println ( " error de comando: " + mensaje);

// si la bandera moveBraccio es verdadera, dispara el movimiento

if (moveBraccio) {

// cliente.println ("moveBraccio");

ServoMovimiento ( 20 , m1, m2, m3, m4, m5, m6);

moveBraccio = falso ;

}

flush ();

}

/ * *

El Brazo robótico Decir 'Adios' con el GRIPPER

/

void sayAdios () {

ServoMovimiento ( 20 , 90 ,   0 , 180 , 160 ,   0 ,   15 );

para ( int i = 0 ; i < 5 ; i ++) {

ServoMovimiento ( 10 , 90 ,   0 , 180 , 160 ,   0 ,   15 );

retraso ( 500 );

ServoMovimiento ( 10 , 90 ,   0 ,    180 ,    160 ,   0 ,    73 );

retraso ( 500 );

}

}

/ * *

Brazo robótico toma la esponja o cualquier objeto

/

void takeponge () {

// posición inicial

// (retardo de paso M1, M2, M3, M4, M5, M6);

ServoMovimiento ( 20 , 0 ,   45 , 180 , 180 ,   90 ,   0 );

// Muevo el brazo hacia la esponja

ServoMovimiento ( 20 , 0 ,   90 , 180 , 180 ,   90 ,    0 );

// el PINZA toma la esponja

ServoMovimiento ( 20 ,     0 ,   90 , 180 , 180 ,   90 ,   60 );

// sube la esponja

ServoMovimiento ( 20 , 0 ,    45 , 180 ,   45 ,   0 , 60 );

}

/ * *

Brazo robótico muestra el objeto al usuario

/

showponge vacío () {

para ( int i = 0 ; i < 2 ; i ++) {

// (retardo de paso M1, M2, M3, M4, M5, M6);

ServoMovimiento ( 10 , 0 ,    45 , 180 ,   45 ,   180 , 60 );

ServoMovimiento ( 10 , 0 ,    45 , 180 ,   45 ,   0 , 60 );

}

}

/ * *

Brazo robótico tira la esponja o cualquier objeto

/

void throwsponge () {

// (retardo de paso M1, M2, M3, M4, M5, M6);

ServoMovimiento ( 20 , 0 ,    45 , 90 ,   45 ,   90 , 60 );

ServoMovimiento ( 5 , 0 ,    45 , 135 ,   90 ,   90 , 60 );

ServoMovimiento ( 5 , 0 ,    90 , 150 ,   90 ,   90 , 0 );

}

Agrega más servos a tu proyecto

Si lo deseas podrás incorporar más motores para que el brazo robótico tenga más movimientos.

Para ello deberás ingresar en el programa los siguientes códigos por cada servo que añadas:

/*

Llamaremos servo1 al primer motor que puedes agregar

servo2 al segundo motor que añadas al brazo robótico

y así indefinidamente

*/

#include

Servo servo1;

Servo servo2;

int x_key = A1;

int y_key = A0;

int x_pos;

int y_pos;

int servo1_pin = 8;

int servo2_pin = 9;

int initial_position = 90;

int initial_position1 = 90;

void setup ( ) {

begin (9600) ;

attach (servo1_pin ) ;

attach (servo2_pin ) ;

write (initial_position);

write (initial_position1);

pinMode (x_key, INPUT) ;

pinMode (y_key, INPUT) ;

}

void loop ( ) {

x_pos = analogRead (x_key) ;

y_pos = analogRead (y_key) ;

if (x_pos < 300){

if (initial_position < 10) { } else{ initial_position = initial_position - 20; servo1.write ( initial_position ) ; delay (100) ; } } if (x_pos > 700){

if (initial_position > 180)

{

}

else{

initial_position = initial_position + 20;

write ( initial_position ) ;

delay (100) ;

}

}

if (y_pos < 300){

if (initial_position1 < 10) { } else{ initial_position1 = initial_position1 - 20; servo2.write ( initial_position1 ) ; delay (100) ; } } if (y_pos > 700){

if (initial_position1 > 180)

{

}

else{

initial_position1 = initial_position1 + 20;

write ( initial_position1 ) ;

delay (100) ;

}

}

}

Programa el módulo de bluetooth HC-05

Terminar con la programación, necesitarás incluir las acciones que deberá realizar el dispositivo electrónico para que tenga un joystick funcional.

Las instrucciones que tendrás que escribir son:

#include <SoftwareSerial.h>

SoftwareSerial BT1(10, 11); // RX | TX

void setup()

{ pinMode(8, OUTPUT); // Al poner en HIGH se fuerza el modo AT

pinMode(9, OUTPUT); // Este pin no es muy usado, por lo que podrás elegir otro

digitalWrite(9, HIGH);

delay (500) ; // Espera antes de encender el módulo

begin(9600);

println("Levantando el módulo HC-06");

digitalWrite (8, HIGH); // Enciende el modulo

println("Esperando comandos AT:");

begin(57600);

}

void loop()

{ if (BT1.available())

write(BT1.read());

if (Serial.available())

write(Serial.read());

}

Lista de los mejores kits de Arduino para hacer robótica que debes conocer

Los mejores kits con materiales para construir en Arduino tu primer brazo robótico los encontrarás a continuación:

Sunfounder brazo robótico de 4-Axis Servo Control - Rotación de 180°

Este kit lo podrás conseguir por alrededor de 70 €. Incluye una pinza que puede girar hasta 260° con una abertura máxima de 9 centímetros, siendo su brazo flexible gracias a los 4 motores de corriente continua que presenta. También se incluye en este kit 4 potenciómetros para ejecutar las interrupciones, un cable USB para realizar la programación y un juego de placa estructural. Debes tener presente que el Arduino UNO no está incluido en el kit, por lo que lo tendrás que comprar por aparte.

KeyEstudio Kit de robótica para Arduino

Con este grupo de materiales vas a poder armar tu primer brazo robótico de una manera muy sencilla. Incluye una placa Arduino UNO R3, 1 joystick de 2 módulos, paneles acrílicos, 4 servos de 180° de amplitud, cables, tornillos y 1 destornillador Philip. Su precio oscila los 50 € en las mejores tiendas electrónicas e incluye un manual en español.

Kit Adeept 5-DOF

La placa Arduino UNO que trae este kit te permitirá crear un brazo electrónico para coger cosas que no sean tan pesadas. Es ideal para los principiantes, ya que incluye un manual de 0 a 100 completamente en español. Vas a encontrar en este kit una pantalla OLED de 2,5 centímetros, 6 servos MG90S, tapas acrílicas, un soporte y un conjunto de cables y tornillos. Su coste es alrededor de 105 €.

Los mejores proyectos Arduino sobre robótica que debes conocer para practicar

Mira los siguientes proyectos que puedes realizar con los conocimientos que acabas de adquirir:

Brazo robótico desde Android

Con este proyecto podrás crear un dispositivo electrónico que te permita mover el robot por medio de dos motores. Lo vas a controlar desde tu móvil Android a través de bluetooth. Vas a necesitar una placa Arduino Mega 2560, un brazo robótico con movimientos en el codo de 270°, en la muñeca de 120° y en la base de 180°. Podrás elegir, por ejemplo, el modelo OWI 535.

También deberás conseguir un módulo para bluetooth HC-05, dos motores de tipo DC, conductores para motor L293D, una batería de 9v y un kit de cables para la conexión. Cuando tengas todo listo, vas a tener que conectar el motor izquierdo a los pines 1 y 2, después tendrás que unir la rueda del motor derecho a las entradas 4 y 5, a continuación; vas a tener que conectar el pasador 6 y 7 al servo de la mano y, por último; la junta 2 y 3 del motor con los pines 8 - 9 y 10 - 11 respectivamente.

Cuando tengas unidos estos elementos vas a tener que ensamblar las juntas 4 y 5 en los pines 12, 13, 14 y 15. El tx de la placa irá conectado con el rx del módulo de bluetooth, mientras que el tx del del HC-05 al rx del Arduino. Por último, deberás conectar el puerto vcc del HC-05 a la entrada de 5v de la placa y la tierra de ambas placas.

Una vez que tengas todo listo, vas a tener que entrar al IDE de Arduino e ingresar estas secuencias de programación: 

int inByte ;

configuración vacía ()

{

Serial . comenzar ( 9600 );

pinMode ( 2 , SALIDA );

pinMode ( 3 , SALIDA );

pinMode ( 4 , SALIDA );

pinMode ( 5 , SALIDA );

pinMode ( 6 , SALIDA );

pinMode ( 7 , SALIDA );

pinMode ( 8 , SALIDA );

pinMode ( 9 , SALIDA );

pinMode ( 10 , SALIDA );

pinMode ( 11 , SALIDA );

pinMode ( 12 , SALIDA );

pinMode ( 13 , SALIDA );

pinMode ( 14 , SALIDA );

pinMode ( 15 , SALIDA );

}

bucle vacío ()

{

si ( Serie . disponible ()  >  0 )

{

inByte =  Serie . leer ();

interruptor ( inByte )

{

caso '1' :

digitalWrite ( 2 , BAJO );

escritura digital ( 3 , ALTA );

digitalWrite ( 4 , BAJO );

escritura digital ( 5 , ALTA );

Serial . println ( "FRENTE" );

romper ;

caso '2' :

escritura digital ( 2 , ALTA );

digitalWrite ( 3 , BAJO );

escritura digital ( 4 , ALTA );

digitalWrite ( 5 , BAJO );

Serial . println ( "ATRÁS" );

romper ;

caso '3' :

digitalWrite ( 2 , BAJO );

digitalWrite ( 3 , BAJO );

digitalWrite ( 4 , BAJO );

escritura digital ( 5 , ALTA );

Serial . println ( "IZQUIERDA" );

romper ;

caso '4' :

digitalWrite ( 2 , BAJO );

escritura digital ( 3 , ALTA );

digitalWrite ( 4 , BAJO );

digitalWrite ( 5 , BAJO );

Serial . println ( "DERECHA" );

romper ;

caso '5' :

digitalWrite ( 2 , BAJO );

digitalWrite ( 3 , BAJO );

digitalWrite ( 4 , BAJO );

digitalWrite ( 5 , BAJO );

Serial . println ( "DETENER" );

romper ;

caso 'A' :

digitalWrite ( 6 , BAJO );

escritura digital ( 7 , ALTA );

Serial . println ( "RELOJ DE JUNTA 1" );

retraso ( 200 );

escritura digital( 6 , BAJO );

escritura digital ( 7 , BAJO );

romper ;

caso 'B' :

escritura digital ( 6 , ALTA  );

escritura digital ( 7, BAJO );

Serial .println ( "JUNTA 1 ANTICBLOQUEO" );

demora( 200 );

escritura digital ( 6, BAJO );

escritura digital ( 7, BAJO );

romper ;

caso 'C' :

digitalWrite ( 8 , BAJO );

escritura digital ( 9 , ALTA );

Serial . println ( "RELOJ DE JUNTA 2" );

retraso ( 200 );

digitalWrite ( 8 , BAJO );

digitalWrite ( 9 , BAJO );

romper ;

caso 'D' :

escritura digital ( 8 , ALTA );

digitalWrite ( 9 , BAJO );

Serial . println ( "JUNTA 2 ANTICBLOQUEO" );

retraso ( 200 );

digitalWrite ( 8 , BAJO );

digitalWrite ( 9 , BAJO );

romper ;

caso 'E' :

escritura digital ( 10 , BAJO );

escritura digital ( 11 , ALTA );

Serial . println ( "RELOJ DE JUNTA 3" );

retraso ( 200);

escritura digital ( 10 , BAJA);

escritura digital ( 11 , BAJA );

rotura;

caso 'F' :

escritura digital ( 10 , ALTA );

digitalWrite ( 11 , BAJO );

Serial . println ( "JUNTA 3 ANTICBLOQUEO" );

retraso ( 200 );

digitalWrite ( 10 , BAJO );

digitalWrite ( 11 , BAJO );

romper ;

caso 'G' :

digitalWrite ( 12 , BAJO );

escritura digital ( 13 , ALTA );

Serial . println ( "RELOJ COMÚN 4" );

retraso ( 200);

escritura digital ( 12 , BAJA);

escritura digital ( 13 , BAJA );

rotura;

caso 'H' :

escritura digital ( 12 , ALTA );

escritura digital ( 13 , BAJA );

Serial . println ( "JUNTA 4 ANTICBLOQUEO" );

retraso ( 200 );

digitalWrite ( 12 , BAJO );

digitalWrite ( 13 , BAJO );

romper ;

caso 'I' :

digitalWrite ( 14 , BAJO );

escritura digital ( 15 , ALTA );

Serial . println ( "RELOJ COMÚN 5" );

retraso ( 200 );

digitalWrite ( 14 , BAJO );

digitalWrite ( 15 , BAJO );

romper ;

caso 'J' :

escritura digital ( 14 , ALTA );

digitalWrite ( 15 , BAJO );

Serial . println ( "JUNTA 5 ANTICBLOQUEO" );

retraso ( 200 );

digitalWrite ( 14 , BAJO );

digitalWrite ( 15 , BAJO );

romper ;

}

}

}

Dispositivo electrónico con cuatro servos

Para este brazo robótico vas a tener que conseguir un Arduino Micro, 4 motores servos modelos Tower Pro MG996R, cables de puente genérico y un joystick analógico. Cuando realices las conexiones teniendo en cuenta la imagen de ensamble vas a tener que entrar al entorno de programación.

Dentro de IDE escribe estas acciones:

#include <Servo.h>

Servo myservo1 ;

Servo myservo2 ;

Servo myservo3 ;

Servo myservo4 ;

Servo myservo5 ;

int potpin  =  0 ;

int potpin1  =  A1 ;

int potpin2  =  A2 ;

int potpin3  =  A3 ;

int potpin4  =  A4 ;

int val ;

int val1 ;

int val2 ;

int val3 ;

int val4 ;

configuración vacía () {

myservo1 . adjuntar ( 9 );

myservo2 . adjuntar ( 10 );

myservo3 . adjuntar ( 11 );

myservo4 . adjuntar ( 12 );

myservo5 . adjuntar ( 8 );

}

bucle vacío () {

val =  analogRead ( potpin );

val1 =  analogRead ( potpin1 );

val2 =  analogRead ( potpin2 );

val3 =  analogRead ( potpin3 );

val4 =  analogRead ( potpin4 );

val =  mapa ( val ,  0 ,  1023 ,  0 ,  60 );

val1 =  mapa ( val1 ,  0 ,  1023 ,  0 ,  100 );

val2 =  mapa ( val2 ,  0 ,  1023 ,  0 ,  100 );

val3 =  mapa ( val3 ,  0 ,  1023 ,  0 ,  100 );

val4 =  mapa ( val4 ,  0 ,  1023 ,  0 ,  100 );

myservo1 . escribir ( val );

myservo2 . escribir ( val1 );

myservo3 . escribir ( val2 );

myservo4 . escribir ( val3 );

myservo5 . escribir ( val4 );

retraso ( 25 );

}

Agarre con brazo robótico

Este es un ejemplo muy simple de llevar adelante. Se trata de un brazo electrónico construido con una placa Arduino UNO que puede coger algunos objetos con comandos manuales. Dispone de cuatro servomotores SG90, una batería genérica de 9v, un interruptor de tipo palanca encendido-encendido, una protoboard genérica, cables puentes y un kit de conectores genéricos. El diagrama de conexiones te ayudará a ensamblar todos los componentes.

Los códigos de programación que harán que el brazo robótico se mueva son:

#include <Servo.h>

Servo motor1 ;

Servo motor2 ;

Servo motor3 ;

Servo motor4 ;

valor int ;

int grado ;

configuración vacía () {

attach ( 3 ) ;

attach ( 5 ) ;

attach ( 6 ) ;

attach ( 10 ) ;

}

bucle vacío () {

valor = analogRead ( A0 ) ;

grado = mapa ( valor, 0 , 1023,0,180 ) ;

write ( grado ) ;

valor = analogRead ( A1 ) ;

grado = mapa ( valor, 0 , 1023,80,150 ) ; // Con esta pieza, el valor del ángulo del servomotor debe ser diferente del estándar 0 -180 ya que la pinza podría tocar el suelo y desequilibrar el brazo. El ángulo limitado se define entre 80 -150°.

write ( grado ) ;

valor = analogRead ( A2 ) ;

grado = mapa ( valor, 0 , 1023,0,180 ) ;

write ( grado ) ;

valor = analogRead ( A4 ) ;

grado = mapa ( valor, 0 , 1023,0,180 ) ;

write ( grado ) ;

}