UNIVERSIDAD POLITECNICA DE TLAXCALA
PROGRAMACION DE ROBOTS
INDUSTRIALES
EMMANUEL DOMINGUEZ SARMIENTO
PROYECTO: BRAZO ROBOTICO
INTEGRANTES:
ALAN YAHIR MUÑOZ CRUZ
CESAR ZARATE HERNANDEZ
YAEL PEREZ PEREZ
ARMANDO CUAMATZI VAZQUEZ
ERIK SAUCEDO ROMERO
7ºH
UNIVERSIDAD POLITECNICA DE TLAXCALA
INTRODUCCION.
Los brazos robóticos antropomórficos representan una de las configuraciones más
versátiles y populares en robótica debido a su capacidad para imitar la movilidad del
brazo humano. Este proyecto aborda el diseño, control y programación de un brazo
robótico de tipo antropomórfico con 4 grados de libertad (4-DOF), capaz de escribir
un nombre en una superficie plana.
El funcionamiento del brazo robótico se basa en la aplicación de técnicas de
cinemática directa e inversa. La cinemática directa permite calcular la posición y
orientación del efector final (en este caso, un lápiz o marcador) en el espacio
cartesiano, a partir de los ángulos de sus articulaciones. En contraste, la cinemática
inversa se utiliza para determinar los valores de las articulaciones necesarios para
que el efector alcance una posición y orientación deseadas en el espacio de trabajo.
El diseño antropomórfico de 4 grados de libertad proporciona la flexibilidad
suficiente para cubrir una amplia gama de movimientos necesarios para escribir
caracteres con precisión. Las tareas clave del proyecto incluyen:
Modelado cinemático del brazo robótico, considerando las características
geométricas y las restricciones físicas.
Planificación de trayectorias, diseñando los movimientos necesarios para trazar
cada letra del nombre de forma suave y precisa.
Implementación del control, asegurando que el brazo siga las trayectorias
planificadas mediante la resolución de ecuaciones cinemáticas inversas.
A través de este proyecto, se exploran conceptos fundamentales de la robótica,
como la transformación de sistemas de referencia, la resolución de ecuaciones no
lineales y el control de movimiento. El resultado final será un brazo robótico capaz
de realizar una tarea compleja que combina precisión, coordinación y autonomía.
UNIVERSIDAD POLITECNICA DE TLAXCALA
DESARROLLO
Se eligió un diseño de internet de un robot antropomórfico y se hizo la impresión en
3d, obteniendo estos resultados.
Teniendo las piezas se procedió hacer el engrasado de los planetarios y colocación
de los balines para un mejor desplazamiento.
Para después unirlos a los motores nema para mejor torque.
UNIVERSIDAD POLITECNICA DE TLAXCALA
Después lo que se hizo fue el ensamblaje de las piezas.
Para hacer el soporte del marcador se hizo la impresión en 3d.
Obtuvimos este resultado.
UNIVERSIDAD POLITECNICA DE TLAXCALA
Para las operaciones ocupamos cinemática inversa
En la cinemática inversa se realiza un análisis geométrico donde se buscan
ecuaciones que definan a los ángulos necesarios para alcanzar la posición
cartesiana deseada para el robot.
UNIVERSIDAD POLITECNICA DE TLAXCALA
Una vez teniendo estas ecuaciones se procede a crear un programa en MATLAB
donde se puedan escribir estas ecuaciones y así calcular los ángulos resultantes en
base a una serie de posiciones que se le darán al robot, estas posiciones en
conjunto forman trayectorias que juntas escriben un nombre, en este caso ALAN.
Primero para obtener la serie de puntos por los cuales el robot debe pasar usamos
GEOGEBRA para trazar los segmentos dentro del área de trabajo del robot tal como
se muestra a continuación:
UNIVERSIDAD POLITECNICA DE TLAXCALA
Una vez teniendo estos puntos pasamos a MATLAB cada coordenada cartesiana
de cada vértice formado por los segmentos de la siguiente forma:
clear all; clc;
% Configurar comunicación serie con Arduino
arduinoSerial = serialport('COM7', 9600); % Reemplaza 'COM7' con tu puerto
correcto
pause(2); % Esperar a que la conexión se estabilice
% Parámetros del robot
L1 = 8.5; % Longitud del primer segmento
L2 = 18.5; % Longitud del segundo segmento
L3 = 16; % Longitud del tercer segmento
% Ángulos iniciales (todos los motores en 90 grados)
initialAngleX = 0;
initialAngleY = 90;
initialAngleZ = 90;
% Relación de engranaje 3:1
gearRatio = 3;
% Puntos para cada letra con transiciones de altura
% Letra A
xA = [linspace(-12, -8, 50), linspace(-8, -4, 50), linspace(-4, -10, 3), ...
linspace(-10, -6, 30), linspace(-6, -2, 3)];
yA = [linspace(18, 26, 50), linspace(26, 18, 50), linspace(18, 22, 3), ...
linspace(22, 22, 30), linspace(22, 26, 3)];
zA = [zeros(1, 50), zeros(1, 50), ones(1, 3), ...
zeros(1, 30), ones(1, 3)];
% Letra L
xL = [linspace(-2, -2, 50), linspace(-2, 4, 50), linspace(4, 6, 3)];
yL = [linspace(26, 18, 50), linspace(18, 18, 50), linspace(18, 18, 3)];
zL = [zeros(1, 50), zeros(1, 50), ones(1, 3)];
% Letra M
xM = [linspace(6, 10, 50), linspace(10, 14, 50), linspace(14, 8, 3), ...
linspace(8, 12, 30), linspace(12, 16, 3)];
yM = [linspace(18, 26, 50), linspace(26, 18, 50), linspace(18, 22, 3), ...
linspace(22, 22, 30), linspace(22, 18, 3)];
zM = [zeros(1, 50), zeros(1, 50), ones(1, 3), ...
zeros(1, 30), ones(1, 3)];
% Letra N
xN = [linspace(16, 16, 50), linspace(16, 22, 50), linspace(22, 22, 50)];
yN = [linspace(18, 26, 50), linspace(26, 18, 50), linspace(18, 26, 50)];
zN = [zeros(1, 50), zeros(1, 50), zeros(1, 50)];
% Concatenar todas las trayectorias
XT = [xA, xL, xM, xN];
YT = [yA, yL, yM, yN];
ZT = [zA, zL, zM, zN];
UNIVERSIDAD POLITECNICA DE TLAXCALA
% Resolver ángulos y enviar a Arduino
for i = 1:length(XT)
xc = XT(i);
yc = YT(i);
zc = ZT(i);
% Calcular ángulos mediante cinemática inversa
D = (xc^2 + yc^2 + (zc - L1)^2 - L2^2 - L3^2) / (2 * L2 * L3);
if abs(D) > 1
warning('El punto (%f, %f, %f) está fuera del alcance del robot.', xc,
yc, zc);
continue; % Saltar al siguiente punto si está fuera del alcance
end
theta1 = atan2(yc, xc);
theta3 = atan2(-sqrt(1 - D^2), D); % Solución física adecuada
theta2 = atan2(zc - L1, sqrt(xc^2 + yc^2)) - atan2(L3 * sin(theta3), L2 + L3
* cos(theta3));
% Ajustar los ángulos para que empiecen desde 90 grados
theta1 = theta1 + deg2rad(initialAngleX); % Ajuste para motor X
theta2 = theta2 + deg2rad(initialAngleY); % Ajuste para motor Y
theta3 = theta3 + deg2rad(initialAngleZ); % Ajuste para motor Z
% Ajustar los ángulos por la relación de engranaje 3:1
theta1 = theta1 * gearRatio; % Aplicar la relación de engranaje
theta2 = theta2 * gearRatio; % Aplicar la relación de engranaje
theta3 = theta3 * gearRatio; % Aplicar la relación de engranaje
% Convertir ángulos a grados
angle1_deg = rad2deg(theta1);
angle2_deg = rad2deg(theta2);
angle3_deg = rad2deg(theta3);
% Enviar ángulos al Arduino en formato "X<valor>,Y<valor>,Z<valor>"
dataToSend = sprintf('X%.2f,Y%.2f,Z%.2f\n', angle1_deg, angle2_deg,
angle3_deg);
write(arduinoSerial, dataToSend, 'string');
pause(0.1); % Ajustar tiempo de espera según velocidad deseada
end
% Cerrar conexión al finalizar
clear arduinoSerial;
disp('Cálculo y envío de ángulos completados.');
Dentro del código también establecemos una conexión con el controlador que hará
posible todo esto, Arduino UNO que esta conectado al puerto COM7 y usando la
función linspace de MATLAB se logra crear un recorrido entre puntos preciso y
ajustable al numero de puntos que deseemos, después estas posiciones se dirigen
a las ecuaciones de cinemática inversa que nos dan como resultado ángulos que
son enviados a través de comunicación serial hacia un segundo programa cargado
en Arduino IDE que es el siguiente:
UNIVERSIDAD POLITECNICA DE TLAXCALA
const int StepX = 2; // Pin STEP para el eje X (θ₁)
const int DirX = 5; // Pin DIR para el eje X (θ₁)
const int StepY = 3; // Pin STEP para el eje Y (θ₂)
const int DirY = 6; // Pin DIR para el eje Y (θ₂)
const int StepZ = 4; // Pin STEP para el eje Z (θ₃)
const int DirZ = 7; // Pin DIR para el eje Z (θ₃)
const int EnablePin = 8; // Pin ENABLE (EN) para habilitar/deshabilitar los
drivers
const int pasosPorRevolucion = 200;
const int microsteps = 8; // Resolución ajustada para mayor precisión
const int pasosTotales = pasosPorRevolucion * microsteps;
const float relacionEngranajes = 3.0; // Relación de engranajes (1 vuelta
del efector = 3 vueltas del motor)
float anguloActualX = 0; // Ángulo inicial del motor X (θ₁)
float anguloActualY = 90; // Ángulo inicial del motor Y (θ₂)
float anguloActualZ = 90; // Ángulo inicial del motor Z (θ₃)
void setup() {
pinMode(StepX, OUTPUT);
pinMode(DirX, OUTPUT);
pinMode(StepY, OUTPUT);
pinMode(DirY, OUTPUT);
pinMode(StepZ, OUTPUT);
pinMode(DirZ, OUTPUT);
pinMode(EnablePin, OUTPUT);
digitalWrite(EnablePin, LOW); // Mantener los motores habilitados
[Link](9600);
[Link]("Esperando ángulos en formato:
X<valor>,Y<valor>,Z<valor>");
}
void loop() {
if ([Link]()) {
String input = [Link]('\n'); // Leer cadena hasta salto
de línea
[Link](); // Elimina espacios en blanco al inicio y final
UNIVERSIDAD POLITECNICA DE TLAXCALA
// Extraer ángulos X, Y y Z de la cadena
int posX = [Link]('X');
int posY = [Link]('Y');
int posZ = [Link]('Z');
if (posX != -1 && posY != -1 && posZ != -1) {
int anguloX = [Link](posX + 1, posY).toInt();
int anguloY = [Link](posY + 1, posZ).toInt();
int anguloZ = [Link](posZ + 1).toInt();
// Mover los tres motores
moveMotor(anguloX, StepX, DirX, anguloActualX);
moveMotor(anguloY, StepY, DirY, anguloActualY);
moveMotor(anguloZ, StepZ, DirZ, anguloActualZ);
[Link]("Motor X (θ₁) movido a: ");
[Link](anguloActualX);
[Link](" grados.");
[Link]("Motor Y (θ₂) movido a: ");
[Link](anguloActualY);
[Link](" grados.");
[Link]("Motor Z (θ₃) movido a: ");
[Link](anguloActualZ);
[Link](" grados.");
} else {
[Link]("Error en el formato. Use
X<valor>,Y<valor>,Z<valor>.");
}
}
}
void moveMotor(int anguloObjetivo, int stepPin, int dirPin, float
&anguloActual) {
// Ajustar el ángulo objetivo según la relación de engranajes
float anguloMotor = anguloObjetivo * relacionEngranajes;
// Calcular rotaciones mínima (horaria o antihoraria)
float rotacionHorario = fmod((anguloMotor - anguloActual + 360 *
relacionEngranajes), 360 * relacionEngranajes);
float rotacionAntihorario = fmod((anguloActual - anguloMotor + 360 *
relacionEngranajes), 360 * relacionEngranajes);
float rotacion = (rotacionHorario <= rotacionAntihorario) ?
rotacionHorario : -rotacionAntihorario;
UNIVERSIDAD POLITECNICA DE TLAXCALA
int pasos = map(abs(rotacion), 0, 360 * relacionEngranajes, 0,
pasosTotales);
// Configurar dirección del motor
if (rotacion > 0) {
digitalWrite(dirPin, HIGH); // Sentido horario
} else {
digitalWrite(dirPin, LOW); // Sentido antihorario
}
// Ejecutar movimiento
for (int i = 0; i < pasos; i++) {
digitalWrite(stepPin, HIGH);
delayMicroseconds(1000); // Ajustar velocidad del motor
digitalWrite(stepPin, LOW);
delayMicroseconds(1000);
}
// Actualizar ángulo actual
anguloActual = anguloMotor / relacionEngranajes;
}
Dentro de este código se reciben los ángulos procedentes de MATLAB y se envían
a los drivers que están montados en una CNC SHIELD que es la encargada de
mover a los motores a los ángulos establecidos.
RESULTADOS
UNIVERSIDAD POLITECNICA DE TLAXCALA
Como puede apreciarse en la imagen el brazo al no tener una base fija que sostenga
su peso realizo las trayectorias de una manera no tan correcta, sin embargo,
cumplió su objetivo parcialmente.
CONCLUSIONES
En conclusión podemos decir que la importancia en el manejo de estos mecanismos
es fundamental para llegar a trabajar posteriormente con equipos mas sofisticados
como robots KUKA, pues al entender en primer lugar a la manera en que un robot
funciona y como se llega hasta posiciones cartesianas exactas únicamente teniendo
algunas relaciones matemáticas es de suma importancia, es decir, primero es
necesario conocer a la parte teórica de estos mecanismos para posteriormente
poder manipularlos, además esta practica nos ayudo a visualizar la manera en como
realizar el control eléctrico de motores a pasos, que son ampliamente usados dentro
de la industria robótica.
