Mostrando entradas con la etiqueta proyecto robotica. Mostrar todas las entradas
Mostrando entradas con la etiqueta proyecto robotica. Mostrar todas las entradas

jueves, 8 de diciembre de 2011

Torneo de sumo Grupal (Programacion de robots)

Autor: Rodrigo Soto Parra
Competencia: Trabajo En Equipo.




Descripcion de la actividad

La actividad tiene por objetivo relizar un torneo de sumo y competir entre los grupos de estudiantes que ahi en el curso para eso ahi unas reglas que tenian que cumplirse antes de relizar la actividad:

DEL ROBOT

● Los robots no pueden superar los 30cm2, y tienen a disposición todas las piezas del
kit básico y complementario asignados (cualquier desbalance entre piezas debe ser
informado a los ayudantes del ramo para su rápida solución).
● Se pueden utilizar los sensores de tacto, luz y ultrasonido.
● No se permite el úso de ningún tipo de manejo a distancia del robot.
 
DE LA LUCHA

● Es descalificado el grupo que use técnicas ilegales: como poner piezas no
correspondientes al Kit del robot, agregarle peso adicional al robot, realizar manejo a
distancia, etc.
● Si algún “motor” se desprende de la estructura del robot, este pierde la lucha.
● Si el mecanismo de movimiento (ruedas, orugas, patas) es destruido el robot pierde
la lucha.
● Si el sensor de luz se suelta o deja de funcionar, el robot pierde el combate.
● Si el robot pierde piezas pero sigue funcionando, la pelea no se detiene; esto sí le
quitará puntaje en el momento de la evaluación de los jueces.
● Los participantes del torneo deben mantenerse a una distancia de medio metro de la
mesa en cada lucha.
● El robot, durante la lucha, sólo puede ser manipulado por el juez a cargo de la mesa.
● Cada grupo debe tener un set de pilas para competir (que la batería no esté cargada
en el momento de la competición, no es excusa durante el torneo).
 
DEL CODIGO

● La elaboración de código es libre pero se deben usar subrutinas, diferenciando
mínimamente con estas, la secuencia de detección de enemigo, ataque y defensa.
● Para participar de los combate se debe señalar su estrategia de ataque y defensa (a
llenar en ficha inscripción), por lo cual el robot debe responder a lo señalado por el
grupo.
● Cada grupo tendrá que presentar un resumen de lo que supuestamente realizará su
robot, por lo cual, habrá un jurado que evaluará si lo que se presentó anteriormente
se cumplió a la hora del combate. Para ello se les entregará un formulario.
● Se permitirá ajustes al código del programa después de cada pelea, los que deberán
ser notificados en sus informes posteriores.
 
DE LA ESTRUCTURA DEL TORNEO

● Se conformarán por sorteo 8 grupos de 3 robots (pertenecientes, cada uno, a grupo
de 4 alumnos), los que tendrán luchar todos contra todos.
● Cada lucha tendrá una duración máxima de 2 minutos.
● El ganador de la lucha recibirá 3 puntos, el perdedor 0. Si los jueces determinaren un
empate, cada luchador recibirá 1 punto.
● Clasificará a 4tos de final el ganador de cada grupo. Así se armarán parejas, según
el sorteo, hasta llegar a un ganador.
 
DE LA EVALUACION

● Cada luchador será evaluado en su combate por un jurado externo. Por lo que
tendrán que presentar un buen proyecto (note que no solo ganar el torneo es
importante).
● Se evaluara, el diseño, funcionalidad del robot y por supuesto “El Código
implementado”.
● Los grupos tendrán 30 min para prepararse, antes de la actividad; esto es, probar la
mesa, peleas de entrenamiento, etc. Luego de esto, el torneo comienza y cualquier
equipo que no se encuentre listo con su robot para empezar su combate será
descalificado (con la correspondiente descuento en su calificación).
● Es necesario que cada grupo presente la ficha que le será entregada días previos
al Torneo. Esta ficha será entregada a los jueces el día de la pelea, y sin ella no
pueden presentarse.
● El ganador total del combate será premiado con nota y trofeo.




Grupo: Terabytes
Juan arroyo. (uso de sensores).
Juan Reyes.( patron de ataque y defensa).
Patricio Riquelme. (diseño de robot).
Rodrigo Soto. (analisis de combates).

Introduccion.

En el presente informe daremos a conocer los detalles de la creacion,  formación del código  y del robot. Dando a conocer las estrategias de ataques y defensas a si como también el porque del diseño del robot y la utilización de los sensores.
Esta nueva actividad consiste en crear un nuevo robot o modificar uno ya existente  utilizando las piezas del kit básico y del avanzado para desarrollar un lucha de “sumo”, prestando principal énfasis en el desempeño del mismo en la pelea,  además de evaluar la estrategia de ataque y defensa del robot.

Diseño del Robot.

El diseño del robot se baso en la estabilidad y potencia que pueda desarrollar  el robot mediante la lucha, junto con esto se busco  desarrollar una estrategia de ataque para vencer al enemigo.
Los motores se encuentran invertidos para que de esta manera se lograra el encaje con el computador para obtener una buena estabilidad y altura, junto con esto se decidió utilizar ruedas directo al motor  directo al motor  y de gran diámetro para obtener tener más potencia y firmeza comparada con el sistema de engranajes.
En frente se implanto una especie de rampa, una “garra” y un sensor, para que de esta manera nuestro robot levante al enemigo, y al tocar el sensor  de tacto se active la “garra” para levantar y enganchar aun mas al robot contrincante para asi derrotarlo.
En frente del computador y detrás de la garra se encuentra el sensor de luz, se ubico en esa posición para que estuviera protegido y además se encuentra lo mas secarno al la superficie para que de esta manera cumpla bn su función.
La “garra” ubicada en el centro de la rampa  hace que de esta manera logre enganchar y asegurar  de manera eficiente al enemigo para derrotarlo.
La ubicación del sensor de ultrasonido se instalo en la parte superior,  alejado de algún posible ataque  además,  para que cumpla  de forma eficiente su función.
La rueda de timon ubicada atrás del robot ayuda a la maniobrabilidad de este.
Para modo de defensa se instalo un sensor la parte trasera para detectar de esta manera algún posible ataque por la retaguardia.

Uso de Sensores:

Sensores de Tacto: El primero ubicado al lado derecho de la parte frontal del robot apuntando hacia el frente, mientras que el otro se ubica en la parte trasera también apuntando atras, sirven para detectar cuando se tiene al robot oponente frontalmente  para atacar con la garra o por la parte posterior para poder defende.
Sensor de luz: Ubicado en el chasis frontal del robot (observando hacia el piso), con el fin de evitar que el robot se logre salir del límite de la arena de batalla, la cual está delimitada por una línea negra.
Sensor de Ultrasonido: Uicado en la parte superior de la estructura (observando hacia el frente), sirve para detectar el robot sumo oponente, cuando se encuentre a una cierta distancia.


Patron de Ataque y Defensa

En el presente código, el uso de motores B y C ha sido invertido. Esto quiere decir que cada vez que se diga: OnFwd(OUT_BC,…); el robot en lugar de avanzar, retrocederá.

En el principio de nuestro código definimos:

#define CERCA 20    // Se define la constante “CERCA” = 20 para el sensor de Ultrasonido, el número al que se iguala esta variable es la cantidad en centímetros.
#define UMBRAL 40  // Se define la constante “UMBRAL” = 40 para el sensor de Luz, el cuál utiliza este umbral para diferenciar el color blanco del negro.
sub adentro(){ 
OnFwd(OUT_BC,70);
Wait(500);
OnRev(OUT_B,100);
OnFwd(OUT_C,100);
Wait(500);
}

// Primera subrutina definida como “adentro”. Esta subrutina es la encargada de ordenar al robot que cuando el Umbral detectado por el sensor de luz es menor que el Umbral definido anteriormente, el robot deberá retroceder con ambos motores a una potencia de 70 durante medio segundo, luego girar en torno a su eje durante medio segundo.
sub ataque(){ 
OnRev(OUT_BC,100);
Wait(700);
if(Sensor(IN_4)==1)
{
OnRev(OUT_A,100);
Wait(100);
OnFwd(OUT_BC,100);
Wait(500);
OnFwd(OUT_A,100);
Wait(100);
}}
// Segunda subrutina definida como “ataque”. Esta subrutina es la encargada de ordenar al robot que cada vez que el sensor de Ultrasonido detecte un objeto a menos de 20 cm., debe avanzar a una potencia de 100 con ambos motores durante 700 milisegundos, a su vez, si el sensor de tacto del puerto 4 se acciona una vez, el motor A deberá avanzar a una  potencia de 100, este motor A posee una garra que cumple una función similar a la de una catapulta. Luego de que la garra haya subido a una potencia de 100 durante 100 milisegundos,  deberá retroceder a una potencia de 100 durante 100 milisegundos.
sub defensa(){ 
OnRev(OUT_B,100);
OnFwd(OUT_C,100);
Wait(500);
}
// Segunda subrutina definida como “defensa”. Esta subrutina es la encargada de ordenar al robot que cada vez que el sensor de Tacto localizado en el puerto 3 se active, el robot  comience a girar en torno a su propio eje a una potencia de 100 durante medio segundo
task main()
{
SetSensorLight(IN_1); //sensor de luz en el puerto 1
SetSensorLowspeed(IN_2); //sensor de ultrasonido en el puerto 2
SetSensorTouch(IN_3); //sensor de defensa en el puerto3
SetSensorTouch(IN_4); //sensor de ataque en el puerto 4
while (true){  // El uso del WHILE nos indica que cada vez que se cumplan las condiciones especificadas más abajo en el código, el robot deberá realizar ciertas ordenes.
OnRev(OUT_BC,70);  // El robot debe avanzar a una potencia de 70 con ambos motores.
if(Sensor(IN_1)<UMBRAL)
{
adentro();
}
while (SensorUS(IN_2)<=CERCA)
{
ataque();
}
if(Sensor(IN_3)==1)

{
defensa();
}
}
}
//El porque el if se encuentran fuera de las rutinas es porque de esta manera si solo se cumple la condición se realizara la subrutina, siendo este método mas eficiente.

Acontinuacion el codigo original utilizado en la actividad.


#define CERCA 20   
#define UMBRAL 40 
sub adentro()
{                                                              // primera sub rutina
OnFwd(OUT_BC,70);                     //retroceder para no Sali de la plataforma
Wait(500);
OnRev(OUT_B,100);
OnFwd(OUT_C,100);
Wait(500);
}
sub ataque()
{                                              //segunda subrutina
OnRev(OUT_BC,100);
Wait(700);
                if(Sensor(IN_4)==1) //sensor de ataque preciso
                {
                OnRev(OUT_A,100); //subir la garra
Wait(100);
OnFwd(OUT_BC,100);
Wait(500);
OnFwd(OUT_A,100); //bajar la garra.
Wait(100);
}
}
sub defensa()
{                              //tercera subrutina
OnRev(OUT_B,100);
OnFwd(OUT_C,100); //girar 100º aprox.
Wait(500);
}
task main()
{
SetSensorLight(IN_1);
SetSensorLowspeed(IN_2);  
SetSensorTouch(IN_3);  
SetSensorTouch(IN_4); //sensores
while (true){ 
OnRev(OUT_BC,70);  /
                if(Sensor(IN_1)<UMBRAL) //condicion para no salirse
                {
                adentro();
                }
while (SensorUS(IN_2)<=CERCA)//condición para atacar
{
ataque();
}
                if(Sensor(IN_3)==1)
                {
                defensa();
                }
     }//del while
}//del main


Análisis de enfrentamiento:

Combate nº1:
En el primer combate lo ganamos y creo que fue muy fácil ya que cada round duro menos de 4 seg  Nuestro robot lo empujo siempre hacia afuera ya que tenia una potencia mejorada y una rampa que levantaba una de sus ruedas para que asi pierda potencia.
Combate nº2:
En el combate fue un poco mas complejo ya que a la vista el robot enemigo se veía firme y muy bien echo pero a la hora del combate el código del enemigo estaba mal echo ya que al atacar este pasaba detrás mio y el robot de nosotros lo empujaba hacia afuera.
Combate nº3
Este combate lo relacione mucho con nuestra estrategia de ataque ya que el robot enemigo tenia una similar estructura de nuestro robot,  ya que se comparaba con la rampla que tenia en nuestro robot y el enemigo, puesto que gracias a nuestra estrategia logramos ganarle a este sin una mayor dificultado solo lanzándolo unos grados de dirección hacia la derecha para poder entrar y atacarlo por el costado.
Combate nº4
En este enfrentamiento no hubo muchas complicaciones ya que el robot enemigo era demasiado bajo y no tenia mucha potencia en sus tracciones puesto que nosotros atacamos de frente y utilizando el sensor de tacto el robot enemigo lo activaba este levantaba a potencia 100 una garra estratégicamente puesta para poder levantar una rueda ya que así el robot enemigo perdería un poco de potencia y lo sacaríamos del circulo.
Combate nº5 y la final
Como en este combate sabemos que era la final teníamos miedo de que lo perdiéramos muy fácil ya que el robot enemigo tenía una muy buena estructura. Contaba con una “muralla” de piezas alrededor del para así poder empujar y que nunca fueran tocadas las ruedas de este es así como luchamos 5 round puesto así arreglamos con el contrincante ese combate duro alo mas 10 minutos ya que fuimos un oponente muy duro para el enemigo como el a nosotros.        Este combate lamentablemente lo perdimos y es asi como es que sacamos segundo lugar. (Fuera de juego, jugamos 3 round mas y salimos ganando los 3 ).


Conclucion.
Para finalizar el informe se puede señalar que con el buen desarrollo de la actividad logramos como grupo plantear una excelente estrategia de pelea y diseño del robot, luego de que este ultimo haya sido desarmado por lo menos 2 veces, para encontrar el equilibrio perfecto entre estabilidad, agilidad, potencia y firmeza, gracias a esto y después de varias pruebas de calidad , y obstáculos logramos obtener el segundo lugar en la competencia.
El uso de sensores fue fundamental en esta activida ya que cada uno brindaba una funcion funddamental para poder lograr  la funcionalida completa del robot y al fiinal el triunfo.
La formacion del codigo es el cerebro de nuestro robot ya que le dice a unas simples piezas que ejerzana alguna funcion determnada.
Al analizar los enfrentamientos de nuestro robot se logra dar cuenta que ibamos directo al triunfo pero lamentablemente no fue asi, por lo mismo podemos señalar unos pequeños detalles  que quizas ubiesen  servido para que el robot tuvieroa un mejor rendimiento dentro de los cuales se encuentran:
Un poco mas de peso para que de esta manera no sea tan ligero.
El palito para activar el sensor un poco mas largo para que se ubiese activado en mas ocaciones para que de esta manera aber activado la garra.



domingo, 13 de noviembre de 2011

Actividad #2 - pitFinder (Proyecto Robotica).

Autor: Rodrigo Andres Soto Parra
Competencia:Aplica las Ciencias de la ingeniería. (Nivel 1).



Descripcion de la actividad 
Un robot recorre la meseta de una montaña, y su misión es detectar las alturas de los precipicios de ésta, información que servirá para escaladores, paracaidistas, deportes extremos en general.

Implementación

  • La meseta de la montaña estará dada por la mesa de competición sin paredes.
  • Cada vez que el robot detecte el fin de la mesa, deberá detenerse, y medir la altura del “precipicio”. Este dato será registrado y guardado en un ARRAY de enteros.
  • Después de medir, debe (al azar) buscar otro borde de la mesa, y realizar la misma operación.
  • El robot finaliza su trabajo de búsqueda cuando registró la medición del 4to “precipicio”.
  • Finalizada la búsqueda genera un reporte que guardará en un archivo (WriteLnString).. Un ejemplo del formato del reporte sería:

REPORTE PITFINDER
--------------------
Precipicio 1 ==> 20 mts
Precipicio 2 ==> 10 mts
Precipicio 3 ==> 30 mts
Precipicio 4 ==> 20 mts
  • Al final, deberá mostrar en el visor del NXT el reporte de los precipicios anteriormente guardado en el archivo, a través de la lectura del mismo (ReadLnString).
 



Introducción
Terminando el trabajo anterior, nos preguntábamos, ¿Cuál podría ser el siguiente trabajo?. Al leer la actividad, nos dimos cuenta que la intención de nuestros profesores no era complicarnos la vida como pensábamos, sino que atreves de tareas medianamente complicadas insertarnos los conocimientos y de alguna manera obligarnos a ocuparlos dentro del trabajo. Para la actividad numero 2, se nos pide que dentro de un espacio determinado (Sin paredes), nuestro robot se desplace de manera aleatoria, hasta que encuentre el fin de la acera. Al momento de conseguir el primer objetivo, se pide que nuestro robot tome la distancia que hay desde la pista hasta el suelo y guardarlo en un arreglo. Luego de repetir durante 4 veces este proceso, se solicita que los resultados sean expuestos por la pantalla del robot. Las nuevas funciones son “WriteLnString” (Escribir en el archivo, o guardar objetos) y “ReadLnString” (Leer el archivo).


Objetivos
Iniciada la actividad numero 2 y unas ves determinas las funciones de cada integrante del grupo, se plantea una serie de objetivos los cuales deben ser cumplidos al término de la actividad. Dentro de estos no estaba solamente entregar el trabajo, sino también que cada uno de los integrantes lograse entender de manera clara el nuevo código y la implementación de las nuevas funciones dentro de este.
· Implementar las nuevas sentencias en de programación pasadas en la semana como:
o WriteLnString (Escribir en el archivo, o guardar objetos).
o ReadLnString (Leer el archivo).
· Trabajar en Grupo.
· Entregar el trabajo puntualmente y sin mayores complicaciones.
· Optimizar el código de manera que sea entendible a simple vista.
· Trabajar con la materia anterior, para formar un código completo, optimizado y sin errores.


Estrategia de Trabajo
Para esta actividad, variaron los cargos rotundamente. En el ramo anterior (Programación de Robots), a medida que los cargos rotaban, todos los integrantes del grupo podían experimentar los diferentes cargos que hay dentro de este. Es por esto que ahora todos podrían estar en cualquier cargo y para demostrar esto, es que cambiamos los roles para este trabajo. Además, el trabajo ejecutado de esta manera, resulta dinámico y entretenido.
Jefe de Grupo: Representante legal de grupo. Encargado principalmente de que en este, se mantenga el orden, la disciplina y predomine el trabajo antes que la pérdida de tiempo. También tiene como función ayudar en lo que se le solicite y resolver dudas de los integrantes del grupo.
Productor multimedia: Preocupado de tomar fotografías para la entrega del informe, pero su principal función es grabar el video que corresponde a un segmento importante y de alto puntaje dentro del trabajo.
Secretario: Atento y veloz en la toma de apuntes y detalles, los cuales pueden ser muy útiles a la hora de la construcción del informe, donde la mayor participación la tiene el mismo.
Staff de apoyo: Ayuda de manera animosa y colaborativa en cualquier tarea donde se le solicite, puede ser en la construcción del informe, en la toma de fotografías o simplemente para subir el trabajo a la plataforma.


Diseño y uso de sensores
Analizando la actividad, nos dimos cuenta de que para este proyecto, la estructura actual del robot no nos serviría, por lo tanto tomamos una clase de laboratorio para estructúralo nuevamente y el resultado fue el siguiente: Se desconectaron todos los sensores excepto en de ultrasonido, el cual, es el único utilizado para esta ocasión. El sensor recién mencionado, es ubicado en la parte Frontal-Posterior del robot (Obviamente, no obstruyendo el trabajo de las ruedas) en dirección hacia el suelo, (De manera que cuando no detectara piso, tomara sin complicaciones la distancia desde este, hacia el suelo). Todo lo demás fue dejado donde mismo, ya que su cambio de ubicación, no afectaría en el resultado final de la actividad.







Código Fuente
int medidas[4];
int a=0;
int i=0;
int j=0;
int num=0;
int tam=512;
byte punteroArchivo;
byte bytesEscritos;
mutex semaforo;
string numeros;
string linea="_==>";
string cadena;
string leer;
string mas="precipicio";
#define Medid 20
sub Altura()
{
medidas[a]=SensorUS(IN_2);
NumOut(0,10*a,medidas[a]);
a++;
}
sub Archivos()
{
CreateFile("Dato.txt", tam, punteroArchivo);
WriteLnString(punteroArchivo, "REPORTE PITFINDER", bytesEscritos);
WriteLnString(punteroArchivo, "--------------------", bytesEscritos);
for(j=0; j < ArrayLen(medidas); j++)
{
num++;
numeros= NumToStr(num);
cadena = NumToStr(medidas[j]);
cadena = mas + numeros + linea + cadena;
WriteLnString(punteroArchivo, cadena, bytesEscritos);
}
CloseFile(punteroArchivo);
}
task Programa()
{
while (i<4)
{
OnFwd(OUT_C,50);
OnFwd(OUT_A,55);
if (SensorUS(IN_2)>Medid)
{
i++;
Acquire(semaforo);
OnFwd(OUT_C,50);
OnFwd(OUT_A,55);
Wait(300);
Off(OUT_AC);
Wait(1000);
Altura();
OnRev(OUT_C,50);
OnRev(OUT_A,55);
Wait(1000);
OnFwd(OUT_C,50);
OnRev(OUT_A,55);
Wait(Random(1500)+400);
Release(semaforo);
}
}
int pa=50;
bool eof = false;
Off(OUT_AC);
Archivos();
ClearScreen();
OpenFileRead("Dato.txt", tam, punteroArchivo);
while (eof == false){ if(ReadLnString(punteroArchivo,leer) != NO_ERR) eof = true;
TextOut(LCD_LINE8,pa,leer);
pa= pa-10;
Wait(500);}
Wait(5000);
CloseFile(punteroArchivo);
}
task main()
{
Precedes(Programa);
SetSensorLowspeed(IN_2);
}


Link del video



Conclusión
 Cuando el informe estuvo totalmente construido, el video editado y el código optimizado y funcionando, pudimos concluir que la actividad resulto todo un éxito, ya que todos los integrantes del grupo cumplieron su función de manera plena y sin complicación alguna. También se ve de manera clara un buen manejo de las funciones aprendidas hasta ahora, junto con las más recientes que son “WriteLnString” y “ReadLnString”, las cuales fueron aplicadas de manera adecuada y se puede comprobar en el video, donde se ve que el código no tuvo ningún problema al momento de su ejecución.

 

domingo, 9 de octubre de 2011

Robot Dribbler (Proyecto Robotica)

Autor: Rodrigo Andres Soto Parra
Competencias: Desarrollo de Software (Nivel 1).

Descripcion De la actividad

Contexto:
Usted es el encargado de construir un robot de competencia para el nuevo juego del verano “Dribbler”.
Reglas del juego:
  1. La idea de la competencia es que un robot autónomo encuentre la mayor cantidad de “zonas de puntaje” (círculo negro) en la pista, sin chocar con los obstáculos presentes (paredes, bloques, etc), ya que cuando pase esto, termina el juego.
  2. Cuando el robot vaya a chocar, el jugador debe indicarle que existe peligro de choque, a través de una señal audible (grito, pitazo, aplauso, etc), de modo que el robot no colisione.
  3. Cada vez que el robot encuentra una zona de puntaje (círculo negro), acumula puntos, pero también aumenta su velocidad.
  4. Gana el jugador que logre el mayor puntaje, antes de chocar con algún obstáculo.
Especificaciones:
  1. El robot debe iniciar su recorrido con una potencia de 20 e iniciar un timer en 0.
  2. Mientras el robot busca zonas de puntaje se emitirá constantemente una música ad-hoc.
  3. Cuando detecte una zona de puntaje (círculo negro), el robot:
  1. Emitirá una música de anotación de puntos
  2. Registrará el puntaje obtenido en la posición correspondiente dentro de un arreglo (array)
  3. Aumenta la potencia de movimiento en 10, hasta el máximo de 100.
  4. Girará aleatoriamente sobre su eje
  5. Reiniciará el timer a 0.
  6. Seguirá su rumbo con la nueva velocidad.
  7. Volverá a su música de recorrido.
  1. El puntaje obtenido por el robot, estará dado por la siguiente función:
                P  =  - 5*t + 50              si t <= 10
                
                P = 0                        si t > 10
                Donde:
                        P= Puntaje.
                        t = Intervalo de tiempo (en segundos) para encontrar la zona de puntaje.
 
  1. Si el robot detecta una señal audible de 80 db (ud. puede ajustarla) girará en un ángulo apropiado (uds. lo definen) de modo de esquivar un obstáculo, o bien corregir su recorrido.
  2. Cuando el robot choque contra algún obstáculo se detendrá, finalizará todas las tareas y mostrará en el visor cada uno de los puntajes guardados en el arreglo y la suma total de los mismos.


Inicio de la actividad
Introducción:
Luego de realizar un gran lista de actividades el primer semestre, logramos, ahora, entrar en un área de un nivel mas avanzado, en comparación a todas las anteriores. Algunas de las funciones nuevas que implementamos en este trabajo fueron: ExitTo, Precedes, Mutex, Acquire, Release. Luego de varias clases comenzamos a entender, en que situaciones aplicar lo aprendido, ya que si estas funciones eran ejecutadas de mala manera, podrían traer consecuencias para la realización del código. En el siguiente trabajo se plantea un problema y se busca con este, que nosotros apliquemos las funciones aprendidas de manera óptima, para que el código resulte mas limpio y solido al momento de su ejecución. La actividad consistía en una competencia, en donde el robot debe encontrar la mayor cantidad de puntaje (En la pista representado con puntos negros), sin chocar con los obstáculos puestos en la pista (Ya sean paredes o Bloques ubicados en posiciones estrategicas dentro de esta). En el caso de que el robot chocara con algún tipo de obstáculo, la actividad llegaría a su fin.

Objetivos
Al momento de iniciar esta actividad, para nosotros, lo principal era entregar el informe y tener nuestra nota, pero a medida que pasaron las clases nos dimos cuenta de que nuestros objetivos no eran solo esos, sino también el lograr sacar provecho de la actividad y aprender nuevas formas de trabajar, para así lograr un mejor rendimiento en todo ámbito, tanto en la universidad, como en la entrega de trabajos. Para esto nos planteamos objetivos antes de comenzar la actividad, los cuales fueron los siguientes:
Lograr desarrollar una solución adecuada para la actividad
Implementar nuevas sentencias aprendidas en clases como:
ExitTo(task)
Precedes(task1,task2,...)
Mutex
Acquire(mutex)
Release(mutex)
Cuando comenzamos la construcciòn del informe nos dimos cuenta de que los objetivos habían sido todo un éxito y que todos los integrantes del grupo tenían una buena manipulación de las funciones y que la solución propuesta para la actividad era la correcta.
Estrategia de trabajo
El planteamiento de la actividad hizo que nos organicemos como grupo de una forma en la cual todos aportaran de una forma pareja para lograr desarrollar una solución concreta. Es por esto que llegamos al acuerdo de que cada integrante debe participar en la formación del código, y una vez finalizado dividir las tareas, quedando de la siguiente manera.
Productor multimedia: realizada por dos integrantes del grupo quienes se encargarían de la grabación y toma de imágenes del desarrollo de la actividad.
Secretario y Staff de apoyo: Igual que el cargo anterior los dos restantes integrantes del grupo se encargarían de la formulación del presente informe y envió.
Jefe de Grupo: Eligió un integrante del grupo para que imponga el orden y representarà al grupo frente a los profesores, asiéndose totalmente responsable del grupo.
Diseño y uso de sensores
El diseño del robot fue algo simple de hacer por el tipo de actividad, ya que debía ser liviano y ágil para poder moverse. Es por este motivo el uso de las ruedas grandes, junto con esto la ubicación y utilización de los sensores era fundamental, ya q para tener el registro de los puntos negros de la mesa se necesitaba que el sensor de luz, el cual debía estar ubicado en la parte inferior apuntando hacia abajo. Además el segundo sensor que se utilizo en este segundo proyecto es el sensor de sonido, el cual se ubico en la parte superior para una buena recepción del sonido y en sentido opuesto a los motores para que estos no afecten el funcionamiento de este sensor.

Código Fuente:
//autor grupo terabytes
//viernes
#define UMBRAL 40
#define DECIBEL 90
int puntos[100];
int timer=0;
int TotalTiempo;
int t=0;
int i=0;
int potencia=20;
task Tono (){
while(true){
PlayToneEx(262,400,9,0); Wait(500);
PlayToneEx(294,400,9,0); Wait(500);
PlayToneEx(330,400,9,0); Wait(500);
PlayToneEx(294,400,9,0); Wait(500);
PlayToneEx(262,1600,9,0); Wait(2000);
}
}
task Choque () {
while(true) {
if(Sensor(IN_1)!=0){
Off(OUT_AB);
Wait(60000);
ExitTo(Tono);
}
OnFwd(OUT_AB,potencia);
if(Sensor(IN_3)>DECIBEL){
OnRev(OUT_AB,50);
Wait(500);
OnFwd(OUT_B,30);
Wait(570);
} } }
task Circulo (){
timer=CurrentTick();
while(true){
if(Sensor(IN_2)<UMBRAL){
i++;
t=CurrentTick();
t=(timer-t)/1000;
PlayTone(500,300);
Wait(1000);
if(t<=10){
puntos[i]=(-5*t)+50;
NumOut(5,5,puntos[i]);
}
else puntos[i]=puntos[i]+0;
Wait(100);
if(potencia<=100){
potencia=potencia+10;}
}
}
}
task main () {
Precedes(Choque,Tono,Circulo);
SetSensorLight(IN_2);
SetSensorSound(IN_3);
SetSensorTouch(IN_1);
}

Pseudo Código:
SubTarea Tono () {
Mientras(verdadero) {
TocaMelodia(262,400); Espera(0,5 seg);
TocaMelodia(294,400); Espera(0,5 seg);
TocaMelodia(330,400); Espera(0,5 seg);
TocaMelodia(294,400); Espera(0,5 seg);
TocaMelodia(262,1600); Espera(2seg);
}
}
SubTarea Choque(){
Mientras(verdadero) {
Si(SensorTacto!=0){
Salir de TONO;
Parar Motores;
Esperar(60Seg);
}
Avanzar(potencia= 20);
Si(SensorAudio>Decibel=90){
Retrocede(Potencia);
Espera(0,5Seg);
Gira 90º(Izquierda);
}
}
SubTarea Circulo(){
variable timer= Tiempo actual;
Mientras(verdadero){
Si(SensorLuz<Umbral 40){
Contador++;
Variable t= Tiempo actual;
t= (timer-t)/1000;
TocaMelodia(500,300);
Esperar(1Seg);

Si(t<=10){
Variable Puntos[100];
Puntos[i]=(-5*t)+50;
Imprime(posX 5,PosY 5,"puntos"puntos[i];
}
Si no {
Puntos[i]=Puntos[i]+0;
}
Espera(0,1Seg);
Si (potencia<=90){
Potencia=Potencia+10;
}
}
}
}

Link del vídeo:
Conclusion:
Al momento de comenzar a subir la actividad, nos dimos cuenta de que todo había resultado como lo esperamos; un manejo adecuado del código, un pseudocodigo bien estructurado, las funciones aprendidas y utilizadas de buena manera. El buen resultado apreciado por nosotros son fruto de una buen planteamiento del problema, organización y participación de todos los integrantes del grupo.
  La actividad constaba de una series de objetivos y desafíos, resultando está muy interesante de realizar, implementando el conocimiento de las nuevas sentencias aprendidas en clases como: ExitTo(task), Precedes(task1,task2,...), junto a otras presentadas en los objetivos.

jueves, 29 de septiembre de 2011

Laboratorio de fisica MRU, NXC Prog. de robots


Autor: Rodrigo Andres Soto Parra.
Competencias:Modela y aplica procedimientos de ciencias de la ingeniería.

Descripcion De la actividad.


· Determinar la relación velocidad-potencia de programación de su robot (MRU).
· Utilizando una velocidad constante conocida, determinar distancias desconocidas.
· Calcular el tiempo y la distancia de encuentro de 2 robots que se mueven en la misma dirección,
pero en sentidos opuestos.



1) Función Velocidad/Potencia de programación.
A través de la toma de datos de velocidad para una determinada potencia de programación, calcular
una función que me entregue la velocidad de su robot en función de la potencia.
Se debe realizar el gráfico de velocidad del robot en función de la potencia de programación, y según
la tendencia del gráfico encontrar una función que represente los datos graficados.



2)Tiempo de encuentro y posición.
Utilizando un segundo robot, se debe hacer un problema de encuentro.
Se requiere:
- Cálculo de las velocidades con las que se moverán los robots.
- Teóricamente calcular el tiempo y la posición de encuentro.
- Demostrar a través de montaje en laboratorio, que se cumple lo que entrega la teoría.




Codigo de programa de aceleracion

//Aceleración cada 2 segundos.
long tiempo,t0,t1;     //Entero sin signo para guardar la info del timer.
int luz,i,j,pm;                  //Entero definido para guardar la info del sensor de Luz.
task main()
{
    PlayTone(5000,30);      //Emitir un sonido al inicio de la ejecución del programa.
    Wait(2000);             //Pausa de 2 segundos.
    i = 1;
    j = 1;
    SetSensorLight(IN_3);   //Definir y encender el sensor de luz, Puerto 3.
    pm = 10;

    while(j<7)
        {
        // ----------------------------------------------------------------------------------------------
        OnFwdReg(OUT_AC,pm,OUT_REGMODE_SPEED);   //Iniciar los motores con control de sincronización de velocidad.
        t0 = CurrentTick();                      //Tiempo inicial del timer antes de entrar al ciclo.
        NumOut(60,j*10,pm);

        while((t1-t0)<2000)
            {
            OnFwdReg(OUT_AC,pm,OUT_REGMODE_SPEED);   //Iniciar los motores con control de sincronización de velocidad.
            luz = Sensor(IN_3);                      //Luz recibe info del sensor de luz.
            t1 = CurrentTick();                      //Tiempo que determinará la salida del ciclo.
            if(luz < 33)
                {
                tiempo = CurrentTick();
                NumOut(10,j*10,tiempo);
                j = j+1;
                if(j==7)
                    {
                    break;
                    }
                if(pm < 40)
                    {
                    Wait(400);              //Tiempo de espera para que tome 1 dato por marca.
                    }
                else
                    {
                    Wait(50);
                    }
                }
            t1 = CurrentTick();
            if((t1-t0)>1999)
                {
                i = i+1;
                pm = 10*(i);
                }
            }
        }
    Float(OUT_AC);
    Wait(60000);
    Wait(50000);
}

Codigo de Velocidad

long tiempo, tiempo_ini,tiempo1;         //Entero largo para guardar la info del timer.
int luz,i,j;                             //Entero definido para guardar la info del sensor de Luz.
task main()
{
    PlayTone(5000,30);      //Emitir un sonido al inicio de la ejecución del programa.
    Wait(2000);             //Pausa de 2 segundos.
    OnFwdReg(OUT_BC,40,OUT_REGMODE_SPEED);   //Iniciar los motores con control de velocidad.
    Wait(10);
    Float(OUT_BC);
    Wait(60000);
}