UNIVERSIDAD DEL VALLE

EXAMEN

Estudiante: Crespo Torrico Emanuel B. Carrera: Ing. Biomedica

Asignatura: ROBÓTICA Grupo: A

CASO DE ESTUDIO (100 PUNTOS)

Mini Urban Challenge

La zona de competición es una ciudad (ver figura 1):

Figura 1. Vista panorámica de la competencia.

Donde el robot móvil LEGO MINDSTORM NXT debe navegar respetando el sentido de circulación de las
calles (ver figura 2):

Figura 2. Sentido de circulación de calles. En cada esquina cuenta con una franja roja.

El robot móvil debe iniciar en la posición “A”, como se muestra en la figura 3.

 Figura 3. Posición del punto de inicio y estacionamientos (LOT 1- 10)

El robot móvil LEGO MINDSTORM NXT debe estacionarse en cualquier casilla de los puntos de
estacionamiento sin invadir las franjas (ver figura 4.), siguiendo la secuencia:

1. (25 PUNTOS) Partir del punto A y estacionarse en LOT2.

2. (35 PUNTOS) Partiendo de LOT2 y estacionarse en LOT3.
3. (40 PUNTOS) Partiendo de LOT3 y estacionarse en LOT8.

Figura 4. Forma de estacionamiento del robot móvil.

En la programación del robot debe usar al menos un sensor (encoders, touch, sonar, giroscopio) de forma
obligatoria. Debe subir el código fuente.

Código fuente
#pragma config(Sensor, S1, Colision, sensorTouch)
#pragma config(Sensor, S2, Giroscopio, sensorI2CHiTechnicGyro)
#pragma config(Sensor, S3, Luz, sensorLightActive)
#pragma config(Sensor, S4, Ultrasonido, sensorSONAR)
#pragma config(Motor, motorA, Garra, tmotorNXT, PIDControl, encoder)
#pragma config(Motor, motorB, MotorDer, tmotorNXT, PIDControl,
driveRight, encoder)
#pragma config(Motor, motorC, MotorIzq, tmotorNXT, PIDControl,
driveLeft, encoder)
//*!!Code automatically generated by 'ROBOTC' configuration wizard !!*//

/// Mueve atras al robot a una distancia determinada en cm

///////////
/// direccion:
/// 0 para ir hacia adelante
/// 1 para ir hacia atras
void mover_distancia(int direccion,float distancia, int velocidad=50)
{
switch(direccion)
 {
case 0: //mover hacia adelante
nMotorEncoder[MotorDer]=0;
nMotorEncoder[MotorIzq]=0;
nMotorPIDSpeedCtrl[MotorDer] = mtrSpeedReg;
nSyncedMotors = synchBC;
nSyncedTurnRatio = 100; //giro de la rueda <100 es a la izquierda y >100
es a la derecha
float recorrido = 0;
motor[MotorDer] = velocidad;
while (recorrido<distancia)
{
recorrido = (nMotorEncoder[MotorDer]*2*PI*2.78)/360;
}
wait1Msec(45);
motor[MotorDer] = 0;
motor[MotorIzq] = 0;
wait1Msec(100);
break;

case 1: //mover hacia atras

nMotorEncoder[MotorDer]=0;
nMotorEncoder[MotorIzq]=0;
nMotorPIDSpeedCtrl[MotorDer] = mtrSpeedReg;
nSyncedMotors = synchBC;
nSyncedTurnRatio = 100;
float recorrido2=0;
motor[MotorDer] = -velocidad;
while (recorrido2<distancia)
{
recorrido2 = -(nMotorEncoder[MotorDer]*2*PI*2.78)/360;
}
wait1Msec(45);
motor[MotorDer] = 0;
motor[MotorIzq] = 0;
wait1Msec(100);
break;
}
}

/////////////////////////////////////////////////
/// Gira al robot sobre su propio eje un determinado angulo
/// angulo en grados
/// velocidad 0 a 100
/// angulo >0 -> giro horario -> derecha
/// angulo <0 -> giro antihorario -> izquierda

void girar(int angulo,int velocidad=20)

{
int anterior=SensorValue(Giroscopio);
int angulo1=angulo;
nMotorPIDSpeedCtrl[MotorDer] = mtrSpeedReg;
nSyncedMotors = synchBC;
nSyncedTurnRatio = -100;
int grados=0;
angulo=angulo*10;
anterior=anterior+angulo;
angulo=anterior;
if(angulo1>=0)// sentido horario
{
angulo = angulo - (velocidad + 2);
motor[MotorDer] = -velocidad-2;
grados=SensorValue(Giroscopio);
while (grados<angulo)
{
grados=SensorValue(Giroscopio);
}
wait1Msec(40);
motor[MotorDer] = 0;
motor[MotorIzq] = 0;
return;
}
else // sentido antihorario
 {
angulo = angulo + (velocidad - 12);
motor[MotorDer] = velocidad;
grados=SensorValue(Giroscopio);
while (grados>angulo)
{
grados=SensorValue(Giroscopio);
}
wait1Msec(40);
motor[MotorDer] = 0;
motor[MotorIzq] = 0;
return;
}
}
//////////////////////////////////////////////

void estabilizar(int izq, int der)

{
motor[MotorDer]=der;
motor[MotorIzq]=izq;
wait1Msec(100);
motor[MotorDer]=0;
motor[MotorIzq]=0;
wait1Msec(100);
}

void girar_rot(float distancia, int velocidad=50, int direcc)

{
nMotorEncoder[MotorDer]=0;
nMotorEncoder[MotorIzq]=0;
nMotorPIDSpeedCtrl[MotorDer] = mtrSpeedReg;
nSyncedMotors = synchBC;
nSyncedTurnRatio = direcc;
float recorrido=0;
motor[MotorDer] = velocidad;
while (recorrido<distancia)
{
recorrido=(nMotorEncoder[MotorDer]*2*PI*2.74)/360;
}
motor[MotorDer] =0;
motor[MotorIzq] =0;
}

void estacionar(float distancia, int velocidad, int giro_angulo)

{
nMotorEncoder[MotorDer]=0;
nMotorEncoder[MotorIzq]=0;
nMotorPIDSpeedCtrl[MotorDer] = mtrSpeedReg;
nSyncedMotors = synchBC;
nSyncedTurnRatio = giro_angulo;
float recorrido2=0;
motor[MotorDer] = -velocidad;
while (recorrido2<distancia)
{
recorrido2 = -(nMotorEncoder[MotorDer]*2*PI*2.78)/360;
}
wait1Msec(45);
motor[MotorDer] = 0;
motor[MotorIzq] = 0;
wait1Msec(100);
}

task main()
{
////////////////////////Etapa 1//////////////////////////////
//////////////primer parqueo de punto A a Lot2///////////////
mover_distancia(0,20,40);
wait1Msec(100);
girar(-83,20);
wait1Msec(100);
mover_distancia(0,82,70);
wait1Msec(100);
girar(-84,20);
 estabilizar(43,15);
mover_distancia(0,322,70);
wait1Msec(100);
girar(-83,20);
estabilizar(10,13);
mover_distancia(0,564,70);
wait1Msec(100);
girar(-83,20);
estabilizar(10,13);
mover_distancia(0,320,70);
wait1Msec(100);
girar(-83,20);
estabilizar(8,11);
mover_distancia(0,358,70);
wait1Msec(100);
girar(-83,20);
estabilizar(20,10);
mover_distancia(0,100,70);
wait1Msec(100);
girar(-23,20);
girar_rot(172,50,78);
girar(119,20);
mover_distancia(0,100,70);
wait1Msec(100);
estacionar(24,25,170);
estabilizar(-60,20);
mover_distancia(1,8,20);
wait1Msec(2000);
////////////////////////Etapa 2//////////////////////////////
//////////////segundo parqueo de Lot2 a Lot3/////////////////
mover_distancia(0,28,40);
wait1Msec(100);
girar(89,20);
estabilizar(30,15);
wait1Msec(100);
mover_distancia(0,92,70);
girar(89,20);
estabilizar(30,15);
mover_distancia(0,102,70);
wait1Msec(100);
girar(90,20);
estabilizar(43,15);
mover_distancia(0,105,70);
wait1Msec(100);
girar(-84,20);
estabilizar(43,15);
mover_distancia(0,76,70);
wait1Msec(100);
girar(-84,20);
estabilizar(43,15);
mover_distancia(0,50,60);
wait1Msec(100);
estacionar(34,35,50);
estabilizar(20,-25);
mover_distancia(1,10,20);
wait1Msec(2000);
}
Link de la grabación en STREAM

https://web.microsoftstream.com/video/61cbbe48-0295-4e6b-867c-470f90bba680