1

ROBOTICA INDUSTRIAL
Informe: Mini proyecto Corte 2

David Ojeda COD: 92294 Camilo Ardila COD: 126595 Gipsy Salgado COD:96980
Julián Rojas COD: 98135 Miguel Lozano COD: 12285 Diego Godoy COD:132893

UNIVERSIDAD: ECCI
INTRUCTOR: Ubaldo García Zaragoza Área: Robótica.

RESUMEN

Este informe presenta un análisis detallado de un proyecto movimientos, la posibilidad de integrar sensores adicionales
enfocado en la construcción de un robot equipado con seis para corregir errores en tiempo real, y la optimización del
servomotores de 180 grados, los cuales se sincronizan código para aumentar la eficiencia computacional y reducir el
mediante un código en Python. Se exploran los métodos de consumo energético del sistema.
cinemática directa e inversa para permitir que los
servomotores se muevan de manera individual y logren ABSTRACT:
alcanzar cualquier punto en el plano, brindando flexibilidad y This report presents a detailed analysis of a project focused on
precisión en el control del robot. building a robot equipped with six 180-degree servo motors,
A lo largo del informe, se describen los procedimientos which are synchronized using Python code. Direct and reverse
implementados, incluyendo la configuración física y kinematics methods are explored to allow servo motors to
electrónica de los servomotores, la estructura mecánica del move individually and reach any point in the plane, providing
robot y el desarrollo del software para controlar los flexibility and precision in robot control.
movimientos. Se profundiza en los algoritmos de cinemática
directa, que permiten calcular las posiciones de los extremos Throughout the report, the procedures implemented are
del robot a partir de los ángulos de los servomotores, y de described, including the physical and electronic configuration
cinemática inversa, utilizada para determinar los ángulos of the servomotors, the mechanical structure of the robot and
necesarios para alcanzar una posición específica en el espacio. the development of the software to control the movements. It
El código en Python juega un papel central en la delves into the algorithms of direct kinematics, which allow
sincronización y control de los servomotores, aprovechando the calculation of the positions of the robot's ends from the
librerías como numpy y controladores de hardware para angles of the servomotors, and inverse kinematics, used to
implementar los cálculos cinemáticos en tiempo real. También determine the angles necessary to reach a specific position in
se discuten las técnicas de interpolación utilizadas para space.
suavizar los movimientos y asegurar que los desplazamientos Python code plays a central role in the synchronization and
entre puntos sean fluidos. control of servo motors, leveraging libraries such as numpy
Se detallan los resultados obtenidos tras implementar y probar and hardware controllers to implement kinematic calculations
el sistema, con ejemplos de movimientos controlados y la in real time. The interpolation techniques used to smooth
precisión lograda al alcanzar posiciones objetivo. Además, se movements and ensure that movements between points are
proporciona una interpretación crítica de las funciones y fluid are also discussed.
algoritmos utilizados, analizando la eficiencia del código, los
posibles errores de cálculo, y las limitaciones del sistema en The results obtained after implementing and testing the system
cuanto a la capacidad de los servomotores y la precisión del are detailed, with examples of controlled movements and the
modelo cinemático. precision achieved when reaching target positions. In addition,
Finalmente, el informe concluye con propuestas para futuras a critical interpretation of the functions and algorithms used is
mejoras, como la implementación de un control de provided, analyzing the efficiency of the code, possible
retroalimentación (PID) para aumentar la precisión de los calculation errors, and the limitations of the system in terms of
the capacity of the servomotors and the accuracy of the
kinematic model.
 2

Estructura del robot: El chasis y los eslabones donde se

Finally, the report concludes with proposals for future montarán los servomotores. La estructura puede ser de
improvements, such as the implementation of a feedback plástico, metal, o material impreso en 3D.
control (PID) to increase the accuracy of movements, the Soportes y tornillería: Para asegurar los servos a los eslabones
y al chasis del robot.
Eslabones del brazo robótico: Estos deben tener la longitud
INTRODUCCION adecuada para permitir que los servos realicen los
movimientos necesarios.
La robótica moderna permite la creación de sistemas Software y Herramientas:
complejos que pueden realizar tareas específicas en entornos • Python: El lenguaje de programación utilizado para el
variados. Este proyecto se centra en la implementación de control de los servomotores y el cálculo de
cinco servomotores de 180 grados en un robot, utilizando cinemática inversa.
cinemática directa e inversa para calcular las posiciones y • Librerías para Python: Librerías como RPi.GPIO o
movimientos necesarios. La correcta sincronización de los pigpio para el control de los servos y NumPy para los
servomotores es crucial para lograr un control preciso y cálculos matemáticos asociados con la cinemática.
eficiente del robot. • IDE o editor de texto: Un entorno de desarrollo
integrado como Thonny, VS Code o un editor de
3. Procedimiento texto para escribir y depurar el código en la
Raspberry Pi.
3.1 Construcción del Robot Herramientas de Montaje:
• Destornilladores y llaves: Para ensamblar la
El robot fue construido utilizando un chasis adecuado para estructura y fijar los servos al robot.
soportar los seis servomotores, asegurando que cada uno • Multímetro: Para medir voltajes y corrientes,
pudiera moverse libremente. Se implementaron conexiones asegurando que los servos estén
eléctricas y se configuró un microcontrolador para gestionar la correctamente conectados y alimentados.
comunicación entre los servomotores y el código en Python. Otros Materiales:
Cables USB: Para conectar la Raspberry Pi a un ordenador
1. Materiales para el Proyecto durante la fase de programación.
Cables de señal y alimentación: Para asegurar una correcta
En este proyecto se utilizará una Raspberry Pi como transmisión de datos y energía entre los servos y la Raspberry
controladora principal, junto con 5 servomotores: 2 Pi.
servomotores de 180 grados y 2 servomotores azules Prototipos o maquetas de prueba: En caso de querer realizar
convencionales. A continuación, se detallan los materiales simulaciones físicas antes de la construcción final.
necesarios considerando esta configuración específica. Resumen de Materiales:
Componentes Electrónicos: 5 servomotores (2 de 180 grados y 2 convencionales azules)
• 5 servomotores: Raspberry Pi
• 2 servomotores de 180 grados: Estos servos permiten Fuente de alimentación adecuada para 5 servos
rotaciones en un rango más amplio y son ideales para Tarjeta MicroSD con sistema operativo Raspbian
movimientos angulares específicos. Cables y conectores para señal y alimentación
• 2 servomotores azules convencionales: Son servos Chasis o estructura para montar el brazo robótico
típicos para tareas de rotación estándar, con un rango Tornillería y soportes para servos
de movimiento menor. Python y librerías (RPi.GPIO, NumPy)
• Placa controladora Raspberry Pi: Actuará como el IDE de desarrollo (VS Code, Thonny)
cerebro del sistema, ejecutando el código en Python Simulador de robótica (opcional)
para controlar los servos y manejar las entradas y Herramientas de montaje (destornilladores, llaves, multímetro)
salidas.
• Fuente de alimentación para servomotores: Asegurar
que la fuente tenga suficiente capacidad para
alimentar los 5 servomotores simultáneamente.
• Cables y conectores: Para conectar los servos a la
Raspberry Pi y a la fuente de alimentación. También
se requerirán cables para las señales de control.
• Componentes Mecánicos:
 3

Cinemática Directa

La cinemática directa se utilizó para calcular la posición del

extremo del robot a partir de los ángulos de los servomotores.
Se implementaron ecuaciones de transformación en Python
que permitieron determinar la ubicación del extremo del robot
en el plano.

CODIGO:
from machine import Pin, PWM
import utime
import math
# Configuración de los servos
servo = PWM(Pin(2))
servo.freq(50)
servo2 = PWM(Pin(4))
servo2.freq(50)
servo3 = PWM(Pin(8))
servo3.freq(50)

servo4 = PWM(Pin(10))
servo4.freq(50)
servo5 = PWM(Pin(12))
servo5.freq(50)
# Parámetros iniciales
L1 = 120 # Longitud del primer segmento
L2 = 191.75 # Longitud del segundo segmento
# Función para mover un servo individual lentamente
def mover_servo_lentamente(servo, angulo_inicial,
angulo_final, paso=1, delay=0.05):
if angulo_inicial < angulo_final:
for angulo in range(angulo_inicial, angulo_final + 1,
paso):
t = int(12 * angulo**2 + 8500 * angulo + 645000)
servo.duty_ns(t)
utime.sleep(delay)
else:
for angulo in range(angulo_inicial, angulo_final - 1, -
paso):
t = int(12 * angulo**2 + 8500 * angulo + 645000)
servo.duty_ns(t)
utime.sleep(delay)
# Posición "home" (0, 90, 90, 0, 0)
posicion_home = [0, 90, 90, 0, 0]
# Mover todos los servos a la posición "home"
def mover_a_home(posiciones_actuales):
mover_servo_lentamente(servo, posiciones_actuales[0],
posicion_home[0])
mover_servo_lentamente(servo2, posiciones_actuales[1],
posicion_home[1])
mover_servo_lentamente(servo3, posiciones_actuales[2],
posicion_home[2])
mover_servo_lentamente(servo4, posiciones_actuales[3],
posicion_home[3])
mover_servo_lentamente(servo5, posiciones_actuales[4],
posicion_home[4])
 4

# Bucle principal mover_a_home(posiciones_actuales)

while True:
print("Moviendo a la posición home...")
posiciones_actuales = posicion_home[:] 3.2 Cinemática Inversa
mover_a_home(posiciones_actuales) La cinemática inversa se aplicó para determinar los ángulos de
try: los servomotores necesarios para alcanzar una posición
# Mover el primer servo (Alfa) específica en el plano. Se utilizaron métodos numéricos y
Alfa = float(input('Digite el ángulo Alfa (en grados): ')) analíticos para resolver este problema, permitiendo que el
if not (0 <= Alfa <= 180): robot se moviera de manera precisa hacia cualquier punto
raise ValueError('Ángulo fuera de rango.') deseado.
mover_servo_lentamente(servo, posicion_home[0], CODIGO:
int(Alfa)) from machine import Pin, PWM
posiciones_actuales[0] = int(Alfa) import utime
# Mover el segundo servo (Beta) import math
Beta = float(input('Digite el ángulo Beta (en grados): '))
if not (0 <= Beta <= 180): # Configuración de los servos
raise ValueError('Ángulo fuera de rango.') servo = PWM(Pin(2))
mover_servo_lentamente(servo2, posicion_home[1], servo.freq(50)
int(Beta))
posiciones_actuales[1] = int(Beta) servo2 = PWM(Pin(4))
# Mover el tercer servo (a3) servo2.freq(50)
a3 = float(input('Digite el ángulo para el servo A2: '))
if not (0 <= a3 <= 180): servo3 = PWM(Pin(8))
raise ValueError('Ángulo fuera de rango.') servo3.freq(50)
mover_servo_lentamente(servo3, posicion_home[2],
int(a3)) servo4 = PWM(Pin(10))
posiciones_actuales[2] = int(a3) servo4.freq(50)
# Mover el cuarto servo (a4)
a4 = float(input('Digite el ángulo para el servo A3: ')) servo5 = PWM(Pin(12))
if not (0 <= a4 <= 180): servo5.freq(50)
raise ValueError('Ángulo fuera de rango.')
mover_servo_lentamente(servo4, posicion_home[3], # Parámetros iniciales
int(a4)) L1 = 120 # Longitud del primer segmento (en mm)
posiciones_actuales[3] = int(a4) L2 = 191.75 # Longitud del segundo segmento (en mm)
# Mover el quinto servo (a5)
a5 = float(input('Digite el ángulo para el servo A4: ')) # Función para mover un servo individual lentamente
if not (0 <= a5 <= 180): def mover_servo_lentamente(servo, angulo_inicial,
raise ValueError('Ángulo fuera de rango.') angulo_final, paso=1, delay=0.05):
mover_servo_lentamente(servo5, posicion_home[4], if angulo_inicial < angulo_final:
int(a5)) for angulo in range(angulo_inicial, angulo_final + 1,
posiciones_actuales[4] = int(a5) paso):
except ValueError as e: t = int(12 * angulo**2 + 8500 * angulo + 645000)
print(f"Error: {e}") servo.duty_ns(t)
continue utime.sleep(delay)
# Calcular Pax y Pay else:
Pax = L1 * math.cos(math.radians(Alfa)) for angulo in range(angulo_inicial, angulo_final - 1, -
Pay = L1 * math.sin(math.radians(Alfa)) paso):
# Calcular Pbx y Pby t = int(12 * angulo**2 + 8500 * angulo + 645000)
Pbx = Pax + (L2 * math.cos(math.radians(Beta))) servo.duty_ns(t)
Pby = Pay + (L2 * math.sin(math.radians(Beta))) utime.sleep(delay)
# Imprimir resultados
print('Pax = {:.3f} m'.format(Pax)) # Posición "home" (0, 90, 90, 0, 0)
print('Pay = {:.3f} m'.format(Pay)) posicion_home = [0, 90, 90, 0, 0]
print('Pbx = {:.3f} m'.format(Pbx))
print('Pby = {:.3f} m'.format(Pby)) # Mover todos los servos a la posición "home"
print("Volviendo a la posición home...") def mover_a_home(posiciones_actuales):
 5

mover_servo_lentamente(servo, posiciones_actuales[0], except ValueError as e:

posicion_home[0]) print(f"Error: {e}")
mover_servo_lentamente(servo2, posiciones_actuales[1], continue
posicion_home[1])
mover_servo_lentamente(servo3, posiciones_actuales[2], # Imprimir los ángulos calculados
posicion_home[2]) print('Ángulo Alfa = {:.3f} grados'.format(Alfa))
mover_servo_lentamente(servo4, posiciones_actuales[3], print('Ángulo Beta = {:.3f} grados'.format(Beta))
posicion_home[3])
mover_servo_lentamente(servo5, posiciones_actuales[4], print("Volviendo a la posición home...")
posicion_home[4]) mover_a_home(posiciones actuales)

# Bucle principal
while True: 3.3 Matriz de Transformación Homogénea (MTH)
print("Moviendo a la posición home...")
posiciones_actuales = posicion_home[:] La MTH es utilizada para combinar rotaciones y traslaciones
mover_a_home(posiciones_actuales) en una única matriz, facilitando la transformación de
coordenadas en sistemas robóticos. El siguiente código
try: ejemplifica la construcción de una MTH para un sistema de
# Pedir las coordenadas del punto objetivo dos eslabones.
Px = float(input('Digite la coordenada Px (en mm): '))
Py = float(input('Digite la coordenada Py (en mm): ')) Se puede evidenciar el análisis a partir de este código:

# Verificar si el punto está dentro del alcance del brazo import numpy as np
robótico import math
distancia = math.sqrt(Px**2 + Py**2)
if distancia > (L1 + L2) or distancia < abs(L1 - L2): # Parámetros iniciales
raise ValueError('El punto está fuera del alcance del L1 = 120 # Longitud del primer segmento (en mm)
robot.') L2 = 191.75 # Longitud del segundo segmento (en mm)

# Calcular Beta usando cinemática inversa # Función para crear una matriz de transformación homogénea
cos_beta = (Px**2 + Py**2 - L1**2 - L2**2) / (2 * L1 * en 2D
L2) def matriz_transformacion(theta, d):
Beta = math.degrees(math.acos(cos_beta)) """
Crea una matriz de transformación homogénea 2D (rotación
# Calcular Alfa usando cinemática inversa y traslación).
k1 = L1 + L2 * math.cos(math.radians(Beta))
k2 = L2 * math.sin(math.radians(Beta)) :param theta: Ángulo de rotación en grados.
Alfa = math.degrees(math.atan2(Py, Px) - math.atan2(k2, :param d: Distancia de traslación (longitud del eslabón).
k1)) :return: Matriz de transformación homogénea 3x3.
"""
# Validar que los ángulos estén dentro del rango del theta_rad = math.radians(theta) # Convertir ángulo a
servo radianes
if not (0 <= Alfa <= 180): T = np.array([[math.cos(theta_rad), -math.sin(theta_rad), d
raise ValueError('Ángulo Alfa fuera de rango.') * math.cos(theta_rad)],
if not (0 <= Beta <= 180): [math.sin(theta_rad), math.cos(theta_rad), d *
raise ValueError('Ángulo Beta fuera de rango.') math.sin(theta_rad)],
[0, 0, 1]])
# Mover los servos a los ángulos calculados return T
mover_servo_lentamente(servo, posicion_home[0],
int(Alfa)) # Pedir al usuario las coordenadas del punto objetivo
posiciones_actuales[0] = int(Alfa) Px = float(input('Digite la coordenada Px (en mm): '))
Py = float(input('Digite la coordenada Py (en mm): '))
mover_servo_lentamente(servo2, posicion_home[1],
int(Beta)) # Verificar si el punto está dentro del alcance del brazo
posiciones_actuales[1] = int(Beta) robótico
distancia = math.sqrt(Px**2 + Py**2)
 6

if distancia > (L1 + L2) or distancia < abs(L1 - L2):

raise ValueError('El punto está fuera del alcance del robot.') El uso de la programación con matrices de transformación
homogénea y la implementación de cinemática inversa en el
# Cálculo de ángulos usando cinemática inversa código proporcionado nos ha permitido lograr un control
cos_beta = (Px**2 + Py**2 - L1**2 - L2**2) / (2 * L1 * L2) preciso de los movimientos del robot de 5 servomotores. A
Beta = math.degrees(math.acos(cos_beta)) continuación, se presentan los principales resultados
obtenidos:
k1 = L1 + L2 * math.cos(math.radians(Beta)) Movimientos Detallados y Precisos: Gracias a la
k2 = L2 * math.sin(math.radians(Beta)) implementación de la cinemática inversa, el robot puede
Alfa = math.degrees(math.atan2(Py, Px) - math.atan2(k2, k1)) alcanzar cualquier punto dentro de su área de trabajo de
manera eficiente. Este método permite calcular con exactitud
# Matrices de transformación homogénea para los dos los ángulos que deben adoptar los servomotores para mover
eslabones los eslabones del brazo hacia posiciones específicas en el
T1 = matriz_transformacion(Alfa, L1) # Primera matriz de espacio 2D. El uso de las matrices de transformación
transformación homogénea para calcular las posiciones intermedias de cada
T2 = matriz_transformacion(Beta, L2) # Segunda matriz de eslabón asegura que la trayectoria del robot sea suave y
transformación controlada.
Control sobre Múltiples Eslabones: La arquitectura de 5
# Matriz total de transformación (T0_2 = T1 * T2) servomotores permite que el robot tenga varios grados de
T0_2 = np.dot(T1, T2) libertad, lo que lo hace ideal para tareas que requieren
movimientos complejos, como manipular objetos en diferentes
# Extraer las coordenadas del extremo final (Px', Py') a partir orientaciones o realizar tareas de precisión. Cada servomotor
de T0_2 se puede programar de manera independiente para adoptar el
P_final = np.dot(T0_2, np.array([0, 0, 1])) # Coordenadas ángulo necesario, en función de las coordenadas objetivo.
homogéneas Implementación de Cinemática Inversa: Al solicitar al usuario
las coordenadas de un punto específico, el código calcula
Px_calculado = P_final[0] automáticamente los ángulos necesarios para que el robot se
Py_calculado = P_final[1] desplace hasta esa ubicación. Este enfoque es particularmente
útil en aplicaciones donde se desea que el robot siga
# Imprimir resultados trayectorias específicas o realice tareas en puntos predefinidos,
print(f'Ángulo Alfa = {Alfa:.2f} grados') como el ensamblaje de piezas o el manejo de materiales.
print(f'Ángulo Beta = {Beta:.2f} grados') Pruebas y Resultados de los Movimientos: Durante las
print(f'Posición final calculada: Px = {Px_calculado:.2f} mm, pruebas de laboratorio, se programaron varios movimientos
Py = {Py_calculado:.2f} mm') para que el robot alcanzara diferentes puntos de interés dentro
de su área de trabajo. Los resultados muestran que el robot
# Aquí puedes implementar el movimiento de los servos como puede moverse de manera fluida y precisa entre posiciones, lo
en el código anterior que confirma la precisión de los cálculos de cinemática
inversa. Los movimientos de los eslabones y sus ángulos
4. Resultados fueron controlados en tiempo real, lo que permitió ajustes
dinámicos en caso de desviaciones o errores mínimos.
Los resultados del proyecto se pueden evidenciar en el Implementación de los Movimientos en el Robot
siguiente link: Para implementar los movimientos detallados en un robot con
5 servomotores utilizando esta programación, se pueden seguir
https://www.google.com/search?sca_esv=bdd267d42e3b57fe los siguientes pasos:
&sca_upv=1&rlz=1C1GCEU_esCO1047CO1047&q=epson+s Definir las Longitudes de los Eslabones y los Ángulos de los
cara+RC&tbm=vid&source=lnms&fbs=AEQNm0CbCVgAZ5 Servos: Primero, es necesario definir las dimensiones físicas
mWEJDg6aoPVcBgWizR0-0aFOH11Sb5tlNhd7Qv31WAq- del brazo robótico (longitud de los eslabones) y las
g3XdD7m281OKwFyA- limitaciones mecánicas de los servomotores. Esto incluye
0X_WEQGTRyn1HvFYU9DcaM_X0ZwJDNJmtmBYo- asegurarse de que los servos tengan un rango de rotación
Q0JO4nnsUsCP19gK0RNhbSX- adecuado, por ejemplo, de 0 a 180 grados, y que las longitudes
CS0sz8m6UBJdWwAbHCUw3dUwTjx6ovwRvnIGNNJNQb de los eslabones sean adecuadas para las tareas a realizar.
uU4BcPf80IpAahe0lMQnMgoITRgFdQHHYnYfMO5s3uIr1f Programación de las Matrices de Transformación: Utilizando
w&sa=X&ved=2ahUKEwj5j-2Cv- Python y la librería numpy (para manejar las operaciones
uIAxWRSzABHdkvKvoQ0pQJegQIEhAB&biw=1366&bih= matriciales), se implementa el cálculo de las matrices de
633&dpr=1#fpstate=ive&vld=cid:7aaba710,vid:jw0C- transformación homogénea. Cada eslabón del robot tendrá su
Er5_u0,st:0 propia matriz de rotación y traslación, lo que nos permitirá
 7

calcular con precisión la posición final del robot al aplicar enfoque garantizó un control detallado del movimiento del
estas transformaciones de manera secuencial. robot en su espacio de trabajo.
Cinemática Inversa para Calcular los Ángulos: A partir de las Sincronización Eficiente de los Servomotores: La
coordenadas del punto objetivo que queremos alcanzar, el sincronización adecuada de los seis servomotores, controlados
algoritmo de cinemática inversa calcula los ángulos de los mediante código en Python, resultó esencial para lograr
servos necesarios para que el robot logre dicha posición. Este movimientos suaves y coordinados. La capacidad de mover
cálculo es crucial para asegurar que el robot pueda seguir los servos de manera lenta y controlada, ajustando los ángulos
trayectorias específicas sin desviaciones, lo que es útil en con precisión, permitió que el robot ejecutara tareas con un
aplicaciones industriales o de precisión. alto grado de exactitud. Esta sincronización es crucial para
Movimiento Suave entre Puntos: Los servos se pueden aplicaciones industriales o de precisión, donde cualquier
controlar mediante pequeñas variaciones angulares, lo que desviación puede afectar la calidad del trabajo.
permite que el brazo robótico se mueva suavemente de un Versatilidad del Sistema Robótico: El diseño de este robot,
punto a otro. Esto es particularmente útil en tareas donde la basado en seis servomotores de 180 grados, mostró su
precisión es importante, como el ensamblaje de componentes flexibilidad para realizar tareas en entornos variados. La
electrónicos o la manipulación de objetos frágiles. combinación de la programación y los principios de
Aplicaciones Prácticas: Este tipo de control detallado y cinemática le otorgan la capacidad de adaptarse a diferentes
preciso es aplicable a una amplia gama de tareas, incluyendo: trayectorias y movimientos, lo que lo hace adecuado para
Automatización Industrial: Manipulación de objetos, diversas aplicaciones, como la automatización industrial, la
ensamblaje de piezas, y soldadura automatizada. manipulación de objetos, o tareas educativas en robótica.
Robótica Educativa: Enseñar los conceptos de cinemática Programación como Herramienta Clave: El uso del lenguaje
directa e inversa a estudiantes de ingeniería y robótica. Python facilitó la implementación de las funciones necesarias
Tareas de Precisión: Tareas como la impresión 3D, donde el para el control de los servos y la ejecución de las operaciones
robot debe realizar movimientos extremadamente precisos y matemáticas asociadas a la cinemática. La estructura modular
seguir trayectorias específicas. del código permitió realizar ajustes en tiempo real y modificar
En conclusión, esta programación no solo ha demostrado ser los parámetros de control para mejorar el desempeño del
eficaz para controlar los 5 servomotores del robot, sino que robot, lo que destaca la importancia de la programación en la
también abre la puerta a su implementación en aplicaciones robótica moderna.
más complejas y variadas, donde los movimientos precisos y Aplicabilidad a Escenarios Reales: La precisión y eficacia
detallados son esenciales para la correcta ejecución de tareas. demostradas por este sistema robótico validan su potencial en
aplicaciones reales. La capacidad de calcular y ejecutar
5. Análisis movimientos complejos, como los alcanzados a través de la
cinemática inversa, permite que este tipo de sistemas robóticos
Cada código cumple con su función específica dentro del sean aplicados en tareas repetitivas y de precisión, como el
contexto de la cinemática robótica: ensamblaje automatizado, manejo de materiales o incluso en el
Cinemática Inversa: Es crucial para determinar la ámbito de la medicina.
configuración angular necesaria para alcanzar una posición En resumen, esta práctica evidenció cómo la combinación de
deseada. Esto es vital en aplicaciones donde la precisión del servomotores sincronizados, principios de cinemática, y la
posicionamiento es crítica. programación en Python puede ofrecer un control detallado y
Cinemática Directa: Permite determinar la ubicación del eficiente de robots en diversas tareas. Estos resultados no solo
extremo del robot, lo que es esencial para la planificación del muestran la capacidad del robot para realizar movimientos
movimiento y para evitar colisiones en entornos complejos. complejos, sino que también subrayan la importancia de la
Matriz de Transformación Homogénea: La MTH unifica las robótica en la automatización moderna.
transformaciones necesarias para modelar la posición final de
un sistema robótico, siendo una herramienta poderosa para la
simulación y análisis de sistemas multi cuerpo. 7. Referencias bibliográficas

6. Conclusiones de la Práctica https://people.disim.univaq.it/~costanzo.manes/EDU_stuff/Ro

Integración Exitosa de la Cinemática Directa e Inversa: La botics_Modelling,%20Planning%20and%20Control_Sciavicc
implementación de los métodos de cinemática directa e o_extract.pdf
inversa en este proyecto ha demostrado ser fundamental para
el control preciso del robot de seis servomotores. La Bruno Siciliano - Robotics
cinemática directa permitió predecir las posiciones finales a
partir de los ángulos de los servomotores, mientras que la
cinemática inversa proporcionó los ángulos exactos necesarios
para alcanzar coordenadas específicas en el plano. Este