Arduino Robotic Arm

En este tutorial, diseñamos un brazo robótico Arduino Uno. Todo el brazo estará diseñado a
partir de algunos materiales de desecho y servos. Todo el proceso de construcción se ha
explicado en detalle a continuación. El brazo se ha construido con cartones y las piezas
individuales se han bloqueado para servomotores. Arduino Uno está programado para
controlar los servomotores. Los servos sirven como articulaciones del brazo robótico aquí.
Esta configuración también se ve como una grúa robótica o podemos convertirla en una
grúa mediante algunos ajustes sencillos. Este proyecto será de gran ayuda para los
principiantes que quieran aprender a desarrollar un Robot simple a bajo costo.

Este brazo robótico Arduino se puede controlar con cuatro potenciómetros conectados, cada
potenciómetro se usa para controlar cada servo. Puede mover estos servos girando las
macetas para recoger algún objeto, con algo de práctica puede recoger y mover fácilmente
el objeto de un lugar a otro. Hemos utilizado servos de bajo torque aquí, pero puede usar
servos más potentes para recoger objetos pesados. Todo el proceso ha quedado bien
demostrado en el video al final. También revise nuestro otro

Componentes requeridos:
 Arduino Uno
 Condensador de 1000uF (4 piezas)
 Condensador 100nF (4 piezas)
 Servo Motor (SG 90- cuatro piezas)
 Potencia 10K- Resistencia Variable (4 piezas)
 Fuente de alimentación (5v, preferiblemente dos)
Servo motor:
Primero hablamos un poco sobre Servo Motors. Los servomotores se usan excesivamente
cuando hay una necesidad de movimiento o posición precisa del eje. Estos no son
propuestos para aplicaciones de alta velocidad. Se proponen servomotores para baja
velocidad, par medio y aplicación de posición precisa. Entonces estos motores son mejores
para diseñar un brazo robótico.

Los servomotores están disponibles en diferentes formas y tamaños. Vamos a usar

servomotores pequeños, aquí usamos cuatro servos SG90. Un servomotor tendrá
principalmente cables, uno para el voltaje positivo, otro para el suelo y el último para el
ajuste de la posición. El cable ROJO está conectado a la alimentación, el cable Negro está
conectado a tierra y el cable AMARILLO está conectado a la señal. Siga este tutorial de
Control de Servomotor con Arduino para obtener más información al respecto. En Arduino
tenemos bibliotecas predefinidas para controlar el Servo, por lo que es muy fácil controlar
el servo, que aprenderá junto con este tutorial.

Construcción de brazo robótico:

Tome una superficie plana y estable, como una mesa o una tarjeta de cartón duro. A
continuación, coloque un servomotor en el medio y péguelo en su lugar. Asegúrese de que
el grado de rotación esté en el área presentada en la figura. Este servo actúa como la base
del brazo.

Coloque una pequeña pieza de cartón encima del primer servo y luego coloque el segundo
servo en esta pieza de cartón y péguela en su lugar. La rotación del servo debe coincidir con
el diagrama.
Tome algunas cartulinas y córtelas en piezas de 3cm x 11cm. Asegúrate de que la pieza no
esté ablandada. Corta un orificio rectangular en un extremo (deja 0.8 cm desde abajo) lo
suficiente para caber otro servo y en el otro extremo ajusta el servo engranaje firmemente
con tornillos o con pegamento. Luego coloque el tercer servo en el primer agujero.

Ahora corte otra pieza de cartón con las longitudes que se muestran en la figura a
continuación y pegue otro engranaje en la parte inferior de esta pieza.
Ahora pegue el cuarto y último servo en el borde de la segunda pieza como se muestra en la
figura.

Con esto, dos piezas juntas se ven como

Cuando adjuntemos esta configuración a la base, debería verse así:

Está casi terminado. Solo tenemos que hacer el gancho para agarrar y recoger el objeto
como una mano robótica. Para gancho, corte otras dos piezas de cartón de 1cmx7cm y
4cmx5cm. Pégueles juntos como se muestra en la figura y pegue el engranaje final en el
mismo borde.

Monta esta pieza en la parte superior y con esto hemos terminado de construir nuestro
brazo robótico.

Con esto, nuestro diseño de brazo robótico básico se completó y así es como
hemos construido nuestro brazo robótico de bajo costo. Ahora conecte el circuito
en la placa de prueba según el diagrama del circuito.
El voltaje en las resistencias variables no es completamente lineal; será ruidoso. Por lo
tanto, para filtrar este ruido, los condensadores se colocan a través de cada resistencia
como se muestra en la figura.

Ahora alimentaremos la tensión proporcionada por estas resistencias variables (voltaje

que representa el control de posición) en los canales ADC de Arduino. Vamos a usar
cuatro canales ADC de UNO de A0 a A3 para esto. Después de la inicialización de ADC,
tendremos un valor digital de los potes que representa la posición que necesita el usuario.
Tomaremos este valor y lo combinaremos con la posición del servo.

Arduino tiene seis canales de ADC. Hemos usado cuatro para nuestro brazo robótico. El
UNO ADC tiene una resolución de 10 bits, por lo que los valores enteros van de 0 a 1023
(2 ^ 10 = 1024 valores). Esto significa que mapeará los voltajes de entrada entre 0 y 5
voltios en valores enteros entre 0 y 1023. Por lo tanto, para cada (5/1024 = 4.9mV) por
unidad. Obtenga más información sobre cómo mapear los niveles de voltaje usando
canales ADC en Arduino aquí.

Ahora, para que UNO convierta la señal analógica en señal digital, necesitamos usar el
canal ADC de Arduino Uno, con la ayuda de las siguientes funciones:

Los canales Arduino ADC tienen un valor de referencia predeterminado de 5V. Esto
significa que podemos proporcionar un voltaje de entrada máximo de 5 V para la
conversión de ADC en cualquier canal de entrada. Como algunos sensores proporcionan
voltajes de 0-2.5 V, por lo que con una referencia de 5V, obtenemos menor precisión, por
lo que tenemos una instrucción que nos permite cambiar este valor de referencia. Entonces
para cambiar el valor de referencia tenemos "analogReference ();"

Como valor predeterminado, obtenemos la resolución máxima de ADC de la placa que es

de 10bits, esta resolución se puede cambiar utilizando las instrucciones
("analogReadResolution (bits);").

En nuestro circuito de mano robótico, hemos dejado esta tensión de referencia en el valor
predeterminado, de modo que podemos leer el valor del canal ADC llamando directamente
a la función "analogRead (pin);" aquí "pin" representa el pin donde conectamos la señal
analógica, digamos queremos leer "A0". El valor de ADC se puede almacenar en un entero
como int SENSORVALUE0 = analogRead (A0) ;.
Ahora hablemos del SERVO, el Arduino Uno tiene una función que nos permite controlar
la posición del servo simplemente dando el valor del grado. Digamos que si queremos que
el servo esté en 30, podemos representar directamente el valor en el programa. El archivo
de encabezado SERVO (Servo.h) se encarga de todos los cálculos de la relación de trabajo
internamente.

Aquí la primera declaración representa el archivo de encabezado para controlar el SERVO

MOTOR. La segunda declaración es nombrar el servo; lo dejamos como servo0 ya que
vamos a usar cuatro. El tercer estado indica dónde está conectado el pin de señal de servo;
esto debe ser un pin PWM. Aquí estamos usando PIN3 para el primer servo. La cuarta
instrucción da comandos para posicionar el servomotor en grados. Si se da 30, el
servomotor gira 30 grados.

Ahora, tenemos la posición servo SG90 de 0 a 180 y los valores ADC son de 0-1023.
Usaremos una función especial que empareja ambos valores automáticamente.

Esta afirmación mapea ambos valores automáticamente y almacena el resultado

en el entero 'servovalue0'. Así es como hemos controlado los Servos en nuestro
proyecto Robotic Arm usando Arduino. Verifique el código completo a
continuación.

Cómo operar el brazo robótico:

Hay cuatro potes provistos al usuario. Y girando estos cuatro potes, proporcionamos voltaje
variable en los canales ADC de UNO. Entonces los valores digitales de Arduino están bajo
el control del usuario. Estos valores digitales se asignan para ajustar la posición del
servomotor, por lo tanto, la posición del servo está en control del usuario y al rotar estos
Pots, el usuario puede mover las articulaciones del brazo robótico y puede recoger o agarrar
cualquier objeto.

#include <Servo.h>
Servo servo0;
Servo servo1;
Servo servo2;
Servo servo3;
int sensorvalue0;
int sensorvalue1;
int sensorvalue2;
int sensorvalue3;
void setup()
{
pinMode(A0,INPUT);
pinMode(3,OUTPUT);
servo0.attach(3);

pinMode(A1,INPUT);
pinMode(5,OUTPUT);
servo1.attach(5);

pinMode(A2,INPUT);
pinMode(6,OUTPUT);
servo2.attach(6);

pinMode(A3,INPUT);
pinMode(9,OUTPUT);
servo3.attach(9);
}
void loop()
{
sensorvalue0 = analogRead(A0);
sensorvalue0 = map(sensorvalue0, 0, 1023, 0, 180);
servo0.write(sensorvalue0);
sensorvalue1 = analogRead(A1);
sensorvalue1 = map(sensorvalue1, 0, 1023, 0, 180);
servo1.write(sensorvalue1);
sensorvalue2 = analogRead(A2);
sensorvalue2 = map(sensorvalue2, 0, 1023, 0, 180);
servo2.write(sensorvalue2);
sensorvalue3 = analogRead(A3);
sensorvalue3 = map(sensorvalue3, 0, 1023, 0, 180);
servo3.write(sensorvalue3);
}