UNIVERSIDAD PRIVADA DEL VALLE

FACULTAD DE INFORMÁTICA Y ELECTRÓNICA

INGENIERÍA BIOMEDICA .MECATRONICA
CAMPUS TIQUIPAYA

Informe de Práctica de Laboratorio N°4

MOVIMIENTO DE
TRAYECTORIA RECTILÍNEA
DEL ROBOT
MÓVIL CON
SINCRONIZACIÓN PID
GRUPO “A”

Integrantes: Chambi Ribera Daniel

Filigrana Meneses Juan
Sánchez Muriel Kevin

Carrera: IBI, IMT

Materia: ROBÓTICA
Docente: Ing. Elias Chavez
Gestión: II-2025
Fecha de presentación: 29 de octubre del 2025
MOVIMIENTO DE TRAYECTORIA RECTILÍNEA DEL ROBOT MÓVIL CON
SINCRONIZACIÓN PID
1. Marco teórico
Un algoritmo de trayectoria rectilínea con sincronización PID para robots móviles diferenciales
consiste en mantener el desplazamiento del robot a lo largo de una línea recta mediante la
utilización de un controlador PID (Proporcional-Integral-Derivativo). El controlador PID ajusta en
tiempo real la velocidad y dirección de las ruedas basándose en la diferencia entre la posición real
y la trayectoria deseada, minimizando el error y compensando posibles perturbaciones externas o
variaciones en la superficie de movimiento (Carmona & Mendoza, 2018; Thai et al., 2022; Amaral
Oliveira et al., 2022; Kumar y Nisha, 2017).

El proceso operativo implica que el robot, equipado con motores independientes y sensores de
posición (como encoders o sensores de luz), evalúe constantemente su desplazamiento. El error
calculado entre la posición actual y la referencia es procesado por el controlador PID, que determina
las correcciones requeridas en cada componente:

• El término Proporcional (P) responde al error inmediato.

• El término Integral (I) corrige desviaciones acumuladas con el tiempo.
• El término Derivativo (D) anticipa y suaviza la respuesta frente a cambios repentinos.

La combinación de estas acciones posibilita que el robot avance de manera precisa y estable en
trayectorias rectas, sincronizando las velocidades y direcciones de ambas ruedas para evitar
desviaciones no deseadas y mantener la estabilidad, incluso ante factores externos adversos.
Este método se aplica en la robótica móvil para lograr navegación autónoma precisa, facilitando el
desplazamiento sobre trayectorias definidas y asegurando la fiabilidad en recorridos prolongados.

2. Resultados de Laboratorio Virtual

Utilizando el robot móvil LEGO MINDSTORMS NXT o LEGO EV3 o LEGO SPIKE PRIME (Prototipo
armado con sensores y actuadores) para completar el laboratorio, programe el robot en BRICX CC o
ROBOTC o SPIKE – PYTHON para que complete dos vueltas alrededor del cuadrado interior del recorrido.
Las líneas a lo largo del camino están ahí para la retroalimentación del sensor de LUZ (debe usar el mismo
para el cambio de trayectoria); sobrepasarlos no es tomando en cuenta como falta en la tarea. También debe
detenerse si se presenta un obstáculo a una distancia de 10 cm.
 Código usado:
from hub import port import time import color_sensor import motor_pair #from runloop import until import
time #import distance_sensor #import gyro #import motor umbral=49 motor_pair.pair(motor_pair.PAIR_1,
port.D, port.C)
Bucle principal para leer y mostrar la lectura del sensor de luz
Función para avanzar encendiendo una pareja de motores con una velocidad específica
def avanzar(velocidad): motor_pair.move(motor_pair.PAIR_1, 0, velocity=velocidad)
Función para apagar una pareja de motores:
def detener(): motor_pair.stop(motor_pair.PAIR_1)
funcion para avanzar una distancia determinada en centímetros
def avanzar_distancia(distancia_cm, velocidad): # Calcular la cantidad de grados a girar en cada motor para
recorrer la distancia deseada DIAMETRO_LLANTA = 5.6 # Diámetro de la llanta en centímetros
CIRCUNFERENCIA = DIAMETRO_LLANTA * 3.14159 # Circunferencia de la llanta grados_por_cm = 360 /
CIRCUNFERENCIA # Cantidad de grados por centímetro recorrido grados_a_girar =int ( distancia_cm *
grados_por_cm) # Encender los motores para avanzar
motor_pair.move_tank_for_degrees(motor_pair.PAIR_1, grados_a_girar, velocidad, velocidad)
funcion para girar
Función para girar el robot una cantidad de grados basada en los encoders de los motores
def girar_con_encoders(velocidad, grados_deseados): # Calcular la cantidad de grados a girar en cada motor
# Insertar la distancia entre los extremos de las ruedas Ancho=12.5# en cm # insertar el diametro de las
ruedas Diametro=5.5 # cm GradosMotor=int (grados_deseados*Ancho/Diametro) # Girar cada motor la
cantidad de grados deseada if GradosMotor<0: motor_pair.move_tank_for_degrees(motor_pair.PAIR_1, -
GradosMotor, -velocidad, velocidad) else : motor_pair.move_tank_for_degrees(motor_pair.PAIR_1,
GradosMotor, velocidad, -velocidad)
#######################################################################################
#escribir tu codigo aquí #1 avanzar(380) time.sleep_ms(2000) lectura_sensor =
color_sensor.reflection(port.B) while lectura_sensor>umbral: lectura_sensor =
color_sensor.reflection(port.B)
print("Lectura del sensor de luz: {}".format(lectura_sensor))
detener() time.sleep_ms(1000) avanzar_distancia(20,150) time.sleep_ms(3500) detener()
girar_con_encoders(100, 80) time.sleep_ms(2500) #2 avanzar(380) time.sleep_ms(2000) lectura_sensor =
color_sensor.reflection(port.B) while lectura_sensor>umbral: lectura_sensor =
color_sensor.reflection(port.B)
print("Lectura del sensor de luz: {}".format(lectura_sensor))
detener() time.sleep_ms(1000) avanzar_distancia(20,150) time.sleep_ms(3500) detener()
girar_con_encoders(100, 80) time.sleep_ms(2500) #3 avanzar(380) time.sleep_ms(2000) lectura_sensor =
color_sensor.reflection(port.B) while lectura_sensor>umbral: lectura_sensor =
color_sensor.reflection(port.B)
print("Lectura del sensor de luz: {}".format(lectura_sensor))
detener() time.sleep_ms(1000) avanzar_distancia(20,150) time.sleep_ms(3500) detener()
girar_con_encoders(100, 80) time.sleep_ms(2500) #4 avanzar(380) time.sleep_ms(2000) lectura_sensor =
color_sensor.reflection(port.B) while lectura_sensor>umbral: lectura_sensor =
color_sensor.reflection(port.B)
print("Lectura del sensor de luz: {}".format(lectura_sensor))
detener() time.sleep_ms(1000) avanzar_distancia(20,150) time.sleep_ms(3500) detener()
girar_con_encoders(100, 80) time.sleep_ms(2500)
#segunda vuelta #1 avanzar(380) time.sleep_ms(2000) lectura_sensor = color_sensor.reflection(port.B) while
lectura_sensor>umbral: lectura_sensor = color_sensor.reflection(port.B)
print("Lectura del sensor de luz: {}".format(lectura_sensor))
detener() time.sleep_ms(1000) avanzar_distancia(20,150) time.sleep_ms(3500) detener()
girar_con_encoders(100, 80) time.sleep_ms(2500) #2 avanzar(380) time.sleep_ms(2000) lectura_sensor =
color_sensor.reflection(port.B) while lectura_sensor>umbral: lectura_sensor =
color_sensor.reflection(port.B)
print("Lectura del sensor de luz: {}".format(lectura_sensor))
detener() time.sleep_ms(1000) avanzar_distancia(20,150) time.sleep_ms(3500) detener()
girar_con_encoders(100, 80) time.sleep_ms(2500) #3 avanzar(380) time.sleep_ms(2000) lectura_sensor =
color_sensor.reflection(port.B) while lectura_sensor>umbral: lectura_sensor =
color_sensor.reflection(port.B)
print("Lectura del sensor de luz: {}".format(lectura_sensor))
detener() time.sleep_ms(1000) avanzar_distancia(20,150) time.sleep_ms(3500) detener()
girar_con_encoders(100, 80) time.sleep_ms(2500) #4 avanzar(380) time.sleep_ms(2000) lectura_sensor =
color_sensor.reflection(port.B) while lectura_sensor>umbral: lectura_sensor =
color_sensor.reflection(port.B)
print("Lectura del sensor de luz: {}".format(lectura_sensor))
detener() time.sleep_ms(1000) avanzar_distancia(20,150) time.sleep_ms(3500) detener()
girar_con_encoders(100, 80) time.sleep_ms(2500)
#tercer vuelta #1 avanzar(380) time.sleep_ms(2000) lectura_sensor = color_sensor.reflection(port.B) while
lectura_sensor>umbral: lectura_sensor = color_sensor.reflection(port.B)
print("Lectura del sensor de luz: {}".format(lectura_sensor))
detener() time.sleep_ms(1000) avanzar_distancia(20,150) time.sleep_ms(3500) detener()
girar_con_encoders(100, 80) time.sleep_ms(2500) #2 avanzar(380) time.sleep_ms(2000) lectura_sensor =
color_sensor.reflection(port.B) while lectura_sensor>umbral: lectura_sensor =
color_sensor.reflection(port.B)
print("Lectura del sensor de luz: {}".format(lectura_sensor))
detener() time.sleep_ms(1000) avanzar_distancia(20,150) time.sleep_ms(3500) detener()
girar_con_encoders(100, 80) time.sleep_ms(2500) #3 avanzar(380) time.sleep_ms(2000) lectura_sensor =
color_sensor.reflection(port.B) while lectura_sensor>umbral: lectura_sensor =
color_sensor.reflection(port.B)
print("Lectura del sensor de luz: {}".format(lectura_sensor))
detener() time.sleep_ms(1000) avanzar_distancia(20,150) time.sleep_ms(3500) detener()
girar_con_encoders(100, 75) time.sleep_ms(2500) #4 avanzar(380) time.sleep_ms(2000) lectura_sensor =
color_sensor.reflection(port.B) while lectura_sensor>umbral: lectura_sensor =
color_sensor.reflection(port.B)
print("Lectura del sensor de luz: {}".format(lectura_sensor))
detener() time.sleep_ms(1000) avanzar_distancia(20,150) time.sleep_ms(3500) detener()
girar_con_encoders(100, 80) time.sleep_ms(2500)
#4 vuelta #1 avanzar(380) time.sleep_ms(2000) lectura_sensor = color_sensor.reflection(port.B) while
lectura_sensor>umbral: lectura_sensor = color_sensor.reflection(port.B)
print("Lectura del sensor de luz: {}".format(lectura_sensor))
detener() time.sleep_ms(1000) avanzar_distancia(20,150) time.sleep_ms(3500) detener()
girar_con_encoders(100, 80) time.sleep_ms(2500) #2 avanzar(380) time.sleep_ms(2000) lectura_sensor =
color_sensor.reflection(port.B) while lectura_sensor>umbral: lectura_sensor =
color_sensor.reflection(port.B)
 print("Lectura del sensor de luz: {}".format(lectura_sensor))
detener() time.sleep_ms(1000) avanzar_distancia(20,150) time.sleep_ms(3500) detener()
girar_con_encoders(100, 80) time.sleep_ms(2500) #3 avanzar(380) time.sleep_ms(2000) lectura_sensor =
color_sensor.reflection(port.B) while lectura_sensor>umbral: lectura_sensor =
color_sensor.reflection(port.B)
print("Lectura del sensor de luz: {}".format(lectura_sensor))
detener() time.sleep_ms(1000) avanzar_distancia(20,150) time.sleep_ms(3500) detener()
girar_con_encoders(100, 80) time.sleep_ms(2500) #4 avanzar(380) time.sleep_ms(2000) lectura_sensor =
color_sensor.reflection(port.B) while lectura_sensor>umbral: lectura_sensor =
color_sensor.reflection(port.B)
print("Lectura del sensor de luz: {}".format(lectura_sensor))
detener() time.sleep_ms(1000) avanzar_distancia(20,150) time.sleep_ms(3500) detener()
girar_con_encoders(100, 80) time.sleep_ms(2500) detener()

Realizar un video que muestren el proceso de movimiento del robot y su finalización en la

plataforma STREAM, añada el link junto al presente documento.
Video de WhatsApp 2025-10-29 a las 23.22.58_34ccf777.mp4
Fotografías de inicio, etapa intermedia y fin del recorrido del robot móvil.

3. Conclusiones
Durante la práctica de laboratorio se programó el robot LEGO SPIKE Prime utilizando el lenguaje Python,
integrando los módulos de control de motores y sensor de color. El objetivo principal fue que el robot siguiera
una trayectoria específica detectando cambios en la superficie mediante su sensor de reflexión, y que repitiera
el recorrido cuatro veces de manera continua y controlada.
El código desarrollado permitió sincronizar el movimiento de los motores con las lecturas del sensor de color,
usando un valor umbral de 49 para determinar cuándo el robot debía detenerse o continuar. A través de
funciones bien estructuradas como avanzar(), detener(), avanzar_distancia() y girar_con_encoders(), se logró
modularizar el programa, facilitando la comprensión y reutilización del código.
Durante la ejecución, el robot fue capaz de seguir su trayectoria correctamente en las cuatro vueltas
programadas, realizando las secuencias de avance, detección, parada, avance controlado por distancia y giros
precisos gracias al uso de los encoders de los motores. Este comportamiento demostró la efectividad del
control basado en sensores y la precisión de los cálculos relacionados con la distancia y el ángulo de giro.

4. Cuestionario

1. Describa la función para mover a los motores del SPIKE PRIME con sintonización PID en
Python de LEGO Education SPIKE

from hub import port import motor import time

Parámetros PID
Kp = 0.5 Ki = 0.1 Kd = 0.05
Configuración del motor en puerto A
m = [Link](port.A)
Velocidad deseada
velocidad_objetivo = 500
Variables del PID
error_anterior = 0 integral = 0
while True: velocidad_actual = m.get_speed() error = velocidad_objetivo - velocidad_actual
integral += error derivada = error - error_anterior salida = Kperror + Kiintegral + Kd*derivada
# Aplicar la corrección al motor
m.run_at_speed(int(salida))

error_anterior = error
time.sleep_ms(50)

Kp, Ki y Kd son las constantes del control PID (sintonización).

Se mide la velocidad actual del motor y se compara con la deseada.
El controlador PID calcula una corrección (salida) que se aplica al motor para mantener la velocidad
estable, En el programa, las funciones como motor_pair.move_tank_for_degrees() ya incluyen
control PID interno, garantizando que ambos motores giren la cantidad exacta de grados y mantengan
la misma velocidad durante el movimiento.

2. Realice un ejemplo de programa de multitarea en LEGO Education SPIKE

from hub import port import motor_pair import color_sensor import runloop import time
#Definir tareas asíncronas (multitarea)
async def mover_robot(): motor_pair.pair(motor_pair.PAIR_1, port.C, port.D) for i in range(5):
motor_pair.move(motor_pair.PAIR_1, 0, velocity=400) await runloop.sleep_ms(500)
motor_pair.stop(motor_pair.PAIR_1)
async def leer_sensor(): for i in range(10): lectura = color_sensor.reflection(port.B)
print("Reflexión:", lectura) await runloop.sleep_ms(300)
 #Programa principal: ejecutar ambas tareas al mismo tiempo
async def main(): await [Link](mover_robot(), leer_sensor())
[Link](main())

async def define funciones asíncronas (tareas).

await runloop.sleep_ms() permite pausar brevemente cada tarea sin bloquear a las demás.
[Link]() ejecuta todas las tareas de forma concurrente.
Mientras el robot se mueve, el sensor de color sigue tomando lecturas.

3. Desarrolle el diagrama de flujo del programa usado en la práctica

• El robot avanza hasta detectar una línea (usando el sensor).

• Se detiene, avanza una distancia fija y gira.
• Repite este patrón cuatro veces por “vuelta”.
• Luego repite el ciclo completo cuatro vueltas más.
• Al final, el robot se detiene completamente.

5. Referencias bibliográficas.
Sun, D., Wang, C., Shang, W., & Feng, G. (2009). A synchronization approach to trajectory tracking of
multiple mobile robots while maintaining time-varying formations. IEEE Transactions on Robotics,
25(5), 1074–1086.
Patle, B. K., et al. (2019). A review: on path planning strategies for navigation of mobile robots.
Journal / Review, 2019